rubykiq 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWIyYTZlNTdiMjRmZDEyMmM0ZDAyZjAxNDg0MThjMzhkZWJhMGEzYQ==
+  data.tar.gz: !binary |-
+    NmFjNWNjY2MzNjBlZTFjYTRiN2ZhYTc1N2EwMGExMzJmYmY3NTdjOQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjA2NmU0YjZhMzZmM2M4MTc1YWYyOTg1NmYxNGUyNWMzMGRkMDVmNzMzNDQw
+    NmZiZGM4NmViMGI0YjMzOGRmOWIyMTNjYjczMmViMjYzNTJiODQ1YzY3MDU0
+    YzUzYTc3Nzg1MzJhZGY2ZDViMzNjM2RlOWNkOGFlMzI4Y2M0ZjU=
+  data.tar.gz: !binary |-
+    NzE1NTkwODZmMzU0YWU1N2I3MmQzZjliMzVhZThkM2QzNTMzMTEyNmJhOThh
+    MTUwYzE2NDgyNjQxYjNiNWRjZDRiMmQxMTMyOTI5ZWE5Y2UyMzJmMGQ2OTNk
+    YWZlN2FiYzMwOTg1MWIyM2UxMjY0YzE4ODM5M2I1Y2RjMDBmYTY=

data/.document

@@ -0,0 +1,3 @@
+LICENSE.md
+README.md
+lib/**/*.rb

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.lock
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--order random
+--format RSpec::Smart::Formatter

data/.travis.yml

@@ -0,0 +1,18 @@
+bundler_args: --without development
+language: ruby
+rvm:
+  - rbx-18mode
+  - rbx-19mode
+  - jruby-18mode
+  - jruby-19mode
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+services:
+  - redis-server
+matrix:
+  allow_failures:
+    - rvm: rbx-18mode
+    - rvm: jruby-18mode
+    - rvm: 1.8.7

data/.yardopts

@@ -0,0 +1,6 @@
+--markup markdown
+-
+CHANGELOG.md
+CONTRIBUTING.md
+LICENSE.md
+README.md

data/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help
+improve this project.
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+
+Here are some ways *you* can contribute:
+
+* by using alpha, beta, and prerelease versions
+* by reporting bugs
+* by suggesting new features
+* by writing or editing documentation
+* by writing specifications
+* by writing code (**no patch is too small**: fix typos, add comments, clean up
+  inconsistent whitespace)
+* by refactoring code
+* by closing [issues][]
+* by reviewing patches
+
+[issues]: https://github.com/karlfreeman/rubykiq/issues
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, please include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+Ideally, a bug report should include a pull request with failing specs.
+
+[gist]: https://gist.github.com/
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Create a topic branch.][branch]
+3. Add specs for your unimplemented feature or bug fix.
+4. Run `bundle exec rake spec`. If your specs pass, return to step 3.
+5. Implement your feature or bug fix.
+6. Run `bundle exec rake spec`. If your specs fail, return to step 5.
+7. Run `open coverage/index.html`. If your changes are not completely covered
+   by your tests, return to step 3.
+8. Add, commit, and push your changes.
+9. [Submit a pull request.][pr]
+
+[fork]: http://help.github.com/fork-a-repo/
+[branch]: http://learn.github.com/p/branching.html
+[pr]: http://help.github.com/send-pull-requests/

data/Gemfile

