statefully 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbde1d672d9e234ef6437588fc07a363f48045b9
-  data.tar.gz: f39ccf8385e78a68c4347e480d221f377037c098
+  metadata.gz: 1962b427e73969e2c630c8fe1c22a0f55e7f2fc4
+  data.tar.gz: 3f5b532398769ecdaeaeb897368230022d22825a
 SHA512:
-  metadata.gz: 7a255b7ca151f1fa64ebf9f46cda4ba21a83403bdf18d70e276b2d1d68d60d31a27f5c6a463053f8647da55e566914629b3386beb257f58c4f3d8669bf9001be
-  data.tar.gz: b74b2c98d7935cbb0be0e610120d790ec7accaef99e05f0a3911e0a682dbad28778a59ffd5e039889b4d9223cac2d97da9a384cbe7047b8d6135374185377ea5
+  metadata.gz: e0189ab5e902b110f36e6189d7c81b88a8b53a99c2015bec935cf54cafb2fcc71747810247297acd609b0d1517a6440b89f821b0d4f853d18632768470400358
+  data.tar.gz: df202b95fe53c904ebb4d2235a759622e6583ee674eca303274b1685f91782af247f82b50b1ffe47fb33d25618d7da3d684c41a99c8906a311f178442edc034a

data/lib/statefully/state.rb

@@ -29,12 +29,16 @@ module Statefully
       !success?
     end
 
+    def finished?
+      false
+    end
+
     def resolve
       self
     end
 
     def inspect
-      inspect_details({})
+      _inspect_details({})
     end
 
     private
@@ -47,7 +51,7 @@ module Statefully
     end
     private_class_method :new
 
-    def inspect_details(extras)
+    def _inspect_details(extras)
       details = [self.class.name]
       fields = _members.merge(extras)
       details << Inspect.from_fields(fields) unless fields.empty?
@@ -74,6 +78,15 @@ module Statefully
       key?(name.to_sym) || %w[? !].any?(&str_name.method(:end_with?)) || super
     end
 
+    class Missing < RuntimeError
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+        super("field '#{field}' missing from state")
+      end
+    end # class Missing
+
     class None < State
       include Singleton
 
@@ -93,15 +106,16 @@ module Statefully
     # Success is a not-yet failed State.
     class Success < State
       def succeed(**values)
-        self
-          .class
-          .send(:new, _members.merge(values).freeze, previous: self)
-          .freeze
+        self.class.send(:new, _members.merge(values).freeze, previous: self)
       end
 
       def fail(error)
         Failure.send(:new, _members, error, previous: self).freeze
       end
+
+      def finish
+        Finished.send(:new, _members, previous: self).freeze
+      end
     end # class Success
     private_constant :Success
 
@@ -127,18 +141,21 @@ module Statefully
       end
 
       def inspect
-        inspect_details(error: error.inspect)
+        _inspect_details(error: error.inspect)
       end
     end # class Failure
+    private_constant :Failure
 
-    class Missing < RuntimeError
-      attr_reader :field
+    class Finished < State
+      def diff
+        :finished
+      end
 
-      def initialize(field)
-        @field = field
-        super("field '#{field}' missing from state")
+      def finished?
+        true
       end
-    end # class Missing
+    end # class Finished
+    private_constant :Finished
 
     module Inspect
       def from_fields(input)

data/spec/spec_helper.rb

@@ -2,4 +2,11 @@ require 'bundler/setup'
 Bundler.setup
 
 require 'pry'
+
+require 'simplecov'
+SimpleCov.start
+
+require 'codecov'
+SimpleCov.formatter = SimpleCov::Formatter::Codecov
+
 require 'statefully'

data/spec/state_spec.rb

@@ -33,21 +33,29 @@ module Statefully
       it { expect(subject.resolve).to eq subject }
       it { expect(subject).to be_success }
       it { expect(subject).not_to be_failure }
+      it { expect(subject).not_to be_finished }
     end # describe 'trivial readers'
 
+    shared_examples 'successful_state' do
+      it { expect(next_state).to be_success }
+      it { expect(next_state.old_key).to eq val }
+
+      it { expect(next_state.previous).to eq subject }
+      it { expect(next_state.resolve).to eq next_state }
+    end # shared_examples 'successful_state'
+
     describe '#succeed' do
-      let(:new_val) { 'new_val' }
-      let(:succeeded) { subject.succeed(new_key: new_val) }
+      let(:new_val)    { 'new_val' }
+      let(:next_state) { subject.succeed(new_key: new_val) }
+
+      it_behaves_like 'successful_state'
 
-      it { expect(succeeded).to be_success }
-      it { expect(succeeded.old_key).to eq val }
-      it { expect(succeeded.new_key).to eq new_val }
-      it { expect(succeeded.keys).to eq %i[old_key new_key] }
-      it { expect(succeeded.previous).to eq subject }
-      it { expect(succeeded.resolve).to eq succeeded }
+      it { expect(next_state).not_to be_finished }
+      it { expect(next_state.new_key).to eq new_val }
+      it { expect(next_state.keys).to eq %i[old_key new_key] }
 
       context 'with history' do
-        let(:history) { succeeded.history }
+        let(:history) { next_state.history }
 
         it { expect(history.size).to eq 2 }
         it { expect(history.first.added).to include :new_key }
@@ -56,28 +64,47 @@ module Statefully
     end # describe '#succeed'
 
     describe '#fail' do
-      let(:error)  { RuntimeError.new('snakes on a plane') }
-      let(:failed) { subject.fail(error) }
+      let(:error)      { RuntimeError.new('snakes on a plane') }
+      let(:next_state) { subject.fail(error) }
 
-      it { expect(failed).not_to be_success }
-      it { expect(failed).to be_failure }
-      it { expect(failed.old_key).to eq val }
-      it { expect(failed.previous).to eq subject }
-      it { expect(failed.error).to eq error }
+      it { expect(next_state).not_to be_success }
+      it { expect(next_state).to be_failure }
+      it { expect(next_state).not_to be_finished }
+      it { expect(subject).not_to be_finished }
+      it { expect(next_state.old_key).to eq val }
+      it { expect(next_state.previous).to eq subject }
+      it { expect(next_state.error).to eq error }
 
       it 'raises passed error on #resolve' do
-        expect { failed.resolve }.to raise_error do |err|
+        expect { next_state.resolve }.to raise_error do |err|
           expect(err).to eq error
         end
       end
 
       context 'with history' do
-        let(:history) { failed.history }
+        let(:history) { next_state.history }
 
         it { expect(history.size).to eq 2 }
         it { expect(history.first).to eq error }
         it { expect(history.last.added).to include :old_key }
       end # context 'with history'
     end # describe '#fail'
+
+    describe '#finish' do
+      let(:new_val)    { 'new_val' }
+      let(:next_state) { subject.finish }
+
+      it_behaves_like 'successful_state'
+
+      it { expect(next_state).to be_finished }
+
+      context 'with history' do
+        let(:history) { next_state.history }
+
+        it { expect(history.size).to eq 2 }
+        it { expect(history.first).to eq :finished }
+        it { expect(history.last.added).to include :old_key }
+      end # context 'with history'
+    end # describe '#finish'
   end # describe 'State::Success'
 end # module Statefully

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statefully
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Marcin Wyszynski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-20 00:00:00.000000000 Z
+date: 2017-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler