Function bodies 314 total

  class AttributeMapRegistry

    class << self
      attr_reader :attribute_maps

      def register_attribute_map(attribute_map_class)
        @attribute_maps ||= {}
        @attribute_maps[attribute_map_class.model_type] = attribute_map_class
      end
    end

      def register_attribute_map(attribute_map_class)
        @attribute_maps ||= {}
        @attribute_maps[attribute_map_class.model_type] = attribute_map_class
      end

    def attribute_map_class(model_class)
      raise "No attribute map defined for #{model_class}" unless self.class.attribute_maps.key?(model_class)

      self.class.attribute_maps[model_class]
    end

  class ErrorHashToAPIAttributesTransformer < AbstractTransformer
    NESTED_ATTRIBUTE_ERROR_KEY = /\A(?<parent>[\w_]+)\[(?<index>\d+)\]\.(?<child>[\w_]+)\z/

    def initialize(config)
      super
      @transform_nested_attributes_with = config[:transform_nested_attributes_with]
    end

    def execute
      api_attributes = api_attribute_names.flat_map do |api_attribute|
        model_attribute = model_attribute(api_attribute)
        next unless error_present_for?(model_attribute)

        error_keys_for(model_attribute).map do |error_key|
          converted_error_key = nested_attribute_error_key?(error_key) ?
            convert_nested_attribute_error_key(error_key, api_attribute) :
            normalize_association_reference(api_attribute, model_attribute)
          [converted_error_key, data_source[error_key]]
        end
      end

    def initialize(config)
      super
      @transform_nested_attributes_with = config[:transform_nested_attributes_with]
    end

    def execute
      api_attributes = api_attribute_names.flat_map do |api_attribute|
        model_attribute = model_attribute(api_attribute)
        next unless error_present_for?(model_attribute)

        error_keys_for(model_attribute).map do |error_key|
          converted_error_key = nested_attribute_error_key?(error_key) ?
            convert_nested_attribute_error_key(error_key, api_attribute) :
            normalize_association_reference(api_attribute, model_attribute)
          [converted_error_key, data_source[error_key]]
        end

    def convert_nested_attribute_error_key(error_key, parent_api_attribute)
      NESTED_ATTRIBUTE_ERROR_KEY.match(error_key) do |match_data|
        child_attribute_map_class = @transform_nested_attributes_with[parent_api_attribute]
        child_model_attribute = match_data[:child].to_sym
        child_api_attribute = child_model_attribute
        if child_attribute_map_class
          mapping = child_attribute_map_class.config[:mappings].find { |_k, v| v == child_model_attribute }
          child_api_attribute = mapping.first if mapping
        end

    def nested_attribute_error_key?(error_key)
      NESTED_ATTRIBUTE_ERROR_KEY.match?(error_key.to_s)
    end

    def error_keys_for(model_attribute)
      data_source.include?(model_attribute) ?
        [model_attribute] :
        nested_attributes_with_errors(model_attribute)
    end

    def error_present_for?(model_attribute)
      data_source.include?(model_attribute) || nested_attributes_with_errors(model_attribute).any?
    end

    def nested_attributes_with_errors(parent_attribute)
      data_source.attribute_names.select { |attribute| attribute.to_s.start_with?("#{parent_attribute}[") }
    end

    def resource_association?(model_attribute)
      resource_associations.include?(model_attribute)
    end

    def collection_association?(model_attribute)
      collection_associations.include?(model_attribute)
    end

    def accepts_nested_attributes_for?(association_name)
      model_type.nested_attributes_options.key?(association_name)
    end

    def resource_associations
      @resource_associations ||= model_type.reflect_on_all_associations
                                           .reject(&:collection?)
                                           .map(&:name)
    end

    def collection_associations
      @collection_associations ||= model_type.reflect_on_all_associations
                                             .select(&:collection?)
                                             .map(&:name)
    end

    def normalize_association_reference(api_attribute, model_attribute)
      if accepts_nested_attributes_for?(model_attribute)
        api_attribute
      elsif resource_association?(model_attribute) && !model_attribute.to_s.end_with?('_id')
        normalize_resource_association_reference(api_attribute)
      elsif collection_association?(model_attribute) && !model_attribute.to_s.end_with?('_ids')
        normalize_collection_association_reference(api_attribute)
      else
        api_attribute
      end

    def normalize_collection_association_reference(api_attribute)
      :"#{api_attribute.to_s.singularize}_ids"
    end

    def normalize_resource_association_reference(api_attribute)
      :"#{api_attribute.to_s.singularize}_id"
    end

  class FilterMap
    attr_reader :filter_factory, :attribute_map_class

    def initialize(filter_factory:, attribute_map_class: nil)
      @filter_factory = filter_factory
      @attribute_map_class = attribute_map_class
    end

    def from_api_filters(api_filters)
      validate(api_filters)
      transform_api_attribute_filters(api_filters).merge(transform_api_custom_filters(api_filters))
    end

    def filter_definitions(filter_names: nil, **)
      supported_filters.filter_map do |filter_name, filter_class|
        next if filter_names&.exclude?(filter_name)

        api_attribute_filter_name_map.key?(filter_name) ?
          attribute_filter_definition(filter_name, filter_class) :
          other_filter_definition(filter_name, filter_class, **)
      end
    end

    def initialize(filter_factory:, attribute_map_class: nil)
      @filter_factory = filter_factory
      @attribute_map_class = attribute_map_class
    end

    def from_api_filters(api_filters)
      validate(api_filters)
      transform_api_attribute_filters(api_filters).merge(transform_api_custom_filters(api_filters))
    end

    def filter_definitions(filter_names: nil, **)
      supported_filters.filter_map do |filter_name, filter_class|
        next if filter_names&.exclude?(filter_name)

        api_attribute_filter_name_map.key?(filter_name) ?
          attribute_filter_definition(filter_name, filter_class) :
          other_filter_definition(filter_name, filter_class, **)
      end

    def attribute_filter_definition(filter_name, filter_class)
      api_filter_name = api_attribute_filter_name_map[filter_name]
      filter_class.definition.merge(name: api_filter_name)
    end

    def other_filter_definition(_filter_name, filter_class, **)
      filter_class.definition(**)
    end

    def api_attribute_filter_names
      @api_attribute_filter_names ||= attribute_map_class.nil? ?
                                        PackAPI::FrozenEmpty::ARRAY :
                                        attribute_map_class.api_type.filterable_attributes.keys
    end

    def api_attribute_filter_name_map
      return @api_attribute_filter_name_map if defined?(@api_attribute_filter_name_map)
      return PackAPI::FrozenEmpty::HASH if attribute_map_class.nil?

      names = {}
      api_attribute_filter_names.each { |name| names[name] = name }
      @api_attribute_filter_name_map = attribute_map_class.model_attribute_keys(names)
    end

    def validate(filters)
      invalid_filter_names = filters.keys.reject { |filter_name| valid?(filter_name) }
      raise PackAPI::InternalError, validation_error_message(invalid_filter_names) if invalid_filter_names.any?
    end

    def valid?(filter_name)
      api_filter_names.include?(filter_name)
    end

    def api_filter_names
      @api_filter_names ||= supported_filters.keys.map do |filter_name|
        api_attribute_filter_name_map.fetch(filter_name, filter_name)
      end

    def validation_error_message(unsupported_filter_names)
      filter_names_string = unsupported_filter_names.map { |filter_name| "'#{filter_name}'" }.join(', ')
      api_type_name = attribute_map_class.api_type.name
      "unsupported #{'filter'.pluralize(unsupported_filter_names.size)} #{filter_names_string} for #{api_type_name}."
    end

    def transform_api_attribute_filters(api_filters)
      return api_filters if attribute_map_class.nil?

      api_attribute_filters = api_filters.select { |filter_name, _| api_attribute_filter_names.include?(filter_name) }
      attribute_map_class.model_attribute_keys(api_attribute_filters)
    end

    def transform_api_custom_filters(api_filters)
      api_filters.except(*api_attribute_filter_names)
    end

    def supported_filters
      @supported_filters ||= filter_factory.filter_classes
    end

  class ModelToAPIAttributesTransformer < AbstractTransformer
    def options=(options)
      super
      @optional_attributes_to_include = nil
      @model_attributes_of_interest = nil
      @api_attributes_of_interest = nil
    end

    def execute
      api_attribute_names.each_with_object({}) do |api_attribute, result|
        model_attribute = model_attribute(api_attribute)
        next unless include_model_attribute?(model_attribute)

        api_value = transform_value(api_attribute, model_value(model_attribute)) if include_api_attribute?(api_attribute)
        result[api_attribute] = api_value
      end
    end

    def options=(options)
      super
      @optional_attributes_to_include = nil
      @model_attributes_of_interest = nil
      @api_attributes_of_interest = nil
    end

    def execute
      api_attribute_names.each_with_object({}) do |api_attribute, result|
        model_attribute = model_attribute(api_attribute)
        next unless include_model_attribute?(model_attribute)

        api_value = transform_value(api_attribute, model_value(model_attribute)) if include_api_attribute?(api_attribute)
        result[api_attribute] = api_value
      end

    def api_attribute_names
      api_attributes_of_interest || api_type.attribute_names
    end

    def include_api_attribute?(api_attribute)
      !optional_api_attribute?(api_attribute) || include_optional_api_attribute?(api_attribute)
    end

    def model_attributes_of_interest
      @model_attributes_of_interest ||= options[:model_attributes_of_interest]
    end

    def api_attributes_of_interest
      @api_attributes_of_interest ||= options[:api_attributes_of_interest]
    end

    def optional_attributes_to_include
      @optional_attributes_to_include ||= options[:optional_attributes]
    end

    def optional_api_attribute?(api_attribute_name)
      api_type_optional_attributes.include?(api_attribute_name)
    end

    def include_optional_api_attribute?(api_attribute_name)
      return true if api_attributes_of_interest && api_attributes_of_interest.include?(api_attribute_name)
      return false if optional_attributes_to_include.nil?
      return false if optional_attributes_to_include.respond_to?(:exclude?) &&
                      optional_attributes_to_include.exclude?(api_attribute_name)

      true
    end

    def include_model_attribute?(model_attribute)
      return true if model_attributes_of_interest.nil?

      model_attributes_of_interest.include?(model_attribute)
    end

    def api_type_optional_attributes
      @api_type_optional_attributes ||= api_type.optional_attributes || PackAPI::FrozenEmpty::ARRAY
    end

    def model_value(model_attribute)
      data_source.public_send(model_attribute)
    end

  class NormalizedAPIAttribute
    PLURAL_IDS = '_ids'
    SINGULAR_ID = '_id'

    attr_reader :api_attribute_names

    def initialize(api_attribute_names)
      @api_attribute_names = api_attribute_names
    end

    def normalize(attribute_name)
      if id_for_resource_association?(attribute_name)
        normalize_resource_association_reference(attribute_name)
      elsif id_for_collection_association?(attribute_name)
        normalize_collection_association_reference(attribute_name)
      else
        attribute_name
      end
    end

    def initialize(api_attribute_names)
      @api_attribute_names = api_attribute_names
    end

    def normalize(attribute_name)
      if id_for_resource_association?(attribute_name)
        normalize_resource_association_reference(attribute_name)
      elsif id_for_collection_association?(attribute_name)
        normalize_collection_association_reference(attribute_name)
      else
        attribute_name
      end