statefully 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1962b427e73969e2c630c8fe1c22a0f55e7f2fc4
-  data.tar.gz: 3f5b532398769ecdaeaeb897368230022d22825a
+  metadata.gz: 97acdf9e907dd51ad5227ef53828030d0943d35d
+  data.tar.gz: 3d9564c5fa59479e584e38c94ebdf504e1e1894d
 SHA512:
-  metadata.gz: e0189ab5e902b110f36e6189d7c81b88a8b53a99c2015bec935cf54cafb2fcc71747810247297acd609b0d1517a6440b89f821b0d4f853d18632768470400358
-  data.tar.gz: df202b95fe53c904ebb4d2235a759622e6583ee674eca303274b1685f91782af247f82b50b1ffe47fb33d25618d7da3d684c41a99c8906a311f178442edc034a
+  metadata.gz: 94467d76d84d115d674c84db44022a6c4e76d81e417b1ca48eb613734802fd80c420f4a79832aa248f1622e9260c26d1bdfb8c72f9c73f078a14df230cde96b5
+  data.tar.gz: 732e6d9e831787099ae318d706a0c6d95280ea8ee06217e1bc0b3f9a30bd058d150b8053a972ffd631a626e3e75937cac403a5fc9e14609f0413f870e6da9894

data/lib/statefully/diff.rb

@@ -2,52 +2,55 @@ require 'set'
 require 'singleton'
 
 module Statefully
-  class Diff
-    attr_reader :added, :changed
-
-    def self.create(current, previous)
+  module Diff
+    # This method reeks of :reek:FeatureEnvy (of current).
+    def create(current, previous)
+      return current.diff if current.failed? || current.finished?
       changes = Builder.new(current, previous).build
-      changes.empty? ? None.instance : new(**changes).freeze
+      changes.empty? ? Unchanged.instance : Changed.new(**changes).freeze
     end
+    module_function :create
 
-    def empty?
-      false
-    end
+    class Changed
+      attr_reader :added, :changed
 
-    def inspect
-      "<#{self.class.name} #{inspect_details}>"
-    end
+      def empty?
+        false
+      end
 
-    def added?(key)
-      added.key?(key)
-    end
+      def inspect
+        "#<#{self.class.name} #{inspect_details}>"
+      end
 
-    def changed?(key)
-      changed.key?(key)
-    end
+      def added?(key)
+        added.key?(key)
+      end
 
-    private
+      def changed?(key)
+        changed.key?(key)
+      end
 
-    def inspect_details
-      [inspect_added, inspect_changed].compact.join(', ')
-    end
+      private
 
-    def inspect_added
-      added.empty? ? nil : "added=#{Inspect.from_hash(added)}"
-    end
+      def inspect_details
+        [inspect_added, inspect_changed].compact.join(', ')
+      end
 
-    def inspect_changed
-      changed.empty? ? nil : "changed=#{Inspect.from_hash(changed)}"
-    end
+      def inspect_added
+        added.empty? ? nil : "added=#{Inspect.from_hash(added)}"
+      end
 
-    def initialize(added:, changed:)
-      @added = added.freeze
-      @changed = changed.freeze
-    end
+      def inspect_changed
+        changed.empty? ? nil : "changed=#{Inspect.from_hash(changed)}"
+      end
 
-    class None
-      include Singleton
+      def initialize(added:, changed:)
+        @added = added.freeze
+        @changed = changed.freeze
+      end
+    end # class Changed
 
+    module NoChanges
       def empty?
         true
       end
@@ -59,11 +62,33 @@ module Statefully
       def changed
         {}
       end
+    end # module NoChanges
+    private_constant :NoChanges
+
+    class Unchanged
+      include Singleton
+      include NoChanges
 
       def inspect
-        "<#{self.class.name}>"
+        "#<#{self.class.name}>"
       end
