praxis 2.0.pre.29 → 2.0.pre.31

data/lib/praxis/mapper/resource.rb

@@ -13,15 +13,42 @@ module Praxis
       end
     end
 
+    # Simple Object that will respond to a set of methods, by simply delegating to the target (will also delegate _resource)
+    class ForwardingStruct
+      extend Forwardable
+      attr_accessor :target
+
+      def self.for(names)
+        Class.new(self) do
+          def_delegator :@target, :_resource
+          def_delegator :@target, :id, :_pk
+          names.each do |(orig, forwarded)|
+            def_delegator :@target, forwarded, orig
+          end
+        end
+      end
+
+      def initialize(target)
+        @target = target
+      end
+    end
+
     class Resource
       extend Praxis::Finalizable
 
       attr_accessor :record
 
       @properties = {}
+      @property_groups = {}
+      @cached_forwarders = {}
+
+      # By default every resource will have the main identifier (by default the id method) accessible through '_pk'
+      def _pk
+        id
+      end
 
       class << self
-        attr_reader :model_map, :properties
+        attr_reader :model_map, :properties, :property_groups, :cached_forwarders
         # Names of the memoizable things (without the @__ prefix)
         attr_accessor :memoized_variables
       end
@@ -42,8 +69,11 @@ module Praxis
                        end
 
           @properties = superclass.properties.clone
+          @property_groups = superclass.property_groups.clone
+          @cached_forwarders = superclass.cached_forwarders.clone
           @registered_batch_computations = {} # hash of attribute_name -> {proc: , with_instance_method: }
           @_filters_map = {}
+          @_order_map = {}
           @memoized_variables = []
         end
       end
@@ -60,10 +90,24 @@ module Praxis
         end
       end
 
-      # The `as:` can be used for properties that correspond to an underlying association of a different name. With this the selector generator, is able to not only add
-      # any extra dependencies needed for the property, but it also follow and pass any incoming nested fields when necessary (as opposed to only add dependencies and discard nested fields)
-      def self.property(name, dependencies: nil, through: nil, as: name) # rubocop:disable Naming/MethodParameterName
-        properties[name] = { dependencies: dependencies, through: through, as: as }
+      # The `as:` can be used for properties that correspond to an underlying association of a different name. With this, the selector generator, is able to
+      # follow and pass any incoming nested fields when necessary (as opposed to only add dependencies and discard nested fields)
+      # No dependencies are allowed to be defined if `as:` is used (as the dependencies should be defined at the final aliased property)
+      def self.property(name, dependencies: nil, as: nil) # rubocop:disable Naming/MethodParameterName
+        raise "Error defining property '#{name}' in #{self}. Property names must be symbols, not strings." unless name.is_a? Symbol
+
+        h = { dependencies: dependencies }
+        if as
+          raise 'Cannot use dependencies for a property when using the "as:" keyword' if dependencies.presence
+
+          h.merge!({ as: as })
+        end
+        properties[name] = h
+      end
+
+      # Saves the name of the group, and the associated mediatype where the group attributes are defined at
+      def self.property_group(name, media_type)
+        property_groups[name] = media_type
       end
 
       def self.batch_computed(attribute, with_instance_method: true, &block)
@@ -81,14 +125,55 @@ module Praxis
       end
 
       def self._finalize!
+        validate_properties
         finalize_resource_delegates
         define_batch_processors
         define_model_accessors
+        define_property_groups
 
         hookup_callbacks
         super
       end
 
+      def self.validate_properties
+        # Disabled for now
+        # errors = detect_invalid_properties
+        # unless errors.nil?
+        #   raise StandardError, errors
+        # end
+      end
+
+      # Verifies if the system has badly defined properties
+      # For example, properties that correspond to an underlying association method (for which there is no
+      # overriden method in the resource) must not have dependencies defined, as it is clear the association is the only one
+      def self.detect_invalid_properties
+        return nil unless !model.nil? && model.respond_to?(:_praxis_associations)
+
+        invalid = {}
+        existing_associations = model._praxis_associations.keys
+        properties.slice(*existing_associations).each do |prop_name, data|
+          # If we have overriden the assoc with our own method, we allow you to define deps (or as: aliases)
+          next if instance_methods.include? prop_name
+
+          example_def = "property #{prop_name} "
+          example_def.concat("dependencies: #{data[:dependencies]}") if data[:dependencies].presence
+          example_def.concat("as: #{data[:as]}") if data[:as].presence
+          # If we haven't overriden the method, we'll create an accessor, so defining deps does not make sense
+          error = "Bad definition of property '#{prop_name}'. Method #{prop_name} is already an association " \
+                  "which will be properly wrapped with an accessor, so you do not need to define it as a property.\n" \
+                  "Current definition looks like: #{example_def}\n"
+          invalid[prop_name] = error
+        end
+        unless invalid.empty?
+          msg = "Error defining one or more propeties in resource #{name}.\n".dup
+          invalid.each_value { |err| msg.concat err }
+          msg.concat 'Only define properties for methods that you override in the resource, as a way to specify which dependencies ' \
+                  "that requires to use inside it\n"
+          return msg
+        end
+        nil
+      end
+
       def self.define_batch_processors
         return unless @registered_batch_computations.presence
 
@@ -99,11 +184,11 @@ module Praxis
           end
           next unless opts[:with_instance_method]
 
-          # Define the instance method for it to call the batch processor...passing its 'id' and value
+          # Define the instance method for it to call the batch processor...passing its _pk (i.e., 'id' by default) and value
           # This can be turned off by setting :with_instance_method, in case the 'id' of a resource
-          # it is not called 'id' (simply define an instance method similar to this one below)
+          # it is not called 'id' (simply define an instance method similar to this one below or redefine '_pk')
           define_method(name) do
-            self.class::BatchProcessors.send(name, rows_by_id: { id => self })[id]
+            self.class::BatchProcessors.send(name, rows_by_id: { id => self })[_pk]
           end
         end
       end
@@ -128,11 +213,28 @@ module Praxis
         end
       end
 
+      def self.validate_associations_path(model, path)
+        first, *rest = path
+
+        assoc = model._praxis_associations[first]
+        return first unless assoc
+
+        rest.presence ? validate_associations_path(assoc[:model], rest) : nil
+      end
+
       def self.define_aliased_methods
-        with_different_alias_name = properties.reject { |name, opts| name == opts[:as] }
+        with_different_alias_name = properties.reject { |name, opts| name == opts[:as] || opts[:as].nil? }
+
         with_different_alias_name.each do |prop_name, opts|
           next if instance_methods.include? prop_name
 
+          # Check that the as: symbol, or each of the dotten notation names are pure association names in the corresponding resources, aliases aren't supported"
+          unless opts[:as] == :self
+            raise "Cannot define property #{prop_name} with an `as:` option (#{opts[:as]}) for resource (#{name}) because it does not have associations!" unless model.respond_to?(:_praxis_associations)
+
+            raise "Invalid property definition named #{prop_name} for `as:` value '#{opts[:as]}': this association name/path does not exist" if validate_associations_path(model, opts[:as].to_s.split('.').map(&:to_sym))
+          end
+
           # Straight call to another association method (that we will generate automatically in our association accessors)
           module_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{prop_name}
@@ -142,6 +244,29 @@ module Praxis
         end
       end
 
+      # Defines the dependencies and the method of a property group
+      # The dependencies are going to be defined as the methods that wrap the group's attributes i.e., 'group_attribute1'
+      # The method defined will return a ForwardingStruct object instance, that will simply define a method name for each existing property
+      # which simply calls the underlying 'group name' prefixed methods on the original object
+      # For example: if we have a group named 'grouping', which has 'name' and 'phone' attributes defined.
+      # - the property dependencies will be defined as: property :grouping, dependencies: [:name, :phone]
+      # - the 'grouping' method will return an instance object, that will respond to 'name' (and forward to 'grouping_name') and to 'phone'
+      #   (and forward to 'grouping_phone')
+      def self.define_property_groups
+        property_groups.each do |(name, media_type)|
+          # Set a property for their dependencies using the "group"_"attribute"
+          prefixed_property_deps = media_type.attribute.attributes[name].type.attributes.keys.each_with_object({}) do |key, hash|
+            hash[key] = "#{name}_#{key}".to_sym
+          end
+          property name, dependencies: prefixed_property_deps.values
+          @cached_forwarders[name] = ForwardingStruct.for(prefixed_property_deps)
+
+          define_method(name) do
+            self.class.cached_forwarders[name].new(self)
+          end
+        end
+      end
+
       def self.hookup_callbacks
         return unless ancestors.include?(Praxis::Mapper::Resources::Callbacks)
 
