gustin-rudeq 2.1.0.2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [Matthew Rudy Jacobs]
+
+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

@@ -0,0 +1,64 @@
+== Author
+  Matthew Rudy Jacobs
+ 
+== Contact
+  MatthewRudyJacobs@gmail.com
+ 
+RudeQ
+=============
+  A simple DB based queue,
+  designed for situations where a server based queue is unnecessary.
+ 
+ 
+INSTALL
+============
+This plugin requires Rails 2.* currently, and has only been tested on MySQL.
+
+On rails 2.1 you can install straight from github:
+  ruby script/plugin install git://github.com/matthewrudy/rudeq.git
+
+Else just check it out into your plugins directory:
+  git clone git://github.com/matthewrudy/rudeq.git vendor/plugins/rudeq
+ 
+USAGE
+============
+After you've installed it just run
+  rake queue:setup
+
+  matthew@iRudy:~/code/jbequeueing $ rake queue:setup
+  (in /Users/matthew/code/jbequeueing)
+      exists  app/models/
+      exists  spec/fixtures/
+      exists  spec/models/
+      create  app/models/rude_queue.rb
+      create  spec/fixtures/rude_queues.yml
+      create  spec/models/rude_queue_spec.rb
+      exists  db/migrate
+      create  db/migrate/029_create_rude_queues.rb
+
+  and you're done.
+  Fully tested, fully index... BOOM!
+
+  Now run migrations, start up a console, and;
+
+      RudeQueue.set(:queue_name, RandomObject)
+      RudeQueue.get(:queue_name)
+      RudeQueue.fetch(:queue_name) do |data|
+        process(data)
+      end
+
+  And, to keep the queue running fast,
+  set up a cron job to run
+
+      rake queue:cleanup
+  
+  the cleanup will remove any queued items which have been processed longer than an hour ago.
+
+      rake queue:cleanup CLEANUP_TIME=86,400
+
+  will clear processed queue items processed longer than 86,400 seconds ago (1 day)
+
+Try Yourself!
+ 
+Copyright (c) 2008 [Matthew Rudy Jacobs Email: MatthewRudyJacobs@gmail.com],
+released under the MIT license

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'spec'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+desc 'Default: run the specs.'
+task :default => :spec
+
+desc 'Run specs for rude_q plugin'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Generate documentation for the rude_q plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RudeQ'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/generators/rude_q/USAGE

@@ -0,0 +1,24 @@
+Description:
+    The rude_q generator creates a fully functioning RudeQ.
+
+    The generator takes a model name as its argument.  The model name may be
+    given in CamelCase or under_score and should not be suffixed with 'Model'.
+
+    The generator creates a model class in app/models, an RSpec spec in
+    spec/models, database fixtures in spec/fixtures/plural_name.yml, and a migration
+    in db/migrate.
+
+    All the generated files are fully functioning, and no extra work should be necessary.
+
+Example:
+    ./script/generate rude_q ProcessQueue
+
+    This will create a ProcessQueue model:
+        Model:      app/models/process_queue.rb
+        Spec:       spec/models/process_queue_spec.rb
+        Fixtures:   spec/fixtures/process_queues.yml
+        Migration:  db/migrate/XXX_add_process_queues.rb
+
+    Run migrations, and you can use it immediately;
+        ProcessQueue.set(queue_name, value)
+        ProcessQueue.get(queue_name)

data/generators/rude_q/rude_q_generator.rb

@@ -0,0 +1,27 @@
+class RudeQGenerator < Rails::Generator::NamedBase
+  def manifest
+
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions class_path, class_name
+
+      # Model, spec, and fixture directories.
+      m.directory File.join('app/models', class_path)
+      m.directory File.join('spec/fixtures', class_path)
+      m.directory File.join('spec/models', class_path)
+
+      # Model class, spec and fixtures.
+      m.template 'rude_q_model.rb',      File.join('app/models', class_path, "#{file_name}.rb")
+      m.template 'model:fixtures.yml',  File.join('spec/fixtures', class_path, "#{table_name}.yml")
+      m.template 'rude_q_model_spec.rb', File.join('spec/models', class_path, "#{file_name}_spec.rb")
+
+      unless options[:skip_migration]
+        m.migration_template 'rude_q_migration.rb', 'db/migrate', :assigns => {
+          :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}"
+        }, :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}"
+      end
+
+    end
+  end
+  
+end

