postqueue 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 922c5d4f8d07a93c7e889709d136de7159014599
+  data.tar.gz: fb6d7ac28ed62728a688a4e1cf8f7b6120626b55
+SHA512:
+  metadata.gz: d9371b02973a1ff7776daa9f0f2dac442723acc42d52c4745497438d261fbdd5956178af4d56aea962d9cd5f040a112f9be834c25d7602b4c01b913bf417b3d8
+  data.tar.gz: 0172ea33447642ca43b836b662a52401bae80810940dfd54e24d423600b7462d5b2a9f9376ce35e0b6a46598cd438de3989f4b6d6ea228c7c494aa8f651c5ae7

data/README.md

@@ -0,0 +1,41 @@
+# Postqueue
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/postqueue`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'postqueue'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install postqueue
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/postqueue.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/postqueue/enqueue.rb

@@ -0,0 +1,23 @@
+module Postqueue
+  module Enqueue
+    Item = ::Postqueue::Item
+
+    def enqueue(op:, entity_type:, entity_id:)
+      # An optimized code path, as laid out below, is 4 times as fast.
+      # However, exec_query changed from Rails 4 to Rails 5.
+
+      # sql = "INSERT INTO postqueue (op, entity_type, entity_id) VALUES($1, $2, $3)"
+      # binds = [ ]
+      #
+      # binds << ActiveRecord::Attribute.from_user("name", op,  ::ActiveRecord::Type::String.new)
+      # binds << ActiveRecord::Attribute.from_user("entity_type", entity_type, ::ActiveRecord::Type::String.new)
+      # binds << ActiveRecord::Attribute.from_user("entity_id", entity_id, ::ActiveRecord::Type::Integer.new)
+      # # Note: Rails 4 does not understand prepare: true
+      # db.exec_query(sql, 'SQL', binds, prepare: true)
+
+      Item.create!(op: op, entity_type: entity_type, entity_id: entity_id)
+    end
+  end
+
+  extend Enqueue
+end

data/lib/postqueue/item.rb

@@ -0,0 +1,30 @@
+require "active_record"
+
+module Postqueue
+  class Item < ActiveRecord::Base
+    self.table_name = :postqueue
+  end
+
+  def self.unmigrate!
+    Item.connection.execute <<-SQL
+      DROP TABLE IF EXISTS postqueue;
+    SQL
+  end
+
+  def self.migrate!
+    Item.connection.execute <<-SQL
+    CREATE TABLE postqueue (
+      id          SERIAL PRIMARY KEY, 
+      op          VARCHAR,
+      entity_type VARCHAR,
+      entity_id   INTEGER NOT NULL DEFAULT 0,
+      created_at  timestamp without time zone NOT NULL DEFAULT (now() at time zone 'utc'),
+      next_run_at timestamp without time zone NOT NULL DEFAULT (now() at time zone 'utc'),
+      failed_attempts INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX postqueue_idx1 ON postqueue(entity_id);
+    CREATE INDEX postqueue_idx2 ON postqueue(next_run_at);
+    SQL
+  end
+end

data/lib/postqueue/processing.rb

@@ -0,0 +1,97 @@
+module Postqueue
+  MAX_ATTEMPTS = 3
+
+  module Processing
+    # Processes many entries
+    #
+    # process limit: 100, skip_duplicates: true
+    def process(options = {}, &block)
+      limit           = options.fetch(:limit, 100)
+      skip_duplicates = options.fetch(:skip_duplicates, true)
+      options.delete :limit
+      options.delete :skip_duplicates
+
+      status, result = Item.transaction do
+        process_inside_transaction options, limit: limit, skip_duplicates: skip_duplicates, &block
+      end
+
+      raise result if status == :err
+      result
+    end
+
+    # Process a single entry from the queue
+    #
+    # Example:
+    #
+    #   process_one do |op, entity_type
+    #   end
+    def process_one(options = {}, &block)
+      options = options.merge(limit: 1, skip_duplicates: false)
+      process options, &block
+    end
+
+    private
+
+    def select_and_lock(relation, limit:)
+      relation = relation.where("failed_attempts < ? AND next_run_at < ?", MAX_ATTEMPTS, Time.now).order(:next_run_at, :id)
+
+      sql = relation.to_sql + " FOR UPDATE SKIP LOCKED"
+      sql += " LIMIT #{limit}" if limit
+      items = Item.find_by_sql(sql)
+
+      items
+    end
+
+    # The actual processing. Returns [ :ok, number-of-items ] or  [ :err, exception ]
+    def process_inside_transaction(options, limit:, skip_duplicates:, &block)
+      relation = Item.all
+      relation = relation.where(options[:where]) if options[:where]
+
+      first_match = select_and_lock(relation, limit: 1).first
+      return [ :ok, nil ] unless first_match
+
+      # find all matching entries with the same entity_type/op value
+      if limit > 1
+        batch_relation = relation.where(entity_type: first_match.entity_type, op: first_match.op)
+        matches = select_and_lock(batch_relation, limit: limit)
+      else
+        matches = [ first_match ]
+      end
+
+      entity_ids = matches.map(&:entity_id)
+
+      # When skipping dupes we'll find and lock all entries that match entity_type,
+      # op, and one of the entity_ids in the first batch of matches
+      if skip_duplicates
+        entity_ids.uniq!
+        process_relations = relation.where(entity_type: first_match.entity_type, op: first_match.op, entity_id: entity_ids)
+        process_items = select_and_lock process_relations, limit: nil
+      else
+        process_items = matches
+      end
+
+      # Actually process the queue items
+      result = [ first_match.op, first_match.entity_type, entity_ids ]
+      result = yield *result if block_given?
+
+      if result == false
+        postpone process_items
+      else
+        Item.where(id: process_items.map(&:id)).delete_all 
+      end
+
+      [ :ok, result ]
+    rescue => e
+      postpone process_items
+      [ :err, e ]
+    end
+
+    def postpone(items)
+      ids = items.map(&:id)
+      sql = "UPDATE postqueue SET failed_attempts = failed_attempts+1, next_run_at = next_run_at + interval '10 second' WHERE id IN (#{ids.join(",")})"
+      Item.connection.exec_query(sql)
+    end
+  end
+  
+  extend Processing
+end

data/lib/postqueue/version.rb

@@ -0,0 +1,3 @@
+module Postqueue
+  VERSION = '0.0.1'
+end

data/lib/postqueue.rb

@@ -0,0 +1,9 @@
+require 'postqueue/item'
+require 'postqueue/enqueue'
+require 'postqueue/processing'
+require 'postqueue/version'
+
+module Postqueue
+end
+
+# require 'postqueue/railtie' if defined?(Rails)

data/spec/postqueue/enqueue_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ::Postqueue::Enqueue do
+  before do
+    Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+  end
+
+  let(:item) { Postqueue::Item.first }
+
+  it 'enqueues items' do
+    expect(item.op).to eq("myop")
+    expect(item.entity_type).to eq("mytype")
+    expect(item.entity_id).to eq(12)
+  end
+
+  it 'sets defaults' do
+    expect(item.created_at).to be > (Time.now - 1.second)
+    expect(item.next_run_at).to be > (Time.now - 1.second)
+    expect(item.failed_attempts).to eq(0)
+  end
+end

data/spec/postqueue/postqueue_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "::Postqueue" do
+  it "reports a version" do
+    expect(Postqueue::VERSION).to satisfy { |s| s =~ /\d\.\d+\.\d+/ }
+  end
+end

data/spec/postqueue/process_errors_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "::Postqueue.process_one" do
+  class E < RuntimeError; end
+
+  before do
+    Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+  end
+
+  it "fails when block raises an exception and reraises the exception" do
+    expect { Postqueue.process_one do |op, type, ids| raise E end }.to raise_error(E)
+    expect(items.map(&:entity_id)).to contain_exactly(12)
+  end
+
+  it "fails when block returns false" do
+    Postqueue.process_one do |op, type, ids| false end
+    expect(items.map(&:entity_id)).to contain_exactly(12)
+  end
+
+  it "keeps item in the queue after failure, with an increased failed_attempt count" do
+    called_block = 0
+    Postqueue.process_one do called_block += 1; false end
+    expect(called_block).to eq(1)
+
+    expect(items.map(&:entity_id)).to contain_exactly(12)
+    expect(items.first.failed_attempts).to eq(1)
+  end
+
+  it "ignores items with a failed_attempt count > MAX_ATTEMPTS" do
+    expect(Postqueue::MAX_ATTEMPTS).to be >= 3
+    items.update_all(failed_attempts: 3)
+
+    called_block = 0
+    r = Postqueue.process_one do called_block += 1; false end
+    expect(r).to eq(nil)
+    expect(called_block).to eq(0)
+
+    expect(items.map(&:entity_id)).to contain_exactly(12)
+    expect(items.first.failed_attempts).to eq(3)
+  end
+end

data/spec/postqueue/process_one_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe "::Postqueue.process_one" do
+  before do
+    Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+    Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 13
+    Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 14
+  end
+
+  it "processes one entry" do
+    r = Postqueue.process_one
+    expect(r).to eq(["myop", "mytype", [12]])
+    expect(items.map(&:entity_id)).to contain_exactly(13, 14)
+  end
+
+  it "honors search conditions" do
+    Postqueue.enqueue op: "otherop", entity_type: "mytype", entity_id: 112
+
+    r = Postqueue.process_one(where: { op: "otherop" })
+    expect(r).to eq(["otherop", "mytype", [112]])
+    expect(items.map(&:entity_id)).to contain_exactly(12, 13, 14)
+  end
+
+  it "yields a block and returns it" do
+    Postqueue.enqueue op: "otherop", entity_type: "mytype", entity_id: 112 
+    r = Postqueue.process_one(where: { op: "otherop" }) do |op, type, ids|
+      expect(op).to eq("otherop")
+      expect(type).to eq("mytype")
+      expect(ids).to eq([112])
+      "yihaa"
+    end
+
+    expect(r).to eq("yihaa")
+    expect(items.map(&:entity_id)).to contain_exactly(12, 13, 14)
+  end
+end

data/spec/postqueue/process_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe "::Postqueue.process" do
+  context 'when having entries with the same entity_type and op' do
+    before do
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 13
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 14
+    end
+
+    it "processes one entries" do
+      r = Postqueue.process limit: 1
+      expect(r).to eq(["myop", "mytype", [12]])
+      expect(items.map(&:entity_id)).to contain_exactly(13, 14)
+    end
+
+    it "processes two entries" do
+      r = Postqueue.process limit: 2
+      expect(r).to eq(["myop", "mytype", [12, 13]])
+      expect(items.map(&:entity_id)).to contain_exactly(14)
+    end
+
+    it "processes many entries" do
+      r = Postqueue.process
+      expect(r).to eq(["myop", "mytype", [12, 13, 14]])
+      expect(items.map(&:entity_id)).to contain_exactly()
+    end
+  end
+
+  context 'when having entries with different entity_type and op' do
+    before do
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 13
+      Postqueue.enqueue op: "otherop", entity_type: "mytype", entity_id: 14
+      Postqueue.enqueue op: "myop", entity_type: "othertype", entity_id: 15
+      Postqueue.enqueue op: "otherop", entity_type: "othertype", entity_id: 16
+    end
+
+    it "processes one entries" do
+      r = Postqueue.process limit: 1
+      expect(r).to eq(["myop", "mytype", [12]])
+      expect(items.map(&:entity_id)).to contain_exactly(13, 14, 15, 16)
+    end
+
+    it "processes two entries" do
+      r = Postqueue.process limit: 2
+      expect(r).to eq(["myop", "mytype", [12, 13]])
+      expect(items.map(&:entity_id)).to contain_exactly(14, 15, 16)
+    end
+
+    it "processes only matching entries when asked for more" do
+      r = Postqueue.process
+      expect(r).to eq(["myop", "mytype", [12, 13]])
+      expect(items.map(&:entity_id)).to contain_exactly(14, 15, 16)
+    end
+
+    it "honors search conditions" do
+      r = Postqueue.process(where: { op: "otherop" })
+      expect(r).to eq(["otherop", "mytype", [14]])
+      expect(items.map(&:entity_id)).to contain_exactly(12, 13, 15, 16)
+    end
+  end
+  
+  context 'when having duplicate entries' do
+    before do
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 13
+      Postqueue.enqueue op: "myop", entity_type: "mytype", entity_id: 12
+    end
+
+    it "removes duplicates from the queue" do
+      r = Postqueue.process limit: 1
+      expect(r).to eq(["myop", "mytype", [12]])
+      expect(items.map(&:entity_id)).to contain_exactly(13)
+    end
+
+    it "does not remove duplicates when skip_duplicates is set to false" do
+      r = Postqueue.process limit: 1, skip_duplicates: false
+      expect(r).to eq(["myop", "mytype", [12]])
+      expect(items.map(&:entity_id)).to contain_exactly(13, 12)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+path = File.expand_path('../../mpx/lib', __FILE__)
+$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+
+ENV['RACK_ENV'] = 'test'
+
+require 'rspec'
+require 'pry'
+require 'simplecov'
+
+SimpleCov.start do
+  minimum_coverage 94
+end
+
+require 'postqueue'
+require './spec/support/configure_active_record'
+
+def items
+  Postqueue::Item.all
+end
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run focus: (ENV['CI'] != 'true')
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+  config.order = 'random'
+
+  config.before(:all) { }
+  config.after { }
+end

data/spec/support/configure_active_record.rb

@@ -0,0 +1,24 @@
+require 'active_record'
+require_relative './models'
+
+$LOAD_PATH << File.dirname(__FILE__)
+
+ActiveRecord::Base.establish_connection(adapter: 'postgresql', 
+                                        database: 'postqueue_test', 
+                                        username: 'postqueue', 
+                                        password: 'postqueue')
+
+require_relative 'schema.rb'
+require_relative 'models.rb'
+
+Postqueue.unmigrate!
+Postqueue.migrate!
+
+RSpec.configure do |config|
+  config.around(:each) do |example|
+    ActiveRecord::Base.connection.transaction do
+      example.run
+      raise ActiveRecord::Rollback, 'Clean up'
+    end
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,123 @@
+__END__
+
+require 'ostruct'
+
+class MockAssocationInfo < OpenStruct
+  def virtual?; mode == :virtual; end
+  def belongs_to?; mode == :belongs_to; end
+  def habtm?; mode == :has_and_belongs_to_many; end
+end
+
+module AnalyticsReflectionStub
+  attr :analytics_reflection
+  def set_analytics_reflection(hsh)
+    @analytics_reflection = OpenStruct.new(hsh)
+  end
+
+  attr :analytics_parent
+  def set_analytics_parent(analytics_parent)
+    @analytics_parent = analytics_parent
+  end
+end
+
+class Unicorn < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+
+  def self.name_without_prefix
+    'UnicornWithoutPrefix'
+  end
+
+  validates_presence_of :name
+
+  set_analytics_reflection associations_by_foreign_keys: {}, analytics_keys: [:name]
+end
+
+class Manticore < ActiveRecord::Base
+  def self.name_without_prefix
+    'ManticoreWithoutPrefix'
+  end
+end
+
+class Rider < ActiveRecord::Base
+end
+
+class Foal < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+
+  belongs_to :parent, class_name: 'Unicorn'
+  has_and_belongs_to_many :riders, class_name: 'Rider'
+
+  set_analytics_reflection associations_by_foreign_keys: 
+    { 
+    parent_id: MockAssocationInfo.new(mode: :belongs_to, klass: Unicorn, name: :parent),
+    rider_ids: MockAssocationInfo.new(mode: :has_and_belongs_to_many, klass: Rider, name: :riders),
+    stable_ids: MockAssocationInfo.new(mode: :virtual, name: :stables)
+  },
+  analytics_keys: [:nick_name, :age, :parent]
+  set_analytics_parent :parent
+end
+
+class Pegasus < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+
+  belongs_to :parent, class_name: 'Foal'
+
+  set_analytics_reflection associations_by_foreign_keys: { :parent_id => OpenStruct.new(klass: Foal, name: :parent) },
+    analytics_keys: [:nick_name, :age, :parent]
+  set_analytics_parent :parent
+
+  attr_reader :affiliation_id
+end
+
+class Dragon < ActiveRecord::Base
+  def self.name_without_prefix
+    'DragonWithoutPrefix'
+  end
+
+  def describe
+    'yihaa'
+  end
+
+  extend AnalyticsReflectionStub
+end
+
+class Asset < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+  attr_reader :affiliation_id
+end
+
+class Product < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+  attr_reader :affiliation_id
+end
+
+class User < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+  attr_reader :affiliation_id
+
+  def analytics_title
+    "my analytics_title"
+  end
+end
+
+class Grouping < ActiveRecord::Base
+  extend AnalyticsReflectionStub
+  attr_reader :affiliation_id
+end
+
+class Group < Grouping
+end
+
+class MockProductAsset < ActiveRecord::Base
+  has_one :asset
+  has_one :product
+
+  attr_accessor :asset, :product
+end
+
+class MockGroupUser < ActiveRecord::Base
+  has_one :group
+  has_one :user
+
+  attr_accessor :group, :user
+end

data/spec/support/schema.rb

@@ -0,0 +1,88 @@
+__END__
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :unicorns, force: true do |t|
+    t.string  :name, null: false
+    t.string :affiliation_id
+  end
+
+  create_table :foals, force: true do |t|
+    t.integer   :parent_id, null: false
+    t.string    :nick_name
+    t.integer   :age
+    t.datetime  :created_at
+  end
+
+  create_table :riders, force: true do |t|
+    t.string    :nick_name
+  end
+
+  create_table :foal_riders, force: true do |t|
+    t.integer :rider_id
+    t.integer :foal_id
+  end
+
+  create_table :pegasus, force: true do |t|
+    t.integer   :parent_id, null: false
+    t.string    :nick_name
+    t.integer   :age
+    t.datetime  :created_at
+  end
+
+  create_table :mock_product_assets, force: true do |t|
+    t.integer   :asset_id
+    t.string    :access_level
+    t.integer   :product_id
+  end
+
+  create_table :mock_group_users, force: true do |t|
+    t.integer   :user_id
+    t.string    :access_level
+    t.integer   :group_id
+  end
+
+  create_table :assets, force: true
+
+  create_table :products, force: true
+
+  create_table :users, force: true do |t|
+    t.string    :title
+  end
+
+  create_table :groupings, force: true
+
+  create_table :manticores, force: true do |t|
+    t.string  :dummy_field
+  end
+
+  create_table :dragons, force: true do |t|
+    t.string  :full_name
+  end
+
+  execute "INSERT INTO unicorns(affiliation_id, id, name) VALUES('mpx', 1, 'Faith')"
+  execute "INSERT INTO unicorns(affiliation_id, id, name) VALUES('mpx', 2, 'Faery')"
+  execute "INSERT INTO unicorns(affiliation_id, id, name) VALUES('mpx', 3, 'Yaser')"
+
+  execute "INSERT INTO foals(id, parent_id, nick_name, age, created_at) VALUES(1, 1, 'Little Faith', 12, 0)"
+  execute "INSERT INTO foals(id, parent_id, nick_name, age, created_at) VALUES(2, 1, 'Faith Nick',   9, 0)"
+
+  execute "INSERT INTO riders(id, nick_name) VALUES(1, 'Storm Rider')"
+  execute "INSERT INTO riders(id, nick_name) VALUES(2, 'Desert Rider')"
+
+  execute "INSERT INTO foal_riders(rider_id, foal_id) VALUES(1, 1)"
+  execute "INSERT INTO foal_riders(rider_id, foal_id) VALUES(2, 1)"
+
+  execute "INSERT INTO pegasus(parent_id, nick_name, age, created_at) VALUES(1, 'Derpy', 12, 0)"
+
+  execute "INSERT INTO dragons(full_name) VALUES('Chrysophylax Dives')"
+  execute "INSERT INTO dragons(full_name) VALUES('Nepomuk')"
+  execute "INSERT INTO dragons(full_name) VALUES('Smaug')"
+
+  execute "INSERT INTO manticores(dummy_field) VALUES('Dumb Manticore')"
+
+  execute "INSERT INTO users(id, title) VALUES(67, 'sixtyseven')"
+
+  execute "INSERT INTO groupings(id) VALUES(42)"
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: postqueue
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- radiospiel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.5.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: a postgres based queue implementation
+email:
+- radiospiel@open-lab.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/postqueue.rb
+- lib/postqueue/enqueue.rb
+- lib/postqueue/item.rb
+- lib/postqueue/processing.rb
+- lib/postqueue/version.rb
+- spec/postqueue/enqueue_spec.rb
+- spec/postqueue/postqueue_spec.rb
+- spec/postqueue/process_errors_spec.rb
+- spec/postqueue/process_one_spec.rb
+- spec/postqueue/process_spec.rb
+- spec/spec_helper.rb
+- spec/support/configure_active_record.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+homepage: https://github.com/radiospiel/postqueue
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: a postgres based queue implementation
+test_files: []