smash_the_state 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffbecb9f1fd850903e2f88e7576bf684f03e38d14e70c3e07e61c0db93621961
-  data.tar.gz: f259e6b012ff0bfca16320de3403967518de35e9c9b8e5d4baf53c5cd03ce6d2
+  metadata.gz: c239b6b0b7a6c2d025a9640781bfe3feea37887be11971a36641c21efdc89c29
+  data.tar.gz: 20b3cb0250ba5d589d76c327a32dcecb327a5626b2c300d0ff8962f0075f8e4c
 SHA512:
-  metadata.gz: 143ca4fdccc3fd34300f133dae21d70e55ceff9121523a456ad499839403901d56d086059913defe0fddc6ba612046489065d8c9160e13b189da0a6a1cfe0719
-  data.tar.gz: 2c40f91ac88831ea57b0ab44b24e4b514eea3524b5445c3cfb246dc12f1d5047731ed7620145f7a4d57478bf292fc93d540bb38916bc5c23a7e513aad83385db
+  metadata.gz: a1fb815ecf8fa1d672a400d1dea88ccafc00ecc571ccdbbe78803f55a12d25e343684ed62a2556711be9650b65251b50b97bec8adf1dd6396da10c845f240530
+  data.tar.gz: 7370311616f9a628e29abcc6c47d0a6728bf28eb274ebc5206e931cc1655741faa8a8b8c9c47908b80afbea36281d05dc14b02bd7c245cc2bed8dfe96bb41786

data/README.md

@@ -96,24 +96,23 @@ class CreateAnalyticsOperation < SmashTheState::Operation
 end
 ```
 
-## Dynamic State Classes (built at runtime)
+## Dynamic Schemas (built at runtime)
 
-Maybe your operation needs a more flexible schema than a static state class can provide. If you need your state class to be evaluated at runtime, you can omit a schema block and the raw params will be passed in as the initial state. From there you can create whatever state class you desire from inside the first step.
+Maybe your operation needs a more flexible schema than a static state class can provide. Maybe you need to base your schema on some other data model that isn't available at the time the class is evaluated. If you need your state class to be evaluated at runtime, you can specify `dynamic_schema` with a block. The raw params hash will be passed in as the initial state. From there you can create whatever state class you desire at runtime. Be careful with this because this can quickly get out of hand. If you find yourself using dynamic schemas frequently, you may actually want distinct operations with static schemas.
 
 ```ruby
-class MyOperation < SmashTheState::Operation
-  step :custom_state_class do |params|
-    c = Operation::State.build do
-      # create whatever state class you need at runtime
-      attribute :some_name, :some_type
+class BillingStuff < SmashTheState::Operation
+  dynamic_schema do |params|
+    # let's say we want to base our schema on an external service.
+    # we can call the service and build our schema off of the keys it returns
+    # let's say it's something like {name: "...", id: "...", is_paid: "..."}
+    BillingService.get_billing_things.keys do |key|
+      attribute key, :string
     end
-
-    c.new(params)
   end
 
-  step :do_more_things do |state, params|
-    # params will be the initial params
-    # ... and so on
+  step :do_more_things do |state|
+    # ... we receive a state with name, id, and is_paid attributes ...
   end
 end
 ```

data/lib/smash_the_state/operation.rb

@@ -35,6 +35,15 @@ module SmashTheState
         @state_class = Operation::State.build(&block)
       end
 
+      def dynamic_schema(&block)
+        sequence.add_step :_dynamic_schema do |params|
+          Operation::State.build(params, &block).new(params)
+        end
+
+        # make sure that the dynamic schema step that we just added above is always first
+        sequence.steps.unshift sequence.steps.pop
+      end
+
       def step(step_name, options = {}, &block)
         sequence.add_step(step_name, options, &block)
       end

data/lib/smash_the_state/operation/dry_run.rb

@@ -7,6 +7,13 @@ module SmashTheState
         def initialize(wet_sequence)
           @wet_sequence = wet_sequence
           @dry_sequence = Operation::Sequence.new
+
+          # in the case of a dynamic schema, front-load it as the first step
+          dynamic_schema_step = @wet_sequence.dynamic_schema_step
+
+          return if dynamic_schema_step.nil?
+
+          step(dynamic_schema_step.name, &dynamic_schema_step.implementation)
         end
 
         def step(step_name, &block)

data/lib/smash_the_state/operation/sequence.rb

@@ -115,12 +115,26 @@ module SmashTheState
         @steps << step
       end
 
+      def dynamic_schema?
+        dynamic_schema_step.nil? == false
+      end
+
+      def dynamic_schema_step
+        steps_for_name(:_dynamic_schema).first
+      end
+
       private
 
+      def make_original_state(state)
+        return dynamic_schema_step.implementation.call(state, state, run_options) if dynamic_schema?
+
+        state.dup
+      end
+
       def run_steps(steps_to_run, state)
         # retain a copy of the original state so that we can refer to it for posterity as
         # the operation state gets mutated over time
-        original_state = state.dup
+        original_state = make_original_state(state)
         current_step = nil
 
         steps_to_run.reduce(state) do |memo, s|

data/lib/smash_the_state/operation/state.rb

@@ -17,9 +17,9 @@ module SmashTheState
       class << self
         attr_accessor :representer
 
-        def build(&block)
+        def build(params = nil, &block)
           Class.new(self).tap do |k|
-            k.class_eval(&block)
+            k.class_exec(params, &block)
           end
         end
 

data/lib/smash_the_state/version.rb

@@ -1,3 +1,3 @@
 module SmashTheState
-  VERSION = "1.3.0".freeze
+  VERSION = "1.4.0".freeze
 end

data/spec/unit/operation_spec.rb

@@ -191,6 +191,35 @@ describe SmashTheState::Operation do
     end
   end
 
+  describe "self#dynamic_schema" do
+    let!(:klass) do
+      Class.new(SmashTheState::Operation).tap do |k|
+        k.class_eval do
+          dynamic_schema do |params|
+            attribute "#{params[:adjective]}_#{params[:animal]}", :string
+          end
+
+          step :step_one do |state|
+            state.fat_ocelot = "maybe"
+            state
+          end
+
+          step :step_two do |state, original_state|
+            [state, original_state]
+          end
+        end
+      end
+    end
+
+    it "produces an 'inline' schema that is evaluated each time the operation "\
+       "runs while passing the 'original' dynamic state onto the next step" do
+      state, original_state = klass.call(adjective: "fat", animal: "ocelot", fat_ocelot: "no")
+
+      expect(state.fat_ocelot).to eq("maybe")
+      expect(original_state.fat_ocelot).to eq("no")
+    end
+  end
+
   describe "self#dry_run_sequence" do
     context "with a custom dry run sequence block" do
       before do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smash_the_state
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Dan Connor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2019-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_attributes