decider 0.10.0 → 2.0.0

data/lib/decider/reactor.rb

@@ -1,142 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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 +0,0 @@
-# frozen_string_literal: true
-
-module Decider
-  VERSION = "0.10.0"
-end

data/lib/decider/view.rb

@@ -1,169 +0,0 @@
-# frozen_string_literal: true
-
-module Decider::View
-  StateAlreadyDefined = Class.new(StandardError)
-  StateNotDefined = Class.new(StandardError)
-
-  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:)
-      case initial_state
-      in Proc
-        define_method(:initial_state) do
-          initial_state.call
-        end
-      else
-        define_method(:initial_state) do
-          initial_state
-        end
-      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 = DEFAULT, &block)
-      raise StateAlreadyDefined if @initial_state != DEFAULT
-
-      @initial_state =
-        if block_given?
-          block
-        else
-          state
-        end
-    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/mise.toml

@@ -1,17 +0,0 @@
-[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

@@ -1,16 +0,0 @@
-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