decider 0.10.0 → 2.0.0

data/README.md

@@ -1,152 +0,0 @@
-# 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/Steepfile

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

data/examples/decide.md

@@ -1,180 +0,0 @@
-# Decide
-
-## Match by command
-
-```ruby
-Command = Data.define(:value)
-State = Data.define(:value)
-
-decider = Decider.define do
-  initial_state State.new(value: 5)
-
-  decide Command do
-    # emit events
-    emit Event.new(
-      value: command.value + state.value
-    )
-  end
-end
-
-decider.decide Command.new(value: 10), decider.initial_state
-#> [#<data Event value=15>]
-```
-
-## Match by command and state
-
-```ruby
-decider = Decider.define do
-  initial_state :turned_off
-
-  decide :turn_on, :turned_off do
-    emit :turned_on
-  end
-
-  decide :turn_off, :turned_on do
-    emit :turned_off
-  end
-end
-
-decider.decide :turn_on, decider.initial_state
-#> [:turned_on]
-decider.decide :turn_off, :turned_on
-#> [:turned_off]
-decider.decide :turn_on, :turned_on
-#> []
-```
-
-## Match by pattern matching
-
-State = Data.define(:status)
-TurnOn = Data.define
-TurnOff = Data.define
-
-```ruby
-decider = Decider.define do
-  initial_state State.new(status: :turned_off)
-
-  decide proc { [command, state] in [TurnOn, State(status: :turned_off)] } do
-    emit :turned_on
-  end
-
-  decide proc { [command, state] in [TurnOff, State(status: :turned_on)] } do
-    emit :turned_off
-  end
-end
-
-decider.decide :turn_on, decider.initial_state
-#> [:turned_on]
-decider.decide :turn_off, :turned_on
-#> [:turned_off]
-decider.decide :turn_on, :turned_on
-#> []
-```
-
-## Handling unknown commands
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-end
-```
-
-Return empty list of events (nothing changed) by default:
-
-```ruby
-decider.decide :unknown, decider.initial_state
-#> []
-```
-
-If you want to raise error, define a catch-all as last one:
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-
-  decide proc { true } do
-    raise ArgumentError, "Unknown command #{command}"
-  end
-end
-decider.decide :unknown, decider.initial_state
-#> Unknown command unknown (ArgumentError)
-```
-
-## Commands
-
-Commands can be primitives like symbols:
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-
-  decide proc { [command, state] in [:start, :initial | :stopped] } do
-    emit :started
-  end
-
-  decide proc { [command, state] in [:stop, :started] } do
-    emit :stopped
-  end
-end
-
-decider.decide :start, decider.initial_state
-#> [:started]
-decider.decide :stop, :started
-#> [:stopped]
-decider.decider :start, :started
-#> []
-```
-
-Or any classes like [Dry::Struct](https://dry-rb.org/gems/dry-struct/) or [Data](https://rubyapi.org/3.3/o/data):
-
-```ruby
-Start = Data.define(:value)
-Stop = Data.define
-
-decider = Decider.define do
-  initial_state :initial
-
-  decide proc { [command, state] in [Start, :initial | :stopped] } do
-    emit [:started, command.value]
-  end
-
-  decide proc { [command, state] in [Stop, :started] } do
-    emit :stopped
-  end
-end
-
-decider.decide Start.new(value: 10), decider.initial_state
-#> [[:started, 10]]
-decider.decide Stop.new, [:started, 10]
-#> [:stopped]
-```
-
-## Emitting Events
-
-Decide can emit 0, 1 or more events:
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-
-  decide :none do
-    # noop
-  end
-
-  decide :one do
-    emit :event
-  end
-
-  decide :multiple do
-    emit :one
-    emit :two
-  end
-end
-
-decider.decide :none, decider.initial_state
-#> []
-decider.decide :one, decider.initial_state
-#> [:event]
-decider.decide :multiple, decider.initial_state
-#> [:one, :two]
-```

data/examples/evolve.md

