fourth_dimensional 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11c3860996942f56fa43873961fdbbf82069813122122326a29d286d33455990
-  data.tar.gz: 42f4c00c835316f5e0fe04a42e699afb25ef758c5e4d6ed3a87242c9eccd2567
+  metadata.gz: 9e42f145173551ac50193f92d2dea18e824e9c08807040cb53bdab953ff57061
+  data.tar.gz: a8813fea8c342ca410cb5935dd4e4deece9fb247fa110b3b03f2f9044ad266bf
 SHA512:
-  metadata.gz: 55df185870d5e5f68b6cf6bd68c83b69e54ec1e3bc606e5568574387a95a441f7c4b75245f9f29e53d3d2916fb18a0b8d34b330a40e7581b80287cc22f9315c9
-  data.tar.gz: c7a17815b197d2a9767714a002b148e54c2fac6fdb7d3f4094ccd132308899d7e96dfd6f8fcb856eb0397ab6db00686cdba009c20b4d7e121a28c2450a9496f3
+  metadata.gz: 32b5cec8272c1d40448a60ffaad530713f02d5373e2a9f181ebacb39a92cf378300ba51a80acfc138fca0fa5f5443612177a2a2fe0f3bb6b7caeaf7fcde3d510
+  data.tar.gz: 39c610fad07ed26675a66c30f5c3324837f70fea7301a5d78bf3b4df1a5aaf68fd4307760538085b7ea32d0e78470bdcbf3e7c0e3be1adafc110a3afb55bfdb5

data/lib/fourth_dimensional.rb

@@ -1,7 +1,80 @@
 require "fourth_dimensional/version"
+require "fourth_dimensional/railtie" if defined?(Rails)
 
 module FourthDimensional
   class Error < StandardError; end
 
+  autoload :AggregateRoot, 'fourth_dimensional/aggregate_root'
+  autoload :Command, 'fourth_dimensional/command'
+  autoload :CommandHandler, 'fourth_dimensional/command_handler'
+  autoload :Configuration, 'fourth_dimensional/configuration'
   autoload :Event, 'fourth_dimensional/event'
+  autoload :Eventable, 'fourth_dimensional/eventable'
+  autoload :EventLoaders, 'fourth_dimensional/event_loaders'
+  autoload :RecordProjector, 'fourth_dimensional/record_projector'
+  autoload :Repository, 'fourth_dimensional/repository'
+
+  # The singleton instance of Configuration
+  def self.config
+    @configuration ||= Configuration.new
+  end
+
+  # Yields the Configuration instance
+  #
+  #   FourthDimensional.configure do |config|
+  #     config.command_handlers = [
+  #       CommentCommandHandler,
+  #       PostCommandHandler
+  #     ]
+  #   end
+  def self.configure
+    yield config
+  end
+
+  # Iniitlaizes a Repository with the required dependencies.
+  #
+  #   FourthDimensional.repository # => FourthDimensional::Repository
+  def self.build_repository
+    Repository.new(event_loader: config.event_loader)
+  end
+
+  # Runs a single or array of commands through all command handlers, saves
+  # commands and applied events, and invokes event handlers.
+  #
+  #   Fourthdimensional.execute_command(command)
+  #   FourthDimensional.execute_commands(command1, command2)
+  #   FourthDimensional.execute_commands([command1, command2])
+  def self.execute_commands(*commands)
+    repository = build_repository
+    call_command_handlers(repository, commands)
+    saved_events = save_commands_and_events(repository)
+    call_event_handlers(saved_events)
+  end
+
+  class << self
+    alias_method :execute_command, :execute_commands
+  end
+
+  private
+
+  def self.call_command_handlers(repository, commands)
+    config.command_handlers.each do |command_handler|
+      commands.flatten.each do |command|
+        command_handler.new(repository: repository).call(command)
+      end
+    end
+  end
+
+  def self.save_commands_and_events(repository)
+    config.event_loader.save_commands_and_events(
+      commands: repository.called_commands,
+      events: repository.applied_events
+    )
+  end
+
+  def self.call_event_handlers(events)
+    config.event_handlers.each do |event_handler|
+      event_handler.call(events)
+    end
+  end
 end

data/lib/fourth_dimensional/aggregate_root.rb

@@ -0,0 +1,100 @@
+module FourthDimensional
+  # == FourthDimensional::AggregateRoot
+  #
+  # An aggregate root is an object whose entire state is built by applying
+  # events in sequential order.
+  #
+  # Often you will see an aggregate root providing a method to create the event
+  # followed by a event binding to apply the changes to the current object.
+  #
+  #   class Post < FourthDimensional::AggregateRoot
+  #     attr_reader :state, :title
+  #
+  #     def initialize(*args)
+  #       super
+  #
+  #       @state = :draft
+  #     end
+  #
+  #     def add(title:)
+  #       apply PostAdded, data: { title: title }
+  #     end
+  #
+  #     def delete
+  #       apply PostDeleted
+  #     end
+  #
+  #     on PostAdded do |event|
+  #       @state = :added
+  #       @title = event.data.fetch('title')
+  #     end
+  #
+  #     on PostDeleted do |event|
+  #       @state = :deleted
+  #     end
+  #   end
+  #
+  #   aggregate = Post.new(id: SecureRandom.uuid)
+  #   aggregate.state # => :draft
+  #   aggregate.title # => nil
+  #
+  #   aggregate.add(title: 'post-title')
+  #   aggregate.state # => :added
+  #   aggregate.title # => 'post-title'
+  #
+  #   aggregate.delete
+  #   aggregate.state # => :deleted
+  class AggregateRoot
+    include Eventable
+
+    UnknownEventError = Class.new(Error)
+
+    # aggregate id
+    attr_reader :id
+
+    # array of events applied
+    attr_reader :applied_events
+
+    # current version
+    attr_reader :version
+
+    # Initializes an aggregate with an id
+    def initialize(id:)
+      @id = id
+
+      @applied_events = []
+      @version = 1
+    end
+
+    # Applies an event to the aggregate when a callback is bound. **+args+ are
+    # merged with the +id+ of the aggregate.
+    #
+    # Callbacks are invoked within the instance of the aggregate root.
+    def apply(event_class, **args)
+      event = event_class.new(args.merge(aggregate_id: id))
+      apply_existing_event(event)
+      applied_events << event
+    end
+
+    # Calls the event binding without persisting the event being applied. Used
+    # when loading an aggregate from an existing store.
+    #
+    #   post.apply_existing_event(title_updated_event)
+    def apply_existing_event(event)
+      callback = self.class.event_bindings[event.class]
+
+      if callback.nil?
+        raise UnknownEventError.new("#{self.class.name} doesn't have a binding for '#{event.class}'")
+      end
+
+      instance_exec(event, &callback)
+      @version = next_version
+    end
+
+    private
+
+    def next_version
+      version + 1
+    end
+  end
+end

data/lib/fourth_dimensional/command.rb

@@ -0,0 +1,63 @@
+require "active_model"
+
+module FourthDimensional
+  # == FourthDimensional::Command
+  #
+  # Commands are the input to create events. They provide an early validation
+  # step to ensuring the data format is correct before validating the current
+  # state of the system.
+  #
+  #   class AddPost < FourthDimensional::Command
+  #     attributes :title, :body, :published
+  #     validates_presence_of :title, :body
+  #   end
+  #
+  #   AddPost.new # => raises ArgumentError.new("missing keywords: aggregate_id, :title, :body, :published)
+  #   command = AddPost.new(aggregate_id: '1-2-3', title: 'post-title', body: 'post-body', published: false)
+  #   command.valid? # => true
+  #   command.aggregate_id # => '1-2-3'
+  #   command.title # => 'post-title'
+  #   command.body # => 'post-body'
+  #   command.published # => false
+  #
+  #   command.to_h # => {'title' => 'post-title', 'body' => 'post-body', 'published' => false}
+  class Command
+    include ActiveModel::Validations
+
+    # The aggregate the command is acting on
+    attr_reader :aggregate_id
+
+    def initialize(aggregate_id:)
+      @aggregate_id = aggregate_id
+    end
+
+    def to_h
+      {}
+    end
+
+    # Defines an initializer with required keyword arguments, readonly only
+    # attributes and +to_h+ to access all defined attributes
+    #
+    #   class AddPost < FourthDimensional::Command
+    #     attributes :title, :body, :published
+    #   end
+    def self.attributes(*attributes)
+      attr_reader *attributes
+
+      method_arguments = attributes.map { |arg| "#{arg}:" }.join(', ')
+      method_assignments = attributes.map { |arg| "@#{arg} = #{arg}" }.join(';')
+      method_attrs_to_hash = attributes.map { |arg| "'#{arg}' => #{arg}" }.join(',')
+
+      class_eval <<~CODE
+        def initialize(aggregate_id:, #{method_arguments})
+          @aggregate_id = aggregate_id
+          #{method_assignments}
+        end
+
+        def to_h
+          {#{method_attrs_to_hash}}
+        end
+      CODE
+    end
+  end
+end

data/lib/fourth_dimensional/command_handler.rb

@@ -0,0 +1,79 @@
+module FourthDimensional
+  # == FourthDimensional::CommandHandler
+  #
+  # Command handlers have bindings that wrap a Command to load an aggregate and
+  # apply events.
+  #
+  #   class PostCommandHandler < FourthDimensional::CommandHandler
+  #     on AddPost do |command|
+  #       with_aggregate(PostAggregate, command) do |post|
+  #         post.add(title: command.title, body: command.body)
+  #       end
+  #     end
+  #
+  #     # manually load and save aggregate
+  #     on UpdateTitle do |command|
+  #       post = repository.load_aggregate(PostAggregate, command.aggregate_id)
+  #       post.update_title(title: command.title)
+  #       save(command, post)
+  #     end
+  #
+  #     on PublishPost do |command|
+  #       with_aggregate(PostAggregate, command) do |post|
+  #         post.publish
+  #       end
+  #     end
+  #   end
+  class CommandHandler
+    include Eventable
+
+    attr_reader :repository
+
+    class CommandAndEvents
+      attr_reader :command, :events
+
+      def initialize(command:, events:)
+        @command = command
+        @events = events
+      end
+
+      def ==(other)
+        self.class == other.class && command == other.command && events == other.events
+      end
+    end
+
+    def initialize(repository:)
+      @repository = repository
+    end
+
+    # Invokes a callback for an command.
+    def call(command)
+      callback = self.class.event_bindings[command.class]
+      return if callback.nil?
+      instance_exec(command, &callback)
+    end
+
+    # Yields the aggregate and saves the applied events
+    def with_aggregate(aggregate_class, command, &block)
+      aggregate = repository.load_aggregate(aggregate_class, command.aggregate_id)
+      yield aggregate
+      save(command, aggregate)
+    end
+
+    # Saves the command and aggregate's applied events
+    #
+    #   class PostCommandHandler < FourthDimensional::CommandHandler
+    #     on AddPost do |command|
+    #       post = repository.load_aggregate(PostAggregate, command.aggregate_id)
+    #       post.add(title: command.title)
+    #       save(command, post)
+    #     end
+    #   end
+    def save(command, aggregate)
+      repository.save_command_and_events(CommandAndEvents.new(
+        command: command,
+        events: aggregate.applied_events
+      ))
+    end
+  end
+end

data/lib/fourth_dimensional/configuration.rb

@@ -0,0 +1,28 @@
+module FourthDimensional
+  # == FourthDimensional::Configuration
+  #
+  #   FourthDimensional.configure do |config|
+  #     config.command_handlers = [...]
+  #     config.event_handlers = [...]
+  #     config.event_loader = FourthDimensional::ActiveRecord::EventLoader.new
+  #   end
+  class Configuration
+    # An array of command handlers
+    attr_accessor :command_handlers
+
+    # An array of event handlers
+    attr_accessor :event_handlers
+
+    # The event loader
+    attr_accessor :event_loader
+
+    # The table prefix
+    attr_accessor :table_prefix
+
+    def initialize
+      @command_handlers = []
+      @event_handlers = []
+      @table_prefix = 'fourd_'
+    end
+  end
+end

data/lib/fourth_dimensional/event.rb

@@ -1,3 +1,6 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/inflector"
+
 module FourthDimensional
   # == FourthDimensional::Event
   #
@@ -29,6 +32,9 @@ module FourthDimensional
     # hash of data with stringified keys
     attr_reader :data, :metadata
 
+    # persisted event attributes
+    attr_reader :id, :version, :created_at, :updated_at
+
     # Initializes an event with the required +aggregate_id+ and optional +data+
     # and +metadata+.
     #
@@ -41,14 +47,33 @@ module FourthDimensional
     # strings to accommodate deserializing the values from json.
     #
     #   event = MyEvent.new(aggregate_id: '1-2-3',
+    #                       version: 1,
     #                       data: { one: 1 },
     #                       metadata: { two: 2 })
+    #   event.version # => 1
     #   event.data # => { 'one' => 1 }
     #   event.metadata # => { 'two' => 2 }
-    def initialize(aggregate_id:, data: nil, metadata: nil)
+    def initialize(aggregate_id:,
+                   id: nil,
+                   version: nil,
+                   created_at: nil,
+                   updated_at: nil,
+                   data: nil,
+                   metadata: nil)
       @aggregate_id = aggregate_id
-      @data = data || {}
-      @metadata = metadata || {}
+      @id = id
+      @version = version
+      @created_at = created_at
+      @updated_at = updated_at
+      @data = (data || {}).transform_keys(&:to_s)
+      @metadata = (metadata || {}).transform_keys(&:to_s)
+    end
+
+    # Underscored event type
+    #
+    #     Products::Events::Created.new.type # => "products/events/created"
+    def type
+      self.class.name.underscore
     end
   end
 end

data/lib/fourth_dimensional/event_loaders.rb

@@ -0,0 +1,5 @@
+module FourthDimensional
+  module EventLoaders
+    autoload :ActiveRecord, 'fourth_dimensional/event_loaders/active_record'
+  end
+end

data/lib/fourth_dimensional/event_loaders/active_record.rb

@@ -0,0 +1,85 @@
+require 'active_record'
+
+module FourthDimensional
+  module EventLoaders
+    # == FourthDimensional::EventLoaders::ActiveRecord
+    #
+    #   FourthDimensional.configure do |config|
+    #     config.event_loader = FourthDimensional::EventLoaders::ActiveRecord.new
+    #   end
+    class ActiveRecord
+      # Loads events by +aggregate_id+ and deserializes them.
+      #
+      #   FourthDimensional.config.event_loader.for_aggregate(aggregate_id)
+      def for_aggregate(aggregate_id)
+        Event.where(aggregate_id: aggregate_id)
+          .order(:version)
+          .map(&method(:deserialize_event))
+      end
+
+      # Deserializes a single event.
+      def deserialize_event(event)
+        event.event_type.camelize.constantize.new(aggregate_id: event.aggregate_id,
+                                                  id: event.id,
+                                                  version: event.version,
+                                                  data: event.data,
+                                                  metadata: event.metadata,
+                                                  created_at: event.created_at,
+                                                  updated_at: event.updated_at)
+      end
+
+      # Saves commands and events in active record compatible database.
+      def save_commands_and_events(commands:, events:)
+        FourthDimensionalRecord.transaction do
+          create_commands!(commands)
+          create_events!(events).map(&method(:deserialize_event))
+        end
+      end
+
+      class FourthDimensionalRecord < ::ActiveRecord::Base # :nodoc:
+        self.abstract_class = true
+      end
+
+      class Command < FourthDimensionalRecord # :nodoc:
+        self.table_name = FourthDimensional.config.table_prefix + 'commands'
+
+        serialize :data, JSON
+      end
+
+      class Event < FourthDimensionalRecord # :nodoc:
+        self.table_name = FourthDimensional.config.table_prefix + 'events'
+
+        serialize :data, JSON
+        serialize :metadata, JSON
+      end
+
+      private
+
+      def create_commands!(commands)
+        commands.each do |command|
+          Command.create!(aggregate_id: command.aggregate_id,
+                          command_type: command.class.name.underscore,
+                          data: command.to_h)
+        end
+      end
+
+      def create_events!(events)
+        versions = aggregate_versions
+        events.map do |event|
+          version = versions[event.aggregate_id] += 1
+          Event.create!(uuid: SecureRandom.uuid,
+                        aggregate_id: event.aggregate_id,
+                        version: version,
+                        event_type: event.type,
+                        data: event.data,
+                        metadata: event.metadata)
+        end
+      end
+
+      def aggregate_versions
+        Hash.new { |hash, key| hash[key] = 0 }
+          .merge(Event.group(:aggregate_id).maximum(:version).to_h)
+      end
+    end
+  end
+end

data/lib/fourth_dimensional/eventable.rb

@@ -0,0 +1,56 @@
+module FourthDimensional
+  # == Eventable
+  #
+  # Provides an api for registering event bindings.
+  #
+  #   class CantHandleTheTruth
+  #     include FourthDimensional::Eventable
+  #
+  #     on TheTruth do |event|
+  #       raise RunTimeError.new("an error occured that can not be rescued")
+  #     end
+  #   end
+  module Eventable
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Binds an event to the aggregate. Raises a +KeyError+ if the event has
+      # already been bound.
+      #
+      #   Post.on(PostAdded, -> (event) {})
+      #   Post.on(PostAdded, -> (event) {}) # => raises KeyError
+      def on(klass, &block)
+        if event_bindings.has_key?(klass)
+          raise KeyError.new("#{klass.name} is already bound on #{self.name}") 
+        end
+
+        event_bindings[klass] = block
+      end
+
+      # Returns an array of class names for the bound events.
+      #
+      #   Post.on(PostAdded, -> (event) {})
+      #   Post.on(PostDeleted, -> (event) {})
+      #
+      #   Post.events # => [PostAdded, PostDeleted]
+      def events
+        event_bindings.keys
+      end
+
+      # Returns a hash of event classes and the callback.
+      #
+      #   Post.on(PostAdded, -> (event) {})
+      #   Post.on(PostDeleted, -> (event) {})
+      #
+      #   Post.event_bindings # => {
+      #     PostAdded => Proc,
+      #     PostDeleted => Proc
+      #   }
+      def event_bindings
+        @event_bindings ||= {}
+      end
+    end
+  end
+end

data/lib/fourth_dimensional/railtie.rb

@@ -0,0 +1,4 @@
+module Fourthdimensional
+  class Railtie < ::Rails::Railtie
+  end
+end

data/lib/fourth_dimensional/record_projector.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/class/attribute'
+
+module FourthDimensional
+  # == FourthDimensional::RecordProjector
+  #
+  #   class PostProjector < FourthDimensional::RecordProjector
+  #     self.record_class = 'Post'
+  #
+  #     on TitleChanged do |event|
+  #       record.title = event.title
+  #     end
+  #   end
+  class RecordProjector
+    include Eventable
+
+    # Record class this projector creates
+    class_attribute :record_class
+
+    # The current instance of the projected record
+    attr_reader :record
+
+    def initialize(aggregate_id:)
+      @record = record_class.constantize.find_or_initialize_by(id: aggregate_id)
+    end
+
+    # Invokes the event binding.
+    #
+    #   post_projector.apply_event(TitleChanged.new(aggregate_id: aggregate_id,
+    #                                               data: {title: 'new-post-title'}))
+    def apply_event(event)
+      callback = self.class.event_bindings[event.class]
+      return if callback.nil?
+      instance_exec(event, &callback)
+    end
+
+    # Saves the record at it's current state.
+    #
+    #   post_projector.save
+    def save
+      record.save
+    end
+
+    # Applies multiple events and saves at the end.
+    #
+    #   projector.record.persisted? # => false
+    #   projector.call(event1, event2)
+    #   projector.record.persisted? # => true
+    def call(*events)
+      events.flatten.map(&method(:apply_event))
+      save
+    end
+
+    # Bulk apply and save events to multiple aggregates.
+    def self.call(*events)
+      events.flatten.group_by(&:aggregate_id).each do |aggregate_id, events|
+        new(aggregate_id: aggregate_id).call(events)
+      end
+    end
+  end
+end

data/lib/fourth_dimensional/repository.rb

@@ -0,0 +1,87 @@
+module FourthDimensional
+  # == FourthDimensional::Repository
+  #
+  # Event sourcing is a good application for the repository pattern since we
+  # need to have a single source track commands and events being applied to the
+  # system.
+  #
+  # The FourthDimensional::Repository is a wrapper around loading and persisting
+  # events/commands with dependency injection. This allows new repositories to
+  # be defined and easily registered.
+  #
+  # The loading and persisting of events/commands are separated to allow
+  # separating the reading and writing databases should that become necessary.
+  #
+  #   class InMemoryEvents
+  #     attr_reader :events
+  #
+  #     def initialize
+  #       @events = []
+  #     end
+  #     
+  #     def self.instance
+  #       @instance ||= InMemoryEvents.new
+  #     end
+  #   end
+  #
+  #   class InMemoryEventLoader
+  #     def for_aggregate(aggregate_id)
+  #       InMemoryEvents.events
+  #         .filter { |event| event.aggregate_id == aggregate_id }
+  #     end
+  #
+  #     def save_commands_and_events(commands:, events:)
+  #       InMemoryEvents.events.concat(events)
+  #     end
+  #   end
+  #
+  #   FourthDimensional.configure do |config|
+  #     config.event_loader = InMemoryEventLoader.new
+  #   end
+  class Repository
+    # The source to load events
+    attr_reader :event_loader
+
+    # An array of events saved
+    attr_reader :applied_events
+
+    # An array of commands called
+    attr_reader :called_commands
+    
+    def initialize(event_loader:)
+      @event_loader = event_loader
+      @applied_events = []
+      @called_commands = []
+    end
+
+    # Delegates to +event_loader#for_aggregate+
+    #
+    #   FourthDimensional.repository.events_for_aggregate(aggregate_id)
+    def events_for_aggregate(aggregate_id)
+      event_loader.for_aggregate(aggregate_id)
+    end
+
+    # Loads events from +event_loader+ and applies them to a new instance of
+    # +aggregate_class+
+    #
+    #   FourthDimensional.repository.load_aggregate(PostAggregate, aggregate_id) # => PostAggregate
+    def load_aggregate(aggregate_class, aggregate_id)
+      events_for_aggregate(aggregate_id)
+        .reduce(aggregate_class.new(id: aggregate_id)) do |aggregate, event|
+          aggregate.apply_existing_event(event)
+          aggregate
+        end
+    end
+
+    # Saves the command and events with the +event_loader+
+    #
+    #   repository.save_command_and_events(FourthDimensional::CommandHandler::CommandAndEvents.new(
+    #     command: AddPost,
+    #     events: [PostAdded]
+    #   ))
+    def save_command_and_events(command_and_events)
+      called_commands << command_and_events.command
+      applied_events.concat(command_and_events.events)
+    end
+  end
+end

data/lib/fourth_dimensional/version.rb

@@ -1,3 +1,3 @@
 module FourthDimensional
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/generators/fourth_dimensional/install_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators'
+
+module FourthDimensional
+  class InstallGenerator < ::Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    def initializer
+      template 'initializer.rb', 'config/initializers/fourth_dimensional.rb'
+    end
+  end
+end

data/lib/generators/fourth_dimensional/migration_generator.rb

@@ -0,0 +1,29 @@
+require 'rails/generators'
+require 'rails/generators/active_record'
+
+module FourthDimensional
+  class MigrationGenerator < ::Rails::Generators::Base
+    include ::Rails::Generators::Migration
+    source_root File.expand_path('templates', __dir__)
+
+    def install
+      migration_template(
+        'migration.rb.erb',
+        'db/migrate/create_fourth_dimensional_tables.rb',
+        migration_version: migration_version
+      )
+    end
+
+    def self.next_migration_number(dirname)
+      ActiveRecord::Generators::Base.next_migration_number(dirname)
+    end
+
+    private
+
+    def migration_version
+      if ActiveRecord::VERSION::MAJOR >= 5
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/generators/fourth_dimensional/templates/initializer.rb

@@ -0,0 +1,7 @@
+Rails.configuration.to_prepare do
+  FourthDimensional.configure do |config|
+    config.event_loader = FourthDimensional::EventLoaders::ActiveRecord.new
+    config.command_handlers = []
+    config.event_handlers = []
+  end
+end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: fourth_dimensional
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Baylor Rae'
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-02-22 00:00:00.000000000 Z
+date: 2019-02-27 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +108,40 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 description: |-
   Fourth Dimensional is an event sourcing library to account for the state of a
     system in relation to time.
@@ -75,19 +151,22 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- ".rspec"
-- ".travis.yml"
-- Gemfile
-- Gemfile.lock
-- README.md
-- Rakefile
-- bin/console
-- bin/setup
-- fourth_dimensional.gemspec
 - lib/fourth_dimensional.rb
+- lib/fourth_dimensional/aggregate_root.rb
+- lib/fourth_dimensional/command.rb
+- lib/fourth_dimensional/command_handler.rb
+- lib/fourth_dimensional/configuration.rb
 - lib/fourth_dimensional/event.rb
+- lib/fourth_dimensional/event_loaders.rb
+- lib/fourth_dimensional/event_loaders/active_record.rb
+- lib/fourth_dimensional/eventable.rb
+- lib/fourth_dimensional/railtie.rb
+- lib/fourth_dimensional/record_projector.rb
+- lib/fourth_dimensional/repository.rb
 - lib/fourth_dimensional/version.rb
+- lib/generators/fourth_dimensional/install_generator.rb
+- lib/generators/fourth_dimensional/migration_generator.rb
+- lib/generators/fourth_dimensional/templates/initializer.rb
 homepage: https://github.com/baylorrae/fourth_dimensional
 licenses: []
 metadata: {}

data/.gitignore

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

data/.rspec

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

data/.travis.yml

@@ -1,15 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.6.1
-before_install: gem install bundler -v 1.17.2
-deploy:
-  local-dir: ./doc
-  provider: pages
-  skip-cleanup: true
-  github-token: $GITHUB_TOKEN
-  keep-history: true
-  on:
-    branch: master

data/Gemfile

@@ -1,6 +0,0 @@
-source "https://rubygems.org"
-
-git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
-
-# Specify your gem's dependencies in fourth_dimensional.gemspec
-gemspec

data/Gemfile.lock

@@ -1,39 +0,0 @@
-PATH
-  remote: .
-  specs:
-    fourth_dimensional (0.1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.3)
-    rake (10.5.0)
-    rdoc (6.1.1)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.0)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.2)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.0)
-    sdoc (1.0.0)
-      rdoc (>= 5.0)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.17)
-  fourth_dimensional!
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  sdoc (~> 1.0)
-
-BUNDLED WITH
-   1.17.2

