vuderacha-orq 0.0.0

data/README.rdoc

@@ -0,0 +1,43 @@
+= Introduction
+ORQ (Object Relational Queueing) provides an abstraction for working with message queues directly
+from your objects.
+
+= Getting Started
+Install ORQ with the following:
+  git clone git://github.com/vuderacha/orq.git
+  cd orq
+  rake install
+
+Create a simple impulse:
+  # mymessage.rb
+  class MyMessage < ORQ::Impulse
+    field :text
+    field :interesting
+  end
+
+Create your configuration file (assuming that you are running an AMQP broker on the default port):
+  # messaging.yml
+  development:
+    default:
+      driver: amqp
+
+Create your application:
+  # testapp.rb
+  require 'rubygems'
+  require 'eventmachine'
+  require 'orq/impulse'
+  require 'mymessage'
+  
+  ORQ::Impulse.configure File.join(File.dirname(__FILE__), 'messaging.yml'), 'development'
+  
+  EM.run {
+    ORQ::Impulse.start
+
+    MyMessage.subscribe do |m|
+      puts "Got message: #{m.text} (#{m.interesting})"
+    end
+   
+    EM.add_periodic_timer(1) do
+      MyMessage.new({:text => 'Text', :interesting => 'Cheese'}).fire!
+    end
+  }

data/Rakefile

@@ -0,0 +1,67 @@
+require 'rake'
+require 'spec/rake/spectask'
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+	t.spec_opts  = ["-cfs"]
+	t.spec_files = FileList['spec/**/*_spec.rb']
+	t.libs = ['lib', 'spec/support']
+end
+
+desc "Print specdocs"
+Spec::Rake::SpecTask.new(:doc) do |t|
+	t.spec_opts = ["--format", "specdoc", "--dry-run"]
+	t.spec_files = FileList['spec/*_spec.rb']
+end
+
+desc "Generate RCov code coverage report"
+Spec::Rake::SpecTask.new('rcov') do |t|
+	t.spec_files = FileList['spec/*_spec.rb']
+	t.rcov = true
+	t.rcov_opts = ['--exclude', 'examples']
+end
+
+task :default => :spec
+
+######################################################
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'fileutils'
+include FileUtils
+# $:.push File.join(File.dirname(__FILE__), 'lib')
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "orq"
+  	s.summary = "Ruby Object Relational Queueing."
+  	s.description = "ORQ is a queueing abstraction layer allowing messaging to be done directly from object."
+  	s.author = "Paul Jones"
+  	s.email = "pauljones23@gmail.com"
+  	s.homepage = "http://github.com/vuderacha/orq/"
+  	
+  	s.files = %w(Rakefile README.rdoc) + Dir.glob("{bin,lib,spec}/**/*")
+  	s.require_path = "lib"
+  	s.add_dependency('activesupport', '>= 2.2.2')
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+task :test => [ :spec ]
+
+Rake::RDocTask.new do |t|
+	t.rdoc_dir = 'rdoc'
+	t.title    = "ORQ -- Object Relational Queueing"
+	t.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+	t.options << '--charset' << 'utf-8'
+	t.rdoc_files.include('README.rdoc')
+	t.rdoc_files.include('lib/orq/*.rb')
+end
+
+CLEAN.include [ 'build/*', '**/*.o', '**/*.so', '**/*.a', 'lib/*-*', '**/*.log', 'pkg', 'lib/*.bundle', '*.gem', '.config' ]
+

data/lib/orq/adapters/amqp_adapter.rb

@@ -0,0 +1,33 @@
+require 'mq'
+
+# Adapter providing access to AMQP based message systems from ORQ
+class AmqpAdapter
+  def initialize(config)
+    @config = config
+  end
+  
+  def start
+    # Do connection
+    @connection = AMQP.connect :host => (@config['host'] || 'localhost'), :port => (@config['port'] || 5672).to_i
+    @channel = MQ.new @connection
+  end
+  
+  def subscribe(impulseType, &block)
+    raise "No block provided - a block must be provided to the subscribe method" unless block_given?
+    
+    queue = MQ::Queue.new @channel, impulseType.uri
+    exchange = MQ::Exchange.new @channel, :direct, impulseType.uri
+    queue.bind(exchange)
+    
+    queue.subscribe :ack => true do |headers, msg|
+      yield impulseType.load(msg)
+      headers.ack
+    end
+  end
+  
+  def fire(impulseUri, content)
+    exchange = MQ::Exchange.new @channel, :direct, impulseUri
+    exchange.publish content, :content_type => 'application/json'
+  end
+end
+      

