statefully 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 325ca9dcf556d7c2493333c687e6f2c1046bc2c8
+  data.tar.gz: 8b7127063fd59e6ddefb39b6a945b88bd46f09b2
+SHA512:
+  metadata.gz: 20a634a516a98ca760fafad39b6df32e03415f6e5a46f55726ba179c6b3dde95c8e3ca153c76c697731fc34659f4a20a6dc850174a35ef3529a16ea348ae37d8
+  data.tar.gz: 5c5c8195b0317a7f2edba1ae64f27971f719aa49068a2cebc6146d7b67e9a7e666286d8c21547b13d6e053db0c85c501be146038eebd9c4470da50204c95717c

data/lib/statefully/diff.rb

@@ -0,0 +1,131 @@
+require 'set'
+require 'singleton'
+
+module Statefully
+  class Diff
+    attr_reader :added, :changed
+
+    def self.create(current, previous)
+      changes = Builder.new(current, previous).build
+      changes.empty? ? None.instance : new(**changes).freeze
+    end
+
+    def empty?
+      false
+    end
+
+    def inspect
+      "<#{self.class.name} #{inspect_details}>"
+    end
+
+    def added?(key)
+      added.key?(key)
+    end
+
+    def changed?(key)
+      changed.key?(key)
+    end
+
+    private
+
+    def inspect_details
+      [inspect_added, inspect_changed].compact.join(', ')
+    end
+
+    def inspect_added
+      added.empty? ? nil : "added=#{Inspect.from_hash(added)}"
+    end
+
+    def inspect_changed
+      changed.empty? ? nil : "changed=#{Inspect.from_hash(changed)}"
+    end
+
+    def initialize(added:, changed:)
+      @added = added.freeze
+      @changed = changed.freeze
+    end
+
+    class None
+      include Singleton
+
+      def empty?
+        true
+      end
+
+      def added
+        {}
+      end
+
+      def changed
+        false
+      end
+
+      def inspect
+        "<#{self.class.name}>"
+      end
+    end # class None
+
+    class Change
+      attr_reader :current, :previous
+
+      def initialize(current, previous)
+        @current = current
+        @previous = previous
+      end
+
+      def none?
+        @current == @previous
+      end
+
+      def inspect
+        "#<#{self.class.name} " \
+        "#{Inspect.from_fields(current: current, previous: previous)}>"
+      end
+    end # class Change
+
+    class Builder
+      def initialize(current, previous)
+        @current = current
+        @previous = previous
+      end
+
+      def build
+        empty? ? {} : { added: added, changed: changed }
+      end
+
+      private
+
+      def added
+        @added ||=
+          (current_keys - previous_keys)
+          .map { |key| [key, @current.fetch(key)] }
+          .to_h
+      end
+
+      def changed
+        @changed ||=
+          (current_keys & previous_keys)
+          .map { |key| [key, change_for(key)] }
+          .to_h
+          .reject { |_, val| val.none? }
+      end
+
+      def change_for(key)
+        Change.new(@current.fetch(key), @previous.fetch(key)).freeze
+      end
+
+      def empty?
+        added.empty? && changed.empty?
+      end
+
+      def current_keys
+        Set.new(@current.keys)
+      end
+
+      def previous_keys
+        Set.new(@previous.keys)
+      end
+    end # class Builder
+    private_constant :Builder
+  end # class Diff
+end # module Statefully

data/lib/statefully/state.rb

@@ -0,0 +1,146 @@
+require 'forwardable'
+require 'singleton'
+
+module Statefully
+  class State
+    extend Forwardable
+
+    attr_reader :previous
+    def_delegators :@_members, :key?, :keys, :fetch
+
+    def self.create(**values)
+      Success.send(:new, values, previous: None.instance).freeze
+    end
+
+    def diff
+      Diff.create(self, previous)
+    end
+
+    def history
+      ([diff] + previous.history).freeze
+    end
+
+    def success?
+      true
+    end
+
+    def resolve
+      self
+    end
+
+    def inspect
+      inspect_details({})
+    end
+
+    private
+
+    attr_reader :_members
+
+    def initialize(values, previous:)
+      @_members = values.freeze
+      @previous = previous
+    end
+    private_class_method :new
+
+    def inspect_details(extras)
+      details = [self.class.name]
+      fields = _members.merge(extras)
+      details << Inspect.from_fields(fields) unless fields.empty?
+      "#<#{details.join(' ')}>"
+    end
+
+    # This method reeks of :reek:TooManyStatements.
+    def method_missing(name, *args, &block)
+      sym_name = name.to_sym
+      return fetch(sym_name) if key?(sym_name)
+      str_name = name.to_s
+      modifier = str_name[-1]
+      return super unless %w[? !].include?(modifier)
+      base = str_name[0...-1].to_sym
+      known = key?(base)
+      return known if modifier == '?'
+      return fetch(base) if known
+      raise Missing, base
+    end
+
+    # This method reeks of :reek:BooleanParameter.
+    def respond_to_missing?(name, _include_private = false)
+      str_name = name.to_s
+      key?(name.to_sym) || %w[? !].any?(&str_name.method(:end_with?)) || super
+    end
+
+    class None < State
+      include Singleton
+
+      def history
+        []
+      end
+
+      private
+
+      def initialize
+        @_members = {}.freeze
+        @previous = self
+      end
+    end # class None
+    private_constant :None
+
+    # Success is a not-yet failed State.
+    class Success < State
+      def succeed(**values)
+        self
+          .class
+          .send(:new, _members.merge(values).freeze, previous: self)
+          .freeze
+      end
+
+      def fail(error)
+        Failure.send(:new, _members, error, previous: self).freeze
+      end
+    end # class Success
+    private_constant :Success
+
+    # Failure is a failed State.
+    class Failure < State
+      attr_reader :error
+
+      def initialize(values, error, previous:)
+        super(values, previous: previous)
+        @error = error
+      end
+
+      def diff
+        error
+      end
+
+      def success?
+        false
+      end
+
+      def resolve
+        raise error
+      end
+
+      def inspect
+        inspect_details(error: error.inspect)
+      end
+    end # class Failure
+
+    class Missing < RuntimeError
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+        super("field '#{field}' missing from state")
+      end
+    end # class Missing
+
+    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

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

