Function bodies 314 total

class PackAPI::FrozenEmpty
  ARRAY = [].freeze
  HASH = {}.freeze
end

  class InternalError < StandardError
    attr_reader :object, :options

    def initialize(msg = nil, object: nil, options: {})
      super(msg)
      @object = object
      @options = options
    end

    def message
      to_s
    end

    def to_s
      return super unless object.present?

      "#{super} - #{object.inspect}"
    end
  end

    def initialize(msg = nil, object: nil, options: {})
      super(msg)
      @object = object
      @options = options
    end

    def message
      to_s
    end

    def to_s
      return super unless object.present?

      "#{super} - #{object.inspect}"
    end

  class AbstractTransformer
    attr_accessor :mappings, :api_type, :model_type, :data_source
    attr_reader :options

    def initialize(config)
      @mappings = config[:mappings]
      @api_type = config[:api_type]
      @model_type = config[:model_type]
      @transform_value = config[:transform_value]
      @options = PackAPI::FrozenEmpty::HASH
    end

    ###
    # @abstract
    def execute
      raise NotImplementedError
    end

    def options=(value)
      @options = value.presence || PackAPI::FrozenEmpty::HASH
    end

    protected

    def transform_value(api_attribute, value)
      @transform_value.call(api_attribute, value)
    end

    def model_attribute(api_attribute)
      # support _destroy and other special attributes used by Rails
      return api_attribute if api_attribute.start_with?('_')

      # prevent api_attributes from being used unless they are in the public type definition
      unless mappings.key?(api_attribute)
        raise PackAPI::InternalError.n

    def initialize(config)
      @mappings = config[:mappings]
      @api_type = config[:api_type]
      @model_type = config[:model_type]
      @transform_value = config[:transform_value]
      @options = PackAPI::FrozenEmpty::HASH
    end

    def execute
      raise NotImplementedError
    end

    def options=(value)
      @options = value.presence || PackAPI::FrozenEmpty::HASH
    end

    def transform_value(api_attribute, value)
      @transform_value.call(api_attribute, value)
    end

    def model_attribute(api_attribute)
      # support _destroy and other special attributes used by Rails
      return api_attribute if api_attribute.start_with?('_')

      # prevent api_attributes from being used unless they are in the public type definition
      unless mappings.key?(api_attribute)
        raise PackAPI::InternalError.new("unknown attribute '#{api_attribute}' for #{@model_type.name}.")
      end

    def api_attribute_names
      api_type.attribute_names
    end

  class APIToModelAttributesTransformer < AbstractTransformer
    def execute
      result = {}
      attribute_names = NormalizedAPIAttribute.new(api_attribute_names)
      data_source.each do |api_attribute, api_value|
        normalized_api_attribute = attribute_names.normalize(api_attribute)
        model_attribute = model_attribute(normalized_api_attribute)
        model_value = transform_value(normalized_api_attribute, api_value)
        result[model_attribute] = model_value
      end
      result
    end

    def execute
      result = {}
      attribute_names = NormalizedAPIAttribute.new(api_attribute_names)
      data_source.each do |api_attribute, api_value|
        normalized_api_attribute = attribute_names.normalize(api_attribute)
        model_attribute = model_attribute(normalized_api_attribute)
        model_value = transform_value(normalized_api_attribute, api_value)
        result[model_attribute] = model_value
      end

  class AttributeHashTransformer < AbstractTransformer
    def execute
      options.fetch(:contains_model_attributes, true) ?
        model_attributes_to_api_attributes :
        api_attributes_to_model_attributes
    end

    protected

    def api_attributes_to_model_attributes
      attribute_names = NormalizedAPIAttribute.new(api_attribute_names)
      result = {}
      data_source.each_key do |api_attribute|
        normalized_api_attribute = attribute_names.normalize(api_attribute)
        next unless mappings.key?(normalized_api_attribute)

        model_attribute = model_attribute(normalized_api_attribute)
        result[model_attribute] = data_source[api_attribute]
      end
      result
    end

    def execute
      options.fetch(:contains_model_attributes, true) ?
        model_attributes_to_api_attributes :
        api_attributes_to_model_attributes
    end

    def api_attributes_to_model_attributes
      attribute_names = NormalizedAPIAttribute.new(api_attribute_names)
      result = {}
      data_source.each_key do |api_attribute|
        normalized_api_attribute = attribute_names.normalize(api_attribute)
        next unless mappings.key?(normalized_api_attribute)

        model_attribute = model_attribute(normalized_api_attribute)
        result[model_attribute] = data_source[api_attribute]
      end

    def model_attributes_to_api_attributes
      reversed_mappings = mappings.invert
      result = {}
      data_source.each_key do |model_attribute|
        next unless reversed_mappings.key?(model_attribute)

        api_attribute = reversed_mappings[model_attribute]
        result[api_attribute] = data_source[model_attribute]
      end

  class AttributeMap
    attr_reader :config, :options

    class << self
      def map(source_attr, to: nil, from_api_attribute: nil, from_model_attribute: nil, readonly: nil, transform_nested_attributes_with: nil)
        @mappings ||= {}
        @from_api_attributes ||= {}
        @from_model_attributes ||= {}
        @transform_nested_attributes_with ||= {}
        @mappings[source_attr] = to || source_attr
        @from_model_attributes[source_attr] = from_model_attribute if from_model_attribute.present?
        @from_api_attributes[source_attr] = from_api_attribute if from_api_attribute.present?
        @transform_nested_attributes_with[source_attr] = transform_nested_attributes_with if transform_nested_attributes_with.present?
        if readonly
          @from_api_attributes[source_attr] = ->(*) { raise PackAPI::InternalError, "Unable to modify read-only attribute '#{source_attr}'" }
        end
      end

      def map(source_attr, to: nil, from_api_attribute: nil, from_model_attribute: nil, readonly: nil, transform_nested_attributes_with: nil)
        @mappings ||= {}
        @from_api_attributes ||= {}
        @from_model_attributes ||= {}
        @transform_nested_attributes_with ||= {}
        @mappings[source_attr] = to || source_attr
        @from_model_attributes[source_attr] = from_model_attribute if from_model_attribute.present?
        @from_api_attributes[source_attr] = from_api_attribute if from_api_attribute.present?
        @transform_nested_attributes_with[source_attr] = transform_nested_attributes_with if transform_nested_attributes_with.present?
        if readonly
          @from_api_attributes[source_attr] = ->(*) { raise PackAPI::InternalError, "Unable to modify read-only attribute '#{source_attr}'" }
        end

      def api_type(api_type = nil)
        return @api_type unless api_type

        @api_type = api_type
      end

      def model_type(model_type = nil)
        return @model_type unless model_type

        @model_type = model_type
      end

      def config
        {
          mappings: @mappings,
          from_api_attributes: @from_api_attributes,
          from_model_attributes: @from_model_attributes,
          transform_nested_attributes_with: @transform_nested_attributes_with,
          api_type: @api_type,
          model_type: @model_type
        }
      end

    def self.model_attribute_keys(hash)
      options = { contains_model_attributes: false,
                  transformer_type_for_source: AttributeHashTransformer.name }
      new(hash.symbolize_keys, options).attributes
    end

    def self.api_attribute_keys(hash)
      options = { contains_model_attributes: true,
                  transformer_type_for_source: AttributeHashTransformer.name }
      new(hash.symbolize_keys, options).attributes
    end

    def initialize(data_source = nil, options = nil)
      @options = DEFAULT_OPTIONS
      @config = self.class.config

      self.options = options
      self.data_source = data_source
    end

    def from_model_attributes
      @from_model_attributes ||= config[:from_model_attributes].transform_values do |proc_or_method_name|
        ValueTransformationChain.new([ValueTransformation.new(self.class, proc_or_method_name, options)])
      end

    def from_api_attributes
      return @from_api_attributes if defined?(@from_api_attributes)

      @from_api_attributes = config[:from_api_attributes].transform_values do |proc_or_method_name|
        ValueTransformationChain.new([ValueTransformation.new(self.class, proc_or_method_name, options)])
      end

    def data_source=(data_source)
      transformer_type = transformer_type_for_source(data_source)
      unless @transformer.is_a?(transformer_type)
        @transformer = transformer_type.new(config_for_adapter_type(transformer_type))
      end

    def data_source
      @transformer&.data_source
    end

    def options=(new_options)
      return if new_options == @provided_options

      @provided_options = new_options
      @options = @provided_options ?
                   DEFAULT_OPTIONS.merge(@provided_options) :
                   DEFAULT_OPTIONS
      from_model_attributes.each_value { |transformation| transformation.kwargs = options }
      @transformer&.options = options
    end

    def register_transformation_from_model_attribute(source_attr, proc_or_method_name)
      from_model_attributes[source_attr] ||= ValueTransformationChain.new([])
      transformation = ValueTransformation.new(self.class, proc_or_method_name, options)
      from_model_attributes[source_attr].transformations << transformation
    end

    def attributes
      @transformer.execute
    end

    def api_type
      self.class.api_type
    end

    def model_type
      self.class.model_type
    end

    def convert_nested_attribute(parent_attribute_value, attribute_map_class:)
      attribute_map = attribute_map_class.new
      if parent_attribute_value.is_a?(Array)
        parent_attribute_value.map do |nested_attributes|
          attribute_map.data_source = nested_attributes
          attribute_map.attributes
        end

    def transformer_type_for_source(source)
      if options.key?(:transformer_type_for_source)
        options[:transformer_type_for_source].constantize
      elsif source.nil?
        NullTransformer
      elsif source.is_a?(Hash)
        APIToModelAttributesTransformer
      elsif source.is_a?(ActiveModel::Errors)
        ErrorHashToAPIAttributesTransformer
      elsif source.is_a?(ActiveModel::AttributeAssignment)
        ModelToAPIAttributesTransformer
      else
        raise "Unknown source #{source}"
      end

    def config_for_adapter_type(adapter_type)
      if [ErrorHashToAPIAttributesTransformer, ModelToAPIAttributesTransformer].include?(adapter_type)
        transform_value = method(:transform_value_for_api)
        config.merge(transform_value:)
      elsif adapter_type == APIToModelAttributesTransformer
        transform_value = method(:transform_value_for_model)
        config.merge(transform_value:)
      else
        config
      end

    def transform_value_for_api(api_attribute, model_value)
      from_model_attributes.key?(api_attribute) ?
        from_model_attributes[api_attribute].call(self, model_value) :
        model_value
    end

    def transform_value_for_model(api_attribute, api_value)
      from_api_attributes.key?(api_attribute) ?
        from_api_attributes[api_attribute].call(self, api_value) :
        api_value
    end

    class ValueTransformation
      attr_reader :proc, :instance_method

      def initialize(klass, proc_or_method_name, kwargs = nil)
        if proc_or_method_name.is_a?(Proc)
          @proc = proc_or_method_name
        else
          @instance_method = klass.instance_method(proc_or_method_name)
        end
        self.kwargs = kwargs
      end

      def initialize(klass, proc_or_method_name, kwargs = nil)
        if proc_or_method_name.is_a?(Proc)
          @proc = proc_or_method_name
        else
          @instance_method = klass.instance_method(proc_or_method_name)
        end

      def call(attribute_map, attribute_value)
        if @kwargs
          proc ?
            attribute_map.instance_exec(attribute_value, **@kwargs, &proc) :
            attribute_map.send(instance_method.name, attribute_value, **@kwargs)
        else
          proc ?
            attribute_map.instance_exec(attribute_value, &proc) :
            attribute_map.send(instance_method.name, attribute_value)
        end

      def kwargs=(new_kwargs)
        @kwargs = new_kwargs == DEFAULT_OPTIONS || new_kwargs.blank? ?
                    nil :
                  supported_kwargs(new_kwargs)
      end

      def supported_kwargs(kwargs)
        return if parameters.empty?

        overlap = parameters.any? { |p| kwargs.key?(p) }
        return unless overlap

        kwargs.slice(*parameters)
      end

      def parameters
        @parameters ||= (proc || instance_method).parameters.map(&:last)
      end

    class ValueTransformationChain
      attr_reader :transformations
      def initialize(transformations)
        @transformations = transformations
      end

      def kwargs=(new_kwargs)
        transformations.each { it.kwargs = new_kwargs }
      end

      def call(attribute_map, attribute_value)
        transformations.reduce(attribute_value) do |prev_result, next_transformation|
          next_transformation.call(attribute_map, prev_result)
        end
      end

      def initialize(transformations)
        @transformations = transformations
      end

      def kwargs=(new_kwargs)
        transformations.each { it.kwargs = new_kwargs }
      end

      def call(attribute_map, attribute_value)
        transformations.reduce(attribute_value) do |prev_result, next_transformation|
          next_transformation.call(attribute_map, prev_result)
        end