data/README.md

@@ -1,123 +0,0 @@
-# Fourth Dimensional
-
-Fourth Dimensional is an event sourcing library to account for the state of a
-system in relation to time.
-
-This project is a lightweight dsl for commands and events for use with
-ActiveRecord. Eventually I'd like it to support Sequel as well.
-
-[RDoc][rdoc_url]
-
-[![Build Status]][travis_status]
-
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'fourth_dimensional'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install fourth_dimensional
-
-## Usage
-
-This API is in flux, but here's the general idea.
-
-```ruby
-class PostAdded < FourthDimensional::Event
-  def title
-    data.fetch('title')
-  end
-
-  def body
-    data.fetch('body')
-  end
-
-  def published
-    data.fetch('published')
-  end
-end
-
-class AddPost < FourthDimensional::Command
-  attributes :title, :body, :published
-  validates_presence_of :title, :body
-end
-
-class PostCommandHandler < FourthDimensional::CommandHandler
-  on AddPost do |command|
-    with_aggregate(PostAggregate, command) do |post|
-      post.add(title: command.title,
-               body: command.body,
-               published: command.published)
-    end
-  end
-end
-
-class PostAggregate < FourthDimensional::AggregateRoot
-  def add(title:, body:, published:)
-    apply(PostAdded,
-      data: {
-        title: title,
-        body: body,
-        published: published
-      }
-    )
-  end
-end
-
-class PostProjector < FourthDimensional::RecordProjector
-  self.record_class = 'Post'
-
-  on PostAdded do |event|
-    record.title = event.title
-    record.body = event.body
-    record.published = event.published
-  end
-end
-
-def main
-  FourthDimensional.configure do |config|
-    config.event_handlers = [
-      PostCommandHandler,
-      PostProjector
-    ]
-  end
-
-  aggregate_id = SecureRandom.uuid
-
-  command = AddPost.new(aggregate_id: aggregate_id,
-                        title: 'post-title',
-                        body: 'post-body',
-                        published: true)
-
-  # persists command and event if successful
-  FourthDimensional.execute_commands(command)
-
-  post = Post.find(aggregate_id)
-  expect(post.title).to eq('post-title')
-  expect(post.body).to eq('post-body')
-  expect(post.published).to be_truthy
-end
-```
-
-## 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).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/baylorrae/fourth_dimensional.
-
-[rdoc_url]: https://baylorrae.com/fourth_dimensional
-
-[Build Status]: https://travis-ci.org/BaylorRae/fourth_dimensional.svg?branch=master
-[travis_status]: https://travis-ci.org/BaylorRae/fourth_dimensional

