lieutenant 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b4bd4305e270917371083e9ad6138b7a45f6473
+  data.tar.gz: 5bd3c11a3945578b07e45226dc95efdd4388ba3a
+SHA512:
+  metadata.gz: 11e225acbc456c2e8093eb467a1537df64c98400686d295a1ecfbd1c96f2d7463f896cc1c2363d38b8d37700a30db74f7cb731c4b967d11562a1ad0e461b9f30
+  data.tar.gz: 95136b8ad7cd14e41d4bc2eb7b2a3c8e4a76f2fad74b684574ef76d63e962422585377d2b044eb6ee1d7ec813269c5970c6ba4888ad57cf57276ffea4704e467

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,23 @@
+AllCops:
+  TargetRubyVersion: 2.4
+
+Metrics/LineLength:
+  Max: 120
+
+Metrics/ClassLength:
+  Max: 150
+
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/BlockLength:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Layout/IndentArray:
+  Enabled: false
+
+Layout/IndentHash:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.16.0.pre.2

data/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gemspec

data/README.md

@@ -0,0 +1,108 @@
+# **Lieutenant**
+
+## **CQRS/ES Toolkit to command them all**
+
+Lieutenant is a toolkit that implements various of the components of Command & Query Responsability Segregation (CQRS) and Event Sourcing (ES). It means that your application can get rid of the "current" state of the entities you choose and store all the *changes* that led them to it.
+
+This gem aims to be most independent as possible of your tecnological choices, it means that it should work with Rails, Sinatra, pure Rack apps or whatever you want.
+
+If you are not familiarized, you may check this references:
+
+- [CQRS Journey](https://msdn.microsoft.com/en-us/library/jj554200.aspx)
+- [crqs.nu](http://cqrs.nu/)
+- [Event Sourcing, by Martin Fowler](https://martinfowler.com/eaaDev/EventSourcing.html)
+- [CQRS Documents, by Greg Young](https://cqrs.files.wordpress.com/2010/11/cqrs_documents.pdf)
+- [Choosing an architecture, from TrustBK](https://blog.trustbk.com/choosing-an-architecture-85750e1e5a03)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lieutenant'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lieutenant
+
+## Usage
+
+By now, Lieutenant offer the components listed below. With each one, there's a description and example usage. If you cannot understand it, feel free to open an issue. Or if you think that it's not sufficient to other people, pull requests are welcome!
+
+- [Commands](#commands)
+- [Command Sender](#command-sender)
+- [Command Handlers](#command-handlers)
+- [Aggregate Repositories](#aggregate-repositories)
+- [Aggregates](#aggregates)
+- [Events](#events)
+- [Event Store](#event-store)
+- [Event Bus](#event-bus)
+
+### Commands
+
+TODO
+
+
+### Command Sender
+
+TODO
+
+
+### Command Handlers
+
+TODO
+
+
+### Aggregate Repositories
+
+TODO
+
+
+### Aggregates
+
+TODO
+
+
+### Events
+
+TODO
+
+
+### Event Store
+
+TODO
+
+
+### Event Bus
+
+TODO
+
+
+## Roadmap
+
+In order to give some directions to the development of this gem, the roadmap below presents in a large picture of the plans to the future (more or less ordered).
+
+- Projections
+- Better documentation
+- Command filters
+- Command retry policies
+- Sagas
+- More implementations of event store
+- More implementations of event bus
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` 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 tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+You can also use `bundle exec rake lint` to be sure that your code follows our policies. We currently use [rubocop](https://github.com/bbatsov/rubocop) and [reek](https://github.com/troessner/reek).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gabteles/lieutenant.

data/Rakefile

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'reek/rake/task'
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new(:rubocop) do |t|
+  t.options = ['--display-cop-names']
+end
+Reek::Rake::Task.new do |t|
+  t.fail_on_error = false
+end
+YARD::Rake::YardocTask.new
+
+task default: :spec
+task lint: %i[rubocop reek]
+task fulltest: %i[spec lint]

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'lieutenant'
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/lieutenant/aggregate.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Representation of an aggregate root
+  module Aggregate
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # Define common class methods to aggregates
+    module ClassMethods
+      def load_from_history(id, history)
+        allocate.send(:load_from_history, id, history)
+      end
+
+      def on(*event_classes, &handler)
+        event_classes.each do |event_class|
+          unless event_class < Event
+            raise(Lieutenant::Exception, "Expected #{event_class} to include Lieutenant::Event")
+          end
+
+          handlers[event_class] = handlers[event_class].push(handler)
+        end
+      end
+
+      def handlers_for(event_class)
+        handlers[event_class]
+      end
+
+      private
+
+      def handlers
+        @handlers ||= Hash.new { [] }
+      end
+    end
+
+    attr_reader :id
+    attr_reader :uncommitted_events
+    attr_reader :version
+
+    def mark_as_committed
+      self.version += uncommitted_events.size
+      uncommitted_events.clear
+    end
+
+    protected
+
+    def apply(event_class, **params)
+      event = event_class.with(**params)
+      internal_apply(event)
+      uncommitted_events << event
+    end
+
+    attr_writer :version
+
+    private
+
+    def setup(id)
+      @id = id
+      @uncommitted_events = []
+      @version = -1
+    end
+
+    def load_from_history(id, history)
+      setup(id)
+
+      history.each do |event|
+        internal_apply(event)
+        self.version += 1
+      end
+
+      self
+    end
+
+    def internal_apply(event)
+      raise(Lieutenant::Exception, "Invalid event: #{event.inspect}") unless event.valid?
+      self.class.handlers_for(event.class).each { |handler| instance_exec(event, &handler) }
+    end
+  end
+end

data/lib/lieutenant/aggregate_repository.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Manages the repository logic to persist and retrieve aggregates
+  class AggregateRepository
+    def initialize(store)
+      @store = store
+    end
+
+    def unit_of_work
+      AggregateRepositoryUnit.new(store)
+    end
+
+    private
+
+    attr_reader :store
+
+    # Represents one unit of work of the repository to grant independence
+    # between multiple concurrent commands being handled
+    class AggregateRepositoryUnit
+      def initialize(store)
+        @aggregates = {}
+        @store = store
+      end
+
+      def add_aggregate(aggregate)
+        aggregates[aggregate.id] = aggregate
+      end
+
+      def load_aggregate(aggregate_type, aggregate_id)
+        aggregates[aggregate_id] ||= begin
+          history = store.event_stream_for(aggregate_id)
+          aggregate_type.load_from_history(aggregate_id, history)
+        end
+      end
+
+      def execute
+        yield(self)
+        commit
+      ensure
+        clean
+      end
+
+      private
+
+      def commit
+        return if aggregates.empty?
+
+        store.transaction do
+          aggregates.each_value(&method(:commit_aggregate))
+        end
+      end
+
+      def clean
+        aggregates.clear
+      end
+
+      attr_reader :aggregates
+      attr_reader :store
+
+      # :reek:FeatureEnvy
+      def commit_aggregate(aggregate)
+        store.save_events(aggregate.id, aggregate.uncommitted_events, aggregate.version)
+        aggregate.mark_as_committed
+      end
+    end
+  end
+end

data/lib/lieutenant/command.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Syntax helper to define commands
+  module Command
+    def self.included(base)
+      base.include(Message)
+    end
+  end
+end

data/lib/lieutenant/command_handler.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Command handler helper. Allows clean syntax to register handlers:
+  #
+  #   module FooCommandHandler
+  #     include Lieutenant::CommandHandler
+  #
+  #     on(BarCommand) do |repository, command|
+  #        # ...
+  #     end
+  #   end
+  module CommandHandler
+    def self.included(base)
+      base.extend(self)
+    end
+
+    # :reek:UtilityFunction
+    def on(command_class, &block)
+      Lieutenant.config.command_sender.register(command_class, block)
+    end
+  end
+end

data/lib/lieutenant/command_sender.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Command bus dispatch commands to the appropriate handler and manages the repository commit/clean
+  class CommandSender
+    def initialize(aggregate_repository)
+      @aggregate_repository = aggregate_repository
+      @handlers = {}
+    end
+
+    def register(command_class, handler)
+      raise(Lieutenant::Exception, "Handler for #{command_class} already registered") if handlers.key?(command_class)
+      handlers[command_class] = handler
+    end
+
+    def dispatch(command)
+      handler = handler_for(command.class)
+      # TODO: Filters
+      raise(Lieutenant::Exception, "Invalid command: #{command.inspect}") unless command.valid?
+      aggregate_repository.unit_of_work.execute { |repository| handler.call(repository, command) }
+      # rescue Exception::ConcurrencyConflict
+      #   TODO: implement command retry policy
+    end
+
+    alias call dispatch
+
+    private
+
+    attr_reader :aggregate_repository
+    attr_reader :handlers
+
+    def handler_for(command_class)
+      handlers.fetch(command_class) do
+        raise(Exception::NoRegisteredHandler, "No registered handler for #{command_class}")
+      end
+    end
+  end
+end

data/lib/lieutenant/config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Manages configuration
+  class Config
+    # :reek:BooleanParameter
+    def event_bus(implementation = false)
+      return @event_bus = implementation if implementation
+      @event_bus ||= EventBus::InMemory.new
+    end
+
+    # :reek:BooleanParameter
+    def event_store(implementation = false)
+      return @event_store_implementation = implementation if implementation
+      @event_store ||= EventStore.new(@event_store_implementation, event_bus)
+    end
+
+    def aggregate_repository
+      @aggregate_repository ||= AggregateRepository.new(event_store)
+    end
+
+    def command_sender
+      @command_sender ||= CommandSender.new(aggregate_repository)
+    end
+  end
+end

data/lib/lieutenant/event.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # The basic interface to register the aggregates events
+  module Event
+    def self.included(base)
+      base.include(Message)
+    end
+
+    attr_reader :aggregate_id, :sequence_number
+
+    def prepare(aggregate_id, sequence_number)
+      @aggregate_id = aggregate_id
+      @sequence_number = sequence_number
+    end
+  end
+end

data/lib/lieutenant/event_bus/in_memory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  module EventBus
+    # Memory implementation of the event bus. Publishes and notifies on the same memory space.
+    class InMemory
+      def initialize
+        @handlers = Hash.new { [] }
+      end
+
+      def subscribe(*event_classes, &handler)
+        event_classes.each do |event_class|
+          handlers[event_class] = handlers[event_class].push(handler)
+        end
+      end
+
+      def publish(event)
+        block = CALL_HANDLER_WITH_EVENT[event]
+        handlers[:all].each(&block)
+        handlers[event.class].each(&block)
+      end
+
+      private
+
+      attr_reader :handlers
+
+      CALL_HANDLER_WITH_EVENT = ->(event) { ->(handler) { handler.call(event) } }
+      private_constant :CALL_HANDLER_WITH_EVENT
+    end
+  end
+end

data/lib/lieutenant/event_bus.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Publishes and receives messages from the aggregates updates
+  module EventBus
+    autoload :InMemory, 'lieutenant/event_bus/in_memory'
+  end
+end

data/lib/lieutenant/event_store/in_memory.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  class EventStore
+    # Memory implementation of the event store. Stores events while the application is running
+    class InMemory
+      def initialize
+        @store = {}
+      end
+
+      def persist(events)
+        events.each { |event| (store[event.aggregate_id] ||= []).push(event) }
+      end
+
+      def event_stream_for(aggregate_id)
+        events = store[aggregate_id]
+        return nil unless events
+        Enumerator.new { |yielder| events.each(&yielder.method(:<<)) }
+      end
+
+      def aggregate_sequence_number(aggregate_id)
+        return -1 unless store.key?(aggregate_id)
+        store[aggregate_id].last.sequence_number
+      end
+
+      def transaction
+        # In memory event store currently does not support transactions.
+        yield
+      end
+
+      private
+
+      attr_reader :store
+    end
+  end
+end

data/lib/lieutenant/event_store.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Event stores handles pushing and pulling events from the event store.
+  class EventStore
+    autoload :InMemory, 'lieutenant/event_store/in_memory'
+
+    def initialize(store, event_bus)
+      @store = store
+      @event_bus = event_bus
+    end
+
+    def save_events(aggregate_id, events, expected_version)
+      raise(Exception::ConcurrencyConflict) if store.aggregate_sequence_number(aggregate_id) != expected_version
+
+      PREPARE_EVENTS[aggregate_id, events, expected_version].tap do |final_events|
+        store.persist(final_events)
+        final_events.each(&event_bus.method(:publish))
+      end
+    end
+
+    def event_stream_for(aggregate_id)
+      store.event_stream_for(aggregate_id) || raise(Exception::AggregateNotFound, aggregate_id)
+    end
+
+    def transaction(&blk)
+      store.transaction(&blk)
+    end
+
+    private
+
+    attr_reader :store
+    attr_reader :event_bus
+
+    PREPARE_EVENTS = lambda do |aggregate_id, events, sequence_number|
+      events.lazy.with_index.map do |event, idx|
+        event.prepare(aggregate_id, sequence_number + idx + 1)
+        event
+      end
+    end
+
+    private_constant :PREPARE_EVENTS
+  end
+end

data/lib/lieutenant/exception/aggregate_not_found.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  class Exception
+    # Raised when eventes associated with an aggregate id are not found
+    class AggregateNotFound < Lieutenant::Exception
+    end
+  end
+end

data/lib/lieutenant/exception/concurrency_conflict.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  class Exception
+    # Raised when expected version of the agreggate does not match the real one
+    # when saving events
+    class ConcurrencyConflict < Lieutenant::Exception
+    end
+  end
+end

data/lib/lieutenant/exception/no_registered_handler.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  class Exception
+    # Raised when a handler to a command is not registered
+    class NoRegisteredHandler < Lieutenant::Exception
+    end
+  end
+end

data/lib/lieutenant/exception.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Generic class to all Lieutenant exceptions. Anything is
+  # rescue-able with Lieutenant::Exception
+  class Exception < StandardError
+    autoload :AggregateNotFound,   'lieutenant/exception/aggregate_not_found'
+    autoload :ConcurrencyConflict, 'lieutenant/exception/concurrency_conflict'
+    autoload :NoRegisteredHandler, 'lieutenant/exception/no_registered_handler'
+  end
+end

data/lib/lieutenant/message.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  # Helper to define messages with validation
+  module Message
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(ActiveModel::Validations)
+    end
+
+    # Define common class methods to commands
+    module ClassMethods
+      def with(params)
+        new.tap do |command|
+          params.each_pair do |key, value|
+            begin
+              command.send("#{key}=", value)
+            rescue NoMethodError # rubocop:disable Lint/HandleExceptions
+              # DO NOTHING
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lieutenant/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Lieutenant
+  VERSION = '0.1.0'
+end

data/lib/lieutenant.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'active_model'
+
+# Lieutenant namespace
+module Lieutenant
+  autoload :Aggregate,           'lieutenant/aggregate'
+  autoload :AggregateRepository, 'lieutenant/aggregate_repository'
+  autoload :Command,             'lieutenant/command'
+  autoload :CommandHandler,      'lieutenant/command_handler'
+  autoload :CommandSender,       'lieutenant/command_sender'
+  autoload :Config,              'lieutenant/config'
+  autoload :Event,               'lieutenant/event'
+  autoload :EventBus,            'lieutenant/event_bus'
+  autoload :EventStore,          'lieutenant/event_store'
+  autoload :Exception,           'lieutenant/exception'
+  autoload :Message,             'lieutenant/message'
+  autoload :VERSION,             'lieutenant/version'
+
+  module_function
+
+  @config = Config.new
+
+  def config
+    block_given? ? yield(@config) : @config
+  end
+end

data/lieutenant.gemspec

@@ -0,0 +1,33 @@
+
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lieutenant/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'lieutenant'
+  spec.version       = Lieutenant::VERSION
+  spec.authors       = ['Gabriel Teles']
+  spec.email         = ['gab.teles@hotmail.com']
+
+  spec.summary       = 'CQRS/ES Toolkit to command them all'
+  spec.homepage      = 'https://github.com/gabteles/lieutenant'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'reek'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'yard'
+  spec.add_dependency 'activemodel'
+end

metadata

@@ -0,0 +1,197 @@
+--- !ruby/object:Gem::Specification
+name: lieutenant
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gabriel Teles
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-12-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- gab.teles@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/lieutenant.rb
+- lib/lieutenant/aggregate.rb
+- lib/lieutenant/aggregate_repository.rb
+- lib/lieutenant/command.rb
+- lib/lieutenant/command_handler.rb
+- lib/lieutenant/command_sender.rb
+- lib/lieutenant/config.rb
+- lib/lieutenant/event.rb
+- lib/lieutenant/event_bus.rb
+- lib/lieutenant/event_bus/in_memory.rb
+- lib/lieutenant/event_store.rb
+- lib/lieutenant/event_store/in_memory.rb
+- lib/lieutenant/exception.rb
+- lib/lieutenant/exception/aggregate_not_found.rb
+- lib/lieutenant/exception/concurrency_conflict.rb
+- lib/lieutenant/exception/no_registered_handler.rb
+- lib/lieutenant/message.rb
+- lib/lieutenant/version.rb
+- lieutenant.gemspec
+homepage: https://github.com/gabteles/lieutenant
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: CQRS/ES Toolkit to command them all
+test_files: []