smash_the_state 1.2.4

data/lib/smash_the_state/operation/state_type.rb

@@ -0,0 +1,19 @@
+module SmashTheState
+  class Operation
+    class StateType < ActiveModel::Type::Value
+      def initialize(block)
+        @schema_class = Operation::State.build(&block)
+      end
+
+      private
+
+      def cast_value(attributes)
+        @schema_class.new(attributes)
+      end
+    end
+  end
+end
+
+ActiveModel::Type.register(:state_for_smashing) do |_name, options|
+  SmashTheState::Operation::StateType.new(options[:schema])
+end

data/lib/smash_the_state/operation/step.rb

@@ -0,0 +1,21 @@
+module SmashTheState
+  class Operation
+    class Step
+      attr_accessor :error_handler
+      attr_reader :name, :implementation, :options
+
+      def initialize(step_name, options = {}, &block)
+        @name           = step_name
+        @implementation = block
+        @options        = {
+          # defaults
+          side_effect_free: nil # nil roughly implies unknown
+        }.merge(options)
+      end
+
+      def side_effect_free?
+        options[:side_effect_free] == true
+      end
+    end
+  end
+end

data/lib/smash_the_state/version.rb

@@ -0,0 +1,3 @@
+module SmashTheState
+  VERSION = "1.2.4".freeze
+end

data/spec/unit/operation/definition_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+# not sure why getting a `NoMethodError: undefined method `empty?' for nil:NilClass` error
+# when the literal module is referenced here as opposed to as a string
+describe "SmashTheState::Operation::Definition" do
+  let!(:subject) do
+    location_definition = Class.new(SmashTheState::Operation::Definition).tap do |k|
+      k.class_eval do
+        definition "Location"
+
+        schema do
+          attribute :postal_code, :string
+          attribute :lat, :float
+          attribute :lon, :float
+        end
+      end
+    end
+
+    Class.new(SmashTheState::Operation::Definition).tap do |k|
+      k.class_eval do
+        definition "Syndicate"
+
+        schema do
+          # smoke test nested definitions
+          schema :location, ref: location_definition
+        end
+      end
+    end
+  end
+
+  describe "inheritance" do
+    it "inherits from State" do
+      expect(subject.ancestors).to include(SmashTheState::Operation::State)
+    end
+  end
+
+  describe "#ref" do
+    it "returns the definition name" do
+      expect(subject.ref).to eq("Syndicate")
+    end
+  end
+
+  describe "#to_s" do
+    it "returns the ref" do
+      expect(subject.to_s).to eq(subject.ref)
+    end
+  end
+
+  describe "#schema with a referenced definition" do
+    it "pulls in the schema from the referened definition" do
+      expect(
+        # wheeeeeee
+        subject.attributes_registry[:location][1][:ref].attributes_registry.keys
+      ).to eq(%i[postal_code lat lon])
+    end
+  end
+end

data/spec/unit/operation/sequence_spec.rb

