metacosm 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d542356d48068642523496b69d59aa7b8bfc6c6
+  data.tar.gz: 42389cba5819b48ccb74a2927200f664ee5a3ad6
+SHA512:
+  metadata.gz: 6482d50736208180e023f36cb5a4d053b64d8d2ea5c8d2d77bb14c4ae7fe9725f7fc6bbecda4d42fa18bb703b1cc183e860794e3baff566ff4444bb7e1d0e83a
+  data.tar.gz: 23a94920bac7b7e87f11ebefd0cf090f381f76600a6932c69edce9ea92b62a90fa4015768e6ac20cb363b56938facb7c93343cf43d7c1e05ea01d599fde5b4df

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,6 @@
+/.bundle
+/.yardoc/
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/cache/*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "metacosm Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2016-02-16
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,18 @@
+source 'https://rubygems.org'
+
+ruby '2.3.0'
+
+gemspec
+
+gem 'frappuccino'
+gem 'activesupport'
+gem 'passive_record'
+
+group :test do
+  gem 'rspec-its'
+end
+
+group :development do
+  gem 'kramdown'
+  gem 'pry'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Joseph Weissman
+
+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,171 @@
+# metacosm
+
+* [Homepage](https://rubygems.org/gems/metacosm)
+* [Documentation](http://rubydoc.info/gems/metacosm/frames)
+* [Email](mailto:jweissman1986 at gmail.com)
+
+[![Code Climate GPA](https://codeclimate.com/github/deepcerulean/metacosm/badges/gpa.svg)](https://codeclimate.com/github/deepcerulean/metacosm)
+
+## Description
+
+Metacosm is an awesome microframework for building reactive systems.
+
+The idea is to enable quick prototyping of command-query separated or event-sourced systems.
+
+One core concept is that we use commands to update "write-only" models, 
+which trigger events that update "read-only" view models that are used by queries. 
+
+Models only transform their state in response to commands, so their state can be reconstructed by replaying the stream of commands.
+
+## Features
+
+ - One interesting feature here is a sort of mock in-memory AR component called `Registrable` that is used for internal tests (note: this has been extracted to [PassiveRecord](http://github.com/deepcerulean/passive_record))
+
+## Examples
+
+A Fizzbuzz implementation contrived enough to show off many of the features of the framework.
+
+````ruby
+  require 'metacosm'
+  include Metacosm
+  
+  class Counter < Model
+    def initialize
+      @counter = 0
+      super
+    end
+  
+    def fizz!
+      emit fizz
+    end
+  
+    def buzz!
+      emit buzz
+    end
+  
+    def increment!(inc)
+      @counter += inc
+      emit(counter_incremented)
+    end
+  
+    protected
+    def fizz
+      FizzEvent.create(value: @counter, counter_id: @id)
+    end
+  
+    def buzz
+      BuzzEvent.create(value: @counter, counter_id: @id)
+    end
+  
+    def counter_incremented
+      CounterIncrementedEvent.create(
+        value: @counter, 
+        counter_id: @id
+      )
+    end
+  end
+  
+  class CounterView < View
+    attr_accessor :value, :counter_id
+    def update_value(new_value)
+      @value = new_value
+      self
+    end
+  end
+  
+  class IncrementCounterCommand < Struct.new(:increment, :counter_id)
+  end
+  
+  class IncrementCounterCommandHandler
+    def handle(command)
+      counter = Counter.find_by(command.counter_id)
+      counter.increment!(command.increment)
+    end
+  end
+  
+  class CounterIncrementedEvent < Event
+    attr_accessor :value, :counter_id
+  end
+  
+  class CounterIncrementedEventListener < EventListener
+    def receive(value:,counter_id:)
+      update_counter_view(counter_id, value)
+  
+      fizz_buzz!(counter_id, value)
+      puts(value) unless fizz?(value) || buzz?(value)
+    end
+  
+    def update_counter_view(counter_id, value)
+      counter_view = CounterView.where(counter_id: counter_id).first_or_create
+      counter_view.value = value
+    end
+  
+    private
+    def fizz_buzz!(counter_id, n)
+      fire(FizzCommand.new(counter_id, n)) if fizz?(n)
+      fire(BuzzCommand.new(counter_id, n)) if buzz?(n)
+    end
+  
+    def fizz?(n); n % 3 == 0 end
+    def buzz?(n); n % 5 == 0 end
+  end
+  
+  class FizzCommand < Struct.new(:counter_id, :value); end
+  class FizzCommandHandler
+    def handle(command)
+      counter = Counter.find_by(command.counter_id)
+      counter.fizz!
+    end
+  end
+  
+  class BuzzCommand < Struct.new(:counter_id, :value); end
+  class BuzzCommandHandler
+    def handle(command)
+      counter = Counter.find_by(command.counter_id)
+      counter.buzz!
+    end
+  end
+  
+  class FizzEvent < Event
+    attr_accessor :value, :counter_id
+  end
+  
+  class FizzEventListener < EventListener
+    def receive(event)
+      puts "fizz"
+    end
+  end
+  
+  class BuzzEvent < Event
+    attr_accessor :value, :counter_id
+  end
+  
+  class BuzzEventListener < EventListener
+    def receive(event)
+      puts "buzz"
+    end
+  end
+  
+  class CounterValueQuery
+    def execute(counter_id:)
+      counter = CounterView.find_by(counter_id: counter_id)
+      counter.value
+    end
+  end
+````
+
+## Requirements
+
+## Install
+
+    $ gem install metacosm
+
+## Synopsis
+
+    $ metacosm
+
+## Copyright
+
+Copyright (c) 2016 Joseph Weissman
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler/setup'
+rescue LoadError => e
+  abort e.message
+end
+
+require 'rake'
+
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w[--format pretty]
+end

data/bin/metacosm

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+if File.directory?(File.join(root,'.git'))
+  Dir.chdir(root) do
+    begin
+      require 'bundler/setup'
+    rescue LoadError => e
+      warn e.message
+      warn "Run `gem install bundler` to install Bundler"
+      exit -1
+    end
+  end
+end

data/features/metacosm.feature

@@ -0,0 +1 @@
+Feature: Blah blah blah

data/features/step_definitions/metacosm_steps.rb

@@ -0,0 +1 @@
+@wip

data/gemspec.yml

@@ -0,0 +1,17 @@
+name: metacosm
+summary: "reactive simulation framework"
+description: "pure Ruby functional-reactive simulation metaframework"
+license: MIT
+authors: Joseph Weissman
+email: jweissman1986@gmail.com
+homepage: https://rubygems.org/gems/metacosm
+dependencies:
+  passive_record: ~> 0.1.8
+development_dependencies:
+  bundler: ~> 1.10
+  codeclimate-test-reporter: ~> 0.1
+  cucumber: ~> 0.10.2
+  rake: ~> 10.0
+  rspec: ~> 3.0
+  rubygems-tasks: ~> 0.2
+  yard: ~> 0.8

data/lib/metacosm.rb

@@ -0,0 +1,159 @@
+require 'passive_record'
+require 'frappuccino'
+require 'metacosm/version'
+
+module Metacosm
+  class Model
+    include PassiveRecord
+    after_create :register_observer, :emit_creation_event
+
+    def update(attrs={})
+      attrs.each do |k,v|
+        send("#{k}=",v)
+      end
+
+      emit(updation_event(attrs)) if updated_event_class
+    end
+
+    protected
+    def register_observer
+      Simulation.current.watch(self)
+    end
+
+    def emit_creation_event
+      emit(creation_event) if created_event_class
+    end
+
+    def attributes_with_external_id
+      attrs = to_h
+      if attrs.key?(:id)
+        new_id_key = self.class.name.split('::').last.underscore + "_id"
+        attrs[new_id_key.to_sym] = attrs.delete(:id)
+      end
+      attrs
+    end
+
+    # trim down extenralized attrs for evt
+    def attributes_for_event(klass, additional_attrs={})
+      # assume evts attrs are attr_accessible?
+      keys_to_keep = klass.instance_methods.find_all do |method|
+        method != :== &&
+          method != :! &&
+          klass.instance_methods.include?(:"#{method}=")
+      end
+
+      attributes_with_external_id.
+        delete_if {|k,v| !keys_to_keep.include?(k) }.
+        merge(additional_attrs)
+    end
+
+    def assemble_event(klass, addl_attrs={})
+      klass.create(attributes_for_event(klass).merge(addl_attrs))
+    end
+
+    def creation_event
+      assemble_event(created_event_class)
+    end
+
+    def created_event_class
+      created_event_name = self.class.name + "CreatedEvent"
+      Object.const_get(created_event_name) rescue nil
+    end
+
+    def updation_event(changed_attrs={})
+      assemble_event(updated_event_class, changed_attrs)
+    end
+
+    def updated_event_class
+      updated_event_name = self.class.name + "UpdatedEvent"
+      Object.const_get(updated_event_name) rescue nil
+    end
+
+    def blacklisted_attribute_names
+      [ :@observer_peers ]
+    end
+  end
+
+  class View
+    include PassiveRecord
+  end
+
+  class Command
+    include PassiveRecord
+
+    def attrs
+      to_h.keep_if { |k,_| k != :id }
+    end
+
+    def ==(other)
+      attrs == other.attrs
+    end
+  end
+
+  class Event
+    include PassiveRecord
+
+    def attrs
+      to_h.keep_if { |k,_| k != :id }
+    end
+
+    def ==(other)
+      attrs == other.attrs
+    end
+  end
+
+  class EventListener < Struct.new(:simulation)
+    def fire(command)
+      self.simulation.apply(command)
+    end
+  end
+
+  class Simulation
+    def watch(model)
+      Frappuccino::Stream.new(model).on_value(&method(:receive))
+    end
+
+    def apply(command)
+      handler_for(command).handle(command.attrs)
+    end
+
+    def receive(event, record: true)
+      events.push(event) if record
+
+      listener = listener_for(event)
+      if event.attrs.any?
+        listener.receive(event.attrs)
+      else
+        listener.receive
+      end
+    end
+
+    def events
+      @events ||= []
+    end
+
+    def self.current
+      @current ||= new
+    end
+
+    def clear!
+      @events = []
+    end
+
+    protected
+    def handler_for(command)
+      @handlers ||= {}
+      @handlers[command] ||= Object.const_get(command.class.name.split('::').last + "Handler").new
+    end
+
+    def listener_for(event)
+      @listeners ||= {}
+      @listeners[event] ||= construct_listener_for(event)
+    end
+
+    def construct_listener_for(event)
+      listener = Object.const_get(event.class.name.split('::').last + "Listener").new(self)
+      listener
+    end
+  end
+end

data/lib/metacosm/version.rb

@@ -0,0 +1,4 @@
+module Metacosm
+  # metacosm version
+  VERSION = "0.1.1"
+end

data/metacosm.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'metacosm/version'
+                  Metacosm::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = Array(gemspec['requirements'])
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/spec/metacosm_spec.rb

@@ -0,0 +1,215 @@
+require 'spec_helper'
+
+describe "a simple simulation (fizzbuzz)" do
+  subject(:simulation) { Simulation.current }
+  let!(:model) { Counter.create }
+  let(:last_event) { simulation.events.last }
+
+  describe "#apply" do
+    let(:increment_counter) do
+      IncrementCounterCommand.create(
+        increment: 1, counter_id: model.id
+      )
+    end
+
+    context "one command once" do
+      before { simulation.apply(increment_counter) }
+
+      describe "the last event" do
+        subject { last_event }
+        it { is_expected.to be_a CounterIncrementedEvent }
+        its(:counter_id) { is_expected.to eql(model.id) }
+        its(:value) { is_expected.to eq(1) }
+      end
+
+      describe "querying for the counter value" do
+        let(:counter_value_query) do
+          CounterValueQuery.new
+        end
+
+        subject do
+          counter_value_query.execute(counter_id: model.id)
+        end
+
+        it { is_expected.to eq(1) }
+      end
+    end
+
+    context "one command ten times" do
+      it 'is expected to play fizz buzz' do
+        expect {
+          10.times { simulation.apply(increment_counter) }
+        }.to output(%w[ 1 2 fizz 4 buzz fizz 7 8 fizz buzz ].join("\n") + "\n").to_stdout
+      end
+    end
+
+    context "one command repeatedly" do
+      let(:n) { 10 } # ops
+
+      context 'with a single command source' do
+        before do
+          n.times { simulation.apply(increment_counter) }
+        end
+
+        describe "the last event" do
+          subject { last_event }
+          it { is_expected.to be_a BuzzEvent }
+        end
+
+        describe "querying for the counter value" do
+          let(:counter_value_query) do
+            CounterValueQuery.new
+          end
+
+          subject do
+            counter_value_query.execute(counter_id: model.id)
+          end
+
+          it { is_expected.to eq(n) } #"The counter is at 1") }
+        end
+      end
+
+      context 'with concurrent command sources' do
+        let(:m) { 2 }       # fibers
+        let(:threads) {
+          ts = []
+          m.times do
+            ts.push(Thread.new do
+              (n/m).times { simulation.apply(increment_counter) }
+            end)
+          end
+          ts
+        }
+
+        before do
+          threads.map(&:join)
+        end
+
+        describe "the last event" do
+          subject { last_event }
+
+          it { is_expected.to be_a BuzzEvent }
+        end
+
+        describe "querying for the counter value" do
+          let(:counter_value_query) do
+            CounterValueQuery.new
+          end
+
+          subject do
+            counter_value_query.execute(counter_id: model.id)
+          end
+
+          it { is_expected.to eq(n) }
+        end
+      end
+    end
+  end
+end
+
+describe "a more complex simulation (village)" do
+  subject(:simulation) { Simulation.current }
+  let!(:world) { World.create(id: world_id) }
+  let(:world_id) { 'world_id' }
+
+  describe "#apply" do
+    context 'create and populate villages' do
+      let(:person_id) { 'person_id' }
+      let(:village_id) { 'village_id' }
+      let(:village_name) { 'Oakville Ridge' }
+
+      let(:people_per_village)  { 10 }
+
+      let(:create_village_command) do
+        CreateVillageCommand.create(
+          world_id: world_id,
+          village_id: village_id,
+          village_name: village_name
+        )
+      end
+
+      let(:rename_village_command) do
+        RenameVillageCommand.create(
+          village_id: village_id,
+          new_village_name: "Newcity"
+        )
+      end
+
+      let(:village_created_event) do
+        VillageCreatedEvent.create(
+          world_id: world_id,
+          village_id: village_id,
+          name: village_name
+        )
+      end
+
+      let(:populate_world_command) do
+        PopulateWorldCommand.create(
+          world_id: world_id,
+          name_dictionary: %w[ Alice ],
+          per_village: people_per_village
+        )
+      end
+      #
+      let(:create_person_command) do
+        CreatePersonCommand.create(
+          world_id: world_id,
+          village_id: village_id,
+          person_id: person_id,
+          person_name: "Alice"
+        )
+      end
+
+      let(:person_created_event) do
+        PersonCreatedEvent.create(village_id: village_id, person_id: person_id, name: "Alice")
+      end
+
+      let(:village_names_query) do
+        VillageNamesQuery.new(world_id)
+      end
+
+      let(:people_names_query) do
+        PeopleNamesQuery.new(world_id)
+      end
+
+      describe "handling a create village command" do
+        it 'should result in a village creation event' do
+          given_no_activity.
+            when(create_village_command).expect_events([village_created_event])
+        end
+      end
+
+      describe 'recieving a village created event' do
+        it 'should create a village view we can lookup' do
+          given_events([village_created_event]).
+            expect_query(village_names_query, to_find: ["Oakville Ridge"])
+        end
+      end
+
+      it 'should create a village and a person' do
+        given_no_activity.
+          when(create_village_command, create_person_command).
+            expect_events([village_created_event, person_created_event]).
+            expect_query(village_names_query, to_find: ["Oakville Ridge"]).
+            expect_query(people_names_query, to_find: ["Alice"])
+      end
+
+      it 'should populate the world' do
+        expected_names = Array.new(people_per_village) { "Alice" }
+
+        given_no_activity.
+          when(create_village_command, populate_world_command).
+          expect_query(village_names_query, to_find: ["Oakville Ridge"]).
+          expect_query(people_names_query, to_find: expected_names)
+      end
+
+      it 'should rename a village' do
+        given_no_activity.
+          when(
+            create_village_command,
+            rename_village_command
+          ).expect_query(village_names_query, to_find: ["Newcity"])
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,120 @@
+require 'rspec'
+require 'rspec/its'
+
+require 'pry'
+require 'ostruct'
+require 'metacosm'
+
+include Metacosm
+
+require 'support/fizz_buzz'
+require 'support/village'
+
+class GivenWhenThen < Struct.new(:given_events,:when_command,:then_event_class)
+  include RSpec::Matchers
+
+  def when(*commands)
+    @when_commands ||= []
+    commands.each do |command|
+      @when_commands.push command
+    end
+    self
+  end
+
+  def expect_events(evts)
+    @then_events = evts
+    verify!
+    self
+  end
+
+  def expect_query(query, to_find:)
+    @query = query
+    @expected_query_results = to_find
+    verify!
+    self
+  end
+
+  protected
+
+  def verify!
+    clean_slate!
+    receive_events!
+    fire_commands!
+
+    validate_events!
+    validate_query!
+
+    self
+  end
+
+  private
+
+  def clean_slate!
+    PassiveRecord.drop_all
+    Simulation.current.clear!
+    self
+  end
+
+  def receive_events!
+    unless self.given_events.nil?
+      self.given_events.each do |evt| 
+        sim.receive(evt, record: false)
+      end
+    end
+    self
+  end
+
+  def fire_commands!
+    unless @when_commands.nil?
+      @when_commands.each do |cmd|
+        sim.apply(cmd)
+      end
+    end
+    self
+  end
+
+  def validate_events!
+    if @then_event_class
+      expect(@then_event_class).to eq(sim.events.last.class) 
+    end
+
+    if @then_events
+      expect(@then_events).to match_array(sim.events) 
+    end
+
+    if @then_event_attrs
+      @then_event_attrs.each do |k,v|
+        expect(sim.events.last.send(k)).to eq(v)
+      end
+    end
+
+    self
+  end
+
+  def validate_query!
+    if @query
+      expect(@query.execute).to eq(@expected_query_results)
+    end
+    self
+  end
+
+  def sim
+    @sim ||= Simulation.current
+  end
+end
+
+module Metacosm
+  module SpecHelpers
+    def given_no_activity
+      GivenWhenThen.new
+    end
+
+    def given_events(events)
+      GivenWhenThen.new(events)
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include Metacosm::SpecHelpers
+end

data/spec/support/fizz_buzz.rb

@@ -0,0 +1,128 @@
+class Counter < Model
+  def initialize
+    @counter = 0
+    super
+  end
+
+  def fizz!
+    emit fizz
+  end
+
+  def buzz!
+    emit buzz
+  end
+
+  def increment!(inc)
+    @counter += inc
+    emit(counter_incremented)
+  end
+
+  protected
+  def fizz
+    FizzEvent.create
+  end
+
+  def buzz
+    BuzzEvent.create
+  end
+
+  def counter_incremented
+    CounterIncrementedEvent.create(
+      value: @counter,
+      counter_id: @id
+    )
+  end
+end
+
+class CounterView < View
+  attr_accessor :value, :counter_id
+  def update_value(new_value)
+    @value = new_value
+    self
+  end
+end
+
+class IncrementCounterCommand < Command
+  attr_accessor :increment, :counter_id
+end
+
+class IncrementCounterCommandHandler
+  def handle(increment:,counter_id:)
+    counter = Counter.find(counter_id)
+    counter.increment!(increment)
+  end
+end
+
+class CounterIncrementedEvent < Event
+  attr_accessor :value, :counter_id
+end
+
+class CounterIncrementedEventListener < EventListener
+  def receive(value:,counter_id:)
+    update_counter_view(counter_id, value)
+
+    fizz_buzz!(counter_id, value)
+    puts(value) unless fizz?(value) || buzz?(value)
+  end
+
+  def update_counter_view(counter_id, value)
+    counter_view = CounterView.where(counter_id: counter_id).first_or_create
+    counter_view.value = value
+  end
+
+  private
+  def fizz_buzz!(counter_id, n)
+    fire(FizzCommand.create(counter_id: counter_id)) if fizz?(n)
+    fire(BuzzCommand.create(counter_id: counter_id)) if buzz?(n)
+  end
+
+  def fizz?(n); n % 3 == 0 end
+  def buzz?(n); n % 5 == 0 end
+end
+
+class FizzCommand < Command
+  attr_accessor :counter_id
+end
+
+class FizzCommandHandler
+  def handle(counter_id:)
+    counter = Counter.find(counter_id)
+    counter.fizz!
+  end
+end
+
+class BuzzCommand < Command
+  attr_accessor :counter_id
+end
+
+class BuzzCommandHandler
+  def handle(counter_id:)
+    counter = Counter.find(counter_id)
+    counter.buzz!
+  end
+end
+
+class FizzEvent < Event
+end
+
+class FizzEventListener < EventListener
+  def receive
+    puts "fizz"
+  end
+end
+
+class BuzzEvent < Event
+end
+
+class BuzzEventListener < EventListener
+  def receive
+    puts "buzz"
+  end
+end
+
+class CounterValueQuery
+  def execute(counter_id:)
+    counter = CounterView.find_by(counter_id: counter_id)
+    counter.value
+  end
+end

data/spec/support/village.rb

@@ -0,0 +1,155 @@
+class Person < Model
+  belongs_to :village
+  attr_accessor :name
+end
+
+class PersonView < View
+  belongs_to :village_view
+  attr_accessor :person_name, :person_id, :village_id
+end
+
+class Village < Model
+  belongs_to :world
+  has_many :people
+  attr_accessor :name
+end
+
+class VillageView < View
+  belongs_to :world_view
+  has_many :person_views
+  attr_accessor :name, :village_id, :world_id
+end
+
+class World < Model
+  has_many :villages
+  has_many :people, :through => :villages
+end
+
+class WorldView < View
+  attr_accessor :world_id
+  has_many :village_views
+  has_many :person_views, :through => :village_views
+end
+
+class CreateVillageCommand < Command
+  attr_accessor :world_id, :village_id, :village_name
+end
+
+class CreateVillageCommandHandler
+  def handle(world_id:,village_id:,village_name:)
+    world = World.where(id: world_id).first_or_create
+    world.create_village(name: village_name, id: village_id)
+    self
+  end
+end
+
+class VillageCreatedEvent < Event
+  attr_accessor :village_id, :name, :world_id
+end
+
+class VillageCreatedEventListener < EventListener
+  def receive(world_id:, village_id:, name:)
+    world = WorldView.where(world_id: world_id).first_or_create
+    world.create_village_view(
+      world_id: world_id,
+      village_id: village_id,
+      name: name
+    )
+  end
+end
+
+class RenameVillageCommand < Command
+  attr_accessor :village_id, :new_village_name
+end
+
+class RenameVillageCommandHandler
+  def handle(village_id:, new_village_name:)
+    village = Village.find(village_id)
+    village.update name: new_village_name
+  end
+end
+
+class VillageUpdatedEvent < Event
+  attr_accessor :village_id, :name
+end
+
+class VillageUpdatedEventListener < EventListener
+  def receive(village_id:, name:)
+    village_view = VillageView.find_by(village_id: village_id)
+    village_view.name = name
+  end
+end
+
+
+class CreatePersonCommand < Command
+  attr_accessor :world_id, :village_id, :person_id, :person_name
+end
+
+class CreatePersonCommandHandler
+  def handle(world_id:, village_id:, person_id:, person_name:)
+    world = World.where(id: world_id).first_or_create
+    world.create_person(id: person_id, village_id: village_id, name: person_name)
+  end
+end
+
+class PersonCreatedEvent < Event
+  attr_accessor :name, :person_id, :village_id
+end
+
+class PersonCreatedEventListener < EventListener
+  def receive(name:, person_id:, village_id:)
+    village_view = VillageView.where(village_id: village_id).first
+    village_view.create_person_view(
+      person_name: name,
+      person_id: person_id,
+      village_id: village_id
+    )
+  end
+end
+
+class PopulateWorldCommand < Command
+  attr_accessor :world_id, :name_dictionary, :per_village
+end
+
+class PopulateWorldCommandHandler
+  def handle(world_id:, name_dictionary:, per_village:)
+    world_id   = world_id
+    dictionary = name_dictionary
+
+    world = World.where(id: world_id).first_or_create
+
+    world.villages.each do |village|
+      name = dictionary.sample
+      per_village.times do
+        village.create_person(name: name)
+      end
+    end
+  end
+end
+
+class CreateWorldCommand < Command
+  attr_accessor :world_id
+end
+
+class CreateWorldCommandHandler
+  def handle(cmd)
+    world_id = cmd.world_id
+    World.create(id: world_id)
+  end
+end
+
+## queries
+
+class VillageNamesQuery < Struct.new(:world_id)
+  def execute
+    world = WorldView.where(world_id: world_id).first_or_create
+    world.village_views.map(&:name)
+  end
+end
+
+class PeopleNamesQuery < Struct.new(:world_id)
+  def execute
+    world_view = WorldView.where(world_id: world_id).first_or_create
+    world_view.person_views.flat_map(&:person_name)
+  end
+end

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: metacosm
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Joseph Weissman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: passive_record
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: pure Ruby functional-reactive simulation metaframework
+email: jweissman1986@gmail.com
+executables:
+- metacosm
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/metacosm
+- features/.gitkeep
+- features/metacosm.feature
+- features/step_definitions/.gitkeep
+- features/step_definitions/metacosm_steps.rb
+- gemspec.yml
+- lib/metacosm.rb
+- lib/metacosm/version.rb
+- metacosm.gemspec
+- schema.png
+- spec/metacosm_spec.rb
+- spec/spec_helper.rb
+- spec/support/fizz_buzz.rb
+- spec/support/village.rb
+homepage: https://rubygems.org/gems/metacosm
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: reactive simulation framework
+test_files: []