decider 0.9.0

data/lib/decider/view.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Decider::View
+  class Module < ::Module
+    EVOLVE_FALLBACK = proc { [nil, proc { state }] }
+
+    Evolve = Data.define(:state, :event) do
+      def self.build(state, event)
+        new(state: state, event: event)
+      end
+    end
+
+    def initialize(initial_state:, evolutions:)
+      define_method(:initial_state) do
+        initial_state
+      end
+
+      define_method(:evolve) do |*args|
+        if args.empty?
+          ->(state, event) { evolve(state, event) }
+        else
+          context = Evolve.build(*args)
+
+          evolutions.find(EVOLVE_FALLBACK) do |args, _|
+            case args
+            in [Proc => fn]
+              context.instance_exec(&fn)
+            in [etype]
+              context_event = context.event
+              context_event in ^etype
+            in [stype, etype]
+              context_state = context.state
+              context_event = context.event
+              [context_state, context_event] in [^stype, ^etype]
+            else
+              false
+            end
+          end => [_, handler]
+
+          context.instance_exec(&handler)
+        end
+      end
+
+      define_method(:lmap_on_event) do |fn|
+        Decider::View.lmap_on_event(fn, self)
+      end
+
+      define_method(:lmap_on_state) do |fn|
+        Decider::View.lmap_on_state(fn, self)
+      end
+
+      define_method(:rmap_on_state) do |fn|
+        Decider::View.rmap_on_state(fn, self)
+      end
+
+      define_method(:dimap_on_state) do |fl:, fr:|
+        Decider::View.dimap_on_state(fl, fr, self)
+      end
+
+      define_method(:many) do
+        Decider::View.many(self)
+      end
+    end
+  end
+
+  class Builder
+    DEFAULT = Object.new
+
+    def initialize
+      @initial_state = DEFAULT
+      @evolutions = {}
+    end
+
+    def build(&block)
+      instance_exec(&block) if block_given?
+
+      raise StateNotDefined if @initial_state == DEFAULT
+
+      view = Class.new
+
+      mod = Module.new(
+        initial_state: @initial_state,
+        evolutions: evolutions
+      )
+
+      view.extend(mod)
+
+      view
+    end
+
+    private
+
+    attr_reader :evolutions
+
+    def initial_state(state)
+      raise StateAlreadyDefined if @initial_state != DEFAULT
+
+      @initial_state = state
+    end
+
+    def evolve(*args, &block)
+      evolutions[args] = block
+    end
+  end
+  private_constant :Builder
+
+  def self.define(&block)
+    builder = Builder.new
+    builder.build(&block)
+  end
+
+  def self.lmap_on_event(fn, view)
+    define do
+      initial_state view.initial_state
+
+      evolve proc { true } do
+        view.evolve(state, fn.call(event))
+      end
+    end
+  end
+
+  def self.lmap_on_state(fn, view)
+    dimap_on_state(fn, ->(state) { state }, view)
+  end
+
+  def self.rmap_on_state(fn, view)
+    dimap_on_state(->(state) { state }, fn, view)
+  end
+
+  def self.dimap_on_state(fl, fr, view)
+    define do
+      initial_state fr.call(view.initial_state)
+
+      evolve proc { true } do
+        fr.call(view.evolve(fl.call(state), event))
+      end
+    end
+  end
+
+  def self.many(view)
+    define do
+      initial_state({})
+
+      evolve proc { [state, event] in [Hash, [_id, _]] } do
+        event => [id, event]
+
+        vs = state.fetch(id) { view.initial_state }
+        vs = view.evolve(vs, event)
+
+        state.merge(id => vs)
+      end
+    end
+  end
+end

data/lib/decider.rb

@@ -0,0 +1,380 @@
+# frozen_string_literal: true
+
+require_relative "decider/reactor"
+require_relative "decider/view"
+
+module Decider
+  StateAlreadyDefined = Class.new(StandardError)
+  StateNotDefined = Class.new(StandardError)
+
+  Pair = Data.define(:left, :right)
+
+  class Left
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def deconstruct
+      [:left, value]
+    end
+
+    def ==(other)
+      value == other.value
+    end
+  end
+
+  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
+    DECIDE_FALLBACK = proc { [nil, proc {}] }
+    EVOLVE_FALLBACK = proc { [nil, proc { state }] }
+
+    Decide = Data.define(:command, :state, :_events) do
+      def emit(*events)
+        _events.push(*events)
+      end
+    end
+    Evolve = Data.define(:state, :event) do
+      def self.build(state, event)
+        new(state: state, event: event)
+      end
+    end
+    Terminal = Data.define(:state)
+
+    def initialize(initial_state:, deciders:, evolutions:, terminal:)
+      define_method(:initial_state) do
+        initial_state
+      end
+
+      define_method(:decide) do |command, state|
+        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 |*args|
+        if args.empty?
+          ->(state, event) { evolve(state, event) }
+        else
+          context = Evolve.build(*args)
+
+          evolutions.find(EVOLVE_FALLBACK) do |args, _|
+            case args
+            in [Proc => fn]
+              context.instance_exec(&fn)
+            in [etype]
+              context_event = context.event
+              context_event in ^etype
+            in [stype, etype]
+              context_state = context.state
+              context_event = context.event
+              [context_state, context_event] in [^stype, ^etype]
+            else
+              false
+            end
+          end => [_, handler]
+
+          context.instance_exec(&handler)
+        end
+      end
+
+      define_method(:terminal?) do |state|
+        context = Terminal.new(state: state)
+
+        context.instance_exec(&terminal)
+      end
+
+      define_method(:lmap_on_command) do |fn|
+        Decider.lmap_on_command(fn, self)
+      end
+
+      define_method(:lmap_on_state) do |fn|
+        Decider.lmap_on_state(fn, self)
+      end
+
+      define_method(:map) do |fn|
+        Decider.map(fn, self)
+      end
+
+      define_method(:rmap_on_state) do |fn|
+        Decider.rmap_on_state(fn, self)
+      end
+
+      define_method(:dimap_on_state) do |fl:, fr:|
+        Decider.dimap_on_state(fl, fr, self)
+      end
+
+      define_method(:lmap_on_event) do |fn|
+        Decider.lmap_on_event(fn, self)
+      end
+
+      define_method(:rmap_on_event) do |fn|
+        Decider.rmap_on_event(fn, self)
+      end
+
+      define_method(:dimap_on_event) do |fl:, fr:|
+        Decider.dimap_on_event(fl, fr, self)
+      end
+
+      define_method(:many) do
+        Decider.many(self)
+      end
+
+      define_method(:apply) do |f|
+        Decider.apply(self, f)
+      end
+    end
+  end
+
+  class Builder
+    DEFAULT = Object.new
+
+    def initialize
+      @initial_state = DEFAULT
+      @deciders = {}
+      @evolutions = {}
+      @terminal = proc { false }
+    end
+
+    def build(&block)
+      instance_exec(&block) if block_given?
+
+      raise StateNotDefined if @initial_state == DEFAULT
+
+      decider = Class.new
+
+      mod = Module.new(
+        initial_state: @initial_state,
+        deciders: deciders,
+        evolutions: evolutions,
+        terminal: terminal
+      )
+
+      decider.extend(mod)
+
+      decider
+    end
+
+    private
+
+    attr_reader :deciders, :evolutions, :terminal
+
+    def initial_state(state)
+      raise StateAlreadyDefined if @initial_state != DEFAULT
+
+      @initial_state = state
+    end
+
+    def decide(*args, &block)
+      deciders[args] = block
+    end
+
+    def evolve(*args, &block)
+      evolutions[args] = block
+    end
+
+    def terminal?(&block)
+      @terminal = block
+    end
+  end
+  private_constant :Builder
+
+  def self.define(&block)
+    builder = Builder.new
+    builder.build(&block)
+  end
+
+  def self.compose(left, right)
+    define do
+      initial_state Pair.new(
+        left: left.initial_state,
+        right: right.initial_state
+      )
+
+      decide proc { command in [:left, _] } do
+        left.decide(command.value, state.left).each { emit Left.new(_1) }
+      end
+
+      decide proc { command in [:right, _] } do
+        right.decide(command.value, state.right).each { emit Right.new(_1) }
+      end
+
+      evolve proc { event in [:left, _] } do
+        state.with(
+          left: left.evolve(state.left, event.value)
+        )
+      end
+
+      evolve proc { event in [:right, _] } do
+        state.with(
+          right: right.evolve(state.right, event.value)
+        )
+      end
+
+      terminal? do
+        left.terminal?(state.left) && right.terminal?(state.right)
+      end
+    end
+  end
+
+  def self.lmap_on_command(fn, decider)
+    define do
+      initial_state decider.initial_state
+
+      decide proc { true } do
+        decider.decide(fn.call(command), state).each(&method(:emit))
+      end
+
+      evolve proc { true } do
+        decider.evolve(state, event)
+      end
+
+      terminal? do
+        decider.terminal?(state)
+      end
+    end
+  end
+
+  def self.lmap_on_state(fn, decider)
+    dimap_on_state(fn, ->(state) { state }, decider)
+  end
+
+  def self.map(fn, decider)
+    dimap_on_state(->(state) { state }, fn, decider)
+  end
+
+  def self.rmap_on_state(fn, decider)
+    dimap_on_state(->(state) { state }, fn, decider)
+  end
+
+  def self.dimap_on_state(fl, fr, decider)
+    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
+
+  def self.lmap_on_event(fn, decider)
+    dimap_on_event(fn, ->(event) { event }, decider)
+  end
+
+  def self.rmap_on_event(fn, decider)
+    dimap_on_event(->(event) { event }, fn, decider)
+  end
+
+  def self.dimap_on_event(fl, fr, decider)
+    define do
+      initial_state decider.initial_state
+
+      decide proc { true } do
+        decider.decide(command, state).each do |event|
+          emit fr.call(event)
+        end
+      end
+
+      evolve proc { true } do
+        decider.evolve(state, fl.call(event))
+      end
+
+      terminal? do
+        decider.terminal?(state)
+      end
+    end
+  end
+
+  def self.many(decider)
+    define do
+      initial_state({})
+
+      decide proc { [command, state] in [[_id, _], Hash] } do
+        command => [id, command]
+
+        ds = state.fetch(id) { decider.initial_state }
+
+        decider.decide(command, ds).each do |event|
+          emit [id, event]
+        end
+      end
+
+      evolve proc { [state, event] in [Hash, [_id, _]] } do
+        event => [id, event]
+
+        ds = state.fetch(id) { decider.initial_state }
+        ds = decider.evolve(ds, event)
+
+        state.merge(id => ds)
+      end
+
+      terminal? do
+        state.any? && state.all? { |_, ds| decider.terminal?(ds) }
+      end
+    end
+  end
+
+  def self.apply(f, x)
+    map2(->(f, x) { f.call(x) }, f, x)
+  end
+
+  def self.map2(fn, dx, dy)
+    define do
+      initial_state fn.call(dx.initial_state, dy.initial_state)
+
+      decide proc { true } do
+        dx.decide(command, state).each(&method(:emit))
+        dy.decide(command, state).each(&method(:emit))
+      end
+
+      evolve proc { true } do
+        fn.call(
+          dx.evolve(state, event),
+          dy.evolve(state, event)
+        )
+      end
+
+      terminal? do
+        dx.terminal?(state) && dy.terminal?(state)
+      end
+    end
+  end
+end

data/mise.toml

@@ -0,0 +1,17 @@
+[env]
+_.path = ["bin"]
+
+[tools]
+ruby = "4.0.2"
+
+[tasks.test]
+run = "bundle exec rake"
+alias = "t"
+
+[tasks.console]
+run = "console"
+alias = "c"
+
+[tasks.release]
+run = "bundle exec rake release"
+alias = "r"

data/sig/decider.rbs

@@ -0,0 +1,16 @@
+module Decider
+  VERSION: String
+
+  interface _Decider[C, S, E]
+    def decide: (C, S) -> Array[E]
+
+    def evolve: (S, E) -> S
+
+    def initial_state: () -> S
+
+    def terminal?: (S) -> bool
+  end
+
+  def self.compose: [C1, S1, E1, C2, S2, E2] (_Decider[C1, S1, E1], _Decider[C2, S2, E2]) -> _Decider[C1 | C2, S1 & S2, E1 | E2]
+  def self.define: [C, S, E] () -> _Decider[C, S, E]
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: decider
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Jan Dudulski
+bindir: exe
+cert_chain: []
+date: 1980-01-02 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
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- 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/reactor.rb
+- lib/decider/state.rb
+- lib/decider/version.rb
+- lib/decider/view.rb
+- mise.toml
+- sig/decider.rbs
+homepage: https://github.com/jandudulski/decider
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  bug_tracker_uri: https://github.com/jandudulski/decider/issues
+  changelog_uri: https://github.com/jandudulski/decider/CHANGELOG.md
+  documentation_uri: https://github.com/jandudulski/decider
+  homepage_uri: https://github.com/jandudulski/decider
+  source_code_uri: https://github.com/jandudulski/decider
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Functional Event Sourcing Decider in Ruby
+test_files: []