data/Rakefile

@@ -1,16 +0,0 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "sdoc"
-require "rdoc/task"
-
-RSpec::Core::RakeTask.new(:spec)
-
-RDoc::Task.new do |rdoc|
-  rdoc.rdoc_dir = 'doc'
-  rdoc.options << '--format=sdoc'
-  rdoc.options << '--github'
-  rdoc.main = 'README.md'
-  rdoc.rdoc_files.include('README.md', 'lib/**/*.rb')
-end
-
-task :default => [:spec, :rdoc]

data/bin/console

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-
-require "bundler/setup"
-require "fourth_dimensional"
-
-# You can add fixtures and/or initialization code here to make experimenting
-# with your gem easier. You can also use a different console, if you like.
-
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start(__FILE__)

data/bin/setup

@@ -1,8 +0,0 @@
-#!/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/fourth_dimensional.gemspec

@@ -1,31 +0,0 @@
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "fourth_dimensional/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "fourth_dimensional"
-  spec.version       = FourthDimensional::VERSION
-  spec.authors       = ["Baylor Rae'"]
-  spec.email         = ["baylor@thecodedeli.com"]
-
-  spec.summary       = %q{Fourth Dimensional is an event sourcing library to account for the state of a
-  system in relation to time.}
-  spec.description   = %q{Fourth Dimensional is an event sourcing library to account for the state of a
-  system in relation to time.}
-  spec.homepage      = "https://github.com/baylorrae/fourth_dimensional"
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |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", "~> 1.17"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "sdoc", "~> 1.0"
-end