ayl 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,18 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.3.0"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.6.4"
+  gem "rcov", ">= 0"
+  gem 'pry'
+end
+
+group :test do
+  gem 'pry'
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    coderay (0.9.8)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    method_source (0.6.7)
+      ruby_parser (>= 2.3.1)
+    pry (0.9.7.4)
+      coderay (~> 0.9.8)
+      method_source (~> 0.6.7)
+      ruby_parser (>= 2.3.1)
+      slop (~> 2.1.0)
+    rake (0.9.2.2)
+    rcov (0.9.11)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    ruby_parser (2.3.1)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.8)
+    slop (2.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  jeweler (>= 1.6.4)
+  pry
+  rcov
+  rspec (>= 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 j0hnds@gmail.com
+
+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.rdoc

@@ -0,0 +1,44 @@
+= ayl
+
+A small framework to support asynchronous method calls in Ruby.
+
+== Description
+
+ayl (At Your Leisure or As You Like or ...) is a small framework that simplifies the process of implementing
+asynchronous method calls in Ruby. Fundamentally, it works by handing off a method call to be executed in a 
+separate processing thread (maybe a thread, maybe a separate process, etc.).
+
+The actual implementation of the code that executes the methods has
+been abstracted away from the general framework. You can implement any
+"Engine" you like to provide the asynchronous functionality. A
+reference implementation of an engine using beanstalk
+({beanstalkd}[http://kr.github.com/beanstalkd/],
+{beanstalk-client}[http://beanstalk.rubyforge.org/]) as a queuing
+mechanism is provided to give you a leg up:
+{ayl-beanstalk}[https://github.com/j0hnds/ayl-beanstalk]. If you
+decide to use a different mechanism, you can simply provide an
+implementation of the Ayl::Engine interface. 
+
+If you would like to leverage asynchronous processes in your rails
+application, take a look at
+{ayl-rails}[https://github.com/j0hnds/ayl-rails]; it provides the
+ability to asynchronize ActiveRecord callbacks (e.g. after_save,
+after_update, etc.).
+
+See the {wiki}[https://github.com/j0hnds/ayl/wiki/ayl-Home] for more detailed documentation.
+
+== Contributing to ayl
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 j0hnds@gmail.com. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+# require 'bundler'
+# begin
+#   Bundler.setup(:default, :development)
+# rescue Bundler::BundlerError => e
+#   $stderr.puts e.message
+#   $stderr.puts "Run `bundle install` to install missing gems"
+#   exit e.status_code
+# end
+# require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "ayl"
+  gem.homepage = "http://github.com/j0hnds/ayl"
+  gem.license = "MIT"
+  gem.summary = %Q{Invoke code At Your Leisure}
+  gem.description = %Q{Invoke code At Your Leisure. ayl is a small framework that simplifies the process of implementing asynchronous method calls in Ruby.}
+  gem.email = "j0hnds@gmail.com"
+  gem.authors = ["Dave Sieh"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "ayl #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/ayl.rb

@@ -0,0 +1,8 @@
+require 'ayl/logging'
+require 'ayl/extensions'
+require 'ayl/message'
+require 'ayl/engine'
+require 'ayl/message_options'
+require 'ayl/unrecoverable_message_exception'
+require 'ayl/logger'
+require 'ayl/worker'

data/lib/ayl/engine.rb

@@ -0,0 +1,52 @@
+require 'singleton'
+
+module Ayl
+
+  class Engine
+    include Singleton
+    include Ayl::Logging
+
+    class << self
+
+      def get_active_engine
+        self.engines ||= []
+        engine = self.engines.detect { |engine| engine.is_connected? }
+        engine ||= self.instance
+      end
+
+      def add_engine(engine)
+        raise "engine must respond to asynchronous?" unless engine.respond_to?(:asynchronous?)
+        raise "engine must respond to is_connected?" unless engine.respond_to?(:is_connected?)
+        self.engines << engine
+      end
+
+      def clear_engines
+        @engines = []
+      end
+
+      def engines
+        @engines ||= []
+      end
+
+    end
+
+    # These methods define the API that must be implemented
+    # by all engines
+    def asynchronous?() false end
+    def is_connected?() true end
+
+    def submit(message)
+      log_call(:submit) do
+        worker.process_message(message)
+      end
+    end
+
+    private
+
+    def worker
+      @worker ||= Worker.new
+    end
+
+  end
+
+end

data/lib/ayl/extensions.rb

@@ -0,0 +1,74 @@
+module Ayl
+
+  module Extensions
+
+    def ayl_send(selector, *args)
+      ayl_send_opts(selector, {}, *args)
+    end
+
+    def ayl_send_opts(selector, opts, *args)
+      engine = Ayl::Engine.get_active_engine
+      message = Message.new(self, selector, MessageOptions.new(opts), *args)
+      engine.submit(message)
+    end
+
+  end
+
+  module InstanceExtensions
+    def to_rrepr()
+      method = (respond_to? :get_cache) ? 'get_cache' : 'find'
+      "#{self.class.to_rrepr}.unscoped.#{method}(#{id.to_rrepr})"
+    end
+  end
+
+end
+
+[ Array, Hash, Module, Numeric, Range, String, Symbol ].each { |c| c.send :include, Ayl::Extensions }
+
+class Symbol
+  def to_rrepr() inspect end
+end
+
+class Module
+  def to_rrepr() name end
+end
+
+class NilClass
+  def to_rrepr() inspect end
+end
+
+class FalseClass
+  def to_rrepr() inspect end
+end
+
+class TrueClass
+  def to_rrepr() inspect end
+end
+
+class Numeric
+  def to_rrepr() inspect end
+end
+
+class String
+  def to_rrepr() inspect end
+end
+
+class Array
+  def to_rrepr() '[' + map(&:to_rrepr).join(', ') + ']' end
+end
+
+class Hash
+  def to_rrepr() '{' + map{|k,v| k.to_rrepr + '=>' + v.to_rrepr}.join(', ') + '}' end
+end
+
+class Range
+  def to_rrepr() "(#{first.to_rrepr}#{exclude_end? ? '...' : '..'}#{last.to_rrepr})" end
+end
+
+class Time
+  def to_rrepr() "Time.parse('#{self.inspect}')" end
+end
+
+class Date
+  def to_rrepr() "Date.parse('#{self.inspect}')" end
+end

data/lib/ayl/logger.rb

@@ -0,0 +1,24 @@
+require 'singleton'
+
+module Ayl
+
+  class Logger
+    include Singleton
+
+    attr_accessor :logger
+
+    LOG_METHODS = [ :debug, :error, :fatal, :info, :warn ]
+
+    LOG_METHODS.each do |method|
+      define_method(method) do |message|
+        if logger
+          logger.send(method, message)
+        else
+          Kernel.puts "#{method.upcase}: #{message}"
+        end
+      end
+    end
+
+  end
+
+end

data/lib/ayl/logging.rb

@@ -0,0 +1,14 @@
+module Ayl
+  module Logging
+
+    def logger() Logger.instance end
+
+    def log_call(method)
+      logger.info "#{self.class.name} invoking #{method}"
+      yield
+    ensure
+      logger.info "#{self.class.name} done invoking #{method}"
+    end
+
+  end
+end

data/lib/ayl/message.rb

@@ -0,0 +1,49 @@
+module Ayl
+
+  class Message
+
+    attr_accessor :object, :selector, :options, :arguments
+
+    def initialize(object, selector, opts, *args)
+      @object = object
+      @selector = selector
+      @options = opts
+      @arguments = args
+    end
+
+    def self.from_hash(message_hash)
+      raise Ayl::UnrecoverableMessageException, "parameter must be a hash" unless message_hash.is_a?(Hash)
+      raise Ayl::UnrecoverableMessageException, "not a valid message hash" if message_hash[:type] != :ayl || message_hash[:code].nil?
+      raise Ayl::UnrecoverableMessageException, "No code provided in job: #{job.body}" if message_hash[:code].nil?
+
+      code = message_hash[:code]
+
+      Message.new(nil, nil, MessageOptions.new).tap do | m |
+        m.send(:message_hash=, message_hash)
+        m.send(:code=, code)
+      end
+      
+    end
+
+    def to_rrepr
+      @code ||= %Q{#{@object.to_rrepr}.#{@selector}(#{@arguments.to_rrepr[1...-1]})}
+    end
+
+    def to_hash
+      @message_hash ||= {
+        :type => :ayl,
+        :code => to_rrepr
+      }
+    end
+
+    def evaluate(top_binding)
+      code_to_eval = to_rrepr
+      eval(code_to_eval, top_binding, code_to_eval, 1)
+    end
+
+    private
+    
+    attr_writer :message_hash, :code
+  end
+
+end

data/lib/ayl/message_options.rb

@@ -0,0 +1,32 @@
+module Ayl
+
+  class MessageOptions
+
+    OPTIONS = [ :priority, :fuzz, :delay, :time_to_run, :queue_name ]
+
+    attr_accessor *OPTIONS
+
+    class << self
+      attr_accessor :default_priority, :default_fuzz, :default_delay, :default_time_to_run, :default_queue_name
+    end
+
+    # Set the default options
+    self.default_priority = 512
+    self.default_fuzz = 0
+    self.default_delay = 0
+    self.default_time_to_run = 120
+    self.default_queue_name = 'default'
+
+    def initialize(opts=nil)
+      opts ||= {}
+      raise "parameter must be a hash" unless opts.is_a?(Hash)
+      unknown_options = opts.keys - OPTIONS
+      raise "unknown options specified: #{unknown_options}" unless unknown_options.empty?
+      OPTIONS.each do |o|
+        send("#{o}=".to_sym, opts.fetch(o, self.class.send("default_#{o}".to_sym)))
+      end
+    end
+
+  end
+
+end

data/lib/ayl/unrecoverable_message_exception.rb

@@ -0,0 +1,6 @@
+module Ayl
+
+  class UnrecoverableMessageException < RuntimeError
+  end
+
+end

data/lib/ayl/worker.rb

@@ -0,0 +1,19 @@
+module Ayl
+
+  class Worker
+    include Ayl::Logging
+
+    attr_accessor :eval_binding
+
+    def process_messages
+      logger.error "Attempt to invoke #{self.class.name}.process_messages failed"
+      raise "synchronous worker cannot receive messages"
+    end
+
+    def process_message(message)
+      message.evaluate(@eval_binding)
+    end
+    
+  end
+
+end

data/spec/engine_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe Ayl::Engine do
+
+  context "Engine Selection" do
+
+    it "should return the default (synchronous) engine if no other engines are configured" do
+      engine = Ayl::Engine.get_active_engine
+
+      engine.should_not be_nil
+      engine.should be_an_instance_of(Ayl::Engine)
+    end
+
+    it "should allow a different engine to be configured and selected if active" do
+      mock_engine = mock("FakeEngine")
+      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(true)
+      mock_engine.should_receive(:respond_to?).with(:is_connected?).and_return(true)
+      mock_engine.should_receive(:is_connected?).and_return(true)
+      
+      Ayl::Engine.clear_engines
+      Ayl::Engine.add_engine(mock_engine)
+
+      Ayl::Engine.get_active_engine.should == mock_engine
+    end
+
+    it "should allow a different engine to be configured but select the default if the new one is not active" do
+      mock_engine = mock("FakeEngine")
+      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(true)
+      mock_engine.should_receive(:respond_to?).with(:is_connected?).and_return(true)
+      mock_engine.should_receive(:is_connected?).and_return(false)
+
+      Ayl::Engine.clear_engines
+      Ayl::Engine.add_engine(mock_engine)
+
+      Ayl::Engine.get_active_engine.should == Ayl::Engine.instance
+    end
+
+    it "should raise an exception if a new engine is added that doesn't respond to :asynchronous" do
+      mock_engine = mock("FakeEngine")
+      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(false)
+      
+      lambda { Ayl::Engine.add_engine(mock_engine) }.should raise_error
+    end
+
+    it "should raise an exception if a new engine is added that doesn't respond to :is_connected" do
+      mock_engine = mock("FakeEngine")
+      mock_engine.should_receive(:respond_to?).with(:asynchronous?).and_return(true)
+      mock_engine.should_receive(:respond_to?).with(:is_connected?).and_return(false)
+      
+      lambda { Ayl::Engine.add_engine(mock_engine) }.should raise_error
+    end
+
+  end
+
+  context "Default Engine Behavior" do
+    
+    before(:each) do
+      @default_engine = Ayl::Engine.instance
+    end
+
+    it "should identify itself as synchronous" do
+      @default_engine.asynchronous?.should be_false
+    end
+
+    it "should respond that it is connected" do
+      @default_engine.is_connected?.should be_true
+    end
+
+    it "should simply execute the code provided in the message submission" do
+      mock_logger = mock("Ayl::Logger")
+      mock_logger.stub(:info)
+      
+      Ayl::Logger.instance.logger = mock_logger
+
+      mock_message = mock("Ayl::Message")
+
+      mock_worker = mock("Ayl::Worker")
+      mock_worker.should_receive(:process_message).with(mock_message).and_return(8)
+      Ayl::Worker.should_receive(:new).and_return(mock_worker)
+
+      @default_engine.submit(mock_message).should == 8
+    end
+
+  end
+
+end

data/spec/extensions_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Ayl::Extensions do
+
+  class ExtendedClass
+    include Ayl::Extensions
+  end
+
+  context "Send methods" do
+
+    before(:each) do
+      @cut = ExtendedClass.new
+    end
+
+    it "should delegate the call to ayl_send to ayl_send_opts" do
+      @cut.should_receive(:ayl_send_opts).with(:something, {}, "arg1", "arg2")
+      @cut.ayl_send(:something, "arg1", "arg2")
+    end
+
+    it "should have the message submit the call from ayl_send_opts" do
+      mock_engine = mock("Ayl::Engine")
+
+      Ayl::Engine.should_receive(:get_active_engine).and_return(mock_engine)
+      
+      mock_message_opts = mock("Ayl::MessageOptions")
+      Ayl::MessageOptions.should_receive(:new).with({}).and_return(mock_message_opts)
+      
+      mock_message = mock("Ayl::Message")
+
+      Ayl::Message.should_receive(:new).with(@cut, :something, mock_message_opts, "arg1", "arg2").and_return(mock_message)
+      mock_engine.should_receive(:submit).with(mock_message)
+
+      @cut.ayl_send_opts(:something, {}, "arg1", "arg2")
+    end
+
+    it "should extend a common set up classes" do
+      [ Array, Hash, Module, Numeric, Range, String, Symbol ].each do |c|
+        c.should respond_to :ayl_send
+        c.should respond_to :ayl_send_opts
+      end
+    end
+
+  end
+
+end

data/spec/logger_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Ayl::Logger do
+
+  before(:each) do
+    Ayl::Logger.instance.logger = nil
+  end
+
+  context "Logger Configuration" do
+
+    it "should respond with nil if a logger isn't configured" do
+      Ayl::Logger.instance.logger.should be_nil
+    end
+
+    it "should respond with the logger set if the logger is configured" do
+      mock_logger = mock("Logger")
+
+      Ayl::Logger.instance.logger = mock_logger
+      Ayl::Logger.instance.logger.should == mock_logger
+    end
+
+  end
+
+  context "Logging" do
+
+    it "should log calls to the logger through std out when no logger is configured" do
+      Kernel.should_receive(:puts).with("DEBUG: Debug message")
+      Kernel.should_receive(:puts).with("ERROR: Error message")
+      Kernel.should_receive(:puts).with("FATAL: Fatal message")
+      Kernel.should_receive(:puts).with("INFO: Info message")
+      Kernel.should_receive(:puts).with("WARN: Warn message")
+      
+      Ayl::Logger.instance.logger = nil
+
+      [ :debug, :error, :fatal, :info, :warn ].each do |method|
+        Ayl::Logger.instance.send(method, "#{method.to_s.capitalize} message")
+      end
+    end
+
+    it "should log calls to the configured logger" do
+      mock_logger = mock("Logger")
+      mock_logger.should_receive(:debug).with("Debug message")
+      mock_logger.should_receive(:error).with("Error message")
+      mock_logger.should_receive(:fatal).with("Fatal message")
+      mock_logger.should_receive(:info).with("Info message")
+      mock_logger.should_receive(:warn).with("Warn message")
+
+      Ayl::Logger.instance.logger = mock_logger
+      
+      [ :debug, :error, :fatal, :info, :warn ].each do |method|
+        Ayl::Logger.instance.send(method, "#{method.to_s.capitalize} message")
+      end
+    end
+
+  end
+
+end

data/spec/message_options_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Ayl::MessageOptions do
+
+  context "Option Default Accessors" do
+
+    it "should have the correct defaults" do
+      Ayl::MessageOptions.default_priority.should == 512
+      Ayl::MessageOptions.default_fuzz.should == 0
+      Ayl::MessageOptions.default_delay.should == 0
+      Ayl::MessageOptions.default_time_to_run.should == 120
+      Ayl::MessageOptions.default_queue_name.should == 'default'
+    end
+
+    it "should reflect the changes if changes have been made" do
+      Ayl::MessageOptions.default_priority = 256
+      Ayl::MessageOptions.default_fuzz = 18
+      Ayl::MessageOptions.default_delay = 2300
+      Ayl::MessageOptions.default_time_to_run = 1
+      Ayl::MessageOptions.default_queue_name = 'different'
+
+      Ayl::MessageOptions.default_priority.should == 256
+      Ayl::MessageOptions.default_fuzz.should == 18
+      Ayl::MessageOptions.default_delay.should == 2300
+      Ayl::MessageOptions.default_time_to_run.should == 1
+      Ayl::MessageOptions.default_queue_name.should == 'different'
+    end
+
+  end
+
+  context "Initialization" do
+
+    it "should respond with the correct defaults when initialized with an empty hash" do
+      mo = Ayl::MessageOptions.new({})
+
+      mo.priority.should == Ayl::MessageOptions.default_priority
+      mo.fuzz.should == Ayl::MessageOptions.default_fuzz
+      mo.delay.should == Ayl::MessageOptions.default_delay
+      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
+      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
+    end
+
+    it "should respond with the correct defaults when initialized with nil" do
+      mo = Ayl::MessageOptions.new(nil)
+
+      mo.priority.should == Ayl::MessageOptions.default_priority
+      mo.fuzz.should == Ayl::MessageOptions.default_fuzz
+      mo.delay.should == Ayl::MessageOptions.default_delay
+      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
+      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
+    end
+
+    it "should respond with the correct defaults when initialized with no parameter" do
+      mo = Ayl::MessageOptions.new()
+
+      mo.priority.should == Ayl::MessageOptions.default_priority
+      mo.fuzz.should == Ayl::MessageOptions.default_fuzz
+      mo.delay.should == Ayl::MessageOptions.default_delay
+      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
+      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
+    end
+
+    it "should respond with the correct values when all are specified in the options" do
+      opts = { :priority => 22, :fuzz => 88, :delay => 99, :time_to_run => 11, :queue_name => 'stub' }
+      mo = Ayl::MessageOptions.new(opts)
+
+      mo.priority.should == opts[:priority]
+      mo.fuzz.should == opts[:fuzz]
+      mo.delay.should == opts[:delay]
+      mo.time_to_run.should == opts[:time_to_run]
+      mo.queue_name.should == opts[:queue_name]
+    end
+
+    it "should respond with the correct values when some values are specified in the options" do
+      opts = { :priority => 22, :fuzz => 88, :delay => 99 }
+      mo = Ayl::MessageOptions.new(opts)
+
+      mo.priority.should == opts[:priority]
+      mo.fuzz.should == opts[:fuzz]
+      mo.delay.should == opts[:delay]
+      mo.time_to_run.should == Ayl::MessageOptions.default_time_to_run
+      mo.queue_name.should == Ayl::MessageOptions.default_queue_name
+    end
+
+    it "should raise an exception when an invalid option is provided in the hash" do
+      lambda { Ayl::MessageOptions.new({:bob => 'something' }) }.should raise_error
+    end
+
+    it "should raise an exception when a non-hash is provided as a parameter" do
+      lambda { Ayl::MessageOptions.new(14) }.should raise_error
+    end
+
+  end
+
+end

data/spec/message_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Ayl::Message do
+
+  context "Initialization" do
+
+    it "should accept an object, selector options and a set of arguments" do
+      options = Ayl::MessageOptions.new
+      m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
+      
+      m.object.should == "object"
+      m.selector.should == :method_name
+      m.options.should == options
+      m.arguments.should == [ "arg1", "arg2" ]
+    end
+
+    it "should accept an object, selector options and no arguments" do
+      options = Ayl::MessageOptions.new
+      m = Ayl::Message.new("object", :method_name, options)
+      
+      m.object.should == "object"
+      m.selector.should == :method_name
+      m.options.should == options
+      m.arguments.should == [ ]
+    end
+
+  end
+
+  context "Code generation" do
+    
+    it "should generate code when arguments are present" do
+      options = Ayl::MessageOptions.new
+      m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
+      m.to_rrepr.should == "\"object\".method_name(\"arg1\", \"arg2\")"
+    end
+
+    it "should generate code when no arguments are present" do
+      options = Ayl::MessageOptions.new
+      m = Ayl::Message.new("object", :method_name, options)
+      m.to_rrepr.should == "\"object\".method_name()"
+    end
+
+  end
+
+  context "Message Packaging" do
+    
+    it "should package up the message into a hash" do
+      options = Ayl::MessageOptions.new
+      m = Ayl::Message.new("object", :method_name, options, "arg1", "arg2")
+      m.to_hash.should == { :type => :ayl, :code => "\"object\".method_name(\"arg1\", \"arg2\")" }
+    end
+
+    it "should be able to create a message from a hash with code that has arguments" do
+      m_hash = { :type => :ayl, :code => "\"object\".method_name(\"arg1\", \"arg2\")" }
+      m = Ayl::Message.from_hash(m_hash)
+      m.options.is_a?(Ayl::MessageOptions).should be_true
+      m.to_hash.should === m_hash
+    end
+
+    it "should be able to create a message from a hash with code that has no arguments" do
+      m_hash = { :type => :ayl, :code => "\"object\".method_name()" }
+      m = Ayl::Message.from_hash(m_hash)
+      m.options.is_a?(Ayl::MessageOptions).should be_true
+      m.to_hash.should === m_hash
+    end
+
+    it "should be able to create a message from a hash with code that has no arguments and no parens" do
+      m_hash = { :type => :ayl, :code => "\"object\".method_name" }
+      m = Ayl::Message.from_hash(m_hash)
+      m.options.is_a?(Ayl::MessageOptions).should be_true
+      m.to_hash.should === m_hash
+    end
+
+    it "should be able to create a message from a hash with code that has one arguments with multiple parens" do
+      m_hash = { :type => :ayl, :code => "\"object\".method_name('string'.length())" }
+      m = Ayl::Message.from_hash(m_hash)
+      m.options.is_a?(Ayl::MessageOptions).should be_true
+      m.to_hash.should === m_hash
+    end
+
+    # Sample._ayl_after_create(Sample.find(106))
+    it "should be able to create a message from a hash with code that has one arguments with multiple parens" do
+      m_hash = { :type => :ayl, :code => "String._ayl_after_create(2.to_s(2))" }
+      m = Ayl::Message.from_hash(m_hash)
+      m.options.is_a?(Ayl::MessageOptions).should be_true
+      m.to_hash.should === m_hash
+    end
+
+
+  end
+
+  context "Code Evaluation" do
+    
+    it "should evaluate the code associated with the message" do
+      array_of_nums = [ 3, 2, 8, 1 ]
+      m = Ayl::Message.new(array_of_nums, :length, Ayl::MessageOptions.new)
+      m.evaluate(binding).should == 4
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'ayl'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

data/spec/worker_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Ayl::Worker do
+
+  context "Messages Processing" do
+
+    before(:each) do
+      Ayl::Logger.instance.logger = nil
+      @worker = Ayl::Worker.new
+    end
+
+    it "should raise an exception if receive is called on an engine that is not asynchronous" do
+      Kernel.stub(:puts)
+      lambda { @worker.process_messages }.should raise_error(RuntimeError, "synchronous worker cannot receive messages")
+    end
+
+  end
+
+  context "Message Processing" do
+
+    it "should be able to invoke the code for a message" do
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: ayl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Dave Sieh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-20 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &84028120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *84028120
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &84027830 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *84027830
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &83964270 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *83964270
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &83964020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *83964020
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &83963730 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *83963730
+description: Invoke code At Your Leisure. ayl is a small framework that simplifies
+  the process of implementing asynchronous method calls in Ruby.
+email: j0hnds@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/ayl.rb
+- lib/ayl/engine.rb
+- lib/ayl/extensions.rb
+- lib/ayl/logger.rb
+- lib/ayl/logging.rb
+- lib/ayl/message.rb
+- lib/ayl/message_options.rb
+- lib/ayl/unrecoverable_message_exception.rb
+- lib/ayl/worker.rb
+- spec/engine_spec.rb
+- spec/extensions_spec.rb
+- spec/logger_spec.rb
+- spec/message_options_spec.rb
+- spec/message_spec.rb
+- spec/spec_helper.rb
+- spec/worker_spec.rb
+homepage: http://github.com/j0hnds/ayl
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Invoke code At Your Leisure
+test_files: []