flow 0.10.4 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a8a4adcc10876350cd8358f5847ad928962037235e646bded446262f98c5c05e
-  data.tar.gz: b50a5bae755061296098405e5e93241911822132b84abd83f65fdad2a00b3bfb
+  metadata.gz: 946ff11930523a9982a5f4210d74ef656e66c0f84c0267f484799b6a4173956e
+  data.tar.gz: 7c148b9935abaf957f966c3f576620f5d444e5d8561e35fa40cbc3dc7c525ca7
 SHA512:
-  metadata.gz: 5dbd29e46bc44783d9ccbac12cf0fd8bf626cc61809fbdf787ede2d1283418a4646dacfdb6d13b0d278d139a9bedfecca6a8f4b6f5df66010c93842ff82ac717
-  data.tar.gz: f53636ff842d54aef60c0f8e84c5fff32d394ae66f74d05f5244470307217373f7187d94013980ac6594e9f2f99e71b8caff23a84db9d93f2a98c04106a9b5ad
+  metadata.gz: a3c5c2cf05a2b9ffbe25bf0ebad9a3b33c83d3f76a79f76717e7ca96744a39b89778cb8fb4ad3cb6522c1f59094fd9619cc878ec4152a26c6876c01e6afadbcb
+  data.tar.gz: 374fdd652be6bc5bff0db2f5eed97f974f0e78cd0512742294ad8196fa47e58fa72b21ca319375314c0d98ffedc01b1d11279d9a5645b488bef4151d89d17c44

data/README.md