-    end # class None
+    end # class Unchanged
+
+    class Failed
+      include NoChanges
+      attr_reader :error
+
+      def initialize(error)
+        @error = error
+      end
+
+      def inspect
+        "#<#{self.class.name} error=#{error.inspect}>"
+      end
+    end # class Failed
+
+    class Finished < Unchanged
+    end # class Finished
 
     class Change
       attr_reader :current, :previous
@@ -127,5 +152,5 @@ module Statefully
       end
     end # class Builder
     private_constant :Builder
-  end # class Diff
+  end # module Diff
 end # module Statefully

data/lib/statefully/inspect.rb

@@ -0,0 +1,14 @@
+module Statefully
+  module Inspect
+    def from_hash(input)
+      '{' + input.map { |key, val| "#{key}: #{val.inspect}" }.join(', ') + '}'
+    end
+    module_function :from_hash
+
+    def from_fields(input)
+      input.map { |key, val| "#{key}=#{val.inspect}" }.join(', ')
+    end
+    module_function :from_fields
+  end # module Inspect
+  private_constant :Inspect
+end # module Statefully

data/lib/statefully/state.rb

@@ -21,12 +21,12 @@ module Statefully
       ([diff] + previous.history).freeze
     end
 
-    def success?
+    def successful?
       true
     end
 
-    def failure?
-      !success?
+    def failed?
+      !successful?
     end
 
     def finished?
@@ -129,10 +129,10 @@ module Statefully
       end
 
       def diff
-        error
+        Diff::Failed.new(error).freeze
       end
 
-      def success?
+      def successful?
         false
       end
 
@@ -146,9 +146,12 @@ module Statefully
     end # class Failure
     private_constant :Failure
 
+    # Finished state is a state which is successful, but should not be processed
+    # any further. This could be useful for things like early returns.
     class Finished < State
+      # This method reeks of :reek:UtilityFunction - just implementing an API.
       def diff
-        :finished
+        Diff::Finished.instance
       end
 
       def finished?
@@ -156,13 +159,5 @@ module Statefully
       end
     end # class Finished
     private_constant :Finished
-
-    module Inspect
-      def from_fields(input)
-        input.map { |key, val| "#{key}=#{val.inspect}" }.join(', ')
-      end
-      module_function :from_fields
-    end # module Inspect
-    private_constant :Inspect
   end # class State
 end # module Statefully

data/lib/statefully.rb

@@ -1,2 +1,3 @@
 require 'statefully/diff'
+require 'statefully/inspect'
 require 'statefully/state'

data/spec/diff_spec.rb

@@ -13,6 +13,9 @@ module Statefully
       it { expect(subject.added?(:key)).to be_truthy }
       it { expect(subject.added.fetch(:key)).to eq 'val' }
       it { expect(subject.changed).to be_empty }
+
+      it { expect(subject.inspect).to start_with '#<Statefully::Diff::Changed' }
+      it { expect(subject.inspect).to include 'added={key: "val"}>' }
     end # context 'when key added'
 
     context 'when key changed' do
@@ -24,6 +27,8 @@ module Statefully
       it { expect(subject.changed).to have_key(:key) }
       it { expect(subject.changed?(:key)).to be_truthy }
 
+      it { expect(subject.inspect).to include 'changed=' }
+
       context 'with change' do
         let(:change) { subject.changed.fetch(:key) }
 
@@ -37,6 +42,35 @@ module Statefully
       let(:previous) { current }
 
       it { expect(subject).to be_empty }
+      it { expect(subject.inspect).to eq '#<Statefully::Diff::Unchanged>' }
     end # context 'when nothing changed'
