matthewrudy-rudeq 2.0 → 2.1.0

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/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

@@ -1,5 +1,4 @@
 # RudeQ
-require 'digest/sha1'
 
 # simply doing;
 #   class RudeQueue < ActiveRecord::Base
@@ -12,9 +11,18 @@ module RudeQ
 
   def self.included(mod) # :nodoc:
     mod.extend(ClassMethods)
-    mod.serialize(:data)
+    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
     #
@@ -25,7 +33,6 @@ module RudeQ
     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))
     #
@@ -37,6 +44,7 @@ module RudeQ
     #   -> 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
@@ -86,9 +94,20 @@ module RudeQ
     end
 
     # A snapshot count of unprocessed items for the given +queue_name+
-    def backlog(queue_name)
-      qname = sanitize_queue_name(queue_name)
-      self.count(:conditions => {:queue_name => qname, :processed => false})
+    #
+    #   >> 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:
@@ -126,6 +145,12 @@ module RudeQ
       @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:
@@ -161,9 +186,12 @@ module RudeQ
   # 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")
@@ -188,5 +216,5 @@ module RudeQ
       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/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/{process_queue.rb → models/rude_queue.rb}

@@ -1,4 +1,4 @@
-class ProcessQueue < ActiveRecord::Base
+class RudeQueue < ActiveRecord::Base
   include RudeQ
   
   class << self
@@ -10,4 +10,5 @@ class ProcessQueue < ActiveRecord::Base
     attr_accessor :raise_on_processed
   end
     
-end
+end
+

data/spec/models/something.rb

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

data/spec/rude_q_spec.rb

@@ -1,111 +1,117 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
+describe RudeQ::ClassMethods do # RudeQueue extends ClassMethods
   before(:each) do
-    ProcessQueue.delete_all
-    ProcessQueue.raise_on_processed = false
+    RudeQueue.delete_all
+    RudeQueue.raise_on_processed = false
     create_some_noise
   end
   
   def create_some_noise
-    ProcessQueue.create!(:queue_name => "doNT use this in Specs", :data => {:not => "to be messed with"})
-    ProcessQueue.create!(:queue_name => "abcde", :data => {:same_as => "the specs but already processed"}, :processed => true)
+    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
-      ProcessQueue.set('abcde', "Something to set")
-      ProcessQueue.get('abcde').should == "Something to set"
+      RudeQueue.set('abcde', "Something to set")
+      RudeQueue.get('abcde').should == "Something to set"
     end
     it "should work with symbols" do
-      ProcessQueue.set('abcde', :a_symbol)
-      ProcessQueue.get('abcde').should == :a_symbol
+      RudeQueue.set('abcde', :a_symbol)
+      RudeQueue.get('abcde').should == :a_symbol
     end
     it "should work with arrays" do
       array = [1, :b, "C"]
-      ProcessQueue.set('abcde', array)
-      ProcessQueue.get('abcde').should == array
+      RudeQueue.set('abcde', array)
+      RudeQueue.get('abcde').should == array
     end
     it "should work with hashes" do
       hash = {:symbol => "A string", "stringy" => 23, 74 => :cheese}
-      ProcessQueue.set('abcde', hash)
-      ProcessQueue.get('abcde').should == hash
+      RudeQueue.set('abcde', hash)
+      RudeQueue.get('abcde').should == hash
     end
     it "should work with integers" do
-      ProcessQueue.set('abcde', 7816327370)
-      ProcessQueue.get('abcde').should == 7816327370
+      RudeQueue.set('abcde', 7816327370)
+      RudeQueue.get('abcde').should == 7816327370
     end
-    it "unfortunately doesnt resolve booleans correctly" do
-      ProcessQueue.set('abcde', true)
-      ProcessQueue.get('abcde').should == 1
+    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
       
-      ProcessQueue.set('abcde', false)
-      ProcessQueue.get('abcde').should == 0
+      RudeQueue.set('abcde', false)
+      RudeQueue.get('abcde').should == false
     end
     
     it "should :get in the same order they are :set" do
-      ProcessQueue.set('abcde', :first)
-      ProcessQueue.set('abcde', "second")
+      RudeQueue.set('abcde', :first)
+      RudeQueue.set('abcde', "second")
       
-      ProcessQueue.get('abcde').should == :first
+      RudeQueue.get('abcde').should == :first
       
-      ProcessQueue.set('abcde', 33.3333)
+      RudeQueue.set('abcde', 33.3333)
       
-      ProcessQueue.get('abcde').should == "second"
-      ProcessQueue.get('abcde').should == 33.3333
-      ProcessQueue.get('abcde').should be(nil)
+      RudeQueue.get('abcde').should == "second"
+      RudeQueue.get('abcde').should == 33.3333
+      RudeQueue.get('abcde').should be(nil)
     end
     
     it "should keep queues seperated" do
-      ProcessQueue.set('queue_1', :data_1)
-      ProcessQueue.set('queue_2', "DATA2")
+      RudeQueue.set('queue_1', :data_1)
+      RudeQueue.set('queue_2', "DATA2")
       
-      ProcessQueue.get('queue_2').should == "DATA2"
-      ProcessQueue.get('queue_2').should be(nil)
-      ProcessQueue.get('queue_1').should == :data_1
-      ProcessQueue.get('queue_1').should be(nil)
+      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")
       
-      ProcessQueue.set(qname, ["Data"])
-      ProcessQueue.get(qname).should == ["Data"]
+      RudeQueue.set(qname, ["Data"])
+      RudeQueue.get(qname).should == ["Data"]
     end
     
     it "should work with queue name as strings or symbols" do
-      ProcessQueue.set(:bah, "something about bah")
-      ProcessQueue.get("bah").should == "something about bah"
+      RudeQueue.set(:bah, "something about bah")
+      RudeQueue.get("bah").should == "something about bah"
       
-      ProcessQueue.set("girah", {:craziness => "embodied"})
-      ProcessQueue.get(:girah).should == {:craziness => "embodied"}
+      RudeQueue.set("girah", {:craziness => "embodied"})
+      RudeQueue.get(:girah).should == {:craziness => "embodied"}
     end
   end
   
   describe ".set" do
     it "should delegate to :create!" do
-      ProcessQueue.should_receive(:create!).with(:queue_name => 'abcde', :data => :magical_planet)
-      ProcessQueue.set('abcde', :magical_planet)
+      RudeQueue.should_receive(:create!).with(:queue_name => 'abcde', :data => :magical_planet)
+      RudeQueue.set('abcde', :magical_planet)
     end
     it "should return nil" do
-      ProcessQueue.set('abcde', "something").should be(nil)
+      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
-      ProcessQueue.raise_on_processed = true
-      ProcessQueue.set('abcde', :this_will_remain_unprocessed)
+      RudeQueue.raise_on_processed = true
+      RudeQueue.set('abcde', :this_will_remain_unprocessed)
       
       # confirm the object is in the db
-      record = ProcessQueue.find(:first, :order => "id DESC")
+      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 {ProcessQueue.get('abcde')}.should raise_error(RuntimeError)
+      lambda {RudeQueue.get('abcde')}.should raise_error(RuntimeError)
       
       record.reload
       record.queue_name.should == 'abcde'
@@ -119,11 +125,11 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
     describe "with data" do
       
       before(:each) do
-        ProcessQueue.set(:fetch_queue, "some data")
+        RudeQueue.set(:fetch_queue, "some data")
       end
   
       it "should return the value of the block" do
-        rtn = ProcessQueue.fetch(:fetch_queue) do |data|
+        rtn = RudeQueue.fetch(:fetch_queue) do |data|
           data.should == "some data"
           :the_return
         end
@@ -132,7 +138,7 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
 
       it "should execute the block with the data" do
         self.should_receive(:something)
-        ProcessQueue.fetch(:fetch_queue) do |data|
+        RudeQueue.fetch(:fetch_queue) do |data|
           self.something
           data.should == "some data"
         end
@@ -144,13 +150,13 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
 
       it "should not execute the block" do
         self.should_not_receive(:something)
-        ProcessQueue.fetch(:fetch_queue) do |data|
+        RudeQueue.fetch(:fetch_queue) do |data|
           raise(Exception, "this should never get here")
         end
       end
 
       it "should return nil" do
-        rtn = ProcessQueue.fetch(:fetch_queue) do |data|
+        rtn = RudeQueue.fetch(:fetch_queue) do |data|
           raise(Exception, "again this shouldnt happen")
         end
         rtn.should be_nil
@@ -163,33 +169,33 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
     describe :processed do
       describe "set to :destroy" do
         before(:each) do
-          @old_processed = ProcessQueue.queue_options[:processed]
-          ProcessQueue.queue_options[:processed] = :destroy
+          @old_processed = RudeQueue.queue_options[:processed]
+          RudeQueue.queue_options[:processed] = :destroy
         end
         after(:each) do
