decide.rb 0.4.1 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bde47991ca269c4a20a47e138fb8eeb5d1135262a390991bb4b946daa778362d
-  data.tar.gz: 5c3712f51013003b099ee4e3f7a568adecd92b0cd5d988c2f4140bb578f88e0c
+  metadata.gz: ef8d1d4fca8684c60ecb2488adc19d4f755b122124b9b593da08cf7beffa7d94
+  data.tar.gz: 6aacf3454c6daaff3b51aae6f420b9b892a3c2e66e344a881cceef89f68e91fd
 SHA512:
-  metadata.gz: ae016ee97e995c8338221555a0cd444aa600a6ff2e22fa83e53fe2743747dca391392b07d032a3100cce9240978cd0605f86fb355692d0938bf0fd34560c8222
-  data.tar.gz: 97ca74eb8729f4fbd1fdfe86e545cb428ef58974cfc7b91645ea246f0db140e0432229e2bec5e686898dd4a365e36419ea8dfd6ca903d643a6524c4db470380d
+  metadata.gz: 8b8439f8b22c039685579b2b5bb600df10e1f22d521dae322aec3647240725583f9a4c804c9ceb8ccac14e1cc892e173d55de7371ce22e148914c98b9c61be31
+  data.tar.gz: 1274953fe8087229ad4595e903634751ef3253cf66243f60842d2d43f0be0a24f9d9be3d8a4fe24f05bbe1f5f85cf0a3ecc63abd8d6ac11c26cdaed45c6d78ab

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+# 0.5.0
+
+* Support pattern matching for commands and events
+* Support passing state to decider and evolve matchers
+* Remove explicit arguments for handlers
+* Remove redundant bang methods - raise error in catch-all if needed
+* Add Left|Right value wrappers for composition
+* Use `emit` to return events in `decide`
+
 # 0.4.1
 
 * `define` returns new class, not object

data/README.md

@@ -49,7 +49,7 @@ ValueDecider = Decider.define do
   initial_state State.new(value: 0)
 
   # decide command with state
-  decide Commands::Increase do |command, state|
+  decide Commands::Increase do
     # return collection of events
     if state.max?
       []
@@ -58,7 +58,7 @@ ValueDecider = Decider.define do
     end
   end
 
-  decide Commands::Decrease do |command, state|
+  decide Commands::Decrease do
     if state.min?
       []
     else
@@ -67,17 +67,17 @@ ValueDecider = Decider.define do
   end
 
   # evolve state with events
-  evolve Events::ValueIncreased do |state, event|
+  evolve Events::ValueIncreased do
     # return new state
     state.with(value: state.value + 1)
   end
 
-  evolve Events::ValueDecreased do |state, event|
+  evolve Events::ValueDecreased do
     # state is immutable Data object
     state.with(value: state.value - 1)
   end
 
-  terminal? do |state|
+  terminal? do
     state <= 0
   end
 end
@@ -96,15 +96,15 @@ Right = Data.define(:value)
 left = Decider.define do
   initial_state Left.new(value: 0)
 
-  decide Commands::LeftCommand do |command, state|
+  decide Commands::LeftCommand do
     [Events::LeftEvent.new(value: command.value)]
   end
 
-  evolve Events::LeftEvent do |state, event|
+  evolve Events::LeftEvent do
     state.with(value: state.value + 1)
   end
 
-  terminal? do |state|
+  terminal? do
     state <= 0
   end
 end
@@ -112,15 +112,15 @@ end
 right = Decider.define do
   initial_state Right.new(value: 0)
 
-  decide Commands::RightCommand do |command, state|
+  decide Commands::RightCommand do
     [Events::RightEvent.new(value: command.value)]
   end
 
-  evolve Events::RightEvent do |state, event|
+  evolve Events::RightEvent do
     state.with(value: state.value + 1)
   end
 
-  terminal? do |state|
+  terminal? do
     state <= 0
   end
 end
@@ -128,13 +128,13 @@ end
 Composition = Decider.compose(left, right)
 
 state = Composition.initial_state
-#> #<data left=#<data Left value=0>, right=#<data Right value=0>>
+#> #<data Decider::Pair left=#<data Left value=0>, right=#<data Right value=0>>
 
-events = Composition.decide(Commands::LeftCommand.new(value: 1), state)
-#> [#<data value=1>]
+events = Composition.decide(Decider::Left.new(Commands::LeftCommand.new(value: 1)), state)
+#> [#<Decider::Left value=#<data value=1>]
 
 state = events.reduce(state, &Composition.method(:evolve))
-#> #<data left=#<data value=1>, right=#<data value=0>>
+#> #<data Decider::Pair left=#<data value=1>, right=#<data value=0>>
 ```
 
 ## Development

data/examples/decide.md

@@ -1,5 +1,76 @@
 # 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
+#> [Event.new(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
@@ -15,11 +86,18 @@ decider.decide :unknown, decider.initial_state
 #> []
 ```
 
-Raise error when using `decide!`:
+If you want to raise error, define a catch-all as last one:
 
 ```ruby
-decider.decide! :unknown, decider.initial_state
-#> raise ArgumentError, Unknown command
+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
@@ -30,24 +108,21 @@ Commands can be primitives like symbols:
 decider = Decider.define do
   initial_state :initial
 
-  decide :start do |command, state|
-    case state
-    in :initial, :stopped
-      [:started]
-    else
-      []
-    end
+  decide proc { [command, state] in [:start, :initial | :stopped] } do
+    emit :started
   end
 
-  decide :stop do |command, state|
-    case state
-    in :started
-      [:stopped]
-    else
-      []
-    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):
@@ -59,23 +134,47 @@ Stop = Data.define
 decider = Decider.define do
   initial_state :initial
 
-  decide Start do |command, state|
-    case state
-    in :initial, :stopped
-      [:started, command.value]
-    else
-      []
-    end
+  decide proc { [command, state] in [Start, :initial | :stopped] } do
+    emit [:started, command.value]
   end
 
-  decide Stop do |command, state|
-    case state
-    in :started
-      [:stopped]
-    else
-      []
-    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/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/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/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

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

data/lib/decider.rb

@@ -4,82 +4,104 @@ module Decider
   StateAlreadyDefined = Class.new(StandardError)
   StateNotDefined = Class.new(StandardError)
 
-  class Composition < Array
-    BLANK = Object.new
-    private_constant :BLANK
+  Pair = Data.define(:left, :right)
 
-    def initialize(left, right)
-      super([left, right]).freeze
+  class Left
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
     end
 
-    def with(left: BLANK, right: BLANK)
-      Composition.new(
-        (left == BLANK) ? self.left : left,
-        (right == BLANK) ? self.right : right
-      )
+    def deconstruct
+      [:left, value]
     end
 
-    def left
-      self[0]
+    def ==(other)
+      value == other.value
     end
+  end
 
-    def right
-      self[1]
+  class Right
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def deconstruct
+      [:right, value]
+    end
+
+    def ==(other)
+      value == other.value
     end
   end
 
   class Module < ::Module
-    def initialize(initial_state:, deciders:, evolutions:, terminal:)
-      define_method(:initial_state) do
-        initial_state
-      end
-
-      define_method(:commands) do
-        deciders.keys
-      end
+    DECIDE_FALLBACK = proc { [nil, proc {}] }
+    EVOLVE_FALLBACK = proc { [nil, proc { state }] }
 
-      define_method(:events) do
-        evolutions.keys
+    Decide = Data.define(:command, :state, :_events) do
+      def emit(*events)
+        _events.push(*events)
       end
+    end
+    Evolve = Data.define(:state, :event)
+    Terminal = Data.define(:state)
 
-      define_method(:decide!) do |command, state|
-        case deciders.find { |key, _| key === command }
-        in [_, handler]
-          handler.call(command, state)
-        else
-          raise ArgumentError, "Unknown command: #{command.inspect}"
-        end
+    def initialize(initial_state:, deciders:, evolutions:, terminal:)
+      define_method(:initial_state) do
+        initial_state
       end
 
       define_method(:decide) do |command, state|
-        case deciders.find { |key, _| key === command }
-        in [_, handler]
-          handler.call(command, state)
-        else
-          []
-        end
-      end
-
-      define_method(:evolve!) do |state, event|
-        case evolutions.find { |key, _| key === event }
-        in [_, handler]
-          handler.call(state, event)
-        else
-          raise ArgumentError, "Unknown event: #{event.inspect}"
-        end
+        context = Decide.new(command: command, state: state, _events: [])
+
+        deciders.find(DECIDE_FALLBACK) do |args, _|
+          case args
+          in [Proc => fn]
+            context.instance_exec(&fn)
+          in [ctype]
+            command in ^ctype
+          in [ctype, stype]
+            [command, state] in [^ctype, ^stype]
+          else
+            false
+          end
+        end => [_, handler]
+
+        context.instance_exec(&handler)
+        context._events
       end
 
       define_method(:evolve) do |state, event|
-        case evolutions.find { |key, _| key === event }
-        in [_, handler]
-          handler.call(state, event)
-        else
-          state
-        end
+        context = Evolve.new(state: state, event: event)
+
+        evolutions.find(EVOLVE_FALLBACK) do |args, _|
+          case args
+          in [Proc => fn]
+            context.instance_exec(&fn)
+          in [etype]
+            event in ^etype
+          in [stype, etype]
+            [state, event] in [^stype, ^etype]
+          else
+            false
+          end
+        end => [_, handler]
+
+        context.instance_exec(&handler)
       end
 
       define_method(:terminal?) do |state|
-        terminal.call(state)
+        context = Terminal.new(state: state)
+
+        context.instance_exec(&terminal)
+      end
+
+      define_method(:dimap_on_state) do |fl:, fr:|
+        Decider.dimap_on_state(self, fl: fl, fr: fr)
       end
     end
   end
@@ -93,7 +115,7 @@ module Decider
       @initial_state = DEFAULT
       @deciders = {}
       @evolutions = {}
-      @terminal = ->(_state) { false }
+      @terminal = proc { false }
     end
 
     def build(&block)
@@ -125,12 +147,12 @@ module Decider
       @initial_state = state
     end
 
-    def decide(command, &block)
-      deciders[command] = block
+    def decide(*args, &block)
+      deciders[args] = block
     end
 
-    def evolve(event, &block)
-      evolutions[event] = block
+    def evolve(*args, &block)
+      evolutions[args] = block
     end
 
     def terminal?(&block)
@@ -146,39 +168,52 @@ module Decider
 
   def self.compose(left, right)
     define do
-      initial_state Composition.new(left.initial_state, right.initial_state)
+      initial_state Pair.new(
+        left: left.initial_state,
+        right: right.initial_state
+      )
 
-      left.commands.each do |klass|
-        decide klass do |command, state|
-          left.decide(command, state.left)
-        end
+      decide proc { command in [:left, _] } do
+        left.decide(command.value, state.left).each { emit Left.new(_1) }
       end
 
-      right.commands.each do |klass|
-        decide klass do |command, state|
-          right.decide(command, state.right)
-        end
+      decide proc { command in [:right, _] } do
+        right.decide(command.value, state.right).each { emit Right.new(_1) }
       end
 
-      left.events.each do |klass|
-        evolve klass do |state, event|
-          state.with(
-            left: left.evolve(state.left, event)
-          )
-        end
+      evolve proc { event in [:left, _] } do
+        state.with(
+          left: left.evolve(state.left, event.value)
+        )
       end
 
-      right.events.each do |klass|
-        evolve klass do |state, event|
-          state.with(
-            right: right.evolve(state.right, event)
-          )
-        end
+      evolve proc { event in [:right, _] } do
+        state.with(
+          right: right.evolve(state.right, event.value)
+        )
       end
 
-      terminal? do |state|
+      terminal? do
         left.terminal?(state.left) && right.terminal?(state.right)
       end
     end
   end
+
+  def self.dimap_on_state(decider, fl:, fr:)
+    define do
+      initial_state fr.call(decider.initial_state)
+
+      decide proc { true } do
+        decider.decide(command, fl.call(state)).each(&method(:emit))
+      end
+
+      evolve proc { true } do
+        fr.call(decider.evolve(fl.call(state), event))
+      end
+
+      terminal? do
+        decider.terminal?(fl.call(state))
+      end
+    end
+  end
 end

metadata

@@ -1,15 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: decide.rb
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.1
 platform: ruby
 authors:
 - Jan Dudulski
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-11 00:00:00.000000000 Z
-dependencies: []
+date: 2025-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
+  name: ruby_event_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.15'
 description: Functional Event Sourcing Decider in Ruby
 email:
 - jan@dudulski.pl
@@ -25,8 +66,12 @@ files:
 - Steepfile
 - examples/decide.md
 - examples/evolve.md
+- examples/infra.md
 - examples/state.md
 - lib/decider.rb
+- lib/decider/event_sourcing.rb
+- lib/decider/in_memory.rb
+- lib/decider/state.rb
 - lib/decider/version.rb
 - sig/decider.rbs
 homepage: https://github.com/jandudulski/decide.rb
@@ -39,7 +84,6 @@ metadata:
   documentation_uri: https://github.com/jandudulski/decide.rb
   homepage_uri: https://github.com/jandudulski/decide.rb
   source_code_uri: https://github.com/jandudulski/decide.rb
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -54,8 +98,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Functional Event Sourcing Decider in Ruby
 test_files: []