replay 0.0.1 → 0.1.0

data/lib/replay/observer.rb

@@ -0,0 +1,18 @@
+module Replay
+  module Observer
+
+    def self.included(base)
+      class << base
+        def observe(event_type, &block)
+          @observer_blocks ||= Hash.new
+          @observer_blocks[Replay::Inflector.underscore(event_type.to_s)] = block
+        end
+
+        def published(stream_id, event)
+          blk = @observer_blocks[Replay::Inflector.underscore(event.class.to_s)]
+          blk.call(stream_id, event, binding) if blk
+        end
+      end
+    end
+  end
+end

data/lib/replay/publisher.rb

@@ -0,0 +1,72 @@
+module Replay
+  module Publisher
+    def self.included(base)
+      include_essentials base
+    end
+
+    def self.include_essentials(base)
+      base.instance_variable_set :@application_blocks, {}
+      base.extend ClassMethods
+      base.extend(Replay::Events)
+    end
+
+    def subscription_manager
+      @subscription_manager ||= Replay::SubscriptionManager.new(Replay.logger)
+    end
+
+    def add_subscriber(subscriber)
+      subscription_manager.add_subscriber(subscriber)
+    end
+
+    def apply(events, raise_unhandled = true)
+      return apply([events], raise_unhandled) unless events.is_a?(Array)
+
+      events.each do |event|
+        blk = block_for(event.class)
+        raise UnhandledEventError.new "event #{event.class.name} is not handled by #{self.class.name}" if (blk.nil? && raise_unhandled)
+        self.instance_exec(event, &blk)
+      end
+      return self
+    end
+
+    def block_for(event_type)
+      self.class.block_for(event_type)
+    end
+    protected :block_for
+
+    def publish(event)
+      apply(event)
+      subscription_manager.notify_subscribers(to_stream_id, event)
+      return self
+    end
+
+
+    def to_stream_id
+      raise Replay::UndefinedKeyError.new("No key attribute defined for #{self.class.to_s}") unless self.class.key_attr
+      self.send(self.class.key_attr).to_s
+    end
+
+    module ClassMethods
+      def key(keysym)
+        @primary_key_method = keysym
+      end
+
+      def key_attr
+        @primary_key_method
+      end
+
+      def apply(event_type, &block)
+        @application_blocks[stringify_class(event_type)] = block
+      end
+
+      def block_for(event_type)
+        blk = @application_blocks[stringify_class(event_type)]
+        return blk
+      end
+
+      def stringify_class(klass)
+        Replay::Inflector.underscore(klass.to_s.dup)
+      end
+    end
+  end
+end

data/lib/replay/repository.rb

@@ -0,0 +1,61 @@
+module Replay
+  module Repository
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      # load will always return an initialized instance of the supplied class (unless it doesn't!). if the given
+      # stream has no events (e.g. is not found, new object, etc), load will attempt to call 
+      # create on the newly initalized instance of klass
+      #
+      #options:
+      #  :create => true  #if false, do not call create on this instance if no stream is found
+      def load(klass, stream_id, options={})
+        repository_load(klass, stream_id, options)
+      end
+
+      def repository_load(klass, stream_id, options={})
+        events = store.event_stream(stream_id)
+        if events.empty?
+          raise Errors::EventStreamNotFoundError.new("Could not find any events for stream identifier #{stream_id}") if options[:create].nil?
+        end
+
+        obj = prepare(klass.new)
+        obj.create(stream_id) if options[:create] && events.empty?
+        obj.apply(events)
+
+        obj
+      end
+
+      #refresh reloads the object from the data store
+      #naive implementation is just a reload. Once deltas are in place
+      #it can just apply the delta events to the object
+      def self.refresh(obj)
+        new_obj = load(obj.class, obj.to_key)
+        new_obj
+      end
+
+      def prepare(obj)
+        @configuration.subscribers.each do |subscriber|
+          obj.add_subscriber(subscriber)
+        end
+        obj
+      end
+
+      def configure 
+        @configuration ||= Configuration.new
+        yield @configuration
+        @configuration
+      end
+
+      def store
+        @configuration.store
+      end
+    end
+  end
+end

data/lib/replay/repository/configuration.rb