data/generators/rude_q/templates/rude_q_migration.rb

@@ -0,0 +1,18 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %> do |t|
+      t.string :queue_name
+      t.text :data
+      t.boolean :processed, :default => false, :null => false
+<% unless options[:skip_timestamps] %>
+      t.timestamps
+<% end -%>
+    end
+    add_index :<%= table_name %>, :processed
+    add_index :<%= table_name %>, [:queue_name, :processed]
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

data/generators/rude_q/templates/rude_q_model.rb

@@ -0,0 +1,3 @@
+class <%= class_name %> < ActiveRecord::Base
+  include RudeQ
+end

data/generators/rude_q/templates/rude_q_model_spec.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../spec_helper'
+
+describe <%= class_name %> do
+  before(:each) do
+    @<%= file_name %> = <%= class_name %>.new
+  end
+
+  it "should be valid" do
+    @<%= file_name %>.should be_valid
+  end
+  
+  describe "get and set" do
+    it "should work with strings" do
+      <%= class_name %>.set('abcde', "Something to set")
+      <%= class_name %>.get('abcde').should == "Something to set"
+    end
+    it "should work with symbols" do
+      <%= class_name %>.set('abcde', :a_symbol)
+      <%= class_name %>.get('abcde').should == :a_symbol
+    end
+    it "should work with arrays" do
+      array = [1, :b, "C"]
+      <%= class_name %>.set('abcde', array)
+      <%= class_name %>.get('abcde').should == array
+    end
+    it "should work with hashes" do
+      hash = {:symbol => "A string", "stringy" => 23, 74 => :cheese}
+      <%= class_name %>.set('abcde', hash)
+      <%= class_name %>.get('abcde').should == hash
+    end
+    
+    it "should :get in the same order they are :set" do
+      <%= class_name %>.set('abcde', :first)
+      <%= class_name %>.set('abcde', "second")
+      
+      <%= class_name %>.get('abcde').should == :first
+      
+      <%= class_name %>.set('abcde', 33.3333)
+      
+      <%= class_name %>.get('abcde').should == "second"
+      <%= class_name %>.get('abcde').should == 33.3333
+      <%= class_name %>.get('abcde').should be(nil)
+    end
+    
+    it "should keep queues seperated" do
+      <%= class_name %>.set('queue_1', :data_1)
+      <%= class_name %>.set('queue_2', "DATA2")
+      
+      <%= class_name %>.get('queue_2').should == "DATA2"
+      <%= class_name %>.get('queue_2').should be(nil)
+      <%= class_name %>.get('queue_1').should == :data_1
+      <%= class_name %>.get('queue_1').should be(nil)
+    end
+    
+    it "should work with queue name as strings or symbols" do
+      <%= class_name %>.set(:bah, "something about bah")
+      <%= class_name %>.get("bah").should == "something about bah"
+      
+      <%= class_name %>.set("girah", {:craziness => "embodied"})
+      <%= class_name %>.get(:girah).should == {:craziness => "embodied"}
+    end
+    
+    it "should work with queue name as strings or integers" do
+      <%= class_name %>.set(23, "something about bah")
+      <%= class_name %>.get("23").should == "something about bah"
+      
+      <%= class_name %>.set("34", {:craziness => "embodied"})
+      <%= class_name %>.get(34).should == {:craziness => "embodied"}
+    end
+  end
+end

data/lib/rude_q.rb

@@ -0,0 +1,220 @@
+# RudeQ
+
+# simply doing;
+#   class RudeQueue < ActiveRecord::Base
+#     include RudeQ
+#   end
+# will include RudeQ::ClassMethods
+#   :get
+#   :set
+module RudeQ
+
+  def self.included(mod) # :nodoc:
+    mod.extend(ClassMethods)
+    mod.send(:include, InstanceMethods)
+  end
+
+  module InstanceMethods
+    def data # :nodoc:
+      YAML.load(self[:data])
+    end
+    def data=(value) # :nodoc:
+      self[:data] = YAML.dump(value)
+    end
+  end
+
+  module ClassMethods
+    # Cleanup old processed items
+    #
+    #   RudeQueue.cleanup!
+    #   RudeQueue.cleanup!(1.week)
+    def cleanup!(expiry=1.hour)
+      self.delete_all(["processed = ? AND updated_at < ?", true, expiry.to_i.ago])
+    end
+  
+    # Add any serialize-able +data+ to the queue +queue_name+ (strings and symbols are treated the same)
+    #   RudeQueue.set(:sausage_queue, Sausage.new(:sauce => "yummy"))
+    #   RudeQueue.set("sausage_queue", Sausage.new(:other => true))
+    #
+    #   >> RudeQueue.get("sausage_queue")
+    #   -> *yummy sausage*
+    #   >> RudeQueue.get(:sausage_queue)
+    #   -> *other_sausage*
+    #   >> RudeQueue.get(:sausage_queue)
+    #   -> nil
+    def set(queue_name, data)
+      queue_name = sanitize_queue_name(queue_name)
+
+      self.create!(:queue_name => queue_name, :data => data)
+      return nil # in line with Starling
+    end
+
+    # Grab the first item from the queue *queue_name* (strings and symbols are treated the same)
+    #   - it should always come out the same as it went in
+    #   - they should always come out in the same order they went in
+    #   - it will return a nil if there is no unprocessed entry in the queue
+    #
+    #   >> RudeQueue.get(21)
+    #   -> {:a => "hash"}
+    #   >> RudeQueue.get(:a_symbol)
+    #   -> 255
+    #   >> RudeQueue.get("a string")
+    #   -> nil
+    def get(queue_name)
+      qname = sanitize_queue_name(queue_name)
+      
+      fetch_with_lock(qname) do |record|
+        if record
+          processed!(record)
+          return record.data
+        else
+          return nil # Starling waits indefinitely for a corresponding queue item
+        end
+      end
+    end
+
+    # Grab the first item from the queue, and execute the supplied block if there is one
+    #   - it will return the value of the block
+    #
+    #   >> RudeQueue.fetch(:my_queue) do |data|
+    #   >>   Monster.devour(data)
+    #   >> end
+    #   -> nil
+    #
+    #   >> status = RudeQueue.fetch(:my_queue) do |data|
+    #   >>   process(data) # returns the value :update in this case
+    #   >> end
+    #   -> :update
+    #   >> status
+    #   -> :update
+    def fetch(queue_name, &block)
+      if data = get(queue_name)
+        return block.call(data)
+      end
+    end
+
+    # A snapshot count of unprocessed items for the given +queue_name+
+    #
+    #   >> RudeQueue.backlog
+    #   -> 265
+    #   >> RudeQueue.backlog(:one_queue)
+    #   -> 212
+    #   >> RudeQueue.backlog(:another_queue)
+    #   -> 53
+    #
+    def backlog(queue_name=nil)
+      conditions = {:processed => false}
+      if queue_name
+        conditions[:queue_name] = sanitize_queue_name(queue_name)
+      end
+      self.count(:conditions => conditions)
+    end
+    
+    def fetch_with_lock(qname, &block) # :nodoc:
+      lock = case queue_options[:lock]
+      when :pessimistic then RudeQ::PessimisticLock
+      when :token       then RudeQ::TokenLock
+      else
+        raise(ArgumentError, "bad queue_option for :lock - #{queue_options[:lock].inspect}")
+      end
+      lock.fetch_with_lock(self, qname, &block)
+    end
+    
+    # class method to make it more easily stubbed
+    def processed!(record) # :nodoc:
+      case queue_options[:processed]
+      when :set_flag
+        record.update_attribute(:processed, true)
+      when :destroy
+        record.destroy
+      else
+        raise(ArgumentError, "bad queue_option for :processed - #{queue_options[:processed].inspect}")
+      end
+    end
+    protected :processed!
+    
+    # configure your RudeQ
+    # ==== :processed - what do we do after retrieving a queue item?
+    # * <tt>:set_flag</tt> - set the +processed+ flag to +true+ (keep data in the db) [*default*]
+    # * <tt>:destroy</tt>  - destroy the processed item (keep our queue as lean as possible
+    #
+    # ==== :lock - what locking method should we use?
+    # * <tt>:pessimistic</tt> - RudeQ::PessimisticLock [*default*]
+    # * <tt>:token</tt>       - RudeQ::TokenLock
+    def queue_options
+      @queue_options ||= {:processed => :set_flag, :lock => :pessimistic}
+    end
+
+    def data # :nodoc:
+      YAML.load(self[:data])
+    end
+    def data=(value) # :nodoc:
+      self[:data] = YAML.dump(value)
+    end
+    private
+    
+    def sanitize_queue_name(queue_name) # :nodoc:
+      queue_name.to_s
+    end
+  end
+  
+  # uses standard ActiveRecord :lock => true
+  # this will invoke a lock on the particular queue
+  #   eg. daemon1: RudeQueue.get(:abc)
+  #       daemon2: RudeQueue.get(:abc) - will have to wait for daemon1 to finish
+  #       daemon3: RudeQueue.get(:def) - will avoid the lock
+  module PessimisticLock
+    class << self
+      
+      def fetch_with_lock(klass, qname) # :nodoc:
+        klass.transaction do
+          record = klass.find(:first,
+            :conditions => {:queue_name => qname, :processed => false},
+            :lock => true, :order => "id ASC", :limit => 1)
+      
+          return yield(record)
+        end
+      end
+    
+    end
+  end
+  
+  # a crazy hack around database locking
+  # that I thought was a good idea
+  # turns out we can't make it use transactions properly
+  # without creating a whole table lock
+  # which misses the point
+  #
+  # also, it doesn't work on SQLite as it requires "UPDATE ... LIMIT 1 ORDER id ASC"
+  # and as of RudeQueue2, you'll need to manually add the "token" column
+  module TokenLock
+    class << self
+      
+      require 'digest/sha1'
+      
+      def fetch_with_lock(klass, qname) # :nodoc:
+        token = get_unique_token
+        klass.update_all(["token = ?", token], ["queue_name = ? AND processed = ? AND token IS NULL", qname, false], :limit => 1, :order => "id ASC")
+        record = klass.find_by_queue_name_and_token_and_processed(qname, token, false)
+      
+        return yield(record)
+      end
+
+      def token_count! # :nodoc:
+        @token_count ||= 0
+        @token_count += 1
+        return @token_count
+      end
+
+      def get_unique_token # :nodoc:
+        digest = Digest::SHA1.new
+        digest << Time.now.to_s
+        digest << Process.pid.to_s
+        digest << Socket.gethostname
+        digest << self.token_count!.to_s # multiple requests from the same pid in the same second get different token
+        return digest.hexdigest
+      end
+    end
+  end
+end
+

data/lib/rude_q/scope.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + "/../rude_q"
+
+module RudeQ
+  class Scope
+
+    def initialize(queue_name)
+      @queue_name = queue_name
+    end
+    attr_reader :queue_name
+
+    def set(data)
+      RudeQueue.set(self.queue_name, data)
+    end
+
+    def get()
+      RudeQueue.get(self.queue_name)
+    end
+
+    def backlog()
+      RudeQueue.backlog(self.queue_name)
+    end
+  end
+end
+

data/lib/rude_q/tasks.rb

@@ -0,0 +1,25 @@
+namespace :queue do
+  desc "Generates your RudeQueue model"
+  task :setup => :environment do
+    require 'rails_generator'
+    require 'rails_generator/scripts/generate'
+    Rails::Generator::Scripts::Generate.new.run(["rude_q", ENV["QUEUE"] || "RudeQueue"])
+  end
+
+  desc "Removes all the old queue items"
+  task :cleanup => :environment do
+    queue_model = (ENV["QUEUE"] || "RudeQueue").constantize
+    args = [ENV["CLEANUP_TIME"]].compact
+    queue_model.cleanup!(*args) # no arg if no CLEANUP_TIME specified
+  end
+end
+
+#namespace :spec do
+#  namespace :plugins do
+#    desc "Runs the examples for RudeQ"
+#    Spec::Rake::SpecTask.new(:rude_q) do |t|
+#      t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+#      t.spec_files = FileList['vendor/plugins/rude_q/spec/**/*_spec.rb']
+#    end
+#  end
+#end

data/lib/rude_q/worker.rb

@@ -0,0 +1,66 @@
+# example worker class: lib/my_worker.rb
+#   class MyWorker < RudeQ::Worker
+#     def queue_name
+#       :my_queue
+#     end
+#
+#     def do_work(data)
+#       MyMailer.send(data)
+#     end
+#   end
+#
+# example rake file: lib/tasks/worker.rake
+#   namespace :worker do
+#     desc "fire off a worker"
+#     task :do => :environment do
+#       worker = MyWorker.new
+#       worker.do!
+#     end
+#   end
+#
+# then add a cron job to run "cd /path/to/wherever && rake worker:do RAILS_ENV=production"
+module RudeQ
+  class Worker
+
+    def queue_name
+      raise NotImplementedError
+    end
+    
+    def do_work(data)
+      raise NotImplementedError
+    end
+    
+    def do!
+      logger.info("starting up")
+      if work = self.queue.get
+        logger.info("found some work")
+        do_work(work)
+      else
+        logger.info("couldn't find any work")
+      end
+      logger.info("finished for now")
+    end      
+  
+    def logger
+      unless @logger
+        @logger = Logger.new(RAILS_ROOT + "/log/#{self.class.to_s.underscore}_#{RAILS_ENV}.log")
+        class << @logger
+          def format_message(severity, timestamp, progname, msg)
+            "#{timestamp.strftime('%Y%m%d-%H:%M:%S')} (#{$$}) #{msg}\n"
+          end
+        end
+      end
+      return @logger
+    end
+
+    class << self
+      def queue
+        RudeQ::Scope.new(self.new.queue_name)
+      end
+    end
+
+    def queue
+      @queue ||= self.class.queue
+    end
+  end
+end

data/spec/database.yml

@@ -0,0 +1,4 @@
+rude_q_test:
+  adapter: mysql
+  username: rude_q
+  database: rude_q_test

data/spec/models/rude_queue.rb

@@ -0,0 +1,14 @@
+class RudeQueue < ActiveRecord::Base
+  include RudeQ
+  
+  class << self
+    def processed_with_raise_hack!(*args)
+      processed_without_raise_hack!(*args)
+      raise RuntimeError if raise_on_processed # want to be able to raise afterwards to check transactions
+    end
+    alias_method_chain :processed!, :raise_hack
+    attr_accessor :raise_on_processed
+  end
+    
+end
+

data/spec/models/something.rb

@@ -0,0 +1,3 @@
+class Something < ActiveRecord::Base
+end
+

data/spec/rude_q_spec.rb

@@ -0,0 +1,372 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe RudeQ::ClassMethods do # RudeQueue extends ClassMethods
+  before(:each) do
+    RudeQueue.delete_all
+    RudeQueue.raise_on_processed = false
+    create_some_noise
+  end
+  
+  def create_some_noise
+    RudeQueue.create!(:queue_name => "doNT use this in Specs", :data => {:not => "to be messed with"})
+    RudeQueue.create!(:queue_name => "abcde", :data => {:same_as => "the specs but already processed"}, :processed => true)
+  end
+  
+  describe "get and set" do
+    it "should work with strings" do
+      RudeQueue.set('abcde', "Something to set")
+      RudeQueue.get('abcde').should == "Something to set"
+    end
+    it "should work with symbols" do
+      RudeQueue.set('abcde', :a_symbol)
+      RudeQueue.get('abcde').should == :a_symbol
+    end
+    it "should work with arrays" do
+      array = [1, :b, "C"]
+      RudeQueue.set('abcde', array)
+      RudeQueue.get('abcde').should == array
+    end
+    it "should work with hashes" do
+      hash = {:symbol => "A string", "stringy" => 23, 74 => :cheese}
+      RudeQueue.set('abcde', hash)
+      RudeQueue.get('abcde').should == hash
+    end
+    it "should work with integers" do
+      RudeQueue.set('abcde', 7816327370)
+      RudeQueue.get('abcde').should == 7816327370
+    end
+    it "should work with ActiveRecords" do
+      record = Something.create!(:name => "MatthewRudy")
+
+      RudeQueue.set('abcde', record)
+      RudeQueue.get('abcde').should == record
+    end
+    it "should resolve booleans correctly" do
+      RudeQueue.set('abcde', true)
+      RudeQueue.get('abcde').should == true
+      
+      RudeQueue.set('abcde', false)
+      RudeQueue.get('abcde').should == false
+    end
+    
+    it "should :get in the same order they are :set" do
+      RudeQueue.set('abcde', :first)
+      RudeQueue.set('abcde', "second")
+      
+      RudeQueue.get('abcde').should == :first
+      
+      RudeQueue.set('abcde', 33.3333)
+      
+      RudeQueue.get('abcde').should == "second"
+      RudeQueue.get('abcde').should == 33.3333
+      RudeQueue.get('abcde').should be(nil)
+    end
+    
+    it "should keep queues seperated" do
+      RudeQueue.set('queue_1', :data_1)
+      RudeQueue.set('queue_2', "DATA2")
+      
+      RudeQueue.get('queue_2').should == "DATA2"
+      RudeQueue.get('queue_2').should be(nil)
+      RudeQueue.get('queue_1').should == :data_1
+      RudeQueue.get('queue_1').should be(nil)
+    end
+    
+    it "should call to_s on inputs" do
+      qname = stub("fake input")
+      qname.should_receive(:to_s).exactly(:twice).and_return("fake queue name")
+      
+      RudeQueue.set(qname, ["Data"])
+      RudeQueue.get(qname).should == ["Data"]
+    end
+    
+    it "should work with queue name as strings or symbols" do
+      RudeQueue.set(:bah, "something about bah")
+      RudeQueue.get("bah").should == "something about bah"
+      
+      RudeQueue.set("girah", {:craziness => "embodied"})
+      RudeQueue.get(:girah).should == {:craziness => "embodied"}
+    end
+  end
+  
+  describe ".set" do
+    it "should delegate to :create!" do
+      RudeQueue.should_receive(:create!).with(:queue_name => 'abcde', :data => :magical_planet)
+      RudeQueue.set('abcde', :magical_planet)
+    end
+    it "should return nil" do
+      RudeQueue.set('abcde', "something").should be(nil)
+    end
+  end
+  
+  describe ".get" do    
+    it "should revert a record if something goes wrong before it finishes" do
+      RudeQueue.raise_on_processed = true
+      RudeQueue.set('abcde', :this_will_remain_unprocessed)
+      
+      # confirm the object is in the db
+      record = RudeQueue.find(:first, :order => "id DESC")
+      record.queue_name.should == 'abcde'
+      record.data.should == :this_will_remain_unprocessed
+      record.processed?.should == false
+      record.token.should == nil
+      
+      lambda {RudeQueue.get('abcde')}.should raise_error(RuntimeError)
+      
+      record.reload
+      record.queue_name.should == 'abcde'
+      record.data.should == :this_will_remain_unprocessed
+      record.processed?.should == false
+      record.token.should == nil
+    end
+  end
+
+  describe "fetch" do
+    describe "with data" do
+      
+      before(:each) do
+        RudeQueue.set(:fetch_queue, "some data")
+      end
+  
+      it "should return the value of the block" do
+        rtn = RudeQueue.fetch(:fetch_queue) do |data|
+          data.should == "some data"
+          :the_return
+        end
+        rtn.should == :the_return
+      end
+
+      it "should execute the block with the data" do
+        self.should_receive(:something)
+        RudeQueue.fetch(:fetch_queue) do |data|
+          self.something
+          data.should == "some data"
+        end
+      end
+
+    end
+
+    describe "without data" do
+
+      it "should not execute the block" do
+        self.should_not_receive(:something)
+        RudeQueue.fetch(:fetch_queue) do |data|
+          raise(Exception, "this should never get here")
+        end
+      end
+
+      it "should return nil" do
+        rtn = RudeQueue.fetch(:fetch_queue) do |data|
+          raise(Exception, "again this shouldnt happen")
+        end
+        rtn.should be_nil
+      end
+
+    end
+  end
+
+  describe "queue_options" do
+    describe :processed do
+      describe "set to :destroy" do
+        before(:each) do
+          @old_processed = RudeQueue.queue_options[:processed]
+          RudeQueue.queue_options[:processed] = :destroy
+        end
+        after(:each) do
+          RudeQueue.queue_options[:processed] = @old_processed
+        end
+        it "should delete processed items" do
+          count = RudeQueue.count
+          
+          RudeQueue.set(:abcde, "some value")
+          RudeQueue.count.should == (count + 1)
+          
+          RudeQueue.get(:abcde).should == "some value"
+          RudeQueue.count.should == count
+        end
+      end
+      describe "set to something crazy" do
+        before(:each) do
+          @old_processed = RudeQueue.queue_options[:processed]
+          RudeQueue.queue_options[:processed] = :something_crazy
+        end
+        after(:each) do
+          RudeQueue.queue_options[:processed] = @old_processed
+        end
+        it "should raise an exception" do
+          RudeQueue.set(:abcde, "some value")
+          lambda {RudeQueue.get(:abcde)}.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+  
+  describe ".backlog" do
+    it "should count the unprocessed items for the provided queue_name" do
+      RudeQueue.delete_all
+
+      RudeQueue.backlog(:abcde).should == 0
+      RudeQueue.backlog().should == 0
+
+      RudeQueue.set(:abcde, "a value")
+      RudeQueue.backlog(:abcde).should == 1
+      RudeQueue.backlog().should == 1
+
+      RudeQueue.set(:something_else, "another value")
+      3.times { RudeQueue.set(:abcde, :add_three_more)}
+      
+      RudeQueue.backlog(:abcde).should == 4
+      RudeQueue.backlog().should == 5
+
+      RudeQueue.get(:abcde).should == "a value"
+      RudeQueue.backlog(:abcde).should == 3
+      RudeQueue.backlog().should == 4
+    end
+  end
+
+  describe ".cleanup!" do
+    it "should use :delete_all" do
+      RudeQueue.should_receive(:delete_all) # not :destroy_all
+      RudeQueue.cleanup!
+    end
+    
+    it "should allow string inputs" do
+      RudeQueue.cleanup!("3600")
+    end
+    
+    it "should allow integer inputs" do
+      RudeQueue.cleanup!(3600)
+    end
+    
+    it "should not clear unprocessed items" do
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.set('abcde', :monkey)
+      RudeQueue.count.should >= 2
+      
+      RudeQueue.cleanup!
+      
+      RudeQueue.count.should >=2
+      RudeQueue.get('abcde').should == :giraffe
+    end
+    
+    it "should not clear old unprocessed items" do
+      RudeQueue.set('abcde', :giraffe)
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
+      
+      time_now = Time.now
+      Time.stub!(:now).and_return(time_now + 1.year)
+      
+      giraffe.updated_at.should < 2.weeks.ago
+      
+      RudeQueue.cleanup!
+      
+      giraffe.reload
+      RudeQueue.get('abcde').should == :giraffe
+    end
+    
+    it "should not clear processed items newer than the argument" do
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
+      
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
+      
+      time_now = Time.now
+      Time.stub!(:now).and_return(time_now + 1.week - 5.minutes)
+      
+      giraffe.updated_at.should > 1.week.ago
+      giraffe.processed.should be(true)
+      
+      RudeQueue.cleanup!(1.week)
+      
+      giraffe.reload
+    end
+    
+    it "should not clear processed items newer than one hour, by default" do
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
+      
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
+      
+      time_now = Time.now
+      Time.stub!(:now).and_return(time_now + 59.minutes)
+      
+      giraffe.updated_at.should > 1.hour.ago
+      giraffe.processed.should be(true)
+      
+      RudeQueue.cleanup!()
+      
+      giraffe.reload
+    end
+    
+    it "should clear processed items older than the argument" do
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
+      
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
+      
+      time_now = Time.now
+      Time.stub!(:now).and_return(time_now + 1.week + 5.minutes)
+      
+      giraffe.updated_at.should < 1.week.ago
+      giraffe.processed.should be(true)
+      
+      RudeQueue.cleanup!(1.week)
+      
+      lambda { giraffe.reload }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+    
+    it "should clear processed items older than one hour, by default" do
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
+      
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
+      
+      time_now = Time.now()
+      Time.stub!(:now).and_return(time_now + 61.minutes)
+      
+      giraffe.updated_at.should < 1.hour.ago
+      giraffe.processed.should be(true)
+      
+      RudeQueue.cleanup!
+      
+      lambda { giraffe.reload }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+  end
+end
+
+describe RudeQ::TokenLock do
+
+  describe ".get_unique_token" do
+    it "should create a unique token" do
+      lots_of_tokens = Array.new(50) do
+        RudeQ::TokenLock.get_unique_token
+      end
+      lots_of_tokens.uniq.should == lots_of_tokens
+    end
+    
+    it "should create a unique token even if time stands still" do
+      time_now = Time.now
+      Time.should_receive(:now).at_least(50).times.and_return(time_now)
+      lots_of_tokens = Array.new(50) do
+        RudeQ::TokenLock.get_unique_token
+      end
+      lots_of_tokens.uniq.should == lots_of_tokens
+    end
+  end
+  
+  # it "should not return a processed item with the same token" do
+  #   @token = "tokEEEannn"
+  # 
+  #   RudeQ::TokenLock.should respond_to(:get_unique_token) # ensure our stub is safe
+  #   RudeQ::TokenLock.should_receive(:get_unique_token).exactly(3).times.and_return(@token)
+  # 
+  #   @existing = RudeQueue.create!(:queue_name => 'abcde', :data => :old_data, :token => @token, :processed => true)
+  # 
+  #   RudeQueue.get('abcde').should be(nil)
+  #     
+  #   RudeQueue.set('abcde', :new_data)
+  #   RudeQueue.get('abcde').should == :new_data
+  #   RudeQueue.get('abcde').should be(nil)
+  # end
+  
+end