-          ProcessQueue.queue_options[:processed] = @old_processed
+          RudeQueue.queue_options[:processed] = @old_processed
         end
         it "should delete processed items" do
-          count = ProcessQueue.count
+          count = RudeQueue.count
           
-          ProcessQueue.set(:abcde, "some value")
-          ProcessQueue.count.should == (count + 1)
+          RudeQueue.set(:abcde, "some value")
+          RudeQueue.count.should == (count + 1)
           
-          ProcessQueue.get(:abcde).should == "some value"
-          ProcessQueue.count.should == count
+          RudeQueue.get(:abcde).should == "some value"
+          RudeQueue.count.should == count
         end
       end
       describe "set to something crazy" do
         before(:each) do
-          @old_processed = ProcessQueue.queue_options[:processed]
-          ProcessQueue.queue_options[:processed] = :something_crazy
+          @old_processed = RudeQueue.queue_options[:processed]
+          RudeQueue.queue_options[:processed] = :something_crazy
         end
         after(:each) do
-          ProcessQueue.queue_options[:processed] = @old_processed
+          RudeQueue.queue_options[:processed] = @old_processed
         end
         it "should raise an exception" do
-          ProcessQueue.set(:abcde, "some value")
-          lambda {ProcessQueue.get(:abcde)}.should raise_error(ArgumentError)
+          RudeQueue.set(:abcde, "some value")
+          lambda {RudeQueue.get(:abcde)}.should raise_error(ArgumentError)
         end
       end
     end
@@ -197,66 +203,72 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
   
   describe ".backlog" do
     it "should count the unprocessed items for the provided queue_name" do
-      ProcessQueue.backlog(:abcde).should == 0
-      
-      ProcessQueue.set(:abcde, "a value")
-      ProcessQueue.backlog(:abcde).should == 1
-      
-      ProcessQueue.set(:something_else, "another value")
-      3.times { ProcessQueue.set(:abcde, :add_three_more)}
-      
-      ProcessQueue.backlog(:abcde).should == 4
+      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)}
       
-      ProcessQueue.get(:abcde).should == "a value"
-      ProcessQueue.backlog(:abcde).should == 3
+      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
-      ProcessQueue.should_receive(:delete_all) # not :destroy_all
-      ProcessQueue.cleanup!
+      RudeQueue.should_receive(:delete_all) # not :destroy_all
+      RudeQueue.cleanup!
     end
     
     it "should allow string inputs" do
-      ProcessQueue.cleanup!("3600")
+      RudeQueue.cleanup!("3600")
     end
     
     it "should allow integer inputs" do
-      ProcessQueue.cleanup!(3600)
+      RudeQueue.cleanup!(3600)
     end
     
     it "should not clear unprocessed items" do
-      ProcessQueue.set('abcde', :giraffe)
-      ProcessQueue.set('abcde', :monkey)
-      ProcessQueue.count.should >= 2
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.set('abcde', :monkey)
+      RudeQueue.count.should >= 2
       
-      ProcessQueue.cleanup!
+      RudeQueue.cleanup!
       
-      ProcessQueue.count.should >=2
-      ProcessQueue.get('abcde').should == :giraffe
+      RudeQueue.count.should >=2
+      RudeQueue.get('abcde').should == :giraffe
     end
     
     it "should not clear old unprocessed items" do
-      ProcessQueue.set('abcde', :giraffe)
-      giraffe = ProcessQueue.find(:first, :conditions => {:data => :giraffe})
+      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
       
-      ProcessQueue.cleanup!
+      RudeQueue.cleanup!
       
       giraffe.reload
-      ProcessQueue.get('abcde').should == :giraffe
+      RudeQueue.get('abcde').should == :giraffe
     end
     
     it "should not clear processed items newer than the argument" do
-      ProcessQueue.set('abcde', :giraffe)
-      ProcessQueue.get('abcde').should == :giraffe
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
       
-      giraffe = ProcessQueue.find(:first, :conditions => {:data => :giraffe})
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
       
       time_now = Time.now
       Time.stub!(:now).and_return(time_now + 1.week - 5.minutes)
@@ -264,16 +276,16 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
       giraffe.updated_at.should > 1.week.ago
       giraffe.processed.should be(true)
       
-      ProcessQueue.cleanup!(1.week)
+      RudeQueue.cleanup!(1.week)
       
       giraffe.reload
     end
     
     it "should not clear processed items newer than one hour, by default" do
