karait 0.0.7 → 0.0.8

data/.gitignore

@@ -0,0 +1,14 @@
+html
+pkg
+doc
+*.gem
+nbproject
+*.bundle
+*.o
+*~
+*#*
+*.class
+*.swp
+*.pid
+*.log
+=*

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+gem "mongo", "~> 1.3.1"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bson (1.3.1)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    mongo (1.3.1)
+      bson (>= 1.3.1)
+    rake (0.9.2)
+    rcov (0.9.10)
+    shoulda (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  mongo (~> 1.3.1)
+  rcov
+  shoulda

data/Rakefile

@@ -0,0 +1,53 @@
+# 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 = "karait"
+  gem.homepage = "http://github.com/bcoe/karait"
+  gem.license = "MIT"
+  gem.summary = %Q{A ridiculously simple cross-language queuing system, built on top of MongoDB.}
+  gem.description = %Q{A ridiculously simple cross-language queuing system, built on top of MongoDB.}
+  gem.email = "bencoe@gmail.com"
+  gem.authors = ["bcoe"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "karait #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.8

data/karait.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "karait"
+  s.version = "0.0.8"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["bcoe"]
+  s.date = "2011-11-12"
+  s.description = "A ridiculously simple cross-language queuing system, built on top of MongoDB."
+  s.email = "bencoe@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.markdown",
+    "Rakefile",
+    "VERSION",
+    "karait.gemspec",
+    "lib/karait.rb",
+    "lib/message.rb",
+    "lib/queue.rb",
+    "test/helper.rb",
+    "test/test_message.rb",
+    "test/test_queue.rb"
+  ]
+  s.homepage = "http://github.com/bcoe/karait"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.11"
+  s.summary = "A ridiculously simple cross-language queuing system, built on top of MongoDB."
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/karait.rb

@@ -0,0 +1,5 @@
+require 'message'
+require 'queue'
+
+module Karait
+end

data/lib/message.rb

@@ -0,0 +1,86 @@
+module Karait
+  class Message
+    
+    include Karait
+    
+    ASSIGN_VARIABLE_REGEX = /^([a-z_][a-zA-Z_0-9]*)=$/
+    VARIABLE_REGEX = /^([a-z_][a-zA-Z_0-9]*)$/
+    BLACKLIST = {
+        '_meta' => true,
+        '_id' => true,
+        '_expired' => true
+    }
+    
+    def initialize(raw_message={}, queue_collection=nil)
+      @source = raw_message
+      @queue_collection = queue_collection
+      @variables_to_serialize = {}
+      set_expired
+      add_accessors raw_message
+    end
+    
+    def to_hash
+      return @variables_to_serialize
+    end
+    
+    def delete
+      @queue_collection.update(
+          {
+              '_id' => @source['_id']
+          },
+          {
+              '$set' => {
+                  '_meta.expired' => true
+              }
+          }
+      )
+    end
+    
+    def expired?
+      return @expired
+    end
+    
+    def get(key)
+      return @variables_to_serialize[key.to_s]
+    end
+    
+    def _get_id
+      return @source['_id']
+    end
+    
+    private
+    
+    def set_expired
+      @expired = false
+      
+      current_time = Time.now().to_f
+      meta = @source.fetch('_meta', {})
+      
+      return if meta.fetch('expire', -1.0) <= -1.0
+      
+      if current_time - meta.fetch('timestamp', 0.0) > meta.fetch('expire', -1.0)
+        @expired = true
+        delete
+      end
+    end
+    
+    def add_accessors(hash)
+      hash.each do |k, v|
+        if not Message::BLACKLIST.has_key? k
+          @variables_to_serialize[k.to_s] = v
+        end
+      end
+    end
+    
+    def method_missing(sym, *args, &block)
+      if matches = sym.to_s.match(Message::ASSIGN_VARIABLE_REGEX) and args.count == 1
+        @variables_to_serialize[matches[1]] = args[0]
+      elsif matches = sym.to_s.match(Message::VARIABLE_REGEX) and args.count == 0
+        return @variables_to_serialize[matches[1]]
+      else
+        super(sym, *args, &block)
+      end
+    end
+    
+  end
+end

data/lib/queue.rb

@@ -0,0 +1,189 @@
+require 'mongo'
+
+module Karait
+  class Queue
+    
+    include Karait
+    
+    MESSAGES_READ = 10
+    NO_OBJECT_FOUND_ERROR = 'No matching object found'
+    
+    def initialize(opts={})
+      set_instance_variables opts
+      create_mongo_connection
+    end
+    
+    def write(message, opts={})
+      if message.class == Hash
+        message_dict = message
+      else
+        message_dict = message.to_hash
+      end
+      
+      message_dict[:_meta] = {
+        :expire => opts.fetch(:expire, -1.0),
+        :timestamp => Time.now().to_f,
+        :expired => false,
+        :visible_after => -1.0
+      }
+      
+      message_dict[:_meta][:routing_key] = opts.fetch(:routing_key) if opts[:routing_key]
+      
+      @queue_collection.insert(message_dict, :safe => true)
+    end
+    
+    def read(opts={})
+      opts = {
+        :messages_read => 10,
+        :visibility_timeout => -1.0,
+        :routing_key => nil,
+        :block => false,
+        :polling_interval => 1,
+        :polling_timeout => nil
+      }.update(opts)
+      
+      current_time = Time.new.to_f
+      messages = []
+      
+      query = {
+          '_meta.expired' => false,
+          '_meta.visible_after' => {
+            '$lt' => current_time
+          }
+      }
+      if opts[:routing_key] != nil
+        query['_meta.routing_key'] = opts[:routing_key]
+      else
+        query['_meta.routing_key'] = {
+          '$exists' => false
+        }
+      end
+      
+      update = false
+      if opts[:visibility_timeout] > -1.0
+        update = {
+            '$set' => {
+              '_meta.visible_after' => current_time + opts[:visibility_timeout]
+            }
+        }
+      end
+      
+      raw_messages = []
+      
+      # if we want to block, loop and sleep until messages are available (or we time out)
+      if opts[:block]
+        block_until_message_available( query, opts[:polling_interval], opts[:polling_timeout] )
+      end
+
+      if update
+        (0..opts[:messages_read]).each do
+          begin
+            
+            raw_message = @queue_collection.find_and_modify(:query => query, :update => update)
+            
+            if raw_message
+              raw_messages << raw_message
+            else
+              break
+            end
+          
+          rescue Mongo::OperationFailure => operation_failure
+            if not  operation_failure.to_s.match(Queue::NO_OBJECT_FOUND_ERROR)
+              raise operation_failure
+            end
+          end
+          
+        end
+      else
+        @queue_collection.find(query).limit(opts[:messages_read]).each do |raw_message|
+          raw_messages << raw_message
+        end
+      end
+      
+      raw_messages.each do |raw_message|
+        message = Karait::Message.new(raw_message=raw_message, queue_collection=@queue_collection)
+        if not message.expired?
+          messages << message
+        end
+      end
+      
+      return messages
+    end
+    
+    def delete_messages(messages)
+      ids = []
+      messages.each {|message| ids << message._get_id}
+      @queue_collection.update(
+          {
+              '_id' => {
+                '$in' => ids
+              }
+          },
+          {
+              '$set' => {
+                  '_meta.expired' => true
+              }
+          },
+          :multi => true,
+          :safe => true
+      )
+    end
+    
+    private
+    
+    def block_until_message_available(query, polling_interval=1.0, polling_timeout=None)
+        current_time = Time.new.to_f
+        
+        while @queue_collection.find(query).count() == 0
+            if polling_timeout and (Time.new.to_f - current_time) > polling_timeout
+                break
+            end
+            
+            sleep polling_interval
+        end
+    end
+    
+    def set_instance_variables(opts)
+      
+      defaults = {
+        :host => 'localhost',
+        :port => 27017,
+        :database => 'karait',
+        :queue => 'messages',
+        :average_message_size => 8192,
+        :queue_size => 4096
+      }.merge(opts)
+      
+      @host = defaults[:host]
+      @port = defaults[:port]
+      @database = defaults[:database]
+      @queue = defaults[:queue]
+      @average_message_size = defaults[:average_message_size]
+      @queue_size = defaults[:queue_size]
+      
+    end
+    
+    def create_mongo_connection
+      @connection = Mongo::Connection.new(
+        @host,
+        @port
+      )
+      @database = @connection[@database]
+      create_capped_collection
+      @queue_collection = @database[@queue]
+      @queue_collection.create_index('_id')
+      @queue_collection.create_index('_meta.routing_key')
+      @queue_collection.create_index('_meta.expired')
+      @queue_collection.create_index('_meta.visible_after')
+    end
+    
+    def create_capped_collection
+      @database.create_collection(
+        @queue,
+        :size => (@average_message_size * @queue_size),
+        :capped => true,
+        :max => @queue_size
+      )
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,18 @@
+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 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'karait'
+
+class Test::Unit::TestCase
+end

data/test/test_message.rb

@@ -0,0 +1,92 @@
+require 'helper'
+require 'karait'
+require 'yaml'
+
+class TestMessage < Test::Unit::TestCase
+  
+  def setup
+    Mongo::Connection.new()['karait_test']['queue_test'].drop()
+  end
+  
+  should "should add attribute accessors when initialized with a raw message" do
+    message = Karait::Message.new(
+      raw_message={
+        :apple => 5,
+        :banana => 3
+      }
+    )
+    
+    message.apple = 6
+    assert_equal 6, message.apple
+    assert_equal 3, message.banana
+  end
+  
+  should "add new attribute accessors for missing methods" do
+    message = Karait::Message.new
+    message.foo = 9
+    assert_equal 9, message.foo
+  end
+  
+  should "return a hash of appropriate instance variables when to_hash is called" do
+    message = Karait::Message.new(
+      raw_message={
+        :apple => 5,
+        :banana => 3
+      }
+    )
+    message.apple = 6
+    message.foo = {'bar' => 9}
+    message.bar = [27]
+    
+    hash = message.to_hash
+    
+    assert_equal 6, hash['apple']
+    assert_equal 3, hash['banana']
+    assert_equal 9, hash['foo']['bar']
+    assert_equal 27, hash['bar'][0]
+    assert_equal 4, hash.keys.count
+  end
+  
+  should "not copy blacklisted keys when to_hash called" do
+      raw_message = {
+          '_id' => 'foobar',
+          '_meta' => {
+              'foo' => 2
+          }
+      }
+      message = Karait::Message.new(raw_message=raw_message)
+      hash = message.to_hash
+      
+      assert_equal 0, hash.keys.count
+  end
+  
+  should "set expired to true when delete is called on a message" do
+      collection = Mongo::Connection.new()['karait_test']['queue_test']
+      collection.insert({
+          'routing_key' => 'foobar',
+          'apple' => 3,
+          'banana' => 5,
+          '_meta' => {
+              'timestamp' => 2523939,
+              'expire' => 20393,
+              'expired' => false
+          }
+      })
+      raw_message = collection.find_one({'_meta.expired' => false})
+      assert_equal 3, raw_message['apple']
+      message = Karait::Message.new(raw_message=raw_message, queue_collection=collection)
+      message.delete()
+      assert_equal 0, collection.find({'_meta.expired' => false}).count
+  end
+  
+  should "allow a get method to be called to retrieve keys that conflict with class variables, e.g., send" do
+    message = Karait::Message.new(
+      raw_message={
+        :send => 5,
+        :banana => 3
+      }
+    )
+    assert_equal 3, message.get(:banana)
+    assert_equal 5, message.get(:send)
+  end
+end

data/test/test_queue.rb

@@ -0,0 +1,254 @@
+require 'helper'
+require 'mongo'
+require 'karait'
+
+class TestQueue < Test::Unit::TestCase
+  
+  def setup
+    Mongo::Connection.new()['karait_test']['queue_test'].drop()
+  end
+  
+  should "initialize a capped collection when a queue is created" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test',
+      :average_message_size => 8192,
+      :queue_size => 4096
+    )
+    
+    options = Mongo::Connection.new()['karait_test']['queue_test'].options
+    
+    assert_equal true, options['capped']
+    assert_equal 4096, options['max']
+    assert_equal (8192 * 4096), options['size']
+  end
+  
+  should "attach to a mongo queue collection that already exists" do
+    collection = Mongo::Connection.new()['karait_test']['queue_test']
+    collection.insert({
+      :message => {
+        :apple => 3,
+        :banana => 5
+      },
+      :_meta => {
+        :timestamp => 2523939,
+        :expire => 20393,
+        :routing_key => 'foo_key'
+      }
+    })
+    assert_equal 1, collection.count()
+    
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+
+    collection = Mongo::Connection.new()['karait_test']['queue_test']
+    assert_equal 1, collection.count()
+    assert_equal nil, collection.options()
+  end
+  
+  should "write a dictionary into the mongo queue collection" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test',
+      :average_message_size => 8192,
+      :queue_size => 4096
+    )
+    
+    queue.write({
+      :apple => 5,
+      :banana => 6,
+      :inner_object => {
+        :foo => 1,
+        :bar => 2
+      }
+    })
+
+    collection = Mongo::Connection.new()['karait_test']['queue_test']
+    obj = collection.find_one()
+    assert_equal 6, obj['banana']
+    assert_equal 2, obj['inner_object']['bar']
+    assert obj['_meta']['expire']
+    assert obj['_meta']['timestamp']
+  end
+  
+  should "write a message object into the mongo queue collection" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    message = Karait::Message.new
+    message.apple = 5
+    message.banana = {
+      :foo => 2
+    }
+    queue.write message
+    
+    collection = Mongo::Connection.new()['karait_test']['queue_test']
+    obj = collection.find_one
+    assert_equal 5, obj['apple']
+    assert_equal 2, obj['banana']['foo']
+  end
+
+  should "read a message object from the mongo queue collection" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+  
+    write_message = Karait::Message.new
+    write_message.apple = 5
+    write_message.banana = 6
+    write_message.inner_object = {
+      'foo' => 1,
+      'bar' => 2
+    }
+    queue.write write_message
+  
+    read_message = queue.read()[0]
+    assert_equal 5, read_message.apple
+    assert_equal 2, read_message.inner_object['bar']
+    assert_equal 3, read_message.to_hash.keys.count
+  end
+  
+  should "return messages in fifo order" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write Karait::Message.new({'foo' => 1})
+    queue.write Karait::Message.new({:foo => 2})
+    queue.write Karait::Message.new({'foo' => 3})
+    messages = queue.read()
+    
+    assert_equal 1, messages[0].foo
+    assert_equal 2, messages[1].foo
+    assert_equal 3, messages[2].foo
+  end
+  
+  should "only return messages with the appropriate routing key when it's provided" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write(Karait::Message.new({:foo => 1}), :routing_key => 'foobar')
+    queue.write Karait::Message.new({:foo => 2})
+
+    messages = queue.read(:routing_key => 'foobar')
+    assert_equal 1, messages.count
+    assert_equal 1, messages[0].foo
+  end
+  
+  should "only return messages with no routing key when none is provided" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write(Karait::Message.new({:foo => 1}), :routing_key => 'foobar')
+    queue.write Karait::Message.new({:foo => 2})
+    
+    messages = queue.read()
+    assert_equal 1, messages.count
+    assert_equal 2, messages[0].foo
+  end
+  
+  should "should no longer return a message when delete is called on it" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write Karait::Message.new({:foo => 1})
+    messages = queue.read()
+    assert_equal 1, messages.count
+    assert_equal 1, messages[0].foo
+    
+    messages[0].delete
+    messages = queue.read()
+    assert_equal 0, messages.count
+  end
+
+  should "not remove message immediately with expire set" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write(Karait::Message.new({:foo => 1}), :expire => 0.5)
+    sleep(0.1)
+    messages = queue.read()
+    assert_equal 1, messages.count
+  end
+  
+  should "remove message once expire time is passed" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write(Karait::Message.new({:foo => 1}), :expire => 0.1)
+    sleep(0.2)
+    messages = queue.read()
+    assert_equal 0, messages.count
+    
+    # Make sure the meta._expired key is actually set.
+    collection = Mongo::Connection.new()['karait_test']['queue_test']
+    raw_message = collection.find_one
+    assert_equal true, raw_message['_meta']['expired']
+  end
+  
+  
+  should "remove all messages in array when delete messages called" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write Karait::Message.new({'foo' => 1})
+    queue.write Karait::Message.new({:foo => 2})
+    queue.write Karait::Message.new({'foo' => 3})
+    messages = queue.read()
+    queue.delete_messages messages
+    messages = queue.read()
+    assert_equal 0, messages.count
+  end
+  
+  should "not see message in queue again until visibility timeout has passed" do
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.write Karait::Message.new({'foo' => 1})
+    queue.write Karait::Message.new({:foo => 2})
+    queue.write Karait::Message.new({'foo' => 3})
+    messages = queue.read(:visibility_timeout => 0.4)
+    assert_equal 3, messages.count
+    messages = queue.read(:visibility_timeout => 0.4)
+    assert_equal 0, messages.count
+    sleep(0.5)
+    messages = queue.read(:visibility_timeout => 0.4)
+    assert_equal 3, messages.count
+  end
+  
+  should "block on reading from queue until polling timeout reached" do
+    start_time = Time.new.to_f
+    
+    queue = Karait::Queue.new(
+      :database => 'karait_test',
+      :queue => 'queue_test'
+    )
+    
+    queue.read( :block => true, :polling_timeout => 0.1 )
+    queue.write Karait::Message.new({'foo' => 1})
+    messages = queue.read( :block => true, :polling_timeout => 0.1 )
+
+    assert_equal 1, messages.count
+    stop_time = Time.new.to_f
+    assert_equal true, stop_time - start_time > 0.1
+  end
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: karait
 version: !ruby/object:Gem::Version 
-  hash: 17
-  prerelease: false
+  hash: 15
+  prerelease: 
   segments: 
   - 0
   - 0
-  - 7
-  segments_generated: true
-  version: 0.0.7
+  - 8
+  version: 0.0.8
 platform: ruby
 authors: 
 - bcoe
@@ -16,90 +15,9 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-11-12 00:00:00 +00:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  type: :runtime
-  prerelease: false
-  name: mongo
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 25
-        segments: 
-        - 1
-        - 3
-        - 1
-        segments_generated: true
-        version: 1.3.1
-  requirement: *id001
-- !ruby/object:Gem::Dependency 
-  type: :development
-  prerelease: false
-  name: shoulda
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        segments_generated: true
-        version: "0"
-  requirement: *id002
-- !ruby/object:Gem::Dependency 
-  type: :development
-  prerelease: false
-  name: bundler
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 23
-        segments: 
-        - 1
-        - 0
-        - 0
-        segments_generated: true
-        version: 1.0.0
-  requirement: *id003
-- !ruby/object:Gem::Dependency 
-  type: :development
-  prerelease: false
-  name: jeweler
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 1
-        - 6
-        - 4
-        segments_generated: true
-        version: 1.6.4
-  requirement: *id004
-- !ruby/object:Gem::Dependency 
-  type: :development
-  prerelease: false
-  name: rcov
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        segments_generated: true
-        version: "0"
-  requirement: *id005
+date: 2011-11-12 00:00:00 Z
+dependencies: []
+
 description: A ridiculously simple cross-language queuing system, built on top of MongoDB.
 email: bencoe@gmail.com
 executables: []
@@ -110,9 +28,20 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.markdown
 files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.markdown
-has_rdoc: true
+- Rakefile
+- VERSION
+- karait.gemspec
+- lib/karait.rb
+- lib/message.rb
+- lib/queue.rb
+- test/helper.rb
+- test/test_message.rb
+- test/test_queue.rb
 homepage: http://github.com/bcoe/karait
 licenses: 
 - MIT
@@ -129,7 +58,6 @@ required_ruby_version: !ruby/object:Gem::Requirement
       hash: 3
       segments: 
       - 0
-      segments_generated: true
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
@@ -139,12 +67,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       hash: 3
       segments: 
       - 0
-      segments_generated: true
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: A ridiculously simple cross-language queuing system, built on top of MongoDB.