@@ -11,6 +11,7 @@
 * [How it Works](#how-it-works)
    * [Flows](#flows)
    * [Operations](#operations)
+      * [Accessors](#accessors)
    * [States](#states)
       * [Input](#input)
       * [Output](#output)
@@ -146,19 +147,24 @@ An **Operation** is a service object which is executed with a **State**.
 Operations should **not** be named with the `Operation` suffix; name them what they do!
 
 ```ruby
-class ClearExistingTimetables < ApplicationOperation
+class ClearExistingTimetable < ApplicationOperation
+  state_accessor :existing_timetable_cells
+
   def behavior
-    state.existing_timetable_cells.update_all(total_minutes: 0)
+    existing_timetable_cells.update_all(total_minutes: 0)
   end
 end
 ```
 
 ```ruby
 class CalculateTimetables < ApplicationOperation
+  state_accessor :minutes_by_project_employee
+  state_reader :timeframe
+  
   def behavior
-    state.minutes_by_project_employee.each do |project_employee, total_minutes|
+    minutes_by_project_employee.each do |project_employee, total_minutes|
       project_id, employee_id = project_employee
-      timetable = state.timeframe.timetables.find_or_create_by!(project_id: project_id)
+      timetable = timeframe.timetables.find_or_create_by!(project_id: project_id)
       cell = timetable.cells.find_or_create_by!(employee_id: employee_id)
       
       cell.update!(total_minutes: total_minutes)
@@ -169,8 +175,10 @@ end
 
 ```ruby
 class SummarizeTimetables < ApplicationOperation
+  state_accessor :timetables
+  
   def behavior
-    state.timetables.each do |timetable| 
+    timetables.each do |timetable| 
       timetable.update!(total_minutes: timetable.cells.sum(:total_minutes))
     end
   end
@@ -179,8 +187,10 @@ end
 
 ```ruby
 class DestroyEmptyTimetableCells < ApplicationOperation
+  state_accessor :empty_cells
+
   def behavior
-    state.empty_cells.destroy_all
+    empty_cells.destroy_all
   end
 end
 ```
@@ -191,8 +201,10 @@ Operations take a state as input and define a `#behavior` that occurs when `#exe
 
 ```ruby
 class ExampleOperation < ApplicationOperation
+  state_reader :first_name
+
   def behavior
-    puts "Hello, #{state.first_name}"
+    puts "Hello, #{first_name}"
   end
 end
 
@@ -202,6 +214,117 @@ operation.execute
 operation.executed? # => true 
 ```
 
+⚠️ **Deprecation Warning**: Direct state access in Operations is being removed. [Learn more](./DEPRECATION_NOTICE.md)
+
+#### Accessors
+
+**Operations** define, through *State Accessors*, what data they will read from and/or write to a **State**. 
+
+These accessors provide an explicit means to declare input needs and output expectations.
+
+```ruby
+class ExampleOperation < ApplicationOperation
+  state_reader :foo
+  state_writer :bar
+  state_accessor :baz
+end
+```
+
+Under the hood, a **StateProxy** adapts a **State** to an **Operation** using these accessors.
+
+⚠️ *Warning*: Your Operation will not be able to access methods on your State if you do not declare them using these accessors!
+
+The following are considered best practices for working with state accessors:
+
+`state_reader` should **only** read data and not alter it
+
+```ruby
+# Bad, don't do it this way:
+class BadOperation < ApplicationOperation
+  state_reader :foo
+  
+  def behavior
+    foo << :more_dataz
+  end
+end
+
+# Good, do it this way:
+class GoodOperation < ApplicationOperation
+  state_reader :foo
+  
+  def behavior
+    SomeThirdParty.do_a_thing if foo == :foo
+  end
+end
+```
+
+`state_writer` should map to a field marked as `output` on the State
+
+```ruby
+class ExampleOperation < ApplicationOperation
+  state_writer :foo
+  
+  def behavior
+    state.foo = :foo
+  end
+end
+
+# Bad, don't do it this way:
+class BadState < ApplicationState
+  option :foo
+end
+
+# Good, do it this way:
+class GoodState < ApplicationState
+  output :foo
+end
+```
+
+`state_accessor` should be used rather than defining both setters and getters:
+
+```ruby
+# Bad, don't do it this way:
+class BadOperation < ApplicationOperation
+  state_reader :foo
+  state_writer :foo
+  
+  def behavior
+    state.foo = :bar if foo == :baz
+  end
+end
+
+# Good, do it this way:
+class GoodOperation < ApplicationOperation
+  state_accessor :foo
+  
+  def behavior
+    state.foo = :bar if foo == :baz
+  end
+end
+```
+
+`state_accessor` should also be used when altering a memory object (ex: Array, Hash, ActiveModel):
+
+```ruby
+# Bad, don't do it this way:
+class BadOperation < ApplicationOperation
+  state_reader :foo
+  
+  def behavior
+    foo << :more_dataz
+  end
+end
+
+# Good, do it this way:
+class GoodOperation < ApplicationOperation
+  state_accessor :foo
+  
+  def behavior
+    foo << :more_dataz
+  end
+end
+```
+
 ### States
 
 A **State** is an aggregation of input and derived data.
@@ -1024,6 +1147,9 @@ This will allow you to use the following custom matchers:
  * [use_operations](lib/flow/custom_matchers/use_operations.rb) tests usage of `ApplicationFlow.operations`
  * [wrap_in_transaction](lib/flow/custom_matchers/wrap_in_transaction.rb) tests usage of `.wrap_in_transaction` for `ApplicationFlow` or `ApplicationOperation`
  * [have_on_state](lib/flow/custom_matchers/have_on_state.rb) tests for data on State after a `ApplicationFlow` or `ApplicationOperation` has been run
+* [access_state](lib/flow/custom_matchers/access_state.rb) tests usage of `ApplicationOperation.state_accessor` (or use of both `state_(reader|writer)`)
+* [read_state](lib/flow/custom_matchers/read_state.rb) tests usage of `ApplicationOperation.state_reader`
+* [write_state](lib/flow/custom_matchers/write_state.rb) tests usage of `ApplicationOperation.state_writer`
 
 ### Testing Flows
 
@@ -1086,6 +1212,10 @@ RSpec.describe MakeTheThingDoTheStuff, type: :operation do
 
   it { is_expected.to inherit_from ApplicationOperation }
 
+  # it { is_expected.to access_state :foo }
+  # it { is_expected.to read_state :bar }
+  # it { is_expected.to write_state :baz }
+
   describe "#execute" do
     subject(:execute) { operation.execute }
   
@@ -1145,10 +1275,12 @@ You are encouraged to use `execute`, rather than `execute!` in testing. You can
 Doing so will allow you to make assertions on the failure without having to expect errors:
 ```ruby
 class SomeOperation < ApplicationOperation
+  state_reader :foo
+
   failure :somethings_invalid
 
   def behavior
-    somethings_invalid_failure! baz: "relevant data" if state.foo == "something invalid"
+    somethings_invalid_failure! baz: "relevant data" if foo == "something invalid"
   end
 end
 ```

data/lib/flow.rb

@@ -13,5 +13,17 @@ require "flow/concerns/transaction_wrapper"
 require "flow/flow_base"
 require "flow/operation_base"
 require "flow/state_base"
+require "flow/state_proxy"
 
-module Flow; end
+module Flow
+  class Error < StandardError; end
+
+  class FlowError < Error; end
+  class StateInvalidError < FlowError; end
+
+  class OperationError < Error; end
+  class AlreadyExecutedError < OperationError; end
+
+  class StateError < Error; end
+  class NotValidatedError < StateError; end
+end

data/lib/flow/flow/callbacks.rb

@@ -2,12 +2,14 @@
 
 # Callbacks provide an extensible mechanism for hooking into a Flow.
 module Flow
-  module Callbacks
-    extend ActiveSupport::Concern
+  module Flow
+    module Callbacks
+      extend ActiveSupport::Concern
 
-    included do
-      include ActiveSupport::Callbacks
-      define_callbacks :initialize, :trigger, :flux
+      included do
+        include ActiveSupport::Callbacks
+        define_callbacks :initialize, :trigger, :flux
+      end
     end
   end
 end

data/lib/flow/flow/core.rb

@@ -2,25 +2,27 @@
 
 # Accepts input representing the arguments and options which define the initial state.
 module Flow
-  module Core
-    extend ActiveSupport::Concern
+  module Flow
+    module Core
+      extend ActiveSupport::Concern
 
-    class_methods do
-      def state_class
-        "#{name.chomp("Flow")}State".constantize
+      class_methods do
+        def state_class
+          "#{name.chomp("Flow")}State".constantize
+        end
       end
-    end
 
-    included do
-      delegate :state_class, to: :class
-      delegate :outputs, to: :state
+      included do
+        delegate :state_class, to: :class
+        delegate :outputs, to: :state
 
-      attr_reader :state
-    end
+        attr_reader :state
+      end
 
-    def initialize(state_instance = nil, **options)
-      run_callbacks(:initialize) do
-        @state = state_instance || state_class.new(**options)
+      def initialize(state_instance = nil, **options)
+        run_callbacks(:initialize) do
+          @state = state_instance || state_class.new(**options)
+        end
       end
     end
   end

data/lib/flow/flow/flux.rb

@@ -2,54 +2,56 @@
 
 # When `#trigger` is called on a Flow, `#execute` is called on Operations sequentially in their given order.
 module Flow
-  module Flux
-    extend ActiveSupport::Concern
+  module Flow
+    module Flux
+      extend ActiveSupport::Concern
 
-    included do
-      set_callback(:initialize, :after) { @executed_operations = [] }
+      included do
+        set_callback(:initialize, :after) { @executed_operations = [] }
 
-      attr_reader :failed_operation
+        attr_reader :failed_operation
 
-      delegate :operation_failure, to: :failed_operation, allow_nil: true
+        delegate :operation_failure, to: :failed_operation, allow_nil: true
 
-      private
+        private
 
-      attr_reader :executed_operations
+        attr_reader :executed_operations
 
-      def _flux
-        executable_operations.each do |operation|
-          operation.execute
-          (@failed_operation = operation) and raise Flow::Flux::Failure if operation.failed?
-          executed_operations << operation
+        def _flux
+          executable_operations.each do |operation|
+            operation.execute
+            (@failed_operation = operation) and raise Flow::Flux::Failure if operation.failed?
+            executed_operations << operation
+          end
+        end
+
+        def executable_operations
+          operation_instances - executed_operations
         end
-      end
 
-      def executable_operations
-        operation_instances - executed_operations
+        def operation_instances
+          _operations.map { |operation_class| operation_class.new(state) }
+        end
+        memoize :operation_instances
       end
 
-      def operation_instances
-        _operations.map { |operation_class| operation_class.new(state) }
+      def failed_operation?
+        failed_operation.present?
       end
-      memoize :operation_instances
-    end
 
-    def failed_operation?
-      failed_operation.present?
-    end
+      def flux
+        flux!
+      rescue StandardError => exception
+        info :error_executing_operation, state: state, exception: exception
 
-    def flux
-      flux!
-    rescue StandardError => exception
-      info :error_executing_operation, state: state, exception: exception
+        raise exception unless exception.is_a? Flow::Flux::Failure
+      end
 
-      raise exception unless exception.is_a? Flow::Flux::Failure
-    end
+      def flux!
+        run_callbacks(:flux) { _flux }
+      end
 
-    def flux!
-      run_callbacks(:flux) { _flux }
+      class Failure < StandardError; end
     end
-
-    class Failure < StandardError; end
   end
 end

data/lib/flow/flow/operations.rb

@@ -2,25 +2,27 @@
 
 # Operations are an ordered list of the behaviors which are executed with (and possibly change) the Flow's state.
 module Flow
-  module Operations
-    extend ActiveSupport::Concern
+  module Flow
+    module Operations
+      extend ActiveSupport::Concern
 
-    included do
-      class_attribute :_operations, instance_writer: false, default: []
+      included do
+        class_attribute :_operations, instance_writer: false, default: []
 
-      delegate :_operations, to: :class
-    end
-
-    class_methods do
-      def inherited(base)
-        base._operations = _operations.dup
-        super
+        delegate :_operations, to: :class
       end
 
-      private
+      class_methods do
+        def inherited(base)
+          base._operations = _operations.dup
+          super
+        end
+
+        private
 
-      def operations(*operations)
-        _operations.concat(operations.flatten)
+        def operations(*operations)
+          _operations.concat(operations.flatten)
+        end
       end
     end
   end

data/lib/flow/flow/status.rb

@@ -2,23 +2,25 @@
 
 # The Flow status is a summary of what has occurred during the runtime, used mainly for analysis and program flow.
 module Flow
-  module Status
-    extend ActiveSupport::Concern
+  module Flow
+    module Status
+      extend ActiveSupport::Concern
 
-    def pending?
-      executed_operations.none?
-    end
+      def pending?
+        executed_operations.none?
+      end
 
-    def triggered?
-      executed_operations.any? || failed_operation?
-    end
+      def triggered?
+        executed_operations.any? || failed_operation?
+      end
 
-    def success?
-      triggered? && (operation_instances - executed_operations).none?
-    end
+      def success?
+        triggered? && (operation_instances - executed_operations).none?
+      end
 
-    def failed?
-      triggered? && !success?
+      def failed?
+        triggered? && !success?
+      end
     end
   end
 end

data/lib/flow/flow/transactions.rb

@@ -2,12 +2,14 @@
 
 # Flows where no operation should be persisted unless all are successful should use a transaction.
 module Flow
-  module Transactions
-    extend ActiveSupport::Concern
+  module Flow
+    module Transactions
+      extend ActiveSupport::Concern
 
-    class_methods do
-      def callback_name
-        :flux
+      class_methods do
+        def callback_name
+          :flux
+        end
       end
     end
   end

data/lib/flow/flow/trigger.rb

@@ -2,37 +2,39 @@
 
 # Triggering a Flow executes all its operations in sequential order (see `Flow::Flux`) *iff* it has a valid state.
 module Flow
-  module Trigger
-    extend ActiveSupport::Concern
-
-    class_methods do
-      def trigger!(*arguments)
-        new(*arguments).trigger!
+  module Flow
+    module Trigger
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def trigger!(*arguments)
+          new(*arguments).trigger!
+        end
+
+        def trigger(*arguments)
+          new(*arguments).trigger
+        end
       end
 
-      def trigger(*arguments)
-        new(*arguments).trigger
-      end
-    end
+      included do
+        delegate :valid?, :validated?, to: :state, prefix: true
 
-    included do
-      delegate :valid?, :validated?, to: :state, prefix: true
-
-      set_callback :trigger, :around, ->(_, block) { surveil(:trigger) { block.call } }
-    end
+        set_callback :trigger, :around, ->(_, block) { surveil(:trigger) { block.call } }
+      end
 
-    def trigger!
-      raise Flow::Errors::StateInvalid unless state_valid?
+      def trigger!
+        raise StateInvalidError unless state_valid?
 
-      run_callbacks(:trigger) { flux }
+        run_callbacks(:trigger) { flux }
 
-      self
-    end
+        self
+      end
 
-    def trigger
-      trigger!
-    rescue Flow::Errors::StateInvalid
-      self
+      def trigger
+        trigger!
+      rescue StateInvalidError
+        self
+      end
     end
   end
 end

data/lib/flow/flow_base.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "flow/errors/state_invalid"
-
 require_relative "flow/callbacks"
 require_relative "flow/core"
 require_relative "flow/flux"
@@ -12,10 +10,8 @@ require_relative "flow/trigger"
 
 # A **Flow** is a collection of procedurally executed **Operations** sharing a common **State**.
 module Flow
-  class FlowBase
-    include ShortCircuIt
-    include Technologic
-    include Flow::TransactionWrapper
+  class FlowBase < Spicerack::RootObject
+    include TransactionWrapper
     include Flow::Callbacks
     include Flow::Core
     include Flow::Flux

data/lib/flow/operation/core.rb

@@ -8,10 +8,21 @@ module Flow
 
       included do
         attr_reader :state
+
+        delegate :state_proxy_class, to: :class
+      end
+
+      class_methods do
+        def state_proxy_class
+          @state_proxy_class ||= Class.new(StateProxy).tap do |proxy_class|
+            delegate_method_names = _state_writers.map { |method_name| "#{method_name}=" } + _state_readers
+            proxy_class.delegate(*delegate_method_names, to: :state) if delegate_method_names.any?
+          end
+        end
       end
 
       def initialize(state)
-        @state = state
+        @state = state_proxy_class.new(state)
       end
     end
   end

data/lib/flow/operation/execute.rb

@@ -12,7 +12,7 @@ module Flow
         attr_reader :operation_failure
 
         set_callback :execute, :around, ->(_, block) { surveil(:execute) { block.call } }
-        set_callback :execute, :before, -> { raise Operation::Errors::AlreadyExecuted }, if: :executed?
+        set_callback :execute, :before, -> { raise AlreadyExecutedError }, if: :executed?
       end
 
       def execute!

data/lib/flow/operation_base.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "operation/errors/already_executed"
-require_relative "operation/errors/already_rewound"
-
 require_relative "operation/accessors"
 require_relative "operation/callbacks"
 require_relative "operation/core"
@@ -14,17 +11,15 @@ require_relative "operation/transactions"
 
 # An **Operation** is a service object which is executed with a **State**.
 module Flow
-  class OperationBase
-    include ShortCircuIt
-    include Technologic
-    include Flow::TransactionWrapper
-    include Flow::Operation::Accessors
-    include Flow::Operation::Callbacks
-    include Flow::Operation::Core
-    include Flow::Operation::ErrorHandler
-    include Flow::Operation::Execute
-    include Flow::Operation::Failures
-    include Flow::Operation::Status
-    include Flow::Operation::Transactions
+  class OperationBase < Spicerack::RootObject
+    include TransactionWrapper
+    include Operation::Accessors
+    include Operation::Callbacks
+    include Operation::Core
+    include Operation::ErrorHandler
+    include Operation::Execute
+    include Operation::Failures
+    include Operation::Status
+    include Operation::Transactions
   end
 end

data/lib/flow/{spec_helper → rspec}/custom_matchers.rb

@@ -6,3 +6,6 @@ require_relative "custom_matchers/handle_error"
 require_relative "custom_matchers/use_operations"
 require_relative "custom_matchers/wrap_in_transaction"
 require_relative "custom_matchers/have_on_state"
+require_relative "custom_matchers/read_state"
+require_relative "custom_matchers/write_state"
+require_relative "custom_matchers/access_state"

data/lib/flow/rspec/custom_matchers/access_state.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usage of `ApplicationOperation.state_accessor` (or use of both `state_(reader|writer)`)
+#
+#     class SomeTask < ApplicationOperation
+#       state_accessor :foo
+#       state_accessor :bar
+#
+#       state_reader :baz
+#       state_writer :baz
+#     end
+#
+#     RSpec.describe SomeTask, type: :operation do
+#       subject { described_class.new(state) }
+#
+#       let(:state) { Class.new(ApplicationState).new }
+#
+#       it { is_expected.to access_state :foo }
+#       it { is_expected.to access_state :bar }
+#       it { is_expected.to access_state :baz }
+#     end
+
+RSpec::Matchers.define :access_state do |field|
+  match { |operation| expect(operation._state_accessors).to include field }
+  description { "access state" }
+  failure_message { "expected #{described_class} to access state #{field}" }
+end

data/lib/flow/rspec/custom_matchers/read_state.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usage of `ApplicationOperation.state_reader`
+#
+#     class SomeTask < ApplicationOperation
+#       state_reader :foo
+#       state_reader :bar
+#     end
+#
+#     RSpec.describe SomeTask, type: :operation do
+#       subject { described_class.new(state) }
+#
+#       let(:state) { Class.new(ApplicationState).new }
+#
+#       it { is_expected.to read_state :foo }
+#       it { is_expected.to read_state :bar }
+#     end
+
+RSpec::Matchers.define :read_state do |field|
+  match { |operation| expect(operation._state_readers).to include field }
+  description { "read state" }
+  failure_message { "expected #{described_class} to read state #{field}" }
+end

data/lib/flow/rspec/custom_matchers/write_state.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# RSpec matcher that tests usage of `ApplicationOperation.state_writer`
+#
+#     class SomeTask < ApplicationOperation
+#       state_writer :foo
+#       state_writer :bar
+#     end
+#
+#     RSpec.describe SomeTask, type: :operation do
+#       subject { described_class.new(state) }
+#
+#       let(:state) { Class.new(ApplicationState).new }
+#
+#       it { is_expected.to write_state :foo }
+#       it { is_expected.to write_state :bar }
+#     end
+
+RSpec::Matchers.define :write_state do |field|
+  match { |operation| expect(operation._state_writers).to include field }
+  description { "write state" }
+  failure_message { "expected #{described_class} to write state #{field}" }
+end

data/lib/flow/spec_helper.rb

@@ -2,7 +2,7 @@
 
 require "spicerack/spec_helper"
 
-require_relative "spec_helper/custom_matchers"
-require_relative "spec_helper/shared_contexts"
-require_relative "spec_helper/shoulda_matcher_helper"
-require_relative "spec_helper/rspec_configuration"
+require_relative "rspec/custom_matchers"
+require_relative "rspec/shared_contexts"
+require_relative "rspec/shoulda_matcher_helper"
+require_relative "rspec/configuration"

data/lib/flow/state/output.rb

@@ -38,7 +38,7 @@ module Flow
 
         def ensure_validation_before(method)
           around_method method do |*arguments|
-            raise Flow::State::Errors::NotValidated unless validated?
+            raise NotValidatedError unless validated?
 
             super(*arguments)
           end

data/lib/flow/state_base.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-require_relative "state/errors/not_validated"
-
 require_relative "state/status"
 require_relative "state/output"
 
 # A **State** is an aggregation of input and derived data.
 module Flow
   class StateBase < Spicerack::InputModel
-    include Flow::State::Status
-    include Flow::State::Output
+    include State::Status
+    include State::Output
   end
 end

data/lib/flow/state_proxy.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# A **StateProxy** adapts a **State** to an **Operation** through an Operation's `state_*` accessors.
+module Flow
+  class StateProxy
+    def initialize(state)
+      @state = state
+    end
+
+    # @deprecated
+    def method_missing(method_name, *arguments, &block)
+      return super unless state.respond_to?(method_name)
+
+      ActiveSupport::Deprecation.warn(
+        "Direct state access of `#{method_name}' on #{state.inspect} will be removed in a future version of flow. "\
+        "Use a state accessor instead - for more information see github/freshly/flow/deprecation_notice"
+      )
+      state.public_send(method_name, *arguments, &block)
+    end
+
+    # @deprecated
+    def respond_to_missing?(method_name, include_private = false)
+      state.respond_to?(method_name) || super
+    end
+
+    private
+
+    attr_reader :state
+  end
+end

data/lib/flow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Flow
-  VERSION = "0.10.4"
+  VERSION = "0.10.5"
 end

data/lib/generators/flow/operation/templates/operation.rb.erb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 class <%= class_name %> < ApplicationOperation
+  # state_accessor :foo
+  # state_reader :bar
+  # state_writer :baz
+
   def behavior
     # Define what this operation does here
   end

data/lib/generators/rspec/application_operation/templates/application_operation_spec.rb

@@ -3,15 +3,19 @@
 require "rails_helper"
 
 RSpec.describe ApplicationOperation, type: :operation do
-  subject(:operation) { described_class.new(state) }
-
-  let(:state) { double }
+  subject { described_class }
 
   it { is_expected.to inherit_from Flow::OperationBase }
 
   describe "#execute" do
     subject(:execute) { operation.execute }
-
-    it "has some behavior"
+    
+    context "when unsuccessful" do
+      pending "describe the effects of an unsuccessful `Operation#execute` (or delete) #{__FILE__}"
+    end
+    
+    context "when successful" do
+      pending "describe the effects of a successful `Operation#execute` (or delete) #{__FILE__}"
+    end
   end
 end

data/lib/generators/rspec/operation/templates/operation_spec.rb.erb

@@ -19,6 +19,10 @@ RSpec.describe <%= class_name %>, type: :operation do
 
   it { is_expected.to inherit_from ApplicationOperation }
 
+  # it { is_expected.to access_state :foo }
+  # it { is_expected.to read_state :bar }
+  # it { is_expected.to write_state :baz }
+
   describe "#execute" do
     subject(:execute) { operation.execute }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: flow
 version: !ruby/object:Gem::Version
-  version: 0.10.4
+  version: 0.10.5
 platform: ruby
 authors:
 - Eric Garside
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-07 00:00:00.000000000 Z
+date: 2020-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -174,6 +174,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bcrypt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.13
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.13
 - !ruby/object:Gem::Dependency
   name: rspice
   requirement: !ruby/object:Gem::Requirement
@@ -242,7 +256,6 @@ files:
 - lib/flow/concerns/transaction_wrapper.rb
 - lib/flow/flow/callbacks.rb
 - lib/flow/flow/core.rb
-- lib/flow/flow/errors/state_invalid.rb
 - lib/flow/flow/flux.rb
 - lib/flow/flow/operations.rb
 - lib/flow/flow/status.rb
@@ -253,29 +266,30 @@ files:
 - lib/flow/operation/callbacks.rb
 - lib/flow/operation/core.rb
 - lib/flow/operation/error_handler.rb
-- lib/flow/operation/errors/already_executed.rb
-- lib/flow/operation/errors/already_rewound.rb
 - lib/flow/operation/execute.rb
 - lib/flow/operation/failures.rb
 - lib/flow/operation/status.rb
 - lib/flow/operation/transactions.rb
 - lib/flow/operation_base.rb
+- lib/flow/rspec/configuration.rb
+- lib/flow/rspec/custom_matchers.rb
+- lib/flow/rspec/custom_matchers/access_state.rb
+- lib/flow/rspec/custom_matchers/define_failure.rb
+- lib/flow/rspec/custom_matchers/define_output.rb
+- lib/flow/rspec/custom_matchers/handle_error.rb
+- lib/flow/rspec/custom_matchers/have_on_state.rb
+- lib/flow/rspec/custom_matchers/read_state.rb
+- lib/flow/rspec/custom_matchers/use_operations.rb
+- lib/flow/rspec/custom_matchers/wrap_in_transaction.rb
+- lib/flow/rspec/custom_matchers/write_state.rb
+- lib/flow/rspec/shared_contexts.rb
+- lib/flow/rspec/shared_contexts/with_failing_operation.rb
+- lib/flow/rspec/shoulda_matcher_helper.rb
 - lib/flow/spec_helper.rb
-- lib/flow/spec_helper/custom_matchers.rb
-- lib/flow/spec_helper/custom_matchers/define_failure.rb
-- lib/flow/spec_helper/custom_matchers/define_output.rb
-- lib/flow/spec_helper/custom_matchers/handle_error.rb
-- lib/flow/spec_helper/custom_matchers/have_on_state.rb
-- lib/flow/spec_helper/custom_matchers/use_operations.rb
-- lib/flow/spec_helper/custom_matchers/wrap_in_transaction.rb
-- lib/flow/spec_helper/rspec_configuration.rb
-- lib/flow/spec_helper/shared_contexts.rb
-- lib/flow/spec_helper/shared_contexts/with_failing_operation.rb
-- lib/flow/spec_helper/shoulda_matcher_helper.rb
-- lib/flow/state/errors/not_validated.rb
 - lib/flow/state/output.rb
 - lib/flow/state/status.rb
 - lib/flow/state_base.rb
+- lib/flow/state_proxy.rb
 - lib/flow/version.rb
 - lib/generators/flow/USAGE
 - lib/generators/flow/application_flow/USAGE
@@ -334,7 +348,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubyforge_project: 
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Write modular and reusable business logic that's understandable and maintainable.

data/lib/flow/flow/errors/state_invalid.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module Flow
-  module Errors
-    class StateInvalid < StandardError; end
-  end
-end

data/lib/flow/operation/errors/already_executed.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Flow
-  module Operation
-    module Errors
-      class AlreadyExecuted < StandardError; end
-    end
-  end
-end

data/lib/flow/operation/errors/already_rewound.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Flow
-  module Operation
-    module Errors
-      class AlreadyRewound < StandardError; end
-    end
-  end
-end

data/lib/flow/state/errors/not_validated.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Flow
-  module State
-    module Errors
-      class NotValidated < StandardError; end
-    end
-  end
-end