@@ -229,15 +354,16 @@ module Praxis
 
         return unless association_resource_class
 
+        association_resource_class_name = "::#{association_resource_class}" # Ensure we point at classes globally
         memoized_variables << name
 
         # Add the call to wrap (for true collections) or simply for_record if it's a n:1 association
         wrapping = \
           case association_spec.fetch(:type)
           when :one_to_many, :many_to_many
-            "@__#{name} ||= #{association_resource_class}.wrap(records)"
+            "@__#{name} ||= #{association_resource_class_name}.wrap(records)"
           else
-            "@__#{name} ||= #{association_resource_class}.for_record(records)"
+            "@__#{name} ||= #{association_resource_class_name}.for_record(records)"
           end
 
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
@@ -322,6 +448,21 @@ module Praxis
           end
       end
 
+      def self.order_mapping(definition = nil)
+        if definition.nil?
+          @_order_map ||= {} # initialize to empty hash by default
+          return @_order_map
+        end
+
+        @_order_map = \
+          case definition
+          when Hash
+            definition.transform_values(&:to_s)
+          else
+            raise 'Resource.orders_mapping only allows a hash'
+          end
+      end
+
       def self.craft_filter_query(base_query, filters:)
         if filters
           raise "To use API filtering, you must define the mapping of api-names to resource properties (using the `filters_mapping` method in #{self})" unless @_filters_map
@@ -342,15 +483,15 @@ module Praxis
         base_query
       end
 
-      def self.craft_pagination_query(base_query, pagination:)
+      def self.craft_pagination_query(base_query, pagination:, selectors:)
         handler_klass = model._pagination_query_builder_class
         return base_query unless handler_klass && (pagination.paginator || pagination.order)
 
         # Gather and save the count if required
         pagination.total_count = handler_klass.count(base_query.dup) if pagination.paginator&.total_count
 
-        base_query = handler_klass.order(base_query, pagination.order)
-        handler_klass.paginate(base_query, pagination)
+        base_query = handler_klass.order(base_query, pagination.order, root_resource: selectors.resource)
+        handler_klass.paginate(base_query, pagination, root_resource: selectors.resource)
       end
 
       def initialize(record)

data/lib/praxis/mapper/selector_generator.rb

@@ -3,35 +3,148 @@
 module Praxis
   module Mapper
     class SelectorGeneratorNode
-      attr_reader :select, :model, :resource, :tracks
+      # prepend SelectorGeneratorNodeDebugger # Uncomment this to see the traces of how methods are called
+      attr_reader :select, :model, :resource, :tracks, :fields_node
+
+      # FieldDependenciesNode, attached to a SelectorGeneratorNode, which will contain, for every field passed in (not properties, but fields), the
+      # list of property dependencies associated with them.
+      # If these property dependenceis are for the 'local' resource of the SelectorGeneratorNode, they'd be just an array of property names
+      # If a field is a property that is an association to another resource, the reference field  will point to which other node it depends on
+      # (this node fields does not need to be one of the immediate tracks, but it could be further down the tracks SelectorGeneratorNode's tree)
+      # In the case of references, any further resolution of dependencies from fields need to be continued in that track's SelectorGenerator's FieldDependenciesNode (recursively)
+      class FieldDependenciesNode
+        attr_reader :deps, :fields, :selector_node
+        attr_accessor :references
+
+        def initialize(name:, selector_node:)
+          @name = name
+          @fields = Hash.new do |hash, key|
+            hash[key] = FieldDependenciesNode.new(name: key, selector_node: selector_node)
+          end
+          @deps = Set.new
+          @references = nil
+          # Field path, currently being processed
+          @current_field = []
+          @selector_node = selector_node
+        end
+
+        def start_field(field_name)
+          @current_field.push field_name
+        end
+
+        def end_field
+          @current_field.pop
+        end
+
+        def add_local_dep(name)
+          pointer = @current_field.empty? ? @fields[true] : @fields.dig(*@current_field)
+          pointer.deps.add name
+        end
+
+        def save_reference(selector_node)
+          pointer = @current_field.empty? ? @fields[true] : @fields.dig(*@current_field)
+          pointer.references = selector_node
+        end
+
+        def dig(...)
+          @fields.dig(...) # rubocop:disable Style/SingleArgumentDig
+        end
+
+        def [](*path)
+          @fields.dig(*path)
+        end
+
+        # For spec/debugging purposes only
+        def dump
+          hash = {}
+          hash[:deps] = @deps.to_a unless @deps.empty?
+          unless @references.nil?
+            # Point, using a simple string, that it references another node (just print the resource name)
+            # We don't know how deep in the tree this will be, or if there are other nodes of the same resource
+            # type, but it seems good enough for checking things in specs
+            hash[:references] = "Linked to resource: #{@references.resource}"
+          end
+          field_deps = @fields.each_with_object({}) do |(name, node), h|
+            dumped = node.dump
+            h[name] = dumped unless dumped.empty?
+          end
+          hash[:fields] = field_deps unless field_deps.empty?
+          hash
+        end
+      end
 
       def initialize(resource)
         @resource = resource