@@ -0,0 +1,33 @@
+source "https://rubygems.org"
+
+gem "rake", ">= 1.2"
+gem "yard"
+
+# platforms :ruby_18 do
+# end
+# platforms :ruby, :mswin, :mingw do
+# end
+# platforms :jruby do
+# end
+
+gem "hiredis", "~> 0.4.5", :require => false
+gem "em-synchrony", :require => false
+
+group :development do
+  gem "kramdown", ">= 0.14"
+  gem "pry"
+  gem "pry-debugger", :platforms => :mri_19
+  gem "awesome_print"
+end
+
+group :test do
+  gem "rspec"
+  gem "rspec-smart-formatter"
+  gem "vcr"
+  gem "timecop"
+  gem "simplecov", :require => false
+  gem "coveralls", :require => false
+  gem "cane"
+end
+
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Karl Freeman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# Rubykiq ( WIP ) [![Gem Version](https://badge.fury.io/rb/rubykiq.png)][gem] [![Build Status](https://travis-ci.org/karlfreeman/rubykiq.png?branch=master)][travis] [![Dependency Status](https://gemnasium.com/karlfreeman/rubykiq.png?travis)][gemnasium] [![Coverage Status](https://coveralls.io/repos/karlfreeman/rubykiq/badge.png?branch=master)][coveralls] [![Code Climate](https://codeclimate.com/github/karlfreeman/rubykiq.png)][codeclimate]
+
+[Sidekiq] agnostic enqueuing using Redis.
+
+[gem]: https://rubygems.org/gems/rubykiq
+[travis]: http://travis-ci.org/karlfreeman/rubykiq
+[gemnasium]: https://gemnasium.com/karlfreeman/rubykiq
+[coveralls]: https://coveralls.io/r/karlfreeman/rubykiq
+[codeclimate]: https://codeclimate.com/github/karlfreeman/rubykiq
+
+[sidekiq]: http://mperham.github.com/sidekiq/
+
+Sidekiq is a fantastic message processing library which has a simple and stable message format. Rubykiq aims to be a portable library to push jobs in to Sidekiq with as little overhead as possible Whilst having feature parity on Sidekiq::Client's conventions.
+
+## Features / Usage Examples
+
+* [Redis][] has support for [alternative drivers](https://github.com/redis/redis-rb#alternate-drivers), Rubykiq is tested with these in mind. ( eg :synchrony )
+* The `:at` parameter supports `Time`, `Date` and any `Time.parse`-able strings.
+* Pushing multiple and singular jobs has the same interface, simply nest args.
+* Slightly less gem dependecies, and by that I mean Sidekiq::Client without Celluloid ( which is already very light! )
+
+[redis]: https://github.com/redis/redis-rb
+
+```ruby
+require "rubykiq"
+
+# will also detect REDIS_URL, REDIS_PROVIDER and REDISTOGO_URL ENV variables
+Rubykiq.url = "redis://127.0.0.1:6379"
+
+# alternative driver support ( :ruby, :hiredis, :synchrony )
+Rubykiq.driver = :synchrony
+
+# defaults to nil
+Rubykiq.namespace = "background"
+
+# uses "default" queue unless specified
+Rubykiq.push(:class => "Worker", :args => ["foo", 1, :bat => "bar"])
+
+# args are optionally set to empty
+Rubykiq.push(:class => "Scheduler", :queue => "scheduler")
+
+# will batch up multiple jobs
+Rubykiq.push(:class => "Worker", :args => [["foo"], ["bar"]]) 
+
+# at param can be a "Time", "Date" or any "Time.parse"-able strings
+Rubykiq.push(:class => "DelayedHourMailer", :at => Time.now + 3600)
+Rubykiq.push(:class => "DelayedDayMailer", :at => DateTime.now.next_day)
+Rubykiq.push(:class => "DelayedMailer", :at => "2013-01-01T09:00:00Z")
+
+# alias based sugar
+job = { :class => "Worker" }
+Rubykiq << job
+```
+__It's advised that using [Sidekiq::Client's push] method when already a dependency is going to be better in most everyday cases__
+
+[sidekiq::client's push]: https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/client.rb#L36
+
+## Supported Ruby Versions
+This library aims to support and is [tested against][travis] the following Ruby
+implementations:
+
+* Ruby 1.9.2 (drivers: ruby, hiredis, synchrony)
+* Ruby 1.9.3 (drivers: ruby, hiredis, synchrony)
+* Ruby 2.0.0 (drivers: ruby, hiredis, synchrony)
+* [JRuby][] (drivers: ruby)
+* [Rubinius][] (drivers: ruby)
+
+[jruby]: http://www.jruby.org/
+[rubinius]: http://rubini.us/
+
+# Credits
+
+Inspiration:
+
+- [Michael Grosser's Enqueue into Sidkiq post](http://grosser.it/2013/01/17/enqueue-into-sidekiq-via-pure-redis-without-loading-sidekiq/)
+
+Cribbed:
+
+- [Sidekiq's internal client class](https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/client.rb)
+- [Sidekiq's internal redis class](https://github.com/mperham/sidekiq/blob/master/lib/sidekiq/redis_connection.rb)
+- [Sidekiq's FAQ](https://github.com/mperham/sidekiq/wiki/FAQ)

data/Rakefile

@@ -0,0 +1,27 @@
+require "bundler"
+Bundler.setup
+Bundler::GemHelper.install_tasks
+
+require "yard"
+YARD::Rake::YardocTask.new
+
+require "rspec/core/rake_task"
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec)
+
+begin
+  require "cane/rake_task"
+  namespace :metric do
+    desc "Analyze for code quality"
+    Cane::RakeTask.new(:quality) do |cane|
+      cane.abc_max = 27
+      cane.no_doc = true
+      cane.style_measure = 200
+    end
+  end
+rescue LoadError
+  warn "Cane is not available, metric:quality task not provided."
+end
+
+task :default => :spec
+task :test => :spec

data/lib/rubykiq/client.rb

@@ -0,0 +1,213 @@
+require 'connection_pool'
+require 'securerandom'
+require 'multi_json'
+require 'time'
+
+module Rubykiq
+
+  class Client
+
+    # An array of valid keys in the options hash when configuring a `Rubykiq::Client`
+    VALID_OPTIONS_KEYS = [
+      :redis_pool_size,
+      :redis_pool_timeout,
+      :url,
+      :namespace,
+      :driver,
+      :retry,
+      :queue
+    ].freeze
+
+    # A hash of valid options and their default values
+    DEFAULT_OPTIONS = {
+      :redis_pool_size => 1,
+      :redis_pool_timeout => 1,
+      :url => nil,
+      :namespace => nil,
+      :driver => :ruby,
+      :retry => true,
+      :queue => "default"
+    }.freeze
+
+    # Bang open the valid options
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    # Initialize a new Client object
+    #
+    # @param options [Hash]
+    def initialize(options = {})
+      reset_options
+      options.each_pair do |key, value|
+        send("#{key}=", value) if VALID_OPTIONS_KEYS.include?(key)
+      end
+    end
+
+    # Fetch the ::ConnectionPool of Rubykiq::Connections
+    #
+    # @return [::ConnectionPool]
+    def connection_pool(options={}, &block)
+      options = valid_options.merge(options)
+
+      @connection_pool ||= ::ConnectionPool.new(:timeout => redis_pool_timeout, :size => redis_pool_size) do
+        Rubykiq::Connection.new(options)
+      end
+
+      if block_given?
+        @connection_pool.with(&block)
+      else
+        return @connection_pool
+      end
+
+    end
+
+    # Push a Sidekiq job to Redis. Accepts a number of options:
+    #
+    #   :class - the worker class to call, required.
+    #   :queue - the named queue to use, optional ( default: "default" )
+    #   :args - an array of simple arguments to the perform method, must be JSON-serializable, optional ( default: [] )
+    #   :retry - whether to retry this job if it fails, true or false, default true, optional ( default: true )
+    #   :at - when the job should be executed. This can be a `Time`, `Date` or any `Time.parse`-able strings, optional.
+    #
+    # Returns nil if not pushed to Redis. In the case of an indvidual job a job ID will be returned,
+    # if multiple jobs are pushed the size of the jobs will be returned
+    #
+    # Example:
+    #   Rubykiq.push(:class => "Worker", :args => ["foo", 1, :bat => "bar"])
+    #   Rubykiq.push(:class => "Scheduler", :queue => "scheduler")
+    #   Rubykiq.push(:class => "DelayedMailer", :at => "2013-01-01T09:00:00Z")
+    #   Rubykiq.push(:class => "Worker", :args => [["foo"], ["bar"]])
+    #
+    # @param items [Array]
+    def push(items)
+      raise(ArgumentError, "Message must be a Hash") unless items.is_a?(Hash)
+      raise(ArgumentError, "Message args must be an Array") if items[:args] && !items[:args].is_a?(Array)
+
+      # args are optional
+      items[:args] ||= []
+
+      # determine if this items arg's is a nested array
+      items[:args].first.is_a?(Array) ? push_many(items) : push_one(items)
+
+    end
+    alias_method :<<, :push
+
+
+    private
+
+    # Create a hash of options and their values
+    def valid_options
+      VALID_OPTIONS_KEYS.inject({}){|o,k| o.merge!(k => send(k)) }
+    end
+
+    # Create a hash of the default options and their values
+    def default_options
+      DEFAULT_OPTIONS
+    end
+
+    # Set the VALID_OPTIONS_KEYS with their DEFAULT_OPTIONS
+    def reset_options
+      VALID_OPTIONS_KEYS.each do |key|
+        send("#{key}=", default_options[key])
+      end
+    end
+
+    # when only one item is needed to persisted to redis
+    def push_one(item)
+
+      # we're expecting item to be a single item so simply normalize it
+      payload = normalize_item(item)
+
+      # if successfully persisted to redis return this item's `jid`
+      pushed = false
+      pushed = raw_push([payload]) if payload
+      pushed ? payload[:jid] : nil
+
+    end
+
+    # when multiple item's are needing to be persisted to redis
+    def push_many(items)
+
+      # we're expecting items to have an nested array of args, lets take each one and correctly normalize them
+      payloads = items[:args].map do |args|
+        raise ArgumentError, "Bulk arguments must be an Array of Arrays: [[:foo => 'bar'], [:foo => 'foo']]" unless args.is_a?(Array)
+        # clone the original items ( for :queue, :class, etc.. )
+        item = items.clone
+        # merge this item's args ( eg the nested `arg` array )
+        item.merge!(:args => args) unless args.empty?
+        # normalize this individual item
+        item = normalize_item(item)
+      end.compact
+
+      # if successfully persisted to redis return the size of the jobs
+      pushed = false
+      pushed = raw_push(payloads) unless payloads.empty?
+      pushed ? payloads.size : nil
+
+    end
+
+    # persist the job message(s)
+    def raw_push(payloads)
+      pushed = false
+      Rubykiq.connection_pool do |connection|
+        if payloads.first[:at]
+          pushed = connection.zadd("schedule", payloads.map {|item| [ item[:at].to_s, ::MultiJson.encode(item) ]})
+        else
+          q = payloads.first[:queue]
+          to_push = payloads.map { |item| ::MultiJson.encode(item) }
+          _, pushed = connection.multi do
+            connection.sadd("queues", q)
+            connection.lpush("queue:#{q}", to_push)
+          end
+        end
+      end
+      pushed
+    end
+
+    #
+    def normalize_item(item)
+      raise(ArgumentError, "Message must be a Hash") unless item.is_a?(Hash)
+      raise(ArgumentError, "Message must include a class and set of arguments: #{item.inspect}") if !item[:class] || !item[:args]
+      raise(ArgumentError, "Message args must be an Array") if item[:args] && !item[:args].is_a?(Array)
+      raise(ArgumentError, "Message class must be a String representation of the class name") unless item[:class].is_a?(String)
+
+      # normalize the time
+      item[:at] = normalize_time(item[:at]) if item[:at]
+      pre_normalized_item = item.clone
+
+      # args are optional
+      pre_normalized_item[:args] ||= []
+
+      # apply the default options
+      [:retry, :queue].each do |key|
+        pre_normalized_item[key] = send("#{key}") unless pre_normalized_item.has_key?(key)
+      end
+
+      # provide a job ID
+      pre_normalized_item[:jid] = ::SecureRandom.hex(12)
+
+      return pre_normalized_item
+
+    end
+
+    # Given an object meant to represent time, try to convert it intelligently to a float
+    def normalize_time(time)
+
+      # if the time param is a `Date` / `String` convert it to a `Time` object
+      if time.is_a?(Date)
+        normalized_time = time.to_time
+      elsif time.is_a?(String)
+        normalized_time = Time.parse(time)
+      else
+        normalized_time = time
+      end
+
+      # convert the `Time` object to a float ( if necessary )
+      normalized_time = normalized_time.to_f unless normalized_time.is_a?(Numeric)
+
+      return normalized_time
+
+    end
+
+  end
+
+end

data/lib/rubykiq/connection.rb

@@ -0,0 +1,38 @@
+require 'redis'
+require 'redis/namespace'
+
+module Rubykiq
+
+  class Connection
+
+    extend Forwardable
+    def_delegators :@redis_connection, :multi, :namespace, :sadd, :zadd, :lpush, :lpop, :lrange, :llen, :zcard, :zrange, :flushdb
+    def_delegators :@redis_client, :host, :port, :db, :password
+
+    # Initialize a new Connection object
+    #
+    # @param options [Hash]
+    def initialize(options = {})
+      url = options.delete(:url) { determine_redis_provider }
+      namespace = options.delete(:namespace)
+      driver = options.delete(:driver)
+      @redis_connection ||= build_conection(url, namespace, driver)
+      @redis_client ||= @redis_connection.client
+      return @redis_connection
+    end
+
+    private
+
+    # lets try and fallback to another redis url
+    def determine_redis_provider
+      ENV["REDISTOGO_URL"] || ENV["REDIS_PROVIDER"] || ENV["REDIS_URL"] || "redis://localhost:6379/0"
+    end
+
+    # construct a namespaced redis connection
+    def build_conection(url, namespace, driver)
+      client = ::Redis.connect(:url => url, :driver => driver)
+      return ::Redis::Namespace.new(namespace, :redis => client)
+    end
+
+  end
+end

data/lib/rubykiq/version.rb

@@ -0,0 +1,3 @@
+module Rubykiq
+  VERSION = "0.0.1" unless defined?(Rubykiq::VERSION)
+end

data/lib/rubykiq.rb

@@ -0,0 +1,23 @@
+require "forwardable"
+require "rubykiq/client"
+require "rubykiq/connection"
+
+module Rubykiq
+  extend SingleForwardable
+
+  def_delegators :client, :<<, :push, :connection_pool
+
+  # delegate all VALID_OPTIONS_KEYS accessors to the client
+  def_delegators :client, *Rubykiq::Client::VALID_OPTIONS_KEYS
+
+  # delegate all VALID_OPTIONS_KEYS setters to the client ( Hacky I know... )
+  def_delegators :client, *(Rubykiq::Client::VALID_OPTIONS_KEYS.dup.collect! do |key| "#{key}=".to_sym; end)
+
+  # Fetch the Rubykiq::Client
+  #
+  # @return [Rubykiq::Client]
+  def self.client(options={})
+    @client ||= Rubykiq::Client.new(options)
+  end
+
+end

data/rubykiq.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rubykiq/version"
+
+Gem::Specification.new do |gem|
+  gem.add_dependency "redis", "~> 3.0"
+  gem.add_dependency "redis-namespace", "~> 1.0"
+  gem.add_dependency "multi_json", "~> 1.0"
+  gem.add_dependency "connection_pool", "~> 1.0"
+  gem.add_development_dependency "bundler", "~> 1.0"
+  gem.name          = "rubykiq"
+  gem.version       = Rubykiq::VERSION
+  gem.authors       = ["Karl Freeman"]
+  gem.email         = ["karlfreeman@gmail.com"]
+  gem.license       = "MIT"
+  gem.description   = %q{Sidekiq agnostic enqueuing using Redis}
+  gem.summary       = %q{Sidekiq agnostic enqueuing using Redis}
+  gem.homepage      = "https://github.com/karlfreeman/rubykiq"
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.required_ruby_version = ">= 1.9.2"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "bundler"
+Bundler.setup
+begin; require "awesome_print"; rescue LoadError; end
+
+require "rspec"
+
+require "support/pry"
+require "support/timecop"
+require "support/simplecov"
+
+require "rubykiq"
+
+# used as a stupid mixin class
+class DummyClass
+end
+
+#
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+#
+def jruby?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+end
+
+#
+def wrap_in_synchrony?(driver)
+
+  yield unless driver == :synchrony
+
+  EM.synchrony do
+    yield if block_given?
+    EM.stop
+  end
+
+end

data/spec/support/pry.rb

@@ -0,0 +1,3 @@
+if !ENV["CI"] && defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
+  require "pry"
+end

data/spec/support/simplecov.rb

@@ -0,0 +1,15 @@
+if defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby"
+
+  require "simplecov"
+
+  if ENV["CI"]
+    require "coveralls"
+    Coveralls.wear!
+    SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  end
+
+  SimpleCov.start do
+    add_filter "vendor"
+  end
+
+end

data/spec/support/timecop.rb

@@ -0,0 +1,2 @@
+require "timecop"
+Timecop.freeze

data/spec/unit/client_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+require "hiredis"
+require "em-synchrony"
+
+describe Rubykiq::Client do
+
+  before(:all) do
+    Timecop.freeze
+  end
+
+  after(:all) do
+    Timecop.return
+  end
+
+  let (:ruby_client) { Rubykiq::Client.new }
+  let (:hiredis_client) { Rubykiq::Client.new(:driver => :hiredis) }
+  let (:synchrony_client) { Rubykiq::Client.new(:driver => :synchrony) }
+
+  # eg with a variety of drivers
+  [:ruby, :hiredis, :synchrony].each do |driver|
+
+    # skip incompatible drivers when running in JRuby
+    next if jruby? && (driver == :hiredis || :synchrony)
+
+    context "with #{driver}" do
+
+      # make sure the let is the current client being tested
+      let(:client) { self.send("#{driver}_client") }
+
+      describe :defaults do
+        subject { client }
+        its(:namespace) { should be_nil }
+        its(:driver) { should be driver }
+        its(:retry) { should be_true }
+        its(:queue) { should eq "default" }
+      end
+
+      describe :push do
+
+        context :validations do
+
+          context "with an incorrect message type" do
+            it "raises an ArgumentError" do
+              expect{ client.push([]) }.to raise_error(ArgumentError, /Message must be a Hash/)
+              expect{ client.push("{}") }.to raise_error(ArgumentError, /Message must be a Hash/)
+              expect{ client.push(DummyClass.new) }.to raise_error(ArgumentError, /Message must be a Hash/)
+            end
+          end
+
+          context "without a class" do
+            it "raises an ArgumentError" do
+              expect{ client.push(:args => ['foo', 1, { :bat => "bar" }]) }.to raise_error(ArgumentError, /Message must include a class/)
+            end
+          end
+
+          context "with an incorrect args type" do
+            it "raises an ArgumentError" do
+              expect{ client.push(:class => "MyWorker", :args => { :bat => "bar" }) }.to raise_error(ArgumentError, /Message args must be an Array/)
+            end
+          end
+
+          context "with an incorrect class type" do
+            it "raises an ArgumentError" do
+              expect{ client.push(:class => DummyClass, :args => ["foo", 1, { :bat => "bar" }]) }.to raise_error(ArgumentError, /Message class must be a String representation of the class name/)
+            end
+          end
+
+        end
+
+        # eg singular and batch
+        args = [[{:bat => "bar"}],[[{:bat => "bar"}],[{:bat => "foo"}]]]
+        args.each do |args|
+
+          context "with args #{args}" do
+
+            it "should create #{args.length} job(s)" do
+
+              wrap_in_synchrony?(driver) do
+
+                client.connection_pool do |connection|
+                  connection.flushdb
+                end
+
+                expect { client.push(:class => "MyWorker", :args => args) }.to change {
+                  client.connection_pool do |connection| connection.llen("queue:default"); end
+                }.from(0).to(args.length)
+
+                raw_jobs = client.connection_pool do |connection| connection.lrange("queue:default", 0, args.length); end
+                raw_jobs.each do |job|
+                  job = MultiJson.decode(job, :symbolize_keys => true)
+                  expect(job).to have_key(:jid)
+                end
+
+              end
+
+            end
+
+            # eg with a variety of different time types
+            times = [ Time.now, DateTime.now, Time.now.utc.iso8601, Time.now.to_f ]
+            times.each do |time|
+
+              context "with time #{time} ( #{time.class} )" do
+
+                it "should create #{args.length} job(s)" do
+
+                  wrap_in_synchrony?(driver) do
+
+                    client.connection_pool do |connection|
+                      connection.flushdb
+                    end
+
+                    expect { client.push(:class => "MyWorker", :args => args, :at => time) }.to change {
+                      client.connection_pool do |connection| connection.zcard("schedule"); end
+                    }.from(0).to(args.length)
+
+                    raw_jobs = client.connection_pool do |connection| connection.zrange("schedule", 0, args.length); end
+                    raw_jobs.each do |job|
+                      job = MultiJson.decode(job, :symbolize_keys => true)
+                      expect(job).to have_key(:at)
+                      expect(job[:at]).to be_within(1).of(Time.now.to_f)
+                    end
+
+                  end
+
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe Rubykiq::Connection do
+
+  describe :defaults do
+    subject { Rubykiq::Connection.new }
+    its(:namespace) { should be_nil }
+    its(:host) { should eq "localhost" }
+    its(:port) { should be 6379 }
+    its(:db) { should be 0 }
+    its(:password) { should be_nil }
+  end
+
+  describe :options do
+
+    context :custom do
+      subject { Rubykiq::Connection.new(:namespace => "yyy") }
+      its(:namespace) { should eq "yyy" }
+    end
+
+    context :inherited_settings do
+      it "should work" do
+        client = Rubykiq::Client.new(:namespace => "xxx")
+        client.connection_pool do |connection|
+          expect(connection.namespace).to eq "xxx"
+        end
+      end
+    end
+
+  end
+
+  describe :env do
+    subject { Rubykiq::Connection.new }
+
+    [{:name => "REDISTOGO_URL", :value => "redistogo"}, {:name => "REDIS_PROVIDER", :value => "redisprovider"}, {:name => "REDIS_URL", :value => "redisurl"} ].each do | test_case |
+      context "with ENV[#{test_case[:name]}]" do
+        before do
+          ENV[test_case[:name]] = "redis://#{test_case[:value]}:6379/0"
+        end
+        after do
+          ENV[test_case[:name]] = nil
+        end
+        its(:host) { should eq test_case[:value] }
+      end
+    end
+
+  end
+
+end

data/spec/unit/rubykiq_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+
+describe Rubykiq do
+
+  describe :version do
+    subject { Rubykiq::VERSION }
+    it { should be_kind_of(String) }
+  end
+
+  describe :client do
+    subject { Rubykiq.client }
+    it { should be_kind_of(Rubykiq::Client) }
+  end
+
+  describe :connection_pool do
+    subject { Rubykiq.connection_pool }
+    it { should be_kind_of(::ConnectionPool) }
+  end
+
+  # for every valid option
+  Rubykiq::Client::VALID_OPTIONS_KEYS.each do |key|
+
+    describe key do
+      subject { Rubykiq }
+      it {should respond_to key }
+      it {should respond_to "#{key}=".to_sym }
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: rubykiq
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Karl Freeman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: redis-namespace
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: connection_pool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Sidekiq agnostic enqueuing using Redis
+email:
+- karlfreeman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- .travis.yml
+- .yardopts
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/rubykiq.rb
+- lib/rubykiq/client.rb
+- lib/rubykiq/connection.rb
+- lib/rubykiq/version.rb
+- rubykiq.gemspec
+- spec/spec_helper.rb
+- spec/support/pry.rb
+- spec/support/simplecov.rb
+- spec/support/timecop.rb
+- spec/unit/client_spec.rb
+- spec/unit/connection_spec.rb
+- spec/unit/rubykiq_spec.rb
+homepage: https://github.com/karlfreeman/rubykiq
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.1
+signing_key: 
+specification_version: 4
+summary: Sidekiq agnostic enqueuing using Redis
+test_files:
+- spec/spec_helper.rb
+- spec/support/pry.rb
+- spec/support/simplecov.rb
+- spec/support/timecop.rb
+- spec/unit/client_spec.rb
+- spec/unit/connection_spec.rb
+- spec/unit/rubykiq_spec.rb
+has_rdoc: