decider 0.9.0

data/examples/decide.md

@@ -0,0 +1,180 @@
+# Decide
+
+## Match by command
+
+```ruby
+Command = Data.define(:value)
+State = Data.define(:value)
+
+decider = Decider.define do
+  initial_state State.new(value: 5)
+
+  decide Command do
+    # emit events
+    emit Event.new(
+      value: command.value + state.value
+    )
+  end
+end
+
+decider.decide Command.new(value: 10), decider.initial_state
+#> [#<data Event value=15>]
+```
+
+## Match by command and state
+
+```ruby
+decider = Decider.define do
+  initial_state :turned_off
+
+  decide :turn_on, :turned_off do
+    emit :turned_on
+  end
+
+  decide :turn_off, :turned_on do
+    emit :turned_off
+  end
+end
+
+decider.decide :turn_on, decider.initial_state
+#> [:turned_on]
+decider.decide :turn_off, :turned_on
+#> [:turned_off]
+decider.decide :turn_on, :turned_on
+#> []
+```
+
+## Match by pattern matching
+
+State = Data.define(:status)
+TurnOn = Data.define
+TurnOff = Data.define
+
+```ruby
+decider = Decider.define do
+  initial_state State.new(status: :turned_off)
+
+  decide proc { [command, state] in [TurnOn, State(status: :turned_off)] } do
+    emit :turned_on
+  end
+
+  decide proc { [command, state] in [TurnOff, State(status: :turned_on)] } do
+    emit :turned_off
+  end
+end
+
+decider.decide :turn_on, decider.initial_state
+#> [:turned_on]
+decider.decide :turn_off, :turned_on
+#> [:turned_off]
+decider.decide :turn_on, :turned_on
+#> []
+```
+
+## Handling unknown commands
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+end
+```
+
+Return empty list of events (nothing changed) by default:
+
+```ruby
+decider.decide :unknown, decider.initial_state
+#> []
+```
+
+If you want to raise error, define a catch-all as last one:
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+
+  decide proc { true } do
+    raise ArgumentError, "Unknown command #{command}"
+  end
+end
+decider.decide :unknown, decider.initial_state
+#> Unknown command unknown (ArgumentError)
+```
+
+## Commands
+
+Commands can be primitives like symbols:
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+
+  decide proc { [command, state] in [:start, :initial | :stopped] } do
+    emit :started
+  end
+
+  decide proc { [command, state] in [:stop, :started] } do
+    emit :stopped
+  end
+end
+
+decider.decide :start, decider.initial_state
+#> [:started]
+decider.decide :stop, :started
+#> [:stopped]
+decider.decider :start, :started
+#> []
+```
+
+Or any classes like [Dry::Struct](https://dry-rb.org/gems/dry-struct/) or [Data](https://rubyapi.org/3.3/o/data):
+
+```ruby
+Start = Data.define(:value)
+Stop = Data.define
+
+decider = Decider.define do
+  initial_state :initial
+
+  decide proc { [command, state] in [Start, :initial | :stopped] } do
+    emit [:started, command.value]
+  end
+
+  decide proc { [command, state] in [Stop, :started] } do
+    emit :stopped
+  end
+end
+
+decider.decide Start.new(value: 10), decider.initial_state
+#> [[:started, 10]]
+decider.decide Stop.new, [:started, 10]
+#> [:stopped]
+```
+
+## Emitting Events
+
+Decide can emit 0, 1 or more events:
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+
+  decide :none do
+    # noop
+  end
+
+  decide :one do
+    emit :event
+  end
+
+  decide :multiple do
+    emit :one
+    emit :two
+  end
+end
+
+decider.decide :none, decider.initial_state
+#> []
+decider.decide :one, decider.initial_state
+#> [:event]
+decider.decide :multiple, decider.initial_state
+#> [:one, :two]
+```

data/examples/evolve.md