-
         @select = Set.new
         @select_star = false
+        @fields_node = FieldDependenciesNode.new(name: '/', selector_node: self)
         @tracks = {}
       end
 
+      def inspect
+        "<#{self.class}# @resource=#{@resource.name} @select=#{@select} @select_star=#{@select_star} tracking: #{@tracks.keys} (recursion omited)>"
+      end
+
       def add(fields)
         fields.each do |name, field|
+          fields_node.start_field(name)
           map_property(name, field)
+          fields_node.end_field
         end
-        self
       end
 
-      def map_property(name, fields)
+      def map_property(name, fields, as_dependency: false)
         praxis_compat_model = resource.model&.respond_to?(:_praxis_associations)
         if resource.properties.key?(name)
-          add_property(name, fields)
+          if (target = resource.properties[name][:as])
+            leaf_node = add_fwding_property(name, fields)
+            fields_node.save_reference(leaf_node) unless target == :self
+          else
+            add_property(name, fields)
+          end
+          fields_node.add_local_dep(name)
         elsif praxis_compat_model && resource.model._praxis_associations.key?(name)
           add_association(name, fields)
+          # Single association properties are also pointing to the corresponding tracked SelectorGeneratorNode
+          # but only if they are implicit properties, without dependencies
+          if as_dependency
+            fields_node.add_local_dep(name)
+          else
+            fields_node.save_reference(tracks[name])
+          end
         else
           add_select(name)
         end
       end
 
+      def add_string_association(first, *rest)
+        association = resource.model._praxis_associations.fetch(first) do
+          raise "missing association for #{resource} with name #{first}"
+        end
+        associated_resource = resource.model_map[association[:model]]
+        raise "Whoops! could not find a resource associated with model #{association[:model]} (root resource #{resource})" unless associated_resource
+
+        # Add the required columns in this model to make sure the association can be loaded
+        association[:local_key_columns].each { |col| add_select(col, add_field: false) }
+
+        node = SelectorGeneratorNode.new(associated_resource)
+        unless association[:remote_key_columns].empty?
+          # Make sure we add the required columns for this association to the remote model query
+          fields = {}
+          new_fields_as_hash = association[:remote_key_columns].each_with_object({}) do |key, hash|
+            hash[key] = true
+          end
+          fields = fields.merge(new_fields_as_hash)
+        end
+
+        node.add(fields) unless fields == true
+        leaf_node = rest.empty? ? nil : node.add_string_association(*rest)
+        merge_track(first, node)
+        leaf_node || node # Return the leaf (i.e., us, if we're the last component or the result of the string_association if there was one)
+      end
+
       def add_association(name, fields)
+        # fields_node.retrieve_last_of_chain = true
         association = resource.model._praxis_associations.fetch(name) do
           raise "missing association for #{resource} with name #{name}"
         end
@@ -39,7 +152,7 @@ module Praxis
         raise "Whoops! could not find a resource associated with model #{association[:model]} (root resource #{resource})" unless associated_resource
 
         # Add the required columns in this model to make sure the association can be loaded
-        association[:local_key_columns].each { |col| add_select(col) }
+        association[:local_key_columns].each { |col| add_select(col, add_field: false) }
 
         node = SelectorGeneratorNode.new(associated_resource)
         unless association[:remote_key_columns].empty?
