Merge pull request rmosolgo#357 from rmosolgo/define-copy

feat(Define) support shallow redefinition with #redefine

Author: rmosolgo

lib/graphql/define/instance_definable.rb

@@ -56,17 +56,23 @@ module Define
     #   # Access it from metadata
     #   subaru_baja.metadata[:all_wheel_drive] # => true
     #
+    # @example Making a copy with an extended definition
+    #   # Create an instance with `.define`:
+    #   subaru_baja = Car.define do
+    #     make "Subaru"
+    #     model "Baja"
+    #     doors 4
+    #   end
+    #
+    #   # Then extend it with `#redefine`
+    #   two_door_baja = subaru_baja.redefine do
+    #     doors 2
+    #   end
     module InstanceDefinable
       def self.included(base)
         base.extend(ClassMethods)
       end
 
-      # Set the definition block for this instance.
-      # It can be run later with {#ensure_defined}
-      def definition_proc=(defn_block)
-        @definition_proc = defn_block
-      end
-
       # `metadata` can store arbitrary key-values with an object.
       #
       # @return [Hash<Object, Object>] Hash for user-defined storage
@@ -84,19 +90,21 @@ def metadata
       def define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
-
-        @definition_proc = ->(obj) {
-          kwargs.each do |keyword, value|
-            public_send(keyword, value)
-          end
-
-          if block
-            instance_eval(&block)
-          end
-        }
+        @pending_definition = Definition.new(kwargs, block)
         nil
       end
 
+      # Make a new instance of this class, then
+      # re-run any definitions on that object.
+      # @return [InstanceDefinable] A new instance, with any extended definitions
+      def redefine(**kwargs, &block)
+        ensure_defined
+        new_instance = self.class.new
+        applied_definitions.each { |defn| defn.apply(new_instance) }
+        new_instance.define(**kwargs, &block)
+        new_instance
+      end
+
       private
 
       # Run the definition block if it hasn't been run yet.
@@ -105,15 +113,39 @@ def define(**kwargs, &block)
       # come from the definition block.
       # @return [void]
       def ensure_defined
-        if @definition_proc
-          defn_proc = @definition_proc
-          @definition_proc = nil
-          proxy = DefinedObjectProxy.new(self)
-          proxy.instance_eval(&defn_proc)
+        if @pending_definition
+          defn = @pending_definition
+          @pending_definition = nil
+          defn.apply(self)
+          applied_definitions << defn
         end
         nil
       end
 
+      def applied_definitions
+        @applied_definitions ||= []
+      end
+
+
+      class Definition
+        def initialize(define_keywords, define_proc)
+          @define_keywords = define_keywords
+          @define_proc = define_proc
+        end
+
+        def apply(instance)
+          defn_proxy = DefinedObjectProxy.new(instance)
+
+          @define_keywords.each do |keyword, value|
+            defn_proxy.public_send(keyword, value)
+          end
+
+          if @define_proc
+            defn_proxy.instance_eval(&@define_proc)
+          end
+        end
+      end
+
       module ClassMethods
         # Create a new instance
         # and prepare a definition using its {.definitions}.

spec/graphql/define/instance_definable_spec.rb

@@ -73,6 +73,26 @@ class Vegetable
     end
   end
 
+  describe "#redefine" do
+    it "re-runs definitions without modifying the original object" do
+      arugula = Garden::Vegetable.define(name: "Arugula", color: :green)
+
+      red_arugula = arugula.redefine(color: :red)
+      renamed_red_arugula = red_arugula.redefine do
+        name "Renamed Red Arugula"
+      end
+
+      assert_equal :green, arugula.metadata[:color]
+      assert_equal "Arugula", arugula.name
+
+      assert_equal :red, red_arugula.metadata[:color]
+      assert_equal "Arugula", red_arugula.name
+
+      assert_equal :red, renamed_red_arugula.metadata[:color]
+      assert_equal "Renamed Red Arugula", renamed_red_arugula.name
+    end
+  end
+
   describe "#metadata" do
     it "gets values from definitions" do
       arugula = Garden::Vegetable.define(name: "Arugula", color: :green)