+
+    shared_examples 'diff_is_empty' do
+      it { expect(subject).to be_empty }
+      it { expect(subject.added).to be_empty }
+      it { expect(subject.changed).to be_empty }
+    end # shared_examples 'diff_is_empty'
+
+    context 'when failed' do
+      let(:error)    { RuntimeError.new('boo!') }
+      let(:previous) { State.create }
+      let(:current)  { previous.fail(error) }
+
+      it_behaves_like 'diff_is_empty'
+
+      it { expect(subject.error).to eq error }
+
+      it { expect(subject.inspect).to start_with '#<Statefully::Diff::Failed' }
+      it { expect(subject.inspect).to include 'error=#<RuntimeError: boo!>' }
+    end # context 'when failed'
+
+    context 'when finished' do
+      let(:previous) { State.create }
+      let(:current)  { previous.finish }
+
+      it_behaves_like 'diff_is_empty'
+
+      it { expect(subject.inspect).to eq '#<Statefully::Diff::Finished>' }
+    end # context 'when finished'
   end # describe Diff
 end # module Statefully

data/spec/state_spec.rb

@@ -4,7 +4,7 @@ module Statefully
   describe State do
     describe '.create' do
       subject { described_class.create(key: 'val') }
-      it      { expect(subject).to be_success }
+      it      { expect(subject).to be_successful }
     end # describe '.create'
   end # describe State
 
@@ -31,13 +31,19 @@ module Statefully
 
     describe 'trivial readers' do
       it { expect(subject.resolve).to eq subject }
-      it { expect(subject).to be_success }
-      it { expect(subject).not_to be_failure }
+      it { expect(subject).to be_successful }
+      it { expect(subject).not_to be_failed }
       it { expect(subject).not_to be_finished }
     end # describe 'trivial readers'
 
+    describe '#inspect' do
+      let(:expected) { '#<Statefully::State::Success old_key="val">' }
+
+      it { expect(subject.inspect).to eq expected }
+    end # describe '#inspect'
+
     shared_examples 'successful_state' do
-      it { expect(next_state).to be_success }
+      it { expect(next_state).to be_successful }
       it { expect(next_state.old_key).to eq val }
 
       it { expect(next_state.previous).to eq subject }
@@ -64,11 +70,11 @@ module Statefully
     end # describe '#succeed'
 
     describe '#fail' do
-      let(:error)      { RuntimeError.new('snakes on a plane') }
+      let(:error)      { RuntimeError.new('boo!') }
       let(:next_state) { subject.fail(error) }
 
-      it { expect(next_state).not_to be_success }
-      it { expect(next_state).to be_failure }
+      it { expect(next_state).not_to be_successful }
+      it { expect(next_state).to be_failed }
       it { expect(next_state).not_to be_finished }
       it { expect(subject).not_to be_finished }
       it { expect(next_state.old_key).to eq val }
@@ -81,11 +87,19 @@ module Statefully
         end
       end
 
+      describe '#inspect' do
+        let(:inspect) { next_state.inspect }
+
+        it { expect(inspect).to start_with '#<Statefully::State::Failure' }
+        it { expect(inspect).to include 'old_key="val"' }
+        it { expect(inspect).to include 'error="#<RuntimeError: boo!>"' }
+      end # describe '#inspect'
+
       context 'with history' do
         let(:history) { next_state.history }
 
         it { expect(history.size).to eq 2 }
-        it { expect(history.first).to eq error }
+        it { expect(history.first.error).to eq error }
         it { expect(history.last.added).to include :old_key }
       end # context 'with history'
     end # describe '#fail'
@@ -102,7 +116,7 @@ module Statefully
         let(:history) { next_state.history }
 
         it { expect(history.size).to eq 2 }
-        it { expect(history.first).to eq :finished }
+        it { expect(history.first).to eq Diff::Finished.instance }
         it { expect(history.last.added).to include :old_key }
       end # context 'with history'
     end # describe '#finish'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: statefully
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Marcin Wyszynski
@@ -52,6 +52,7 @@ extra_rdoc_files: []
 files:
 - lib/statefully.rb
 - lib/statefully/diff.rb
+- lib/statefully/inspect.rb
 - lib/statefully/state.rb
 - spec/diff_spec.rb
 - spec/spec_helper.rb