graphql 0.18.0 → 0.18.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 02de1641b3342ae2dfb6688305141f876b853641
-  data.tar.gz: bca7585eba3aae30e0804b1f6a475df2cf390adc
+  metadata.gz: 4320e19052975ac0ba38fac054d7d56d044657e1
+  data.tar.gz: 2045f552c2acd454a57f4c0ec80f9547f7c6b875
 SHA512:
-  metadata.gz: f2fd6a0147a92875211ff050335d0c476e8119754bc47738f05237e48be231ffb221c3743b70bf3df2ed654b08bffec4f760b9279a63331624046af295d22218
-  data.tar.gz: 5b27edb6d609026598ed2f91a17dd34ec622d666c8dfc1cb95f06bc55aa6152363b690960e790b794ffb25d5b1d72ddf9dd7aa7f163ad6a680a5528697ed0aba
+  metadata.gz: 0db74452c453b954039a685aaa25ad875325de13c0f7eb152dd4ff09a139048b73c83ce637cc84b7824ffb4311ce1de0041b671444a4a208131bb49ed71c6dc9
+  data.tar.gz: bf2b4faf5545b8d13ee5ab3b370e9ea4ab4954e40f458a87b2551bf666e97e4d27270b618b2644b1cdc56f48d7681b48edf3ac74171ce9cc37d113a6bff5d7d6

data/lib/graphql/define.rb

@@ -3,8 +3,26 @@ require "graphql/define/assign_connection"
 require "graphql/define/assign_enum_value"
 require "graphql/define/assign_global_id_field"
 require "graphql/define/assign_object_field"
-require "graphql/define/assignment_dictionary"
 require "graphql/define/defined_object_proxy"
 require "graphql/define/instance_definable"
 require "graphql/define/non_null_with_bang"
 require "graphql/define/type_definer"
+
+module GraphQL
+  module Define
+    # A helper for definitions that store their value in `#metadata`.
+    #
+    # @example Storing application classes with GraphQL types
+    #   # Make a custom definition
+    #   GraphQL::ObjectType.accepts_definitions(resolves_to_class_names: GraphQL::Define.assign_metadata_key(:resolves_to_class_names))
+    #
+    #   # After definition, read the key from metadata
+    #   PostType.metadata[:resolves_to_class_names] # => [...]
+    #
+    # @param [Object] the key to assign in metadata
+    # @return [#call(defn, value)] an assignment for `.accepts_definitions` which writes `key` to `#metadata`
+    def self.assign_metadata_key(key)
+      GraphQL::Define::InstanceDefinable::AssignMetadataKey.new(key)
+    end
+  end
+end

data/lib/graphql/define/instance_definable.rb

@@ -1,22 +1,36 @@
 module GraphQL
   module Define
-    # This module provides the `.define { ... }` API for {GraphQL::BaseType}, {GraphQL::Field}, {GraphQL::Argument} and {GraphQL::Directive}.
+    # This module provides the `.define { ... }` API for
+    # {GraphQL::BaseType}, {GraphQL::Field} and others.
+    #
+    # Calling `.accepts_definitions(...)` creates:
+    #
+    # - a keyword to the `.define` method
+    # - a helper method in the `.define { ... }` block
+    #
+    # The `.define { ... }` block will be called lazily. To be sure it has been
+    # called, use the private method `#ensure_defined`. That will call the
+    # definition block if it hasn't been called already.
     #
     # The goals are:
+    #
     # - Minimal overhead in consuming classes
     # - Independence between consuming classes
     # - Extendable by third-party libraries without monkey-patching or other nastiness
     #
     # @example Make a class definable
     #   class Car
-    #     attr_accessor :make, :model, :all_wheel_drive
-    #
+    #     attr_accessor :make, :model
     #     accepts_definitions(
     #       # These attrs will be defined with plain setters, `{attr}=`
     #       :make, :model,
     #       # This attr has a custom definition which applies the config to the target
     #       doors: -> (car, doors_count) { doors_count.times { car.doors << Door.new } }
     #     )
+    #
+    #     def initialize
+    #       @doors = []
+    #     end
     #   end
     #
     #   # Create an instance with `.define`:
@@ -31,7 +45,7 @@ module GraphQL
     #
     # @example Extending the definition of a class
     #   # Add some definitions:
-    #   Car.accepts_definitions(:all_wheel_drive)
+    #   Car.accepts_definitions(all_wheel_drive: GraphQL::Define.assign_metadata_key(:all_wheel_drive))
     #
     #   # Use it in a definition
     #   subaru_baja = Car.define do
@@ -39,6 +53,9 @@ module GraphQL
     #     all_wheel_drive true
     #   end
     #
+    #   # Access it from metadata
+    #   subaru_baja.metadata[:all_wheel_drive] # => true
+    #
     module InstanceDefinable
       def self.included(base)
         base.extend(ClassMethods)
@@ -50,6 +67,14 @@ module GraphQL
         @definition_proc = defn_block
       end
 
+      # `metadata` can store arbitrary key-values with an object.
+      #
+      # @return [Hash<Object, Object>] Hash for user-defined storage
+      def metadata
+        ensure_defined
+        @metadata ||= {}
+      end
+
       private
 
       # Run the definition block if it hasn't been run yet.
@@ -91,7 +116,17 @@ module GraphQL
         # Each symbol in `accepts` will be assigned with `{key}=`.
         # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
         def accepts_definitions(*accepts)
-          @own_dictionary = own_dictionary.merge(AssignmentDictionary.create(*accepts))
+          new_assignments = if accepts.last.is_a?(Hash)
+            accepts.pop.dup
+          else
+            {}
+          end
+
+          accepts.each do |key|
+            new_assignments[key] = AssignAttribute.new(key)
+          end
+
+          @own_dictionary = own_dictionary.merge(new_assignments)
         end
 
         # Define a reader and writer for each of `attr_names` which
@@ -125,6 +160,26 @@ module GraphQL
           @own_dictionary ||= {}
         end
       end
+
+      class AssignMetadataKey
+        def initialize(key)
+          @key = key
+        end
+
+        def call(defn, value)
+          defn.metadata[@key] = value
+        end
+      end
+
+      class AssignAttribute
+        def initialize(attr_name)
+          @attr_assign_method = :"#{attr_name}="
+        end
+
+        def call(defn, value)
+          defn.public_send(@attr_assign_method, value)
+        end
+      end
     end
   end
 end

data/lib/graphql/relay.rb

@@ -10,4 +10,5 @@ require 'graphql/relay/relation_connection'
 require 'graphql/relay/global_id_resolve'
 require 'graphql/relay/mutation'
 require 'graphql/relay/connection_field'
+require 'graphql/relay/connection_resolve'
 require 'graphql/relay/connection_type'

data/lib/graphql/relay/array_connection.rb

@@ -18,7 +18,7 @@ module GraphQL
 
       # apply first / last limit results
       def paged_nodes
-        @paged_nodes = begin
+        @paged_nodes ||= begin
           items = sliced_nodes
 
           if limit
@@ -31,10 +31,7 @@ module GraphQL
 
       # Apply cursors to edges
       def sliced_nodes
-        @sliced_nodes ||= begin
-          items = object
-          items[starting_offset..-1]
-        end
+        @sliced_nodes ||= nodes[starting_offset..-1]
       end
 
       def index_from_cursor(cursor)

data/lib/graphql/relay/base_connection.rb

@@ -6,11 +6,13 @@ module GraphQL
     #   - {#paged_nodes}, which applies `first` & `last` limits
     #
     # In a subclass, you have access to
-    #   - {#object}, the object which the connection will wrap
+    #   - {#nodes}, the collection which the connection will wrap
     #   - {#first}, {#after}, {#last}, {#before} (arguments passed to the field)
     #   - {#max_page_size} (the specified maximum page size that can be returned from a connection)
     #
     class BaseConnection
+      extend Gem::Deprecate
+
       # Just to encode data in the cursor, use something that won't conflict
       CURSOR_SEPARATOR = "---"
 
@@ -18,49 +20,57 @@ module GraphQL
       # eg {"Array" => ArrayConnection}
       CONNECTION_IMPLEMENTATIONS = {}
 
-      # Find a connection implementation suitable for exposing `items`
-      #
-      # @param [Object] A collection of items (eg, Array, AR::Relation)
-      # @return [subclass of BaseConnection] a connection Class for wrapping `items`
-      def self.connection_for_items(items)
-        # We check class membership by comparing class names rather than
-        # identity to prevent this from being broken by Rails autoloading.
-        # Changes to the source file for ItemsClass in Rails apps cause it to be
-        # reloaded as a new object, so if we were to use `is_a?` here, it would
-        # no longer match any registered custom connection types.
-        ancestor_names = items.class.ancestors.map(&:name)
-        implementation = CONNECTION_IMPLEMENTATIONS.find do |items_class_name, connection_class|
-          ancestor_names.include? items_class_name
+      class << self
+        extend Gem::Deprecate
+
+        # Find a connection implementation suitable for exposing `nodes`
+        #
+        # @param [Object] A collection of nodes (eg, Array, AR::Relation)
+        # @return [subclass of BaseConnection] a connection Class for wrapping `nodes`
+        def connection_for_nodes(nodes)
+          # Check for class _names_ because classes can be redefined in Rails development
+          ancestor_names = nodes.class.ancestors.map(&:name)
+          implementation = CONNECTION_IMPLEMENTATIONS.find do |nodes_class_name, connection_class|
+            ancestor_names.include? nodes_class_name
+          end
+          if implementation.nil?
+            raise("No connection implementation to wrap #{nodes.class} (#{nodes})")
+          else
+            implementation[1]
+          end
         end
-        if implementation.nil?
-          raise("No connection implementation to wrap #{items.class} (#{items})")
-        else
-          implementation[1]
+
+        # Add `connection_class` as the connection wrapper for `nodes_class`
+        # eg, `RelationConnection` is the implementation for `AR::Relation`
+        # @param [Class] A class representing a collection (eg, Array, AR::Relation)
+        # @param [Class] A class implementing Connection methods
+        def register_connection_implementation(nodes_class, connection_class)
+          CONNECTION_IMPLEMENTATIONS[nodes_class.name] = connection_class
         end
-      end
 
-      # Add `connection_class` as the connection wrapper for `items_class`
-      # eg, `RelationConnection` is the implementation for `AR::Relation`
-      # @param [Class] A class representing a collection (eg, Array, AR::Relation)
-      # @param [Class] A class implementing Connection methods
-      def self.register_connection_implementation(items_class, connection_class)
-        CONNECTION_IMPLEMENTATIONS[items_class.name] = connection_class
+        # @deprecated use {#connection_for_nodes} instead
+        alias :connection_for_items :connection_for_nodes
+        deprecate(:connection_for_items, :connection_for_nodes, 2016, 9)
       end
 
-      attr_reader :object, :arguments, :max_page_size, :parent
+      attr_reader :nodes, :arguments, :max_page_size, :parent
 
-      # Make a connection, wrapping `object`
-      # @param The collection of results
+      # Make a connection, wrapping `nodes`
+      # @param [Object] The collection of nodes
       # @param Query arguments
       # @param max_page_size [Int] The maximum number of results to return
       # @param parent [Object] The object which this collection belongs to
-      def initialize(object, arguments, max_page_size: nil, parent: nil)
-        @object = object
+      def initialize(nodes, arguments, max_page_size: nil, parent: nil)
+        @nodes = nodes
         @arguments = arguments
         @max_page_size = max_page_size
         @parent = parent
       end
 
+      # @deprecated use {#nodes} instead
+      alias :object :nodes
+      deprecate(:object, :nodes, 2016, 9)
+
       # Provide easy access to provided arguments:
       METHODS_FROM_ARGUMENTS = [:first, :after, :last, :before, :order]
 
@@ -80,7 +90,7 @@ module GraphQL
         end
       end
 
-      # These are the items to render for this connection,
+      # These are the nodes to render for this connection,
       # probably wrapped by {GraphQL::Relay::Edge}
       def edge_nodes
         @edge_nodes ||= paged_nodes
@@ -127,11 +137,11 @@ module GraphQL
       private
 
       def paged_nodes
-        raise NotImplementedError, "must return items for this connection after paging"
+        raise NotImplementedError, "must return nodes for this connection after paging"
       end
 
       def sliced_nodes
-        raise NotImplementedError, "must return  all items for this connection after chopping off first and last"
+        raise NotImplementedError, "must return  all nodes for this connection after chopping off first and last"
       end
     end
   end

data/lib/graphql/relay/connection_field.rb

@@ -1,11 +1,11 @@
 module GraphQL
   module Relay
-    # Provided a GraphQL field which returns a collection of items,
-    # `ConnectionField.create` modifies that field to expose those items
+    # Provided a GraphQL field which returns a collection of nodes,
+    # `ConnectionField.create` modifies that field to expose those nodes
     # as a collection.
     #
-    # The original resolve proc is used to fetch items,
-    # then a connection implementation is fetched with {BaseConnection.connection_for_items}.
+    # The original resolve proc is used to fetch nodes,
+    # then a connection implementation is fetched with {BaseConnection.connection_for_nodes}.
     class ConnectionField
       ARGUMENT_DEFINITIONS = [
           ["first", GraphQL::INT_TYPE, "Returns the first _n_ elements from the list."],
@@ -27,28 +27,15 @@ module GraphQL
       # Turn A GraphQL::Field into a connection by:
       # - Merging in the default arguments
       # - Transforming its resolve function to return a connection object
-      # @param [GraphQL::Field] A field which returns items to be wrapped as a connection
-      # @param max_page_size [Integer] The maximum number of items which may be requested (if a larger page is requested, it is limited to this number)
-      # @return [GraphQL::Field] A field which serves a connections
+      # @param [GraphQL::Field] A field which returns nodes to be wrapped as a connection
+      # @param max_page_size [Integer] The maximum number of nodes which may be requested (if a larger page is requested, it is limited to this number)
+      # @return [GraphQL::Field] The same field, modified to resolve to a connection object
       def self.create(underlying_field, max_page_size: nil)
         underlying_field.arguments = DEFAULT_ARGUMENTS.merge(underlying_field.arguments)
         original_resolve = underlying_field.resolve_proc
-        underlying_field.resolve = get_connection_resolve(underlying_field.name, original_resolve, max_page_size: max_page_size)
+        underlying_field.resolve = GraphQL::Relay::ConnectionResolve.new(underlying_field.name, original_resolve, max_page_size: max_page_size)
         underlying_field
       end
-
-      private
-
-      # Wrap the original resolve proc
-      # so you capture its value, then wrap it in a
-      # connection implementation
-      def self.get_connection_resolve(field_name, underlying_resolve, max_page_size: nil)
-        -> (obj, args, ctx) {
-          items = underlying_resolve.call(obj, args, ctx)
-          connection_class = GraphQL::Relay::BaseConnection.connection_for_items(items)
-          connection_class.new(items, args, max_page_size: max_page_size, parent: obj)
-        }
-      end
     end
   end
 end

data/lib/graphql/relay/connection_resolve.rb

@@ -0,0 +1,17 @@
+module GraphQL
+  module Relay
+    class ConnectionResolve
+      def initialize(field_name, underlying_resolve, max_page_size: nil)
+        @field_name = field_name
+        @underlying_resolve = underlying_resolve
+        @max_page_size = max_page_size
+      end
+
+      def call(obj, args, ctx)
+        nodes = @underlying_resolve.call(obj, args, ctx)
+        connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(nodes)
+        connection_class.new(nodes, args, max_page_size: @max_page_size, parent: obj)
+      end
+    end
+  end
+end

data/lib/graphql/relay/relation_connection.rb

@@ -22,18 +22,12 @@ module GraphQL
 
       # apply first / last limit results
       def paged_nodes
-        @paged_nodes ||= begin
-          items = sliced_nodes
-          items.limit(limit)
-        end
+        @paged_nodes ||= sliced_nodes.limit(limit)
       end
 
       # Apply cursors to edges
       def sliced_nodes
-        @sliced_nodes ||= begin
-          items = object
-          items.offset(starting_offset)
-        end
+        @sliced_nodes ||= nodes.offset(starting_offset)
       end
 
       def offset_from_cursor(cursor)

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.18.0"
+  VERSION = "0.18.1"
 end

data/readme.md

@@ -122,13 +122,7 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 
 ## To Do
 
-- Accept type name as `type` argument?
-  - Goal: accept `field :post, "Post"` to look up a type named `"Post"` in the schema
-  - Problem: how does a field know which schema to look up the name from?
-  - Problem: how can we load types in Rails without accessing the constant?
-  - Maybe support by third-party library? `type("Post!")` could implement "type_missing", keeps `graphql-ruby` very simple
 - StaticValidation improvements
-  - Include `path: [...]` in validation errors
   - Use catch-all type/field/argument definitions instead of terminating traversal
   - Reduce ad-hoc traversals?
   - Validators are order-dependent, is this a smell?
@@ -142,4 +136,3 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
   - Reduce duplication in ArrayConnection / RelationConnection
   - Improve API for creating edges (better RANGE_ADD support)
   - If the new edge isn't a member of the connection's objects, raise a nice error
-  - Rename `Connection#object` => `Connection#collection` with deprecation

data/spec/graphql/analysis/analyze_query_spec.rb

@@ -75,5 +75,45 @@ describe GraphQL::Analysis do
         assert_equal "Variable cheeseId of type Int! was provided invalid value", error["message"]
       end
     end
+
+    describe "when processing fields" do
+      let(:connection_counter) {
+        -> (memo, visit_type, irep_node) {
+          memo ||= Hash.new { |h,k| h[k] = 0 }
+          if visit_type == :enter
+            if irep_node.ast_node.is_a?(GraphQL::Language::Nodes::Field)
+              irep_node.definitions.each do |type_defn, field_defn|
+                if field_defn.resolve_proc.is_a?(GraphQL::Relay::ConnectionResolve)
+                  memo["connection"] += 1
+                else
+                  memo["field"] += 1
+                end
+              end
+            end
+          end
+          memo
+        }
+      }
+      let(:analyzers) { [connection_counter] }
+      let(:reduce_result) { GraphQL::Analysis.analyze_query(query, analyzers) }
+      let(:query) { GraphQL::Query.new(StarWarsSchema, query_string, variables: variables) }
+      let(:query_string) {%|
+        query getBases {
+          empire {
+            basesByName(first: 30) { edges { cursor } }
+            bases(first: 30) { edges { cursor } }
+          }
+        }
+      |}
+
+      it "knows which fields are connections" do
+        connection_counts = reduce_result.first
+        expected_connection_counts = {
+          "field" => 5,
+          "connection" => 2
+        }
+        assert_equal expected_connection_counts, connection_counts
+      end
+    end
   end
 end

data/spec/graphql/base_type_spec.rb

@@ -21,4 +21,8 @@ describe GraphQL::BaseType do
       GraphQL::ListType.new(of_type: !MilkType)
     )
   end