data/spec/diff_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+module Statefully
+  describe Diff do
+    subject { described_class.create(current, previous) }
+
+    context 'when key added' do
+      let(:current)  { State.create(key: 'val') }
+      let(:previous) { State.create }
+
+      it { expect(subject).not_to be_empty }
+      it { expect(subject.added).to have_key(:key) }
+      it { expect(subject.added?(:key)).to be_truthy }
+      it { expect(subject.added.fetch(:key)).to eq 'val' }
+      it { expect(subject.changed).to be_empty }
+    end # context 'when key added'
+
+    context 'when key changed' do
+      let(:current)  { State.create(key: 'new') }
+      let(:previous) { State.create(key: 'old') }
+
+      it { expect(subject).not_to be_empty }
+      it { expect(subject.added).to be_empty }
+      it { expect(subject.changed).to have_key(:key) }
+      it { expect(subject.changed?(:key)).to be_truthy }
+
+      context 'with change' do
+        let(:change) { subject.changed.fetch(:key) }
+
+        it { expect(change.current).to eq 'new' }
+        it { expect(change.previous).to eq 'old' }
+      end # context 'with change'
+    end # context 'when key changed'
+
+    context 'when nothing changed' do
+      let(:current)  { State.create(key: 'key') }
+      let(:previous) { current }
+
+      it { expect(subject).to be_empty }
+    end # context 'when nothing changed'
+  end # describe Diff
+end # module Statefully

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'pry'
+require 'statefully'

data/spec/state_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Statefully
+  describe State do
+    describe '.create' do
+      subject { described_class.create(key: 'val') }
+      it      { expect(subject).to be_success }
+    end # describe '.create'
+  end # describe State
+
+  describe 'State::Success' do
+    let(:val) { 'val' }
+
+    subject { State.create(old_key: val) }
+
+    describe 'methods delegated to the underlying Hash' do
+      it { expect(subject.keys).to eq [:old_key] }
+      it { expect(subject.key?(:old_key)).to be_truthy }
+    end # describe 'methods delegated to the underlying Hash'
+
+    describe "methods dynamically dispatched using 'method_missing'" do
+      it { expect(subject.old_key).to eq val }
+      it { expect(subject.old_key?).to be_truthy }
+      it { expect(subject.old_key!).to eq val }
+
+      it { expect { subject.new_key }.to raise_error NoMethodError }
+      it { expect(subject.new_key?).to be_falsey }
+      it { expect { subject.new_key! }.to raise_error State::Missing }
+    end # describe "methods dynamically dispatched using 'method_missing'"
+
+    describe 'trivial readers' do
+      it { expect(subject.resolve).to eq subject }
+      it { expect(subject).to be_success }
+    end # describe 'trivial readers'
+
+    describe '#succeed' do
+      let(:new_val) { 'new_val' }
+      let(:succeeded) { subject.succeed(new_key: new_val) }
+
+      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 }
+
+      context 'with history' do
+        let(:history) { succeeded.history }
+
+        it { expect(history.size).to eq 2 }
+        it { expect(history.first.added).to include :new_key }
+        it { expect(history.last.added).to include :old_key }
+      end # context 'with history'
+    end # describe '#succeed'
+
+    describe '#fail' do
+      let(:error)  { RuntimeError.new('snakes on a plane') }
+      let(:failed) { subject.fail(error) }
+
+      it { expect(failed).not_to be_success }
+      it { expect(failed.old_key).to eq val }
+      it { expect(failed.previous).to eq subject }
+      it { expect(failed.error).to eq error }
+
+      it 'raises passed error on #resolve' do
+        expect { failed.resolve }.to raise_error do |err|
+          expect(err).to eq error
+        end
+      end
+
+      context 'with history' do
+        let(:history) { failed.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'
+  end # describe 'State::Success'
+end # module Statefully

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: statefully
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Marcin Wyszynski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.14.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.14.6
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+description: Immutable state with helpers to build awesome things
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/statefully.rb
+- lib/statefully/diff.rb
+- lib/statefully/state.rb
+- spec/diff_spec.rb
+- spec/spec_helper.rb
+- spec/state_spec.rb
+homepage: https://github.com/marcinwyszynski/statefully
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Immutable state with helpers to build awesome things
+test_files:
+- spec/diff_spec.rb
+- spec/spec_helper.rb
+- spec/state_spec.rb