decide.rb 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 560335da25429790af3eb660d743eb7233c3dad032f9582462de1142c9cf3d91
-  data.tar.gz: c42275236a358e3eac7189cf6e7f57cdc3106aa9e00f203b96d139f24360ee91
+  metadata.gz: ae980af0098467da425746f3d2cb9cf41eb67301dea7b369d36ddbba09357414
+  data.tar.gz: 42b2d4110c43de9aa88c33704caf9e53ca9f3bdc346ea0c5108ffe3f34c35d2d
 SHA512:
-  metadata.gz: 0da501705ecb75d91b1696f468c9360bc950e7cc0f5ac1ce52a3427beccb2bba8eca1688bee73e874c46c40f17d579ddde4b132a2e6fe04e3737b7091f99619d
-  data.tar.gz: ea55c13433fb463d9746da6fe08016353bc0d38c3aae988f0b7249cfac86ed5325b0bcbb02c3833e5997f43db61f7b293a822988a851273dc39b087d7e4b2e14
+  metadata.gz: 3d49815edc97d5d4ae52b6c46b320f2b560bb137f7c45cd87b52855d6e420c3bd342985f423c42c9283d4ef3adfa218b14605e409362e5c8ffb81c6ea1803c2d
+  data.tar.gz: 3e36c74937ce1bbf65df117fa541f1ca9a51d6ff859db7ee8ab5d941a14b34f7ec61a643384f58e28c920b7368f15bd855f578d4ca53e2471a46c0452b88125a

data/CHANGELOG.md

@@ -1,3 +1,23 @@
+# 0.8.0
+
+* Add view that can evolve from initial state
+
+```ruby
+view = Decider::View.define do
+  initial_state 0
+
+  evolve :increased do
+    state + 1
+  end
+
+  evolve :decreased do
+    state - 1
+  end
+end
+```
+
+* Add `lmap_on_event`, `dimap_on_state`, `lmap_on_state` and `rmap_on_state` extensions for view
+
 # 0.7.0
 
 * Add reactor that can react to action results and issue actions
@@ -6,7 +26,7 @@
 ActionResult = Data.define(:value)
 Action = Data.define(:value)
 
-reactor = Reactor.define do
+reactor = Decider::Reactor.define do
   react :action_result do
     issue :action
     issue :another_action
@@ -82,7 +102,7 @@ deciders.evolve(state, [id, event])
 
 ```ruby
 decider = Decider.map(fn.curry, deciderx)
-decider = Decider.apply(decider, decidery) 
+decider = Decider.apply(decider, decidery)
 decider = Decider.apply(decider, deciderz)
 # or
 deciderx.map(fn.curry).apply(decidery).apply(deciderz)

data/lib/decider/reactor.rb

@@ -1,141 +1,141 @@
 # frozen_string_literal: true
 
-module Decider::Reactor
-  class Module < ::Module
-    REACT_FALLBACK = proc { [nil, proc {}] }
-
-    React = Data.define(:action_result, :_actions) do
-      def issue(*actions)
-        _actions.push(*actions)
+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
-    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
+      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(: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(: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(: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)
+        define_method(:combine_with_decider) do |decider|
+          Decider::Reactor.combine_with_decider(self, decider)
+        end
       end
     end
-  end
 
-  class Builder
-    DEFAULT = Object.new
+    class Builder
+      DEFAULT = Object.new
 
-    attr_reader :module
-
-    def initialize
-      @reactions = {}
-    end
+      def initialize
+        @reactions = {}
+      end
 
-    def build(&block)
-      instance_exec(&block) if block_given?
+      def build(&block)
+        instance_exec(&block) if block_given?
 
-      reactor = Class.new
+        reactor = Class.new
 
-      @module = Module.new(
-        reactions: reactions
-      )
+        mod = Module.new(
+          reactions: reactions
+        )
 
-      reactor.extend(@module)
+        reactor.extend(mod)
 
-      reactor
-    end
+        reactor
+      end
 
-    private
+      private
 
-    attr_reader :reactions
+      attr_reader :reactions
 
-    def react(arg, &block)
-      reactions[arg] = block
+      def react(arg, &block)
+        reactions[arg] = block
+      end
     end
-  end
-  private_constant :Builder
+    private_constant :Builder
 
-  def self.define(&block)
-    builder = Builder.new
-    builder.build(&block)
-  end
+    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
+    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
-  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)
+    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
-  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
-        }
+    def self.map_on_action(fn, reactor)
+      rmap_on_action(fn, reactor)
+    end
 
-        fn.call([command], [], state).each { |event| emit event }
-      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
+        evolve proc { true } do
+          decider.evolve(state, event)
+        end
 
-      terminal? do
-        decider.terminal?(state)
+        terminal? do
+          decider.terminal?(state)
+        end
       end
     end
   end

data/lib/decider/version.rb

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

data/lib/decider/view.rb

@@ -0,0 +1,132 @@
+# 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 in ^etype
+            in [stype, etype]
+              [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
+    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
+end

data/lib/decider.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "decider/reactor"
+require_relative "decider/reactor"
+require_relative "decider/view"
 
 module Decider
   StateAlreadyDefined = Class.new(StandardError)
@@ -155,8 +156,6 @@ module Decider
   class Builder
     DEFAULT = Object.new
 
-    attr_reader :module
-
     def initialize
       @initial_state = DEFAULT
       @deciders = {}
@@ -171,14 +170,14 @@ module Decider
 
       decider = Class.new
 
-      @module = Module.new(
+      mod = Module.new(
         initial_state: @initial_state,
         deciders: deciders,
         evolutions: evolutions,
         terminal: terminal
       )
 
-      decider.extend(@module)
+      decider.extend(mod)
 
       decider
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: decide.rb
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Jan Dudulski
 bindir: exe
 cert_chain: []
-date: 2025-07-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -74,6 +74,7 @@ files:
 - lib/decider/reactor.rb
 - lib/decider/state.rb
 - lib/decider/version.rb
+- lib/decider/view.rb
 - sig/decider.rbs
 homepage: https://github.com/jandudulski/decide.rb
 licenses:
@@ -99,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Functional Event Sourcing Decider in Ruby
 test_files: []