decide.rb 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73423e6911201b60ed5a3333ef636880cc93751425e95b39e522bed75d9ca4a5
-  data.tar.gz: 2b352d0c34587f8dfe90e819504e3d07093de738ddde24cea4e96a152f09ce0d
+  metadata.gz: 41af414c2f92dc8e43dad1ac61cf6ffb939fa65bc7217223b29e9780067ce5d3
+  data.tar.gz: 96342dea929121644eca8d924fbcd1112fbb21ec34fb666c00e87261cf7d4dc1
 SHA512:
-  metadata.gz: 8f2e2449fac23e3ae81014a6fd0cfefd5a2a888089c3c89b2072cb52592f6ba5bb659c9f2a816c6d8b13eb6082b463f42594dbffedb2add06469857b7bfe07d0
-  data.tar.gz: 1a310ac9f050f40ba09df6605860fc62b348e093133fd0237618726753d25f5c669f72b723b9072664862d1d80a01898dd963dbd323c97ef30c8533ed9f523e7
+  metadata.gz: acec8f3699e15b22ee30780b2b2e30cc95950c9d18701dbcaddc5788723780e0d6c09e16066c000db8a24ec87e62eadf20469c391c5140af662b9b951b61e41b
+  data.tar.gz: b088dec6fb91fe9417f83b73ebe58dd638d31ffb78f1245e62afa826a5f416d1bede83c41cc0d612afa29d50afeb119703a42e5ec3570daad08003b1bb304eb0

data/CHANGELOG.md

@@ -1,4 +1,17 @@
-# Unreleased
+# 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
+
+# 0.4.0
 
 * Accept more data structures for commands and events
 

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/lib/decider/version.rb

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

data/lib/decider.rb

@@ -4,82 +4,100 @@ 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 ==(other)
+      value == other.value
     end
+  end
+
+  class Right
+    attr_reader :value
 
-    def left
-      self[0]
+    def initialize(value)
+      @value = value
     end
 
-    def right
-      self[1]
+    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
     end
   end
@@ -93,7 +111,7 @@ module Decider
       @initial_state = DEFAULT
       @deciders = {}
       @evolutions = {}
-      @terminal = ->(_state) { false }
+      @terminal = proc { false }
     end
 
     def build(&block)
@@ -101,7 +119,7 @@ module Decider
 
       raise StateNotDefined if @initial_state == DEFAULT
 
-      decider = Object.new
+      decider = Class.new
 
       @module = Module.new(
         initial_state: @initial_state,
@@ -125,12 +143,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,37 +164,32 @@ 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: decide.rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Jan Dudulski
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-11-11 00:00:00.000000000 Z
+date: 2024-12-15 00:00:00.000000000 Z
 dependencies: []
 description: Functional Event Sourcing Decider in Ruby
 email: