smash_the_state 1.3.0 → 1.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffbecb9f1fd850903e2f88e7576bf684f03e38d14e70c3e07e61c0db93621961
-  data.tar.gz: f259e6b012ff0bfca16320de3403967518de35e9c9b8e5d4baf53c5cd03ce6d2
+  metadata.gz: 9a4407b73af1d296ca49dc0e0d112e3fd4a497d37e66cc97026bcf75835e8d48
+  data.tar.gz: 19c36a89864c088ff0ff068768049dc68c798b57b3b074dd4cd4721f46386abb
 SHA512:
-  metadata.gz: 143ca4fdccc3fd34300f133dae21d70e55ceff9121523a456ad499839403901d56d086059913defe0fddc6ba612046489065d8c9160e13b189da0a6a1cfe0719
-  data.tar.gz: 2c40f91ac88831ea57b0ab44b24e4b514eea3524b5445c3cfb246dc12f1d5047731ed7620145f7a4d57478bf292fc93d540bb38916bc5c23a7e513aad83385db
+  metadata.gz: 3054575953e6e59b15a454609698b8346a6a2fab75ee578c94029b895e03568ed0af214db70cd283c7db0eb97954a41d752d8ed4b18898282940a01534969b49
+  data.tar.gz: b08cde0d76694574172be59467ffe790013aaa462664182345fb494d84976837102db57c60ba74e0753cda7c1b7925fa85adef77fae15e2eefecf5bb0903b41e

data/README.md

@@ -3,6 +3,8 @@
 # Smash the State
 A useful utility for transforming state that provides step sequencing, middleware, and validation.
 
