decider 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8cf547b60c57f5e6d7de4f9818c6422dd45b7508d7d547e0857596f12dc9dee
+  data.tar.gz: 567d203347522c6401e1fc724316ddec6f5d0c7625f59a44d2214a4dc0299bc9
+SHA512:
+  metadata.gz: b47df204a4040a1377b33f6d3395fcca83e167d0c073a84c7555195b671c54464d3e29f6c0d27036260bcc949547d189e52acb2e5ea7ab6421c774dc1412971b
+  data.tar.gz: 4a808fd5cff184f84e7e6a3be391c431052e5e38106e4ac547b140c405eb1af9fcf2d225e3306f774376a114f75d7108ec837b759514409b6aaf366f5773de7f

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.0

data/CHANGELOG.md

@@ -0,0 +1,377 @@
+# 0.9.0
+
+* Rename gem to `decider`
+* Support `many` in `View`
+
+Big Thanks to [skalnik](https://github.com/skalnik/) for transfering the name ❤️
+
+# 0.8.1
+
+* Fix support for Ruby > 3.4.5
+
+# 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
+
+```ruby
+ActionResult = Data.define(:value)
+Action = Data.define(:value)
+
+reactor = Decider::Reactor.define do
+  react :action_result do
+    issue :action
+    issue :another_action
+  end
+
+  react proc { action_result in ActionResult(value: 42) } do
+    issue Action.new(value: "the answer")
+  end
+
+  react ActionResult do
+    issue Action.new(value: action_result.value)
+  end
+end
+
+reactor.react(:action_result)
+# => [:action, :another_action]
+reactor.react(ActionResult.new(value: 42)
+# => #<data Action value="the answer">
+reactor.react(ActionResult.new(value: 1)
+# => #<data Action value=1>
+```
+
+* Add `lmap_on_action_result` extension to reactor
+* Add `rmap_on_action` (aliased to `map_on_action`) extensions to reactor
+* Add `combine_with_decider` extension to reactor
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  decide :action do
+    emit :result
+  end
+
+  decide :another_action do
+    emit :another_result
+  end
+end
+
+reactor = Decider::Reactor.define do
+  react :result do
+    issue :another_action
+  end
+end
+
+decider = reactor.combine_with_decider(decider)
+decider.decide(:action)
+# => [:result, :another_result]
+```
+
+# 0.6.2
+
+* Add `many` extension that takes a decider and manage many instances
+
+```ruby
+deciders = Decider.many(decider)
+# or
+deciders = decider.many
+
+deciders.initial_state
+# => {}
+
+deciders.decide([id, command], state)
+# => [[id, event], [id, event]]
+
+deciders.evolve(state, [id, event])
+# => state
+```
+
+# 0.6.1
+
+* Add `apply` extension for creating applicatives
+
+```ruby
+decider = Decider.map(fn.curry, deciderx)
+decider = Decider.apply(decider, decidery)
+decider = Decider.apply(decider, deciderz)
+# or
+deciderx.map(fn.curry).apply(decidery).apply(deciderz)
+```
+
+# 0.6.0
+
+* All extensions takes decider as last argument
+
+```ruby
+# Before
+Decider.dimap_on_state(decider, fl:, fr:)
+Decider.dimap_on_event(decider, fl:, fr:)
+Decider.lmap_on_event(decider, fn)
+Decider.lmap_on_command(decider, fn)
+Decider.lmap_on_state(decider, fn)
+Decider.rmap_on_event(decider, fn)
+Decider.rmap_on_state(decider, fn)
+
+# After
+Decider.dimap_on_state(fl, fr, decider)
+Decider.dimap_on_event(fl, fr, decider)
+Decider.lmap_on_event(fn, decider)
+Decider.lmap_on_command(fn, decider)
+Decider.lmap_on_state(fn, decider)
+Decider.rmap_on_event(fn, decider)
+Decider.rmap_on_state(fn, decider)
+```
+
+# 0.5.5
+
+* Add `lmap_on_command` extension that takes proc that maps command and returns a new decider
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  decide :increase do
+    emit :increased
+  end
+end
+
+lmap = decider.lmap_on_command(->(command) { command.to_sym })
+lmap.decide("increase", 0)
+# => [:increased]
+```
+
+* Add `map` extension that works the same way as `rmap_on_state` but `Decider.map` takes function first
+
+```ruby
+# equivalent
+Decider.rmap_on_state(decider, fn)
+Decider.map(fn, decider)
+decider.rmap_on_state(fn)
+decider.map(fn)
+```
+
+* Add `map2` extension that takes function with two arguments and two deciders and returns a decider:
+
+```ruby
+dx = Decider.define do
+  initial_state({score: 0})
+
+  decide :score do
+    emit :scored
+  end
+
+  evolve :scored do
+    {score: state[:score] + 1}
+  end
+end
+
+dy = Decider.define do
+  initial_state({time: 0})
+
+  decide :tick do
+    emit :ticked
+  end
+
+  evolve :ticked do
+    {time: state[:time] + 1}
+  end
+end
+
+decider = Decider.map2(
+  ->(sx, sy) { {score: sx[:score], time: sy[:time]} }, dx, dy
+)
+
+decider.initial_state
+# => {score: 0, time: 0}
+decider.decide(:score, decider.initial_state)
+# => [:scored]
+decider.decide(:tick, decider.initial_state)
+# => [:ticked]
+decider.evolve(decider.initial_state, :scored)
+# => {score: 1, time: 0}
+decider.evolve(decider.initial_state, :ticked)
+# => {score: 0, time: 1}
+```
+
+# 0.5.4
+
+* Add `lmap_on_event` and `rmap_on_event` extensions that takes proc that maps event in or out and returns a new decider
+
+```ruby
+decider = Decider.define do
+  initial_state 0
+
+  decide :increase do
+    emit :increased
+  end
+
+  evolve :increased do
+    state + 1
+  end
+end
+
+lmap = decider.lmap_on_event(->(event) { event.to_sym })
+lmap.evolve(0, "increased")
+# => 1
+
+rmap = decider.rmap_on_event(->(event) { event.to_s })
+rmap.decide(:increase, 0)
+# => "increased"
+```
+
+* Add `lmap_on_state` and `rmap_on_state` extensions that takes proc that maps state in or out and returns a new decider
+
+```ruby
+decider = Decider.define do
+  initial_state :symbol
+
+  decide :command, :state do
+    emit :called
+  end
+
+  evolve :state, :called do
+    :new_state
+  end
+end
+decider.initial_state
+# => :symbol
+
+lmap = decider.lmap_on_state(
+  ->(state) { state.to_sym }
+)
+lmap.initial_state
+# => :symbol
+lmap.decide(:command, "symbol")
+# => [:called]
+lmap.evolve("symbol", :called)
+# => :new_state
+
+rmap = inner.rmap_on_state(
+  ->(state) { state.to_s }
+)
+rmap.initial_state
+# => "symbol"
+rmap.decide(:command, :symbol)
+# => [:called]
+rmap.evolve(:symbol, :called)
+# => "new_state"
+```
+
+# 0.5.3
+
+* Add shortcut for evolving:
+
+```ruby
+# this three are the same now
+[event, event].reduce(state) { |s, e| decider.evolve(s, e) }
+[event, event].reduce(state, &decider.method(:evolve))
+
+# new
+[event, event].reduce(state, &decider.evolve)
+```
+
+# 0.5.2
+
+* Add `dimap_on_event` extension that takes procs that maps event in and out and returns a new decider
+
+```ruby
+inner = Decider.define do
+  initial_state 0
+
+  decide :increase do
+    emit :increased
+  end
+
+  evolve :increased do
+    state + 1
+  end
+end
+
+outer = inner.dimap_on_event(
+  fl: ->(event) { event.to_sym },
+  fr: ->(event) { event.to_s }
+)
+
+outer.decide(:increase, 0)
+# => "increased"
+
+outer.evolve(0, "increased")
+# => 1
+```
+
+# 0.5.1
+
+* Add `dimap_on_state` extension that takes procs that maps state in and out and returns a new decider
+
+```ruby
+inner = Decider.define do
+  initial_state :symbol
+end
+inner.initial_state
+# => :symbol
+
+outer = inner.dimap_on_state(
+  fl: ->(state) { state.to_sym },
+  fr: ->(state) { state.to_s }
+)
+outer.initial_state
+# => "symbol"
+
+# under the hood it will run inner.decide(:command, :symbol)
+outer.decide(:command, "symbol")
+```
+
+# 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
+
+# 0.3.0
+
+* Rename `Decider.state` to `Decider.initial_state`
+* Allow to use anything as state
+* Use tuple-like array for composition
+* Do not raise error when deciding unknown command
+* Do not raise error when evolving unknown event
+
+# 0.2.0
+
+* Added `terminal?` function
+* `Decider.compose(left, right)`
+
+# 0.1.0
+
+* Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Jan Dudulski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,152 @@
+# Decider
+
+This gem provides simple DSL for building Functional Event Sourcing Decider in Ruby. To learn more about the pattern read the original [article by Jérémie Chassaing](https://thinkbeforecoding.com/post/2021/12/17/functional-event-sourcing-decider).
+
+Special credits for [Ismael Celis for inspiration](https://ismaelcelis.com/posts/decide-evolve-react-pattern-in-ruby/).
+
+## Installation
+
+```bash
+gem install decider
+```
+
+or add to Gemfile
+
+```ruby
+gem "decider"
+```
+
+## Usage
+
+```ruby
+require "decider"
+
+State = Data.define(:value) do
+  def max?
+    value >= MAX
+  end
+  
+  def min?
+    value <= MIN
+  end
+end
+
+module Commands
+  Increase = Data.define
+  Decrease = Data.define
+end
+
+module Events
+  ValueIncreased = Data.define
+  ValueDecreased = Data.define
+end
+
+MIN = 0
+MAX = 100
+
+ValueDecider = Decider.define do
+  # define intial state
+  initial_state State.new(value: 0)
+
+  # decide command with state
+  decide Commands::Increase do
+    # return collection of events
+    if state.max?
+      []
+    else
+      [Events::ValueIncreased.new]
+    end
+  end
+
+  decide Commands::Decrease do
+    if state.min?
+      []
+    else
+      [Events::ValueDecreased.new]
+    end
+  end
+
+  # evolve state with events
+  evolve Events::ValueIncreased do
+    # return new state
+    state.with(value: state.value + 1)
+  end
+
+  evolve Events::ValueDecreased do
+    # state is immutable Data object
+    state.with(value: state.value - 1)
+  end
+
+  terminal? do
+    state <= 0
+  end
+end
+
+state = ValueDecider.initial_state
+events = ValueDecider.decide(Commands::Increase.new, state)
+new_state = events.reduce(state) { |state, event| ValueDecider.evolve(state, events)
+```
+
+You can also compose deciders:
+
+```ruby
+Left = Data.define(:value)
+Right = Data.define(:value)
+
+left = Decider.define do
+  initial_state Left.new(value: 0)
+
+  decide Commands::LeftCommand do
+    [Events::LeftEvent.new(value: command.value)]
+  end
+
+  evolve Events::LeftEvent do
+    state.with(value: state.value + 1)
+  end
+
+  terminal? do
+    state <= 0
+  end
+end
+
+right = Decider.define do
+  initial_state Right.new(value: 0)
+
+  decide Commands::RightCommand do
+    [Events::RightEvent.new(value: command.value)]
+  end
+
+  evolve Events::RightEvent do
+    state.with(value: state.value + 1)
+  end
+
+  terminal? do
+    state <= 0
+  end
+end
+
+Composition = Decider.compose(left, right)
+
+state = Composition.initial_state
+#> #<data Decider::Pair left=#<data Left value=0>, right=#<data Right value=0>>
+
+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 Decider::Pair left=#<data value=1>, right=#<data value=0>>
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/decider.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "standard/rake"
+
+task default: %i[test standard]

data/Steepfile

@@ -0,0 +1,26 @@
+D = Steep::Diagnostic
+
+target :lib do
+  signature "sig"
+
+  check "lib"
+  check "Gemfile"
+
+  # library "pathname"              # Standard libraries
+  # library "strong_json"           # Gems
+
+  # configure_code_diagnostics(D::Ruby.strict)       # `strict` diagnostics setting
+  configure_code_diagnostics(D::Ruby.lenient)      # `lenient` diagnostics setting
+  # configure_code_diagnostics(D::Ruby.silent)       # `silent` diagnostics setting
+  # configure_code_diagnostics do |hash|             # You can setup everything yourself
+  #   hash[D::Ruby::NoMethod] = :information
+  # end
+end
+
+# target :test do
+#   signature "sig", "sig-private"
+
+#   check "test"
+
+#   # library "pathname"              # Standard libraries
+# end