queue_classic 2.0.0rc14 → 2.0.0

data/lib/queue_classic/queries.rb

@@ -34,7 +34,7 @@ module QC
 
     def delete_all(q_name=nil)
       s = "DELETE FROM #{TABLE_NAME}"
-      s << "WHERE q_name = $1" if q_name
+      s << " WHERE q_name = $1" if q_name
       Conn.execute(*[s, q_name].compact)
     end
 

data/lib/queue_classic/queue.rb

@@ -20,12 +20,12 @@ module QC
       Queries.delete(id)
     end
 
-    def delete_all(q_name=nil)
-      Queries.delete_all(q_name)
+    def delete_all
+      Queries.delete_all(@name)
     end
 
-    def count(q_name=nil)
-      Queries.count(q_name)
+    def count
+      Queries.count(@name)
     end
 
   end

data/lib/queue_classic/tasks.rb

@@ -1,3 +1,5 @@
+task :environment
+
 namespace :jobs do
   desc "Alias for qc:work"
   task :work  => "qc:work"
@@ -11,7 +13,7 @@ namespace :qc do
 
   desc "Returns the number of jobs in the (default or QUEUE) queue"
   task :count => :environment do
-    QC::Worker.new.queue.count
+    puts QC::Worker.new.queue.count
   end
 
   desc "Setup queue_classic tables and funtions in database"

data/readme.md

@@ -1,10 +1,10 @@
 # queue_classic
 
-v2.0.0rc14
+v2.0.0
 
-queue_classic is a PostgreSQL-backed queueing library that is focused on
-concurrent job locking, minimizing database load & providing a simple &
-intuitive user experience.
+queue_classic provides PostgreSQL-backed queueing focused on concurrent job
+locking and minimizing database load while providing a simple, intuitive user
+experience.
 
 queue_classic features:
 
@@ -19,24 +19,24 @@ queue_classic features:
 
 ## Proven
 
-queue_classic was designed out of necessity. I needed a message queue that was
-fast, reliable, and low maintenance. It was built upon PostgreSQL out of a motivation
-of not wanting to add a redis or 0MQ service to my network of services. It boasts
-a small API and very few features. It was designed to be simple. Thus, if you need
-advanced queueing features, queue_classic is not for you; try 0MQ, rabbitmq, or redis.
-But if you are already running a PostgreSQL database, and you need a simple mechanism to
-distribute jobs to worker processes, then queue_classic is exactly what you need to be using.
+queue_classic was designed out of the necessity for a fast, reliable, low
+maintenance message queue.  It was built upon PostgreSQL to avoid the necessity
+of adding redis or 0MQ services to my applications. It was designed to be
+simple, with a small API and very few features. For a simple mechanism to
+distribute jobs to worker processes, especially if you are already running
+PostgreSQL, queue_classic is exactly what you should be using. If you need
+more advanced queueing features, you should investigate 0MQ, rabbitmq, or redis.
 
 ### Heroku Postgres
 
 The Heroku Postgres team uses queue_classic to monitor the health of