@@ -0,0 +1,30 @@
+module Replay
+  module Repository
+    class Configuration
+      def initialize
+        @default_subscribers =[]
+      end
+
+      def add_default_subscriber(subscriber)
+        subscriber = Replay::Backends.resolve(subscriber) if subscriber.is_a?(String) || subscriber.is_a?(Symbol)
+        @default_subscribers << subscriber
+      end
+
+      def subscribers
+        @default_subscribers
+      end
+
+      def store=(store)
+        store = Replay::Backends.resolve(store)
+        raise Replay::InvalidStorageError.new(store) unless store.respond_to?(:event_stream)
+        raise Replay::InvalidSubscriberError.new(store) unless store.respond_to?(:published)
+        @store = store
+        add_default_subscriber(@store)
+      end
+
+      def store
+        @store
+      end
+    end
+  end
+end

data/lib/replay/repository/identity_map.rb

@@ -0,0 +1,25 @@
+module Replay
+  module Repository
+    module IdentityMap
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      module ClassMethods
+        def load(klass, stream_id, options={})
+          #implement an identity map
+          @_identities ||= {}
+          return @_identities[[klass,stream_id]] if @_identities[[klass, stream_id]]
+
+          obj=repository_load(klass, stream_id, options)
+          @_identities[[klass, stream_id]] = obj
+
+          obj
+        end
+
+        def clear_identity_map
+          @_identities = {}
+        end
+      end
+    end
+  end
+end

data/lib/replay/router.rb

@@ -0,0 +1,5 @@
+module Replay
+  module Router
+
+  end
+end

data/lib/replay/router/default_router.rb

@@ -0,0 +1,21 @@
+module Replay
+  module Router
+    class DefaultRouter
+      include Singleton
+
+      def initialize
+        @subscription_manager = Replay::SubscriptionManager.new
+      end
+
+      def add_observer(observer, *events)
+        @subscription_manager.add_subscriber(observer)
+      end
+
+      def published(stream_id, event)
+        @subscription_manager.notify_subscribers(stream_id, event)
+      end
+    end
+  end
+end
+
+Replay::Backends.register(:replay_router, Replay::Router::DefaultRouter)

data/lib/replay/rspec.rb

@@ -0,0 +1,50 @@
+require 'replay/test'
+
+RSpec::Matchers.define :publish do |expected_event|
+  match do |proc_or_obj|
+    if proc_or_obj.respond_to? :call
+      @result = proc_or_obj.call
+      @result.published?(expected_event, @fuzzy)
+    else
+      proc_or_obj.published?(expected_event, @fuzzy)
+    end
+  end
+
+  chain :fuzzy do 
+    @fuzzy = true
+  end
+
+  def failure_message(expected_event, actual, should = true)
+    actual = @result if actual.is_a? Proc
+
+    str = "expected that #{domain_obj_interpretation(actual)} would#{should ? ' ': ' not'} generate #{@fuzzy ? 'an event like' : 'the event'} #{event_interpretation(expected_event)}"
+    similar = actual.similar_events(expected_event)
+    if similar.empty?
+      str += "\nNo similar events found."
+    else
+      str += "\nThe following events matched type, but not attributes:\n#{similar.map{|s| event_interpretation(s)+"\n"}.join("\t\t")}"
+    end
+  end
+  failure_message_for_should_not do |actual|
+    failure_message(expected_event, actual, false)
+  end
+
+  failure_message_for_should do |actual|
+    failure_message(expected_event, actual )
+  end
+
+  def domain_obj_interpretation(obj)
+    if obj.respond_to?(:call) && obj.kind_of?(Proc)
+      "block"
+    else
+      obj.class.to_s
+    end
+
+  end
+
+  def event_interpretation(event)
+    "#{event.class.to_s} [#{event.attributes.reject{|k,v| v.nil?}.keys.map{|k| "#{k.to_s} = #{event.attributes[k]}"}.join(", ")}]"
+  end
+
+end
+

data/lib/replay/subscription_manager.rb

@@ -0,0 +1,28 @@
+module Replay
+  class SubscriptionManager
+
+    def initialize(logger = nil)
+      @subscribers = []
+      @logger = logger
+    end
+
+    def add_subscriber(subscriber)
+      if subscriber.respond_to?(:published)
+        @subscribers << subscriber 
+      else
+        raise Replay::InvalidSubscriberError.new(subscriber)
+      end
+    end
+
+    def notify_subscribers(stream_id, event)
+      @subscribers.each do |sub|
+        begin
+          sub.published(stream_id, event)
+        rescue Exception => e
+          #hmmmm
+          @logger.error "exception in event subscriber #{sub.class.to_s} while handling event stream #{stream_id} #{event.inspect}: #{e.message}\n#{e.backtrace.join("\n")}" if @logger
+        end
+      end
+    end
+  end
+end

data/lib/replay/test.rb

@@ -0,0 +1,64 @@
+require 'replay'
+
+module Replay::EventExaminer
+  def events
+    @_events ||= []
+  end
+
+  def published?(event, fuzzy=false)
+    if fuzzy
+      !(events.detect{|e| event.kind_of_matches?(e) }.nil?)
+    else
+      events.detect{|e| event.is_a?(Class) ? e.class == event : e == event}
+    end
+  end
+
+  def similar_events(event)
+    events.select{|e| e.class == event.class}
+  end
+
+  def apply(events, raise_unhandled = true)
+    return apply([events], raise_unhandled) unless events.is_a?(Array)
+    retval = super(events, raise_unhandled)
+    events.each do |event|
+      self.events << event
+    end
+    return retval
+  end
+
+  def has_subscriber?(subscriber)
+    @subscription_manager.has_subscriber?(subscriber)
+  end
+end
+
+Replay::SubscriptionManager.class_exec do
+  def has_subscriber?(subscriber)
+    @subscribers.include?(subscriber)
+  end
+end
+
+Replay::Publisher::ClassMethods.module_exec do
+  def self.extended(base)
+    @publishers ||= []
+    @publishers << base
+    base.send(:include, Replay::EventExaminer)
+  end
+end
+
+Replay::EventDecorator.module_exec do
+  #receiver's non-nil values are a subset of parameters non-nil values
+  def kind_of_matches?(event)
+    relevant_attrs_match = event.attributes.reject{|k,v| v.nil?}
+    relevant_attrs_self = self.attributes.reject{|k,v| v.nil?}
+
+    if (relevant_attrs_self.keys - relevant_attrs_match.keys).empty?
+      if relevant_attrs_self.reject{|k, v| event[k] == v}.any?
+        return false
+      else
+        return true
+      end
+    else
+      return false
+    end
+  end
+end

data/lib/replay/test/test_event_stream.rb

@@ -0,0 +1,19 @@
+module Replay
+  class TestEventStream
+
+    def initialize
+      @events = []
+    end
+    def publish(stream_id, event)
+      @events << {stream: stream_id, event: event}
+    end
+
+    def published_event?(event)
+      @events.detect{|e| e[:event]==event}
+    end
+
+    def published?(stream_id, event)
+      @events.detect{|e| e == {stream: stream_id, event: event}}
+    end
+  end
+end

data/lib/replay/version.rb

@@ -1,3 +1,3 @@
 module Replay
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/proofs/all.rb

@@ -0,0 +1,7 @@
+require_relative 'proofs_init.rb'
+
+files = Dir.glob(File.join(File.dirname(__FILE__), '**/*_proof.rb'))
+puts files
+Proof::Suite.run "replay/**/*.rb"
+
+

data/proofs/proofs_init.rb

@@ -0,0 +1,10 @@
+$:<<File.expand_path("./lib")
+$:<<File.expand_path("./proofs")
+
+require 'replay'
+
+require 'proof'
+
+include Proof
+
+

data/proofs/replay/inflector_proof.rb

@@ -0,0 +1,32 @@
+require_relative "../proofs_init.rb"
+require 'replay/inflector'
+
+module Replay::Inflector::Proof 
+  def camelizes?(flat, cameld)
+    Replay::Inflector.camelize(flat) == cameld
+  end
+  def underscores?(from, to)
+    Replay::Inflector.underscore(from) == to
+  end
+  def constantizes?(classname, expected_constant)
+    Replay::Inflector.constantize(classname) == expected_constant
+  end
+end
+Replay::Inflector.extend(Replay::Inflector::Proof)
+
+title "Replay::Inflector"
+
+proof "camelize camel-cases a string" do
+  #Replay::Inflector.prove{ camelizes?("replay.test", "Replay::Test")}
+end
+
+proof "underscore transforms a classname to 'module.class'" do
+  Replay::Inflector.prove{ underscores?("Replay::Test", 'replay.test')}
+  Replay::Inflector.prove{ underscores?("ReplayTest::Test", 'replay_test.test')}
+  Replay::Inflector.prove{ underscores?("Replay2Test::Test", 'replay2_test.test')}
+  Replay::Inflector.prove{ underscores?("Replay::TestData", 'replay.test_data')}
+end
+
+proof "constantize finds the constant for a given string, if defined" do
+  Replay::Inflector.prove{ constantizes? "Replay::ReplayError", Replay::ReplayError }
+end