@@ -0,0 +1,256 @@
+require "spec_helper"
+require "json"
+
+describe SmashTheState::Operation::Sequence do
+  let!(:subject) { SmashTheState::Operation::Sequence }
+
+  describe "#initialize" do
+    it "initializes steps as an array" do
+      expect(subject.new.steps).to be_a(Array)
+    end
+  end
+
+  describe "#call" do
+    let!(:instance) { subject.new }
+
+    context "in general" do
+      before do
+        instance.add_step(:one) do |state|
+          state << 1
+        end
+
+        instance.add_step(:two) do |state|
+          state << 2
+        end
+      end
+
+      it "runs each steps' implementation block, passing each steps' return " \
+         "value to the next step" do
+        expect(instance.call([])).to eq([1, 2])
+      end
+    end
+
+    context "with an Invalid exception" do
+      before do
+        instance.instance_eval do |i|
+          i.add_step(:one) do |state|
+            state << :invalid
+            raise SmashTheState::Operation::State::Invalid, state
+          end
+        end
+
+        instance.add_step(:two) do |_state|
+          raise "should not hit this"
+        end
+      end
+
+      it "returns the state of the step, skips subsequent steps" do
+        expect(instance.call([])).to eq([:invalid])
+      end
+    end
+
+    context "with an Error exception" do
+      before do
+        instance.instance_eval do |i|
+          i.add_step(:one) do |_state|
+            # test that we can pass a different state to the error handler
+            raise SmashTheState::Operation::Error, :custom_state
+          end
+        end
+
+        instance.add_step(:two) do |_state|
+          raise "should not hit this"
+        end
+      end
+
+      context "with an error handler" do
+        before do
+          instance.add_error_handler_for_step :one do |custom_state, original_state|
+            [custom_state, original_state]
+          end
+        end
+
+        it "runs the error handler" do
+          expect(instance.call([])).to eq([:custom_state, []])
+        end
+      end
+
+      context "without an error handler" do
+        it "re-raises the Error exception" do
+          expect do
+            begin
+              instance.call([])
+              raise "should not hit this"
+            rescue SmashTheState::Operation::Error => e
+              expect(e.state).to eq([:foo])
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe "steps" do
+    let!(:instance) { subject.new }
+
+    before do
+      instance.add_step :new_step do |state|
+        state << :step_added
+      end
+    end
+
+    let!(:step) { instance.steps.first }
+
+    describe "#add_step" do
+      it "adds a Step instance with the step name and block" do
+        expect(instance.steps.length).to eq(1)
+        expect(step).to be_a(SmashTheState::Operation::Step)
+        expect(step.name).to eq(:new_step)
+        expect(step.implementation.call(%i[existing])).to eq(%i[existing step_added])
+      end
+    end
+
+    describe "#add_error_handler_for_step" do
+      before do
+        instance.add_error_handler_for_step :new_step do |state|
+          state.tap do
+            state << :handled
+          end
+        end
+      end
+
+      it "the error handler block is added to the named step" do
+        expect(step.error_handler.call([])).to eq([:handled])
+      end
+
+      context "error handlers for missing steps do nothing" do
+        before do
+          instance.add_error_handler_for_step :not_there do |_state|
+            raise "nope"
+          end
+        end
+
+        it "is allowed but does nothing" do
+          expect(instance.steps.map(&:name)).to eq([:new_step])
+        end
+      end
+    end
+  end
+
+  describe "#middleware_class" do
+    let!(:instance) { subject.new }
+
+    before do
+      instance.middleware_class_block = proc do |state|
+        state.to_s
+      end
+    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)
+      end
+    end
+
+    context "with a NameError" do
+      it "returns nil" do
+        expect(instance.middleware_class("Whazzat")).to eq(nil)
+      end
+    end
+
+    context "with a NoMethodError" do
+      let!(:state) { double }
+
+      before do
+        allow(state).to receive(:to_s) do
+          raise NoMethodError
+        end
+      end
+
+      it "returns nil" do
+        expect(instance.middleware_class(state)).to eq(nil)
+      end
+    end
+  end
+
+  describe "#add_middleware_step" do
+    let!(:instance) { subject.new }
+
+    context "with a middleware class defined" do
+      let!(:middleware_class) do
+        class SequenceSpecMiddleware
+          def self.extra_step(state, original_state)
+            state.merge(original_state)
+          end
+        end
+      end
+
+      before do
+        instance.middleware_class_block = proc do |_state, _original_state|
+          "SequenceSpecMiddleware"
+        end
+
+        instance.add_step :inline_step do |_state|
+          { baz: "bing" }
+        end
+
+        instance.add_middleware_step :extra_step
+      end
+
+      it "block receives both the state and 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")
+        end
+
+        instance.call(foo: "bar")
+      end
+
+      it "delegates the step to the middleware class" do
+        expect(instance.call(foo: "bar")).to eq(baz: "bing", foo: "bar")
+      end
+    end
+
+    context "with no middleware class defined" do
+      it "just returns the state" do
+        expect(instance.call(foo: "bar")).to eq(foo: "bar")
+      end
+    end
+  end
+
+  describe "#slice" do
+    let!(:instance) { subject.new }
+
+    before do
+      instance.add_step(:one) do |state|
+        state << 1
+      end
+
+      instance.add_step(:two) do |state|
+        state << 2
+      end
+
+      instance.add_step(:three) do |state|
+        state << 3
+      end
+
+      instance.add_step(:four) do |state|
+        state << 4
+      end
+
+      instance.add_step(:five) do |state|
+        state << 5
+      end
+    end
+
+    it "returns a new sequence cut to the specified length from the " \
+       "specified start" do
+      sliced = instance.slice(1, 3)
+      expect(sliced.steps.map(&:name)).to eq(%i[two three four])
+
+      # doesn't mutate the original
+      expect(instance.steps.length).to eq(5)
+      expect(instance.object_id).to_not eq(sliced.object_id)
+    end
+  end
+end