-      ProcessQueue.set('abcde', :giraffe)
-      ProcessQueue.get('abcde').should == :giraffe
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
       
-      giraffe = ProcessQueue.find(:first, :conditions => {:data => :giraffe})
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
       
       time_now = Time.now
       Time.stub!(:now).and_return(time_now + 59.minutes)
@@ -281,16 +293,16 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
       giraffe.updated_at.should > 1.hour.ago
       giraffe.processed.should be(true)
       
-      ProcessQueue.cleanup!()
+      RudeQueue.cleanup!()
       
       giraffe.reload
     end
     
     it "should clear processed items older than the argument" do
-      ProcessQueue.set('abcde', :giraffe)
-      ProcessQueue.get('abcde').should == :giraffe
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
       
-      giraffe = ProcessQueue.find(:first, :conditions => {:data => :giraffe})
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
       
       time_now = Time.now
       Time.stub!(:now).and_return(time_now + 1.week + 5.minutes)
@@ -298,16 +310,16 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
       giraffe.updated_at.should < 1.week.ago
       giraffe.processed.should be(true)
       
-      ProcessQueue.cleanup!(1.week)
+      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
-      ProcessQueue.set('abcde', :giraffe)
-      ProcessQueue.get('abcde').should == :giraffe
+      RudeQueue.set('abcde', :giraffe)
+      RudeQueue.get('abcde').should == :giraffe
       
-      giraffe = ProcessQueue.find(:first, :conditions => {:data => :giraffe})
+      giraffe = RudeQueue.find(:first, :conditions => {:data => :giraffe})
       
       time_now = Time.now()
       Time.stub!(:now).and_return(time_now + 61.minutes)
@@ -315,7 +327,7 @@ describe RudeQ::ClassMethods do # ProcessQueue extends ClassMethods
       giraffe.updated_at.should < 1.hour.ago
       giraffe.processed.should be(true)
       
-      ProcessQueue.cleanup!
+      RudeQueue.cleanup!
       
       lambda { giraffe.reload }.should raise_error(ActiveRecord::RecordNotFound)
     end
@@ -348,13 +360,13 @@ describe RudeQ::TokenLock do
   #   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 = ProcessQueue.create!(:queue_name => 'abcde', :data => :old_data, :token => @token, :processed => true)
+  #   @existing = RudeQueue.create!(:queue_name => 'abcde', :data => :old_data, :token => @token, :processed => true)
   # 
-  #   ProcessQueue.get('abcde').should be(nil)
+  #   RudeQueue.get('abcde').should be(nil)
   #     
-  #   ProcessQueue.set('abcde', :new_data)
-  #   ProcessQueue.get('abcde').should == :new_data
-  #   ProcessQueue.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

@@ -1,5 +1,5 @@
 ActiveRecord::Schema.define(:version => 1) do
-  create_table :process_queues, :force => true do |t|
+  create_table :rude_queues, :force => true do |t|
     t.string :queue_name
     t.text :data
     t.string :token, :default => nil
@@ -7,6 +7,13 @@ ActiveRecord::Schema.define(:version => 1) do
 
     t.timestamps
   end
-  add_index :process_queues, :processed
-  add_index :process_queues, [:queue_name, :processed]
-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_helper.rb

@@ -4,9 +4,11 @@ require 'active_record'
 
 current_dir = File.dirname(__FILE__)
 require "#{current_dir}/../lib/rude_q"
-require "#{current_dir}/process_queue"
- 
+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")
+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/rude_q_tasks.rake

@@ -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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: matthewrudy-rudeq
 version: !ruby/object:Gem::Version 
-  version: "2.0"
+  version: 2.1.0
 platform: ruby
 authors: 
 - Matthew Rudy Jacobs
@@ -9,11 +9,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-02-12 00:00:00 -08:00
+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: 
@@ -32,13 +33,24 @@ extra_rdoc_files:
 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/process_queue.rb
 - spec/rude_q_spec.rb
+- spec/models/rude_queue.rb
+- spec/models/something.rb
 - spec/schema.rb
-- spec/spec.opts
-- spec/spec_helper.rb
+- tasks/rude_q_tasks.rake
 has_rdoc: true
 homepage: http://github.com/matthewrudy/rudeq
 post_install_message: 
@@ -68,3 +80,4 @@ specification_version: 2
 summary: ActiveRecord-based DB-queue
 test_files: 
 - spec/rude_q_spec.rb
+- spec/worker_spec.rb