+Inspired by [Arpeggiate](https://github.com/onyxrev/arpeggiate), an Elixir operation library by [@onyxrev](https://github.com/onyxrev).
+
 # Example
 
 ``` ruby
@@ -96,24 +98,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
 ```
@@ -318,7 +319,7 @@ end
 
 ## Continuation
 
-Smash the State operations are functional, so they don't support inheritance. In lieu of inheritance, you may use `continues_from`, which frontloads an existing operation in front of the operation being defined. It feeds the state result of the first operation into the first step of the second.
+Smash the State operations can be chained. To simplify this, you may use the `continues_from` helper, which frontloads an existing operation in front of the operation being defined. It feeds the state result of the first operation into the first step of the second.
 
 ``` ruby
 class SecondOperation < SmashTheState::Operation

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)
@@ -54,6 +61,7 @@ module SmashTheState
                 sequence.side_effect_free
               end
 
+        seq.run_options[:dry] = true
         run_sequence(seq, params)
       end
       alias dry_call dry_run

data/lib/smash_the_state/operation/sequence.rb

@@ -32,7 +32,6 @@ module SmashTheState
       # return a copy without the steps that produce side-effects
       def side_effect_free
         dup.tap do |seq|
-          seq.run_options[:dry] = true
           seq.instance_eval do
             @steps = seq.steps.select(&:side_effect_free?)
           end
@@ -94,13 +93,20 @@ module SmashTheState
         step.error_handler = block
       end
 
-      # rubocop:disable Lint/ShadowedException
       def middleware_class(state, original_state = nil)
-        middleware_class_block.call(state, original_state).constantize
-      rescue NameError, NoMethodError
-        nil
+        klass = middleware_class_block.call(state, original_state)
+
+        case klass
+        when Module, Class
+          klass
+        else
+          begin
+            klass.constantize if klass.respond_to?(:constantize)
+          rescue NameError
+            nil
+          end
+        end
       end
-      # rubocop:enable Lint/ShadowedException
 
       def add_middleware_step(step_name, options = {})
         step = Operation::Step.new step_name, options do |state, original_state|
@@ -115,12 +121,28 @@ 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.
+          freeze # don't allow any modifications to the original state
+      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/operation.rb

@@ -35,12 +35,26 @@ 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
 
       def override_step(step_name, options = {}, &block)
         sequence.override_step(step_name, options, &block)
+
+        # also override the dry run step
+        return if dry_run_sequence.steps_for_name(step_name).length.zero?
+
+        dry_run_sequence.override_step(step_name, options, &block)
       end
 
       def error(*steps, &block)
@@ -122,6 +136,9 @@ module SmashTheState
 
       # also copy the state class over
       child_class.instance_variable_set(:@state_class, state_class && state_class.dup)
+
+      # also copy the dry run sequence
+      child_class.dry_run_sequence.steps.concat(dry_run_sequence.steps.map(&:dup))
     end
   end
 end

data/lib/smash_the_state/version.rb

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

data/spec/unit/operation/sequence_spec.rb

@@ -204,28 +204,40 @@ describe SmashTheState::Operation::Sequence do
     end
 
     context "with a middleware_class_block" do
-      it "runs the middleware_class_block, passes in the state, constantizes" do
-        expect(instance.middleware_class("String")).to eq(String)
+      context "that returns a string" do
+        it "runs the middleware_class_block, passes in the state, constantizes" do
+          expect(instance.middleware_class("String")).to eq(String)
+        end
       end
-    end
 
-    context "with a NameError" do
-      it "returns nil" do
-        expect(instance.middleware_class("Whazzat")).to eq(nil)
-      end
-    end
+      context "that returns a constant" do
+        before do
+          instance.middleware_class_block = proc do |state|
+            state
+          end
+        end
 
-    context "with a NoMethodError" do
-      let!(:state) { double }
+        context "that is a class" do
+          let!(:klass) { Class.new }
 
-      before do
-        allow(state).to receive(:to_s) do
-          raise NoMethodError
+          it "runs the middleware_class_block, passes in the state" do
+            expect(instance.middleware_class(klass)).to eq(klass)
+          end
+        end
+
+        context "that returns a module" do
+          let!(:modyule) { Module.new }
+
+          it "runs the middleware_class_block, passes in the state" do
+            expect(instance.middleware_class(modyule)).to eq(modyule)
+          end
         end
       end
+    end
 
+    context "with a NameError" do
       it "returns nil" do
-        expect(instance.middleware_class(state)).to eq(nil)
+        expect(instance.middleware_class("Whazzat")).to eq(nil)
       end
     end
   end
@@ -254,10 +266,11 @@ describe SmashTheState::Operation::Sequence do
         instance.add_middleware_step :extra_step
       end
 
-      it "block receives both the state and original state" do
+      it "block receives both the state and frozen original state" do
         instance.middleware_class_block = proc do |state, original_state|
           expect(state).to eq(baz: "bing")
           expect(original_state).to eq(foo: "bar")
+          expect(original_state.frozen?).to eq(true)
         end
 
         instance.call(foo: "bar")

data/spec/unit/operation_spec.rb

@@ -120,9 +120,9 @@ describe SmashTheState::Operation do
         step_name,
         step_options,
         &implementation
-      ).and_return(token_result)
+      )
 
-      expect(klass.override_step(step_name, step_options, &implementation)).to eq(token_result)
+      klass.override_step(step_name, step_options, &implementation)
     end
   end
 
@@ -147,6 +147,15 @@ describe SmashTheState::Operation do
             state.countup += "two"
             state
           end
+
+          dry_run_sequence do
+            step :one
+            step :two
+            step :three do |state|
+              state.countup += "blar"
+              state
+            end
+          end
         end
       end
     end
@@ -189,13 +198,46 @@ describe SmashTheState::Operation do
       too_large = child.call(countup: "")
       expect(too_large.errors[:countup]).to eq(["can't be blank"])
     end
+
+    it "populates the dry run sequence and honors overridden steps" do
+      expect(child.dry_run(countup: "zero").countup).to eq("zerooneoneandahalfblar")
+    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
-        klass.step :step_one do |state|
-          state.name = state.name + " one"
+        klass.step :step_one do |state, _original_state, run_options|
+          state.name = state.name + " one " + run_options.to_json
           state
         end
 
@@ -224,16 +266,17 @@ describe SmashTheState::Operation do
       end
 
       it "provides a custom sequence for the dry run that " \
-         "contains only side-effect free steps" do
+         "contains only side-effect free steps, and specifies " \
+         "whether the run is dry the run options" do
         result = klass.call(name: "Sam")
-        expect(result.name).to eq("Sam one two three")
+        expect(result.name).to eq("Sam one {\"dry\":false} two three")
 
         expect(
           klass.dry_run_sequence.steps.all?(&:side_effect_free?)
         ).to eq(true)
 
         dry_result = klass.dry_run(name: "Sam")
-        expect(dry_result.name).to eq("Sam one custom")
+        expect(dry_result.name).to eq("Sam one {\"dry\":true} custom")
       end
     end
   end

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.4
 platform: ruby
 authors:
 - Dan Connor
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_attributes
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 6.0.3.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 6.0.3.1
 description: ''
 email:
 - dan@danconnor.com
@@ -83,8 +83,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: A useful utility for transforming state that provides step sequencing, middleware,