data/spec/unit/operation/state_spec.rb

@@ -0,0 +1,143 @@
+require "spec_helper"
+require "json"
+
+describe SmashTheState::Operation::State do
+  let!(:subject) { SmashTheState::Operation::State }
+
+  describe "self#build" do
+    let!(:built) do
+      subject.build do
+        attr_accessor :bread
+      end
+    end
+
+    it "creates a new inherited class and class_evals the block" do
+      expect(built < SmashTheState::Operation::State).to eq(true)
+      expect(built.new.respond_to?(:bread)).to eq(true)
+    end
+  end
+
+  describe "self#schema" do
+    jam_definition = Class.new(SmashTheState::Operation::Definition).tap do |k|
+      k.class_eval do
+        definition "Jam"
+
+        schema do
+          attribute :sweetened, :boolean
+        end
+      end
+    end
+
+    let!(:built) do
+      subject.build do
+        schema :bread do
+          attribute :loaves, :integer
+
+          # inline
+          schema :butter do
+            attribute :salted, :boolean
+          end
+
+          # by reference
+          schema :jam, ref: jam_definition
+        end
+      end
+    end
+
+    let!(:instance) do
+      built.new(
+        bread: {
+          loaves: 3,
+          butter: {
+            salted: true
+          },
+          jam: {
+            sweetened: false
+          }
+        }
+      )
+    end
+
+    it "allows for inline nesting of schemas" do
+      expect(instance.bread.loaves).to eq(3)
+      expect(instance.bread.butter.salted).to eq(true)
+    end
+
+    it "allows for reference of type definitions" do
+      expect(instance.bread.jam.sweetened).to eq(false)
+    end
+  end
+
+  describe "self#eval_validation_directives_block" do
+    let!(:built) do
+      subject.build do
+        attribute :bread, :string
+      end
+    end
+
+    let!(:instance) { built.new }
+
+    it "clears the validators, evals the block, runs validate" do
+      expect(built).to receive(:clear_validators!)
+
+      begin
+        SmashTheState::Operation::State.eval_validation_directives_block(instance) do
+          validates_presence_of :bread
+        end
+      rescue SmashTheState::Operation::State::Invalid => e
+        expect(e.state.errors[:bread]).to include("can't be blank")
+      end
+    end
+
+    context "when validate returns true" do
+      let!(:instance) { built.new(bread: "rye") }
+
+      it "returns the state" do
+        state = SmashTheState::Operation::State.eval_validation_directives_block(instance) do
+          validates_presence_of :bread
+        end
+
+        expect(state.bread).to eq(state.bread)
+      end
+    end
+  end
+
+  describe "#eval_custom_validator_block" do
+    let!(:built) do
+      subject.build do
+        attribute :bread, :string
+      end
+    end
+
+    let!(:instance) { built.new }
+
+    it "calls the block" do
+      begin
+        SmashTheState::Operation::State.eval_custom_validator_block(instance) do |i|
+          i.errors.add(:bread, "is moldy")
+        end
+      rescue SmashTheState::Operation::State::Invalid => e
+        expect(e.state.errors[:bread]).to include("is moldy")
+      end
+    end
+
+    it "only raises an error for the current state" do
+      state = SmashTheState::Operation::State.
+                eval_custom_validator_block(instance, built.new) do |_i, original_state|
+        original_state.errors.add(:bread, "is moldy")
+      end
+
+      expect(state).to eq(instance)
+    end
+
+    context "with no errors present" do
+      it "returns the state" do
+        state = SmashTheState::Operation::State.eval_custom_validator_block(instance) do
+          :noop
+        end
+
+        expect(state).to eq(instance)
+      end
+    end
+  end
+end