+
+  it "Accepts arbitrary metadata" do
+    assert_equal ["Cheese"], CheeseType.metadata[:class_names]
+  end
 end

data/spec/graphql/define/instance_definable_spec.rb

@@ -12,7 +12,7 @@ module Garden
   class Vegetable
     include GraphQL::Define::InstanceDefinable
     lazy_defined_attr_accessor :name, :start_planting_on, :end_planting_on
-    accepts_definitions :name, plant_between: DefinePlantBetween
+    accepts_definitions :name, plant_between: DefinePlantBetween, color: GraphQL::Define.assign_metadata_key(:color)
 
     # definition added later:
     lazy_defined_attr_accessor :height
@@ -61,4 +61,11 @@ describe GraphQL::Define::InstanceDefinable do
       assert_equal Date.new(2000, 7, 1), okra.end_planting_on
     end
   end
+
+  describe "#metadata" do
+    it "gets values from definitions" do
+      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
+      assert_equal :green, arugula.metadata[:color]
+    end
+  end
 end

data/spec/graphql/field_spec.rb

@@ -17,7 +17,6 @@ describe GraphQL::Field do
     assert_equal(DairyProductUnion, field.type)
   end
 
-
   describe ".property " do
     let(:field) do
       GraphQL::Field.define do
@@ -107,4 +106,11 @@ describe GraphQL::Field do
       assert_equal "Xyz", resolved_source
     end
   end