@@ -0,0 +1,150 @@
+# Evolve
+
+## Match by event
+
+```ruby
+Event = Data.define(:value)
+
+decider = Decider.define do
+  initial_state :initial
+
+  evolve Event do
+    event.value
+  end
+end
+
+decider.evolve decider.initial_state, Event.new(value: :changed)
+#> :changed
+```
+
+## Match by state and event
+
+```ruby
+decider = Decider.define do
+  initial_state :turned_off
+
+  evolve :turned_on, :turned_off do
+    event
+  end
+
+  evolve :turned_off, :turned_on do
+    event
+  end
+end
+
+decider.evolve decider.initial_state, :turned_on
+#> :turned_on
+decider.evolve :turned_on, :turned_off
+#> :turned_off
+decider.evolve :turned_on, :unknown
+#> :turned_on
+```
+
+## Match by pattern matching
+
+```ruby
+State = Data.define(:value)
+Event = Data.define(:value)
+
+decider = Decider.define do
+  initial_state State.new(value: :turned_off)
+
+  evolve proc { [state, event] in [State(value: :turned_off), Event(value: :turned_on)] } do
+    state.with(value: event.value)
+  end
+end
+
+decider.evolve decider.initial_state, Event.new(value: :turned_on)
+#> #<data State value=:turned_on>
+decider.evolve decider.initial_state, :unknown
+#> #<data State value=:turned_off>
+```
+
+## Handling unknown events
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+end
+
+decider.decide decider.initial_state, :initial
+#> :initial
+```
+
+If you want to raise error, define a catch-all as last one:
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+
+  evolve proc { true } do
+    raise ArgumentError, "Unknown event #{event}"
+  end
+end
+decider.evolve decider.initial_state, :unknown
+#> Unknown event unknown (ArgumentError)
+```
+
+## Events
+
+Events can be primitives like symbols:
+
+```ruby
+decider = Decider.define do
+  initial_state :initial
+
+  evolve :started do
+    :started
+  end
+
+  evolve :stopped do
+    :stopped
+  end
+end
+```
+
+Or any classes like [Dry::Struct](https://dry-rb.org/gems/dry-struct/) or [Data](https://rubyapi.org/3.3/o/data):
+
+```ruby
+State = Data.define(:speed)
+Started = Data.define(:speed)
+Stopped = Data.define
+
+decider = Decider.define do
+  initial_state State.new(speed: 0)
+
+  evolve State, Started do
+    state.with(speed: event.speed)
+  end
+
+  evolve State, Stopped do
+    State.new(speed: 0)
+  end
+end
+```
+
+## Calculate state
+
+In most cases you want to take a collection of events and reduce them with `evolve` to calculate the state, like:
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  evolve :increased do
+    state + 1
+  end
+end
+
+[:increased, :increased].reduce(decider.initial_state) { |state, event| decider.evolve(state, event) }
+#> 2
+```
+
+You can shortcut that with `&`:
+
+```ruby
+[:increased, :increased].reduce(decider.initial_state, &decider.method(:evolve))
+#> 2
+[:increased, :increased].reduce(decider.initial_state, &decider.evolve)
+#> 2
+```

data/examples/infra.md

@@ -0,0 +1,15 @@
+# Infra
+
+## In memory
+
+```ruby
+require "decider/in_memory"
+
+GLOBAL = Decider::InMemory.new(MyDecider)
+
+# returns list of events
+GLOBAL.handle(command)
+
+# returns current state
+GLOBAL.state
+```

data/examples/state.md

@@ -0,0 +1,55 @@
+# State examples
+
+## Data
+
+```ruby
+State = Data.define(:value)
+
+decider = Decider.define do
+  initial_state State.new(value: 0)
+
+  decide Commands::Command do
+    emit Events::Event.new(value: command.value)
+  end
+
+  evolve Events::Event do
+    state.with(value: state.value + 1)
+  end
+end
+```
+
+## Primitive
+
+```ruby
+decider = Decider.define do
+  initial_state :turned_off
+
+  decide Commands::TurnOn, :turned_off do
+    emit Events::TurnedOn.new
+  end
+
+  decide Commands::TurnOff, :turned_on do
+    emit Events::TurnedOff.new
+  end
+
+  evolve Events::TurnedOn do
+    :turned_on
+  end
+end
+```
+
+## List
+
+```ruby
+decider = Decider.define do
+  initial_state []
+
+  decide Commands::Command, [] do
+    emit Events::Event.new(value: command.value)
+  end
+
+  evolve Events::Event do
+    state + [event]
+  end
+end
+```

data/lib/decider/event_sourcing.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decider
+  class EventSourcing
+    def initialize(decider:, event_store:)
+      @decider = decider
+      @event_store = event_store
+    end
+
+    def call(command, stream_name:)
+      events = event_store.read.stream(stream_name)
+      state = events.reduce(decider.initial_state, &decider.method(:evolve))
+
+      new_events = decider.decide(command, state)
+
+      event_store.append(new_events, stream_name: stream_name, expected_version: events.count)
+
+      [new_events, events.count + new_events.count]
+    end
+
+    private
+
+    attr_reader :decider, :event_store
+  end
+end

data/lib/decider/in_memory.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module Decider
+  class InMemory
+    def initialize(decider)
+      @decider = decider
+      @atom = Concurrent::Atom.new(decider.initial_state)
+    end
+
+    def call(command)
+      events = decider.decide(command, state)
+      atom.swap { |state| events.reduce(state, &decider.method(:evolve)) }
+      events
+    end
+
+    def state
+      atom.value
+    end
+
+    private
+
+    attr_reader :decider, :atom
+  end
+end

data/lib/decider/reactor.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Decider
+  module Reactor
+    class Module < ::Module
+      REACT_FALLBACK = proc { [nil, proc {}] }
+
+      React = Data.define(:action_result, :_actions) do
+        def issue(*actions)
+          _actions.push(*actions)
+        end
+      end
+
+      def initialize(reactions:)
+        define_method(:react) do |action_result|
+          context = React.new(action_result: action_result, _actions: [])
+
+          reactions.find(REACT_FALLBACK) do |arg, _|
+            case arg
+            in Proc => fn
+              context.instance_exec(&fn)
+            in artype
+              action_result in ^artype
+            else
+              false
+            end
+          end => [_, handler]
+
+          context.instance_exec(&handler)
+          context._actions
+        end
+
+        define_method(:lmap_on_action_result) do |fn|
+          Decider::Reactor.lmap_on_action_result(fn, self)
+        end
+
+        define_method(:rmap_on_action) do |fn|
+          Decider::Reactor.rmap_on_action(fn, self)
+        end
+
+        define_method(:map_on_action) do |fn|
+          Decider::Reactor.rmap_on_action(fn, self)
+        end
+
+        define_method(:combine_with_decider) do |decider|
+          Decider::Reactor.combine_with_decider(self, decider)
+        end
+      end
+    end
+
+    class Builder
+      DEFAULT = Object.new
+
+      def initialize
+        @reactions = {}
+      end
+
+      def build(&block)
+        instance_exec(&block) if block_given?
+
+        reactor = Class.new
+
+        mod = Module.new(
+          reactions: reactions
+        )
+
+        reactor.extend(mod)
+
+        reactor
+      end
+
+      private
+
+      attr_reader :reactions
+
+      def react(arg, &block)
+        reactions[arg] = block
+      end
+    end
+    private_constant :Builder
+
+    def self.define(&block)
+      builder = Builder.new
+      builder.build(&block)
+    end
+
+    def self.lmap_on_action_result(fn, reactor)
+      define do
+        react proc { true } do
+          reactor.react(fn.call(action_result)).each do |action|
+            issue action
+          end
+        end
+      end
+    end
+
+    def self.rmap_on_action(fn, reactor)
+      define do
+        react proc { true } do
+          reactor.react(action_result).each do |action|
+            issue fn.call(action)
+          end
+        end
+      end
+    end
+
+    def self.map_on_action(fn, reactor)
+      rmap_on_action(fn, reactor)
+    end
+
+    def self.combine_with_decider(reactor, decider)
+      Decider.define do
+        initial_state decider.initial_state
+
+        decide proc { true } do
+          fn = ->(commands, events, ds) {
+            case commands
+            in []
+              events
+            in [head, *tail]
+              new_events = decider.decide(head, ds)
+              new_commands = new_events.flat_map { |action_result| reactor.react(action_result) }
+              new_state = new_events.reduce(ds, &decider.evolve)
+
+              fn.call(tail + new_commands, events + new_events, new_state)
+            end
+          }
+
+          fn.call([command], [], state).each { |event| emit event }
+        end
+
+        evolve proc { true } do
+          decider.evolve(state, event)
+        end
+
+        terminal? do
+          decider.terminal?(state)
+        end
+      end
+    end
+  end
+end

data/lib/decider/state.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decider
+  class State
+    def initialize(decider:, repository:)
+      @decider = decider
+      @repository = repository
+    end
+
+    def call(command, key:, etag: nil)
+      state, etag = repository.try_load(key: key, etag: etag)
+
+      events = decider.decide(command, state)
+      new_state = events.reduce(state, &decider.method(:evolve))
+
+      new_etag = repository.save(new_state, key: key, etag: etag)
+
+      [events, new_etag]
+    end
+
+    private
+
+    attr_reader :decider, :repository
+  end
+end

data/lib/decider/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Decider
+  VERSION = "0.9.0"
+end