data/lib/orq/impulse.rb

@@ -0,0 +1,115 @@
+require 'rubygems'
+require 'yaml'
+require 'active_support'
+
+module ORQ
+  # Base class inherited by domain objects describing a message that can be sent
+  class Impulse
+    def initialize(config = {})
+      apply_hash!(config)
+    end
+    
+    # Instructs the impulse to send itself to the message queue
+    def fire!
+      self.class.get_target(self.class.target_name).fire self.class.uri, self.to_json
+    end
+    
+    # Instructs the impulse to apply the properties in the given hash
+    def apply_hash!(props)
+      props.each do |k, v|
+        send("#{k}=", v) if respond_to? "#{k}="
+      end
+    end
+    
+    # Class Methods
+    class << self
+        #
+        # Configuration Methods
+        #
+      
+      # Sets the uri for this Impulse if a uri is provided; returns the value for the uri
+      # (or the class name if not overriden)
+      def uri(uri = nil)
+        @uri = uri unless uri.nil?
+        
+        return self.name if @uri.nil?
+        @uri
+      end
+      
+      # Sets the target name for this Impulse if a uri is provided; returns the value for the target name
+      # (or 'default' if not overriden)
+      def target_name(target_name = nil)
+        @target_name = target_name unless target_name.nil?
+        
+        return 'default' if @target_name.nil?
+        @target_name
+      end
+      
+      # Declares a field that should be available on an impulse.
+      def field(name)
+        attr_accessor name
+      end
+      
+        #
+        # Control Methods
+        #
+      def subscribe(&block)
+        target = get_target self.target_name
+        target.subscribe self, &block
+      end
+      
+        #
+        # Loading Methods
+        #
+      def load(text)
+        vals = ActiveSupport::JSON.decode(text)
+        result = new(vals)
+        result
+      end
+    end
+    
+    # Static Methods
+    
+    # Configures the ORQ infrastructure using the file on the given path.
+    def self.configure(path, environment)
+      # Load the given YAML file
+      config = YAML::load_file(path)
+      
+      # Get the configuration for the profile
+      env_config = config[environment.to_s]
+      raise "No configuration for environment #{environment} in #{path}" unless env_config
+      
+      # Clear the list of targets, and then process each
+      @@targets = {}
+      if env_config.is_a? Hash
+        env_config.each do |target_name, target_config|
+        
+          @@targets[target_name] = load_target target_name, target_config
+        end
+      end
+    end
+    
+    # Requests that the ORQ infrastructure start any connections
+    def self.start
+      @@targets.each do |name, target|
+        target.start
+      end
+    end
+    
+    private
+      def self.load_target(name, config)
+        driver = config.delete 'driver'
+        raise "No driver specified for target #{name}" unless driver
+        
+        # Load the adapter for the given driver
+        require "orq/adapters/#{driver}_adapter"
+        driver_class = Kernel.const_get("#{driver}_adapter".classify).new config
+      end
+
+      # Retrieves a target with the given name
+      def self.get_target(name)
+        raise "No target #{name} available" unless @@targets[name]
+        @@targets[name]
+      end
+  end
+end

data/spec/impulse_spec.rb

@@ -0,0 +1,124 @@
+require 'orq/impulse'
+
+describe ORQ::Impulse do
+  it "should be inheritable with default details" do
+    class TrivialObj < ORQ::Impulse
+    end
+    
+    TrivialObj.uri.should == 'TrivialObj'
+  end
+  
+  it "should get fully qualified details by default" do
+    module TrivialNS
+      class TrivialObj < ORQ::Impulse
+      end
+    end
+    
+    TrivialNS::TrivialObj.uri.should == 'TrivialNS::TrivialObj'
+  end
+  
+  it "should allow multiple different types to be created with overidden uri" do
+    class FirstTrivialNamedObj < ORQ::Impulse
+      uri 'http://vuderacha.com/orq/trivial_named/first'
+    end
+    class SecondTrivialNamedObj < ORQ::Impulse
+      uri 'http://vuderacha.com/orq/trivial_named/second'
+    end
+    
+    FirstTrivialNamedObj.uri.should == 'http://vuderacha.com/orq/trivial_named/first'
+    SecondTrivialNamedObj.uri.should == 'http://vuderacha.com/orq/trivial_named/second'
+  end
+  
+  it "should support the declaration of fields" do
+    class FieldedImpulse < ORQ::Impulse
+      field :first_val
+      field :second_val
+    end
+    
+    f = FieldedImpulse.new
+    f.first_val = 'a'
+    f.second_val = 'b'
+    f.first_val.should == 'a'
+    f.second_val.should == 'b'
+  end
+  
+  it "should support restoring from a hash" do
+    class RestorableImpulse < ORQ::Impulse
+      field :first_val
+      field :second_val
+    end
+    
+    f = RestorableImpulse.new({:first_val => 1, :second_val => 'a'})
+    f.first_val.should == 1
+    f.second_val.should == 'a'
+  end
+  
+  it "should support restoring from a hash with too many values" do
+    class AnotherRestorableImpulse < ORQ::Impulse
+      field :first_val
+      field :second_val
+    end
+    
+    f = AnotherRestorableImpulse.new({:first_val => 1, :second_val => 'a', :third_val => [1,2,3]})
+    f.first_val.should == 1
+    f.second_val.should == 'a'
+  end
+  
+  it "should support configuration from a YAML file" do
+    ORQ::Impulse.configure 'spec/simple_config.yml', :development
+  end
+  
+  it "should return default as a target name when not overriden" do
+    class DefaultTargetImpulse < ORQ::Impulse; end
+    DefaultTargetImpulse.target_name.should == 'default'
+  end
+
+  it "should return the configured target name" do
+    class SpecialTargetImpulse < ORQ::Impulse
+      target_name 'special'
+    end
+    SpecialTargetImpulse.target_name.should == 'special'
+  end
+end
+
+describe "configured #{ORQ::Impulse}" do
+  before(:all) do
+    ORQ::Impulse.configure 'spec/stub_config.yml', :development
+  end
+  
+  it "should provide its uri and content to the adapter when being fired" do
+    class AnotherFireableImpulse < ORQ::Impulse 
+      field :simple
+    end
+    StubAdapter.instance.should_receive(:fire).with('AnotherFireableImpulse', '{"simple": "a"}')
+    
+    i = AnotherFireableImpulse.new({:simple => 'a'})
+    i.fire!
+  end
+  
+  it "should support subscribing with a block" do
+    # Declare our subscribable impulse
+    class SubscribableImpulse < ORQ::Impulse
+      field :a
+    end
+    
+    # Create our receiver
+    r = []
+    
+    # Extend the stub adapter to respond the way that way we want it to
+    class StubAdapter
+      def subscribe(type, &block)
+        type.should == SubscribableImpulse
+        yield SubscribableImpulse.new({:a => 1})
+      end
+    end
+    
+    # Perform the subscription
+    SubscribableImpulse.subscribe do |imp|
+      r << imp
+    end
+    
+    r.length.should == 1
+    r[0].a.should == 1
+  end
+end

data/spec/simple_config.yml

@@ -0,0 +1 @@
+development:

data/spec/stub_config.yml

@@ -0,0 +1,3 @@
+development:
+    default:
+        driver: stub

data/spec/support/orq/adapters/stub_adapter.rb

@@ -0,0 +1,9 @@
+class StubAdapter
+  def initialize(config = {})
+    @@instance = self
+  end
+  
+  def self.instance
+    @@instance
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: vuderacha-orq
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Paul Jones
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    version: 
+description: ORQ is a queueing abstraction layer allowing messaging to be done directly from object.
+email: pauljones23@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- Rakefile
+- README.rdoc
+- lib/orq
+- lib/orq/adapters
+- lib/orq/adapters/amqp_adapter.rb
+- lib/orq/impulse.rb
+- spec/impulse_spec.rb
+- spec/simple_config.yml
+- spec/stub_config.yml
+- spec/support
+- spec/support/orq
+- spec/support/orq/adapters
+- spec/support/orq/adapters/stub_adapter.rb
+has_rdoc: true
+homepage: http://github.com/vuderacha/orq/
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Ruby Object Relational Queueing.
+test_files: []
+