+
+  describe "#metadata" do
+    it "accepts user-defined metadata" do
+      similar_cheese_field = CheeseType.get_field("similarCheese")
+      assert_equal [:cheeses, :milks], similar_cheese_field.metadata[:joins]
+    end
+  end
 end

data/spec/support/dairy_app.rb

@@ -2,6 +2,9 @@ require_relative "./dairy_data"
 
 class NoSuchDairyError < StandardError; end
 
+GraphQL::Field.accepts_definitions(joins: GraphQL::Define.assign_metadata_key(:joins))
+GraphQL::BaseType.accepts_definitions(class_names: GraphQL::Define.assign_metadata_key(:class_names))
+
 EdibleInterface = GraphQL::InterfaceType.define do
   name "Edible"
   description "Something you can eat, yum"
@@ -26,6 +29,7 @@ end
 
 CheeseType = GraphQL::ObjectType.define do
   name "Cheese"
+  class_names ["Cheese"]
   description "Cultured dairy product"
   interfaces [EdibleInterface, AnimalProductInterface]
 
@@ -39,6 +43,8 @@ CheeseType = GraphQL::ObjectType.define do
 
   # Or can define by block, `resolve ->` should override `property:`
   field :similarCheese, CheeseType, "Cheeses like this one", property: :this_should_be_overriden  do
+    # metadata test
+    joins [:cheeses, :milks]
     argument :source, !types[!DairyAnimalEnum]
     resolve -> (t, a, c) {
       # get the strings out:

data/spec/support/star_wars_schema.rb

@@ -47,7 +47,7 @@ BaseConnectionWithTotalCountType = BaseType.define_connection do
   name "BasesConnectionWithTotalCount"
   field :totalCount do
     type types.Int
-    resolve -> (obj, args, ctx) { obj.object.count }
+    resolve -> (obj, args, ctx) { obj.nodes.count }
   end
 end
 
@@ -75,7 +75,7 @@ CustomEdgeBaseConnectionType = BaseType.define_connection(edge_class: CustomBase
 
   field :totalCountTimes100 do
     type types.Int
-    resolve -> (obj, args, ctx) { obj.object.count * 100 }
+    resolve -> (obj, args, ctx) { obj.nodes.count * 100 }
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.18.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-04 00:00:00.000000000 Z
+date: 2016-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
@@ -260,7 +260,6 @@ files:
 - lib/graphql/define/assign_enum_value.rb
 - lib/graphql/define/assign_global_id_field.rb
 - lib/graphql/define/assign_object_field.rb
-- lib/graphql/define/assignment_dictionary.rb
 - lib/graphql/define/defined_object_proxy.rb
 - lib/graphql/define/instance_definable.rb
 - lib/graphql/define/non_null_with_bang.rb
@@ -333,6 +332,7 @@ files:
 - lib/graphql/relay/array_connection.rb
 - lib/graphql/relay/base_connection.rb
 - lib/graphql/relay/connection_field.rb
+- lib/graphql/relay/connection_resolve.rb
 - lib/graphql/relay/connection_type.rb
 - lib/graphql/relay/edge.rb
 - lib/graphql/relay/edge_type.rb

data/lib/graphql/define/assignment_dictionary.rb

@@ -1,26 +0,0 @@
-module GraphQL
-  module Define
-    # Create a hash of definitions out of provided arguments.
-    #
-    # @example Create definitions (some default, some custom)
-    #    hash = AssignmentDictionary.create(:name, :description, field: (value, field_name) -> { value.create_field(field) })
-    #
-    module AssignmentDictionary
-      # Turn `keys` into a hash suitable for {GraphQL::Define::InstanceDefinable}
-      # @param Any number of symbols for default assignment, followed by an (optional) hash of custom assignment procs.
-      # @return [Hash] keys are attributes which may be defined. values are procs which assign values to the target object.
-      def self.create(*keys)
-        initial = if keys.last.is_a?(Hash)
-          keys.pop
-        else
-          {}
-        end
-        keys.inject(initial) do |memo, key|
-          assign_key = "#{key}="
-          memo[key] = -> (target, value) { target.public_send(assign_key, value) }
-          memo
-        end
-      end
-    end
-  end
-end