@@ -54,68 +167,100 @@ module Praxis
         node.add(fields) unless fields == true
 
         merge_track(name, node)
+        node
       end
 
-      def add_select(name)
+      def add_select(name, add_field: true)
         return @select_star = true if name == :*
         return if @select_star
 
+        # Do not add a field dependency, if we know we're just adding a Local/FK constraint
+        @fields_node.add_local_dep(name) if add_field
         @select.add name
       end
 
+      def add_fwding_property(name, fields)
+        aliased_as = resource.properties[name][:as]
+        if aliased_as == :self
+          # Special keyword to add itself as the association, but still continue procesing the fields
+          # This is useful when we expose resource fields tucked inside another sub-struct, this way
+          # we can make sure that if the fields necessary to compute things inside the struct, they are preloaded
+          add(fields) unless fields == true
+        else
+          # Assumes (as: option of the property DSL should check check) that all forwarded properties need to be pure associations
+          # We know we've now added the chain of association dependencies under our node...so we'll start getting the 'first' of them
+          # and recurse down the node until the leaf.
+          # Then, we need to apply the incoming fields to that.
+          leaf_node = add_string_association(*aliased_as.to_s.split('.').map(&:to_sym))
+          leaf_node.add(fields) unless fields == true # If true, no fields to apply
+          leaf_node
+        end
+      end
+
       def add_property(name, fields)
         dependencies = resource.properties[name][:dependencies]
         # Always add the underlying association if we're overriding the name...
         if (praxis_compat_model = resource.model&.respond_to?(:_praxis_associations))
           aliased_as = resource.properties[name][:as]
-          if aliased_as == :self
-            # Special keyword to add itself as the association, but still continue procesing the fields
-            # This is useful when we expose resource fields tucked inside another sub-struct, this way
-            # we can make sure that if the fields necessary to compute things inside the struct, they are preloaded
-            add(fields)
-          else
-            first, *rest = aliased_as.to_s.split('.').map(&:to_sym)
-
-            extended_fields = \
-              if rest.empty?
-                fields
-              else
-                rest.reverse.inject(fields) do |accum, prop|
-                  { prop => accum }
+          if aliased_as
+            if aliased_as == :self
+              # Special keyword to add itself as the association, but still continue procesing the fields
+              # This is useful when we expose resource fields tucked inside another sub-struct, this way
+              # we can make sure that if the fields necessary to compute things inside the struct, they are preloaded
+              add(fields)
+            else
+              first, *rest = aliased_as.to_s.split('.').map(&:to_sym)
+
+              extended_fields = \
+                if rest.empty?
+                  fields
+                else
+                  rest.reverse.inject(fields) do |accum, prop|
+                    { prop => accum }
+                  end
                 end
-              end
-            add_association(first, extended_fields) if resource.model._praxis_associations[first]
-          end
-        end
-        dependencies&.each do |dependency|
-          # To detect recursion, let's allow mapping depending fields to the same name of the property
-          # but properly detecting if it's a real association...in which case we've already added it above
-          if dependency == name
-            add_select(name) unless praxis_compat_model && resource.model._praxis_associations.key?(name)
-          else
-            apply_dependency(dependency)
+
+              add_association(first, extended_fields) if resource.model._praxis_associations[first]
+            end
+          elsif resource.model._praxis_associations[name]
+            # Not aliased ... but if there is an existing association for the propety name, we add it (and ignore any deps in place)
+            add_association(name, fields)
           end
         end
+        # If we have a property group, and the subfields want to selectively restrict what to depend on
+        if fields != true && resource.property_groups[name]
+          # Prepend the group name to fields if it's an inner hash
+          prefixed_fields = fields == true ? {} : fields.keys.each_with_object({}) { |k, h| h["#{name}_#{k}".to_sym] = k }
+          # Try to match all inner fields
+          prefixed_fields.each do |prefixedname, origfieldname|
+            next unless dependencies.include?(prefixedname)
 