data/spec/schema.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :rude_queues, :force => true do |t|
+    t.string :queue_name
+    t.text :data
+    t.string :token, :default => nil
+    t.boolean :processed, :default => false, :null => false
+
+    t.timestamps
+  end
+  add_index :rude_queues, :processed
+  add_index :rude_queues, [:queue_name, :processed]
+
+  create_table :somethings, :force => true do |t|
+    t.string :name
+    t.integer :count
+    
+    t.timestamps
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+specdoc
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'spec'
+require 'active_record'
+
+current_dir = File.dirname(__FILE__)
+require "#{current_dir}/../lib/rude_q"
+require "#{current_dir}/../lib/rude_q/worker"
+require "#{current_dir}/../lib/rude_q/scope"
+require "#{current_dir}/models/rude_queue"
+require "#{current_dir}/models/something" 
+config = YAML::load(IO.read(current_dir + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(current_dir + "/debug.log")
+ActiveRecord::Base.establish_connection(config['rude_q_test'])
+load(current_dir + "/schema.rb")

data/spec/worker_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class ExampleWorker < RudeQ::Worker
+  def queue_name
+    :some_queue
+  end
+
+  # for the test, we'll just append each bit of data to a variable
+  attr_accessor :processed_data
+
+  def do_work(data)
+    self.processed_data ||= []
+    self.processed_data << data
+  end
+end
+
+describe RudeQ::Worker do
+  before(:each) do
+    @it = ExampleWorker.new
+    RudeQueue.delete_all
+  end
+  
+  describe "queue" do
+    it "should expose RudeQueue.get scoped for the worker's queue" do
+      RudeQueue.set(:some_queue, ["some data for the worker"])
+      @it.queue.get.should == ["some data for the worker"]
+    end
+
+    it "should expose RudeQueue.set scoped for the worker's queue" do
+      @it.queue.set(:some_other_data_for_the_worker)
+      RudeQueue.get(:some_queue).should == :some_other_data_for_the_worker
+    end
+
+    it "should expose RudeQueue.backlog scoped for the worker's queue" do
+      RudeQueue.set(:who_knows, 1)
+      RudeQueue.set(:my_mum, 23)
+
+      RudeQueue.backlog.should == 2
+      RudeQueue.backlog(:some_queue).should == 0
+      @it.queue.backlog.should == 0
+
+      RudeQueue.set(:some_queue, "purple")
+
+      RudeQueue.backlog.should == 3
+      RudeQueue.backlog(:some_queue).should == 1
+      @it.queue.backlog.should == 1
+    end
+  end
+end

data/tasks/rails.rake

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '/../lib/rude_q/tasks')

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: gustin-rudeq
+version: !ruby/object:Gem::Version 
+  version: 2.1.0.2
+platform: ruby
+authors: 
+- Matthew Rudy Jacobs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A simple DB queueing library built on top of ActiveRecord.
+email: MatthewRudyJacobs@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile
+- MIT-LICENSE
+- lib/rude_q/worker.rb
+- lib/rude_q/scope.rb
+- lib/rude_q.rb
+- generators/rude_q/templates/rude_q_model.rb
+- generators/rude_q/templates/rude_q_model_spec.rb
+- generators/rude_q/templates/rude_q_migration.rb
+- generators/rude_q/rude_q_generator.rb
+- generators/rude_q/USAGE
+- spec/spec.opts
+- spec/worker_spec.rb
+- spec/spec_helper.rb
+- spec/database.yml
+- spec/rude_q_spec.rb
+- spec/models/rude_queue.rb
+- spec/models/something.rb
+- spec/schema.rb
+- tasks/rails.rake
+- lib/rude_q/tasks.rb
+has_rdoc: true
+homepage: http://github.com/matthewrudy/rudeq
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+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: ActiveRecord-based DB-queue
+test_files: 
+- spec/rude_q_spec.rb
+- spec/worker_spec.rb