-customer databases. They process 200 jobs per second using a [fugu](https://postgres.heroku.com/pricing)
+customer databases, processng 200 jobs per second using a [fugu](https://postgres.heroku.com/pricing)
 database. They chose queue_classic because of its simplicity and reliability.
 
 ### Cloudapp
 
-Larry uses queue_classic to deliver cloudapp's push notifications and to collect file meta-data from S3.
-Cloudapp processes nearly 14 jobs per second.
+Larry uses queue_classic to deliver cloudapp's push notifications and collect
+file meta-data from S3, processing nearly 14 jobs per second.
 
 ```
 I haven't even touched QC since setting it up.
@@ -48,8 +48,8 @@ The best queue is the one you don't have to hand hold.
 ## Setup
 
 In addition to installing the rubygem, you will need to prepare your database.
-Database preperation includes creating a table and loading PL/pgSQL functions.
-You can issue the database preperation commands using **PSQL(1)** or place them in a
+Database preparation includes creating a table and loading PL/pgSQL functions.
+You can issue the database preparation commands using **PSQL(1)** or place them in a
 database migration.
 
 ### Quick Start
@@ -69,7 +69,7 @@ $ ruby -r queue_classic -e "QC::Worker.new.work"
 
 ```ruby
 source :rubygems
-gem "queue_classic", "2.0.0rc1"
+gem "queue_classic", "2.0.0"
 ```
 
 **Rakefile**
@@ -86,6 +86,10 @@ require "queue_classic/tasks"
 ENV["DATABASE_URL"] = "postgres://username:password@localhost/database_name"
 ```
 
+queue_classic requires a database table and a PL/pgSQL function to be loaded
+into your database. You can load the table and the function by running a migration
+or using a rake task.
+
 **db/migrations/add_queue_classic.rb**
 
 ```ruby
@@ -104,6 +108,17 @@ class AddQueueClassic < ActiveRecord::Migration
 end
 ```
 
+**Rake Task**
+
+```bash
+# Creating the table and functions
+$ bundle exec rake qc:create
+
+# Dropping the table and functions
+$ bundle exec rake qc:drop
+```
+
+
 ### Sequel Setup
 
 **db/migrations/1_add_queue_classic.rb**
@@ -179,7 +194,7 @@ read up on [OkJson](https://github.com/kr/okjson)
 
 The table containing the jobs has a column named *q_name*. This column
 is the abstraction queue_classic uses to represent multiple queues. This allows
-the programmer to place triggers and indecies on distinct queues.
+the programmer to place triggers and indexes on distinct queues.
 
 ```ruby
 # attach to the priority_queue. this will insert
@@ -203,7 +218,7 @@ p_queue.enqueue("Kernel.puts", ["hello", "world"])
 ```
 
 This code example shows how to produce jobs into a custom queue,
-to consume jobs from the custome queue be sure and set the `$QUEUE`
+to consume jobs from the custom queue be sure and set the `$QUEUE`
 var to the q_name in the worker's UNIX environment.
 
 ### Consumer
@@ -263,7 +278,7 @@ class MyWorker < QC::Worker
 
   # retry the job
   def handle_failure(job, exception)
-    @queue.enque(job[:method], job[:args])
+    @queue.enqueue(job[:method], job[:args])
   end
 
   # the forked proc needs a new db connection
@@ -358,9 +373,9 @@ $ export QC_LISTENING_WORKER='true'
 
 ##### Failure
 
-I bet your worker will encounter a job that raises an exception. Queue_classic
+I bet your worker will encounter a job that raises an exception. queue_classic
 thinks that you should know about this exception by means of you established
-exception tracker. (i.e. Hoptoad, Exceptional) To that end, Queue_classic offers
+exception tracker. (i.e. Hoptoad, Exceptional) To that end, queue_classic offers
 a method that you can override. This method will be passed 2 arguments: the
 exception instance and the job. Here are a few examples of things you might want
 to do inside `handle_failure()`.
@@ -382,19 +397,19 @@ lib=queue_classic level=info action=insert_job elapsed=16
 
 Author: [@em_csquared](https://twitter.com/#!/em_csquared)
 
-I was tesing some code that started out handling some work in a web request and
+I was testing some code that started out handling some work in a web request and
 wanted to move that work over to a queue.  After completing a red-green-refactor
 I did not want my tests to have to worry about workers or even hit the database.
 
-Turns out its easy to get QueueClassic to just work in a synchronous way with:
+Turns out its easy to get queue_classic to just work in a synchronous way with:
 
 ```ruby
 def QC.enqueue(function_call, *args)
-  eval("#{function_call} *args")
+  eval("#{function_call} *#{args.inspect}")
 end
 ```
 
-Now you can test QueueClassic as if it was calling your method directly!
+Now you can test queue_classic as if it was calling your method directly!
 
 
 ### Dispatching new jobs to workers without new code
@@ -409,7 +424,7 @@ these objects. queue_classic to the rescue! (no pun intended)
 
 The API of queue_classic enables you to quickly dispatch jobs to workers. In my
 case I wanted to call `Invoice.destroy(id)` a few thousand times. I fired up a
-heroku console session and executed this line:
+Heroku console session and executed this line:
 
 ```ruby
 Invoice.find(:all, :select => "id", :conditions => "some condition").map {|i| QC.enqueue("Invoice.destroy", i.id) }
@@ -490,7 +505,7 @@ SalesSummaryGenerator class.
 
 I found this abstraction quite powerful and easy to understand. Like
 queue_classic, the clockwork gem is simple to understand and has 0 dependencies.
-In production, I create a heroku process type called clock. This is typically
+In production, I create a Heroku process type called clock. This is typically
 what my Procfile looks like:
 
 ```

data/sql/drop_ddl.sql

@@ -1,3 +1,2 @@
 DROP FUNCTION IF EXISTS lock_head(tname varchar);
-DROP FUNCTION IF EXISTS lock_head(tname name, top_boundary integer);
 DROP FUNCTION IF EXISTS lock_head(q_name varchar, top_boundary integer)

data/test/queue_test.rb

@@ -36,6 +36,18 @@ class QueueTest < QCTest
     assert_equal(0, QC.count)
   end
 
+  def test_delete_all_by_queue_name
+    p_queue = QC::Queue.new("priority_queue")
+    s_queue = QC::Queue.new("secondary_queue")
+    p_queue.enqueue("Klass.method")
+    s_queue.enqueue("Klass.method")
+    assert_equal(1, p_queue.count)
+    assert_equal(1, s_queue.count)
+    p_queue.delete_all
+    assert_equal(0, p_queue.count)
+    assert_equal(1, s_queue.count)
+  end
+
   def test_queue_instance
     queue = QC::Queue.new("queue_classic_jobs", false)
     queue.enqueue("Klass.method")

metadata

@@ -1,19 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: queue_classic
 version: !ruby/object:Gem::Version
-  version: 2.0.0rc14
-  prerelease: 5
+  version: 2.0.0
+  prerelease: 
 platform: ruby
 authors:
-- Ryan Smith (ace hacker)
+- Ryan Smith (♠ ace hacker)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-29 00:00:00.000000000Z
+date: 2012-02-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
-  requirement: &12898980 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,15 @@ dependencies:
         version: 0.13.2
   type: :runtime
   prerelease: false
-  version_requirements: *12898980
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.2
 - !ruby/object:Gem::Dependency
   name: scrolls
-  requirement: &12897580 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +37,12 @@ dependencies:
         version: 0.0.8
   type: :runtime
   prerelease: false
-  version_requirements: *12897580
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.8
 description: queue_classic is a queueing library for Ruby apps. (Rails, Sinatra, Etc...)
   queue_classic features asynchronous job polling, database maintained locks and no
   ridiculous dependencies. As a matter of fact, queue_classic only requires pg.
@@ -42,20 +52,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - readme.md
-- sql/ddl.sql
 - sql/create_table.sql
+- sql/ddl.sql
 - sql/drop_ddl.sql
 - lib/queue_classic/conn.rb
 - lib/queue_classic/okjson.rb
-- lib/queue_classic/worker.rb
+- lib/queue_classic/queries.rb
 - lib/queue_classic/queue.rb
-- lib/queue_classic/tasks.rb
 - lib/queue_classic/setup.rb
-- lib/queue_classic/queries.rb
+- lib/queue_classic/tasks.rb
+- lib/queue_classic/worker.rb
 - lib/queue_classic.rb
-- test/worker_test.rb
-- test/queue_test.rb
 - test/helper.rb
+- test/queue_test.rb
+- test/worker_test.rb
 homepage: http://github.com/ryandotsmith/queue_classic
 licenses: []
 post_install_message: 
@@ -71,15 +81,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: postgres backed queue
 test_files:
-- test/worker_test.rb
 - test/queue_test.rb
+- test/worker_test.rb