lolitra 0.0.1 → 0.0.2

data/.rspec

@@ -0,0 +1 @@
+--default_path spec

data/lib/lolitra/handler_base.rb

@@ -0,0 +1,231 @@
+require 'singleton'
+
+module Lolitra
+  module MessageHandler
+    module Helpers
+      def self.underscore(word)
+        word.gsub!(/::/, '/')
+        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+    end
+
+    class NoHandlerMessageException < StandardError
+      def initialize(handler, message)
+        @handler_class = handler.name
+        @message_class = message.class.name
+      end
+
+      def to_s
+        "No handler (or starter if stateful) for message #{@message_class} in class #{@handler_class}"
+      end
+    end
+
+    module MessageHandlerClass
+      
+      def self.extended(base)
+        class << base
+          attr_accessor :handlers
+          attr_accessor :starters
+          attr_accessor :is_stateful
+        end
+        base.handlers = {}
+        base.starters = []
+        base.is_stateful = false
+      end
+
+      def handle(message)
+        #puts "#{self.name} try to handle new message #{message.class.name}"
+        begin      
+          get_handler(message).handle(message)
+        rescue NoMethodError => e
+          raise NoHandlerMessageException.new(self, message) if e.message == "undefined method `handle' for nil:NilClass"
+          raise
+        end
+      end
+      
+      def publish(message)
+        #TODO: IoC
+        MessageHandlerManager.publish(message)
+      end
+
+      def handle_messages
+        handlers.values.collect { |class_method_pair| class_method_pair[0] }
+      end
+
+    private
+      def message_handler(message_class, id = :id)   
+        message_class.new.send(id) #check if id exists for this class
+        handlers.merge!(message_class.name => [message_class, get_method_by_class(message_class), id])
+      end
+     
+      def started_by(message_class)
+        starters << message_class.name
+      end
+
+      def search(message)
+        id_method_name = handlers[message.class.name][2]
+        send("find_by_#{id_method_name}", message.send(id_method_name))
+      end
+
+      def is_starter?(message)
+        starters.include? message.class.name
+      end
+
+      def get_handler(message)
+        if is_stateful?
+          is_starter?(message) ? (search(message) || new) : search(message)
+        else
+          new
+        end
+      end
+
+      def get_method_by_class(arg_class)
+        MessageHandler::Helpers.underscore(arg_class.name).gsub("/","_").to_sym
+      end
+
+      def stateful(stateful_arg)
+        self.is_stateful = stateful_arg
+      end
+
+      def is_stateful?
+        is_stateful
+      end
+    end
+
+    def self.included(base)
+      base.send :extend, MessageHandlerClass
+    end
+
+    def handle(message)
+      handler_method = self.class.handlers[message.class.name][1]
+      raise "Can't handle message #{message.class}" unless handler_method
+      self.send(handler_method, message)
+    end
+
+  end
+
+  class MessageHandlerManager
+    include Singleton
+
+    attr_accessor :bus
+
+    def self.bus=(new_bus)
+      instance.bus = new_bus
+    end
+
+    def self.bus
+      instance.bus
+    end
+
+    def self.register(handler_class)
+      instance.register(handler_class)
+    end
+   
+    def register(handler_class)
+      register_message_handler(handler_class)    
+    end
+
+    def self.publish(message_instance)
+      instance.publish(message_instance)
+    end
+
+    def publish(message_instance)
+      bus.publish(message_instance)
+    end
+  private
+    def register_message_handler(handler_class)
+      handler_class.handle_messages.each do |message_class|
+        bus.subscribe(message_class, handler_class)
+      end
+    end
+  end
+
+  module AmqpMessage
+
+    module AmqpMessageClass
+      def self.extended(base)
+        class << base; attr_accessor :class_message_key; end
+      end
+
+      def message_key(key = nil)
+        if (key)
+          self.class_message_key = key      
+        else
+          self.class_message_key
+        end
+      end
+
+      def unmarshall(message_json)
+        hash = JSON.parse(message_json)
+        self.new(hash)
+      end
+
+    end
+
+    def self.included(base)
+      base.send :extend, AmqpMessageClass
+    end
+
+    def initialize(hash={})   
+      hash.each { |key, value| self.send("#{MessageHandler::Helper.underscore(key)}=", value) }
+    end
+
+    def marshall
+      JSON.generate(self)
+    end
+  end
+
+  module AmqpMessageHandler
+    module AmqpMessageHandlerClass
+      
+      def self.extended(base)
+        class << base
+          attr_accessor :message_class_by_key
+          alias_method :message_handler_without_class_by_key, :message_handler unless method_defined?(:message_handler_without_class_by_key)
+          alias_method :message_handler, :message_handler_with_class_by_key
+        end
+        base.message_class_by_key = {}
+      end
+
+      def message_handler_with_class_by_key(message_class, id = :id)
+        message_class_by_key.merge!({message_class.message_key => message_class})
+        message_handler_without_class_by_key(message_class, id)
+      end
+
+    end
+
+    def self.included(base)
+      base.send :include, MessageHandler
+      base.send :extend, AmqpMessageHandlerClass
+    end
+
+  end
+
+  class AmqpBus
+    attr_accessor :queue_prefix
+    attr_accessor :exchange
+
+    def initialize(hash = {})
+      self.queue_prefix = hash[:queue_prefix]
+      self.exchange = hash[:exchange]
+    end
+
+    def subscribe(message_class, handler_class)
+      EM.next_tick do
+        AmqpNotifier.new(exchange, queue_prefix + MessageHandler::Helper.underscore(handler_class.name).subscribe(message_class.message_key)) do |info, payload|
+          #all message with the same handler goes here to try to maintain the order in the same queue (not ensured)
+          message_class_tmp = handler_class.message_class_by_key[info.routing_key]
+          handler_class.handle(message_class_tmp.unmarshall(payload))
+        end 
+      end
+    end
+
+    def publish(message)
+      AmqpNotifier.new(exchange).publish(message.class.message_key, message.marshall)
+    end
+  end
+end  

data/lib/lolitra/version.rb

@@ -1,3 +1,3 @@
 module Lolitra
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/lolitra.rb

@@ -1,5 +1,2 @@
 require "lolitra/version"
-
-module Lolitra
-  # Your code goes here...
-end
+require "lolitra/handler_base"

data/lolitra.gemspec

@@ -14,4 +14,6 @@ Gem::Specification.new do |gem|
   gem.name          = "lolitra"
   gem.require_paths = ["lib"]
   gem.version       = Lolitra::VERSION
+
+  gem.add_development_dependency("rspec")
 end

data/spec/lolitra_spec.rb

@@ -0,0 +1,176 @@
+require 'spec_helper.rb'
+
+class TestMessage
+  include Lolitra::AmqpMessage
+
+  message_key "test1"
+
+  def id
+    1
+  end
+end
+
+class TestMessage1
+  include Lolitra::AmqpMessage
+
+  message_key "test2"
+
+  def id
+    2
+  end
+end
+
+class TestMessageHandler
+  include Lolitra::MessageHandler
+
+  started_by TestMessage
+  message_handler TestMessage
+  stateful true
+
+  def self.find_by_id(id)
+    nil
+  end
+
+  def test_message(message)
+    "handled"
+  end
+end
+
+class TestMessageHandler1
+  include Lolitra::MessageHandler
+
+  started_by TestMessage1
+  message_handler TestMessage
+  message_handler TestMessage1
+
+  stateful true
+
+  def self.find_by_id(id)
+    nil
+  end
+
+  def test_message(message)
+    "handled"
+  end
+  
+  def test_message1(message)
+    "handled1"
+  end
+
+end
+
+class TestAmqpMessageHandler
+  include Lolitra::AmqpMessageHandler
+
+  message_handler TestMessage
+  message_handler TestMessage1
+
+  stateful false
+end
+
+describe Lolitra::MessageHandler,'#create_handler' do
+  it "returns old instance of the handler for the same message id" do
+    handler = TestMessageHandler.new
+    TestMessageHandler.should_receive(:new).exactly(1).and_return(handler)
+    TestMessageHandler.handle(TestMessage.new)
+    TestMessageHandler.should_receive(:find_by_id).at_least(:once).and_return(handler)
+    TestMessageHandler.handle(TestMessage.new)
+    TestMessageHandler.handle(TestMessage.new)
+  end
+
+  it "create a new handler if the message starter has different id" do
+    handler1 = TestMessageHandler.new   
+    message1 = TestMessage.new
+    message2 = TestMessage.new
+    message2.stub(:id => 2)
+    
+    TestMessageHandler.should_receive(:new).exactly(2).and_return(handler1)
+    TestMessageHandler.handle(message1)
+    TestMessageHandler.handle(message2)
+  end
+end
+
+describe Lolitra::MessageHandler, '#handle_message' do
+  it "handle message when message arrives" do
+    message_handler = TestMessageHandler1.new
+    TestMessageHandler1.stub(:find_by_id).and_return(nil, message_handler)
+    TestMessageHandler1.handle(TestMessage1.new).should eq "handled1"
+    TestMessageHandler1.handle(TestMessage.new).should eq "handled"
+  end
+end
+
+describe Lolitra::MessageHandler, "#handle_message" do
+  it "handle non starter message thow execption" do
+    expect { TestMessageHandler1.handle(TestMessage.new) }.to raise_error(Lolitra::MessageHandler::NoHandlerMessageException)
+  end
+end
+
+describe Lolitra::MessageHandler, '#publish' do
+  it "can send message to the bus" do
+    message = TestMessage.new
+    bus = TestBus.new
+    Lolitra::MessageHandlerManager.bus = bus
+    Lolitra::MessageHandlerManager.register(TestMessageHandler)
+
+
+    TestMessageHandler.should_receive(:handle).with(message)
+    TestMessageHandler.publish(message)
+  end
+end
+
+describe Lolitra::MessageHandlerManager, '#publish' do
+  it "can send message to the bus" do
+    bus = TestBus.new
+    Lolitra::MessageHandlerManager.bus = bus
+    Lolitra::MessageHandlerManager.register(TestMessageHandler)
+
+    message = TestMessage.new
+
+    TestMessageHandler.should_receive(:handle).with(message)
+
+    Lolitra::MessageHandlerManager.publish(message)
+  end
+end
+
+describe Lolitra::MessageHandlerManager, '#handle_message' do
+  it "handle message with the correct handler" do
+
+    bus = TestBus.new
+    
+    Lolitra::MessageHandlerManager.bus = bus
+
+    Lolitra::MessageHandlerManager.register(TestMessageHandler)
+    Lolitra::MessageHandlerManager.register(TestMessageHandler1)
+
+    message = TestMessage.new
+    message1 = TestMessage1.new
+
+    TestMessageHandler.should_receive(:handle).with(message)
+    TestMessageHandler.should_not_receive(:handle).with(message1)
+
+    TestMessageHandler1.should_receive(:handle).with(message)
+    TestMessageHandler1.should_receive(:handle).with(message1)
+
+    Lolitra::MessageHandlerManager.publish(message)
+    Lolitra::MessageHandlerManager.publish(message1)
+  end
+end
+
+describe Lolitra::AmqpMessage, '#message_key' do
+  it "message_key has constant key for a class" do
+    TestMessage.message_key.should eq "test1"
+    TestMessage1.message_key.should eq "test2"
+    TestMessage.message_key.should eq "test1"
+  end
+end
+
+describe Lolitra::AmqpMessageHandler, '#message_class_by_key' do
+  it "should return the message_class that belongs to key" do
+    TestAmqpMessageHandler.message_class_by_key[TestMessage.message_key].name.should eq "TestMessage" 
+    TestAmqpMessageHandler.message_class_by_key[TestMessage1.message_key].name.should eq "TestMessage1" 
+  end
+end
+
+
+#TODO
+#add test to Lolitra::AmqpMessageHandler and AmqpBus with evented-spec

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+require 'bundler'
+Bundler.setup(:default, :test)
+
+require "lolitra"
+
+class TestBus
+  def initialize
+    @handlers = {}
+    @unmarshallers = {}
+  end
+
+  def publish_directly(message_key, message_payload)
+    publish(@unmarshallers[message_key].unmarshall(message_payload))
+  end
+
+  def publish(message)
+    @handlers[message.class.name].each do |handler|
+      handler.handle(message)
+    end
+  end
+
+  def subscribe(message_class, handler_class)
+    @unmarshallers[message_class.message_key] = message_class
+    @handlers[message_class.name] ||= []
+    @handlers[message_class.name] << handler_class
+  end
+end
+

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Hugo Freire
@@ -14,10 +14,22 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-09-06 00:00:00 +02:00
+date: 2012-09-19 00:00:00 +02:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
 description: Lolitra, build Sagas, a kind of Long Live Transaction (LLT), in less lines
 email: 
 - hfreire@abajar.com
@@ -29,13 +41,17 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- .rspec
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/lolitra.rb
+- lib/lolitra/handler_base.rb
 - lib/lolitra/version.rb
 - lolitra.gemspec
+- spec/lolitra_spec.rb
+- spec/spec_helper.rb
 has_rdoc: true
 homepage: ""
 licenses: []
@@ -68,5 +84,6 @@ rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Lolitra, build Sagas, a kind of Long Live Transaction (LLT), in less lines
-test_files: []
-
+test_files: 
+- spec/lolitra_spec.rb
+- spec/spec_helper.rb