@@ -1,150 +0,0 @@
-# Evolve
-
-## Match by event
-
-```ruby
-Event = Data.define(:value)
-
-decider = Decider.define do
-  initial_state :initial
-
-  evolve Event do
-    event.value
-  end
-end
-
-decider.evolve decider.initial_state, Event.new(value: :changed)
-#> :changed
-```
-
-## Match by state and event
-
-```ruby
-decider = Decider.define do
-  initial_state :turned_off
-
-  evolve :turned_on, :turned_off do
-    event
-  end
-
-  evolve :turned_off, :turned_on do
-    event
-  end
-end
-
-decider.evolve decider.initial_state, :turned_on
-#> :turned_on
-decider.evolve :turned_on, :turned_off
-#> :turned_off
-decider.evolve :turned_on, :unknown
-#> :turned_on
-```
-
-## Match by pattern matching
-
-```ruby
-State = Data.define(:value)
-Event = Data.define(:value)
-
-decider = Decider.define do
-  initial_state State.new(value: :turned_off)
-
-  evolve proc { [state, event] in [State(value: :turned_off), Event(value: :turned_on)] } do
-    state.with(value: event.value)
-  end
-end
-
-decider.evolve decider.initial_state, Event.new(value: :turned_on)
-#> #<data State value=:turned_on>
-decider.evolve decider.initial_state, :unknown
-#> #<data State value=:turned_off>
-```
-
-## Handling unknown events
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-end
-
-decider.decide decider.initial_state, :initial
-#> :initial
-```
-
-If you want to raise error, define a catch-all as last one:
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-
-  evolve proc { true } do
-    raise ArgumentError, "Unknown event #{event}"
-  end
-end
-decider.evolve decider.initial_state, :unknown
-#> Unknown event unknown (ArgumentError)
-```
-
-## Events
-
-Events can be primitives like symbols:
-
-```ruby
-decider = Decider.define do
-  initial_state :initial
-
-  evolve :started do
-    :started
-  end
-
-  evolve :stopped do
-    :stopped
-  end
-end
-```
-
-Or any classes like [Dry::Struct](https://dry-rb.org/gems/dry-struct/) or [Data](https://rubyapi.org/3.3/o/data):
-
-```ruby
-State = Data.define(:speed)
-Started = Data.define(:speed)
-Stopped = Data.define
-
-decider = Decider.define do
-  initial_state State.new(speed: 0)
-
-  evolve State, Started do
-    state.with(speed: event.speed)
-  end
-
-  evolve State, Stopped do
-    State.new(speed: 0)
-  end
-end
-```
-
-## Calculate state
-
-In most cases you want to take a collection of events and reduce them with `evolve` to calculate the state, like:
-
-```ruby
-decider = Decider.define do
-  initial_state 0
-
-  evolve :increased do
-    state + 1
-  end
-end
-
-[:increased, :increased].reduce(decider.initial_state) { |state, event| decider.evolve(state, event) }
-#> 2
-```
-
-You can shortcut that with `&`:
-
-```ruby
-[:increased, :increased].reduce(decider.initial_state, &decider.method(:evolve))
-#> 2
-[:increased, :increased].reduce(decider.initial_state, &decider.evolve)
-#> 2
-```

data/examples/infra.md

@@ -1,15 +0,0 @@
-# Infra
-
-## In memory
-
-```ruby
-require "decider/in_memory"
-
-GLOBAL = Decider::InMemory.new(MyDecider)
-
-# returns list of events
-GLOBAL.handle(command)
-
-# returns current state
-GLOBAL.state
-```

data/examples/state.md

@@ -1,55 +0,0 @@
-# State examples
-
-## Data
-
-```ruby
-State = Data.define(:value)
-
-decider = Decider.define do
-  initial_state State.new(value: 0)
-
-  decide Commands::Command do
-    emit Events::Event.new(value: command.value)
-  end
-
-  evolve Events::Event do
-    state.with(value: state.value + 1)
-  end
-end
-```
-
-## Primitive
-
-```ruby
-decider = Decider.define do
-  initial_state :turned_off
-
-  decide Commands::TurnOn, :turned_off do
-    emit Events::TurnedOn.new
-  end
-
-  decide Commands::TurnOff, :turned_on do
-    emit Events::TurnedOff.new
-  end
-
-  evolve Events::TurnedOn do
-    :turned_on
-  end
-end
-```
-
-## List
-
-```ruby
-decider = Decider.define do
-  initial_state []
-
-  decide Commands::Command, [] do
-    emit Events::Event.new(value: command.value)
-  end
-
-  evolve Events::Event do
-    state + [event]
-  end
-end
-```

data/lib/decider/event_sourcing.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Decider
-  class EventSourcing
-    def initialize(decider:, event_store:)
-      @decider = decider
-      @event_store = event_store
-    end
-
-    def call(command, stream_name:)
-      events = event_store.read.stream(stream_name)
-      state = events.reduce(decider.initial_state, &decider.method(:evolve))
-
-      new_events = decider.decide(command, state)
-
-      event_store.append(new_events, stream_name: stream_name, expected_version: events.count)
-
-      [new_events, events.count + new_events.count]
-    end
-
-    private
-
-    attr_reader :decider, :event_store
-  end
-end

data/lib/decider/in_memory.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "concurrent-ruby"
-
-module Decider
-  class InMemory
-    def initialize(decider)
-      @decider = decider
-      @atom = Concurrent::Atom.new(decider.initial_state)
-    end
-
-    def call(command)
-      events = decider.decide(command, state)
-      atom.swap { |state| events.reduce(state, &decider.method(:evolve)) }
-      events
-    end
-
-    def state
-      atom.value
-    end
-
-    private
-
-    attr_reader :decider, :atom
-  end
-end