-        head, *tail = resource.properties[name][:through]
-        return if head.nil?
-
-        new_fields = tail.reverse.inject(fields) do |thing, step|
-          { step => thing }
+            fields_node.start_field(origfieldname) # Mark it as orig name
+            apply_dependency(prefixedname, fields[origfieldname])
+            fields_node.end_field
+          end
+        else
+          dependencies&.each do |dependency|
+            # To detect recursion, let's allow mapping depending fields to the same name of the property
+            # but properly detecting if it's a real association...in which case we've already added it above
+            if dependency == name
+              add_select(name) unless praxis_compat_model && resource.model._praxis_associations.key?(name)
+            else
+              apply_dependency(dependency)
+            end
+          end
         end
-
-        add_association(head, new_fields)
       end
 
-      def apply_dependency(dependency)
+      def apply_dependency(dependency, fields = true)
         case dependency
         when Symbol
-          map_property(dependency, true)
+          map_property(dependency, fields, as_dependency: true)
         when String
           head, *tail = dependency.split('.').collect(&:to_sym)
           raise 'String dependencies can not be singular' if tail.nil?
 
-          add_association(head, tail.reverse.inject({}) { |hash, dep| { dep => hash } })
+          add_association(head, tail.reverse.inject(true) { |hash, dep| { dep => hash } })
         end
       end
 
@@ -135,13 +280,26 @@ module Praxis
         end
       end
 
-      def dump
+      # Debugging method for rspec, to easily match the desired output
+      # By default it only outputs the info related to computing columns and track dependencies.
+      # Overriding the mode will allow to dump the model and only the field dependencies
+      def dump(mode: :columns_and_tracks)
         hash = {}
         hash[:model] = resource.model
-        if !@select.empty? || @select_star
-          hash[:columns] = @select_star ? [:*] : @select.to_a
+        case mode
+        when :columns_and_tracks
+          if !@select.empty? || @select_star
+            hash[:columns] = @select_star ? [:*] : @select.to_a
+          end
+        when :fields
+          dumped_fields_node = @fields_node.dump
+          raise "Fields node has more keys than fields!! #{dumped_fields_node}" if dumped_fields_node.keys.size > 1
+
+          hash[:fields] = dumped_fields_node[:fields] if dumped_fields_node[:fields]
+        else
+          raise "Unknown mode #{mode} for dumping SelectorGenerator"
         end
-        hash[:tracks] = @tracks.transform_values(&:dump) unless @tracks.empty?
+        hash[:tracks] = @tracks.transform_values { |v| v.dump(mode: mode) } unless @tracks.empty?
         hash
       end
     end
@@ -149,6 +307,8 @@ module Praxis
     # Generates a set of selectors given a resource and
     # list of resource attributes.
     class SelectorGenerator
+      attr_reader :root
+
       # Entry point
       def add(resource, fields)
         @root = SelectorGeneratorNode.new(resource)
@@ -159,6 +319,48 @@ module Praxis
       def selectors
         @root
       end
+
+      def inspect
+        "<#{self.class}# @root=#{@root.inspect}>"
+      end
+    end
+
+    # Includeable module to trace the execution of the method call tree while building the Nodes
+    module SelectorGeneratorNodeDebugger
+      def add(fields)
+        puts "ADD fields: #{fields}"
+        super
+      end
+
+      def map_property(name, fields, **args)
+        puts "MAP PROP #{name} fields: #{fields} (args: #{args})"
+        super
+      end
+
+      def add_association(name, fields, **args)
+        puts "ADD ASSOCIATION #{name} fields: #{fields} (args: #{args})"
+        super
+      end
+
+      def add_select(name, add_field: true)
+        puts "ADD SELECT #{name} (add field: #{add_field})"
+        super
+      end
+
+      def add_fwding_property(name, fields)
+        puts "ADD FWD ASSOC #{name} fields: #{fields}"
+        super
+      end
+
+      def add_property(name, fields)
+        puts "ADD PROP #{name} fields: #{fields}"
+        super
+      end
+
+      def apply_dependency(dependency, fields = true)
+        puts "APPLY DEP #{dependency} fields: #{fields}"
+        super
+      end
     end
   end
 end

data/lib/praxis/media_type_identifier.rb

@@ -190,7 +190,7 @@ module Praxis
 
       suffix = parameters.shift unless parameters.first.include?('=')
       # remove redundant '+'
-      suffix = suffix[1..-1] if suffix && suffix[0] == '+'
+      suffix = suffix[1..] if suffix && suffix[0] == '+'
 
       parameters = parameters.each_with_object({}) do |e, h|
         k, v = e.split('=', 2)