queuel 0.0.1

data/.gitignore

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

data/.irbrc

@@ -0,0 +1,2 @@
+$:<< "./lib"
+require 'queuel'

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.rvmrc

@@ -0,0 +1,46 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 1.9.3" > .rvmrc
+environment_id="ruby-1.9.3-p392@queuel"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.20.4 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  for __hook in "${rvm_path:-$HOME/.rvm}/hooks/after_use"*
+  do
+    if [[ -f "${__hook}" && -x "${__hook}" && -s "${__hook}" ]]
+    then \. "${__hook}" || true
+    fi
+  done
+  unset __hook
+  if (( ${rvm_use_flag:=1} >= 2 )) # display only when forced
+  then
+    if [[ $- == *i* ]] # check for interactive shells
+    then echo "Using: \E[32m$GEM_HOME\E[0m" # show the user the ruby and gemset they are using in green
+    else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
+    fi
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 1.9.2
+  - jruby-19mode
+  - rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in queuel.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jon Phenow
+
+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,101 @@
+# Queuel
+[![Build Status](https://travis-ci.org/sportngin/queuel.png?branch=master)](https://travis-ci.org/sportngin/queuel)
+
+Queuel is a kewl, lite wrapper around Queue interfaces. Currently it implements:
+
+* IronMQ
+* Null pattern
+
+Each of these should reliably implement:
+
+* `push`
+* `pop`
+* `receive`
+
+Along with some further conveniences.
+
+## Installation
+
+Add this line to your application's Gemfile as well as the proper Gem for
+your queuing:
+
+```ruby
+gem 'iron_mq'
+# IronMQ recommends `gem "typhoeus"` as well for some speed benefits
+gem 'queuel'
+```
+
+And then execute:
+
+    $ bundle
+
+You will then want to configure:
+
+```ruby
+Queuel.configure do
+  # Optional, but a queue must be selected before running put/pop/receive
+  default_queue :venues
+
+  # requirement depends on your Queue
+  credentials token: 'asdufasdf8a7sd8fa7sdf', project_id: 'project_id'
+
+  # currently only [:iron_mq, :null] available
+  engine :iron_mq
+end
+```
+
+## Usage
+
+### General Queue API
+
+```ruby
+# Using default Queue
+Queuel.pop
+Queuel.push "My message to you"
+Queuel.receive do |message|
+  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
+end
+
+# With the non-default queue
+Queuel.with("officials").pop
+Queuel.with("officials").push "My message to you"
+Queuel.with("officials").receive do |message|
+  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
+end
+
+# Timeout the receiving
+Queuel.receive poll_timeout: 60 do |message|
+  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
+end
+
+# Don't receive more than 10 nil messages
+Queuel.receive max_consecutive_fails: 10 do |message|
+  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
+end
+
+# Break on nil
+Queuel.receive break_if_nil: true do |message|
+  puts "I received #{message.body}" # NOTE the message interface may change, this is currently not wrapped by the gem
+end
+```
+
+### The message
+
+```ruby
+message.id        # => ID of the message
+message.body      # => Message body
+message.delete    # => Delete the message
+```
+
+## TODO
+
+* Implement AMQP
+* Configureable exponential back-off on `receive`
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/queuel.rb

@@ -0,0 +1,68 @@
+require "queuel/version"
+require "forwardable"
+require "queuel/null/message"
+require "queuel/null/engine"
+require "queuel/null/poller"
+require "queuel/null/queue"
+require "queuel/iron_mq/message"
+require "queuel/iron_mq/engine"
+require "queuel/iron_mq/poller"
+require "queuel/iron_mq/queue"
+require "queuel/client"
+
+module Queuel
+  class << self
+    extend Forwardable
+    def_delegators :client, :push, :pop, :receive, :with
+    def_delegators :config, :credentials, :default_queue
+    alias << pop
+  end
+
+  def self.engine
+    requires
+    Object.module_eval("::#{const_name}", __FILE__, __LINE__)
+  end
+
+  def self.configure(&block)
+    config.instance_eval &block
+  end
+
+  def self.config
+    @config ||= Configurator.new
+  end
+
+  def self.client
+    Client.new engine, credentials
+  end
+
+  def self.engines
+    {
+      iron_mq: { require: 'iron_mq', const: "IronMq" },
+      null: { const: "Null" }
+    }
+  end
+
+  def self.requires
+    require engines[config.engine][:require] if engines.fetch(config.engine, {})[:require]
+  end
+
+  def self.const_name
+    "Queuel::#{engines.fetch(config.engine, {}).fetch(:const, nil) || engines[:null][:const]}::Engine"
+  end
+
+  class Configurator
+    def self.param(*params)
+      params.each do |name|
+        attr_accessor name
+        define_method name do |*values|
+          value = values.first
+          value ? self.send("#{name}=", value) : instance_variable_get("@#{name}")
+        end
+      end
+    end
+
+    param :credentials
+    param :engine
+    param :default_queue
+  end
+end

data/lib/queuel/client.rb

@@ -0,0 +1,37 @@
+module Queuel
+  class Client
+    extend Forwardable
+    def_delegators :queue_connection, :push, :pop, :receive
+
+    def initialize(engine, credentials, init_queue = nil)
+      self.engine = engine
+      self.credentials = credentials
+      self.given_queue = init_queue
+    end
+
+    def with(change_queue = nil)
+      self.clone.tap { |client| client.given_queue = change_queue }
+    end
+
+    def queue
+      bare = (given_queue || Queuel.default_queue)
+      bare.to_s unless bare.nil?
+    end
+
+    protected
+    attr_accessor :given_queue
+
+    private
+
+    def queue_connection
+      engine_client.queue queue
+    end
+
+    def engine_client
+      @engine_client ||= engine.new credentials
+    end
+
+    attr_accessor :credentials
+    attr_accessor :engine
+  end
+end

data/lib/queuel/iron_mq/engine.rb

@@ -0,0 +1,44 @@
+module Queuel
+  module IronMq
+    class Engine
+      IronMqMissingError = Class.new(StandardError)
+
+      def initialize(credentials = {})
+        self.credentials = credentials
+        self.memoized_queues = {}
+      end
+
+      def queue(which_queue)
+        memoized_queues[which_queue.to_s] ||= Queue.new(client, which_queue)
+      end
+
+      private
+      attr_accessor :credentials
+      attr_accessor :memoized_queues
+
+      def client
+        @client ||= client_proper.new credentials
+      end
+
+      def try_typhoeus
+        require 'typhoeus'
+      rescue LoadError
+        false
+      end
+
+      def client_proper
+        if defined?(::IronMQ::Client)
+          try_typhoeus
+          ::IronMQ::Client
+        else
+          begin
+            require 'iron_mq'
+            ::IronMQ::Client
+          rescue LoadError
+            raise(IronMqMissingError)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/queuel/iron_mq/message.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+module Queuel
+  module IronMq
+    class Message
+      extend Forwardable
+      def_delegators :message_object, :delete
+
+      def self.new_from_iron_mq_object(message_object)
+        allocate.tap { |instance|
+          instance.send :initialize_from_iron_mq_object, message_object
+        }
+      end
+
+      def initialize_from_iron_mq_object(message_object)
+        self.message_object = message_object
+      end
+      private :initialize_from_iron_mq_object
+
+      def initialize(id, body, queue = nil)
+        self.id = id
+        self.body = body
+        self.queue = queue
+      end
+
+      def body
+        @body || message_object && message_object.msg
+      end
+
+      [:id, :queue].each do |delegate|
+        define_method(delegate) do
+          instance_variable_get("@#{delegate}") || message_object && message_object.public_send(delegate)
+        end
+
+        private
+        attr_writer delegate
+      end
+
+      private
+      attr_accessor :message_object
+      attr_writer :body
+    end
+  end
+end

data/lib/queuel/iron_mq/poller.rb

@@ -0,0 +1,123 @@
+require 'timeout'
+module Queuel
+  module IronMq
+    class Poller
+      def initialize(queue, options, block)
+        self.queue = queue
+        self.options = options || {}
+        self.block = block
+        self.tries = 0
+        self.continue_looping = true
+      end
+
+      def poll
+        choose_looper do |msg|
+          if msg.nil?
+            tried
+            quit_looping! if break_if_nil? || maxed_tried?
+            sleep(sleep_time)
+          else
+            reset_tries
+            block.call msg
+            msg.delete
+          end
+          !msg.nil?
+        end
+      end
+
+      protected
+      attr_accessor :tries
+
+      private
+      attr_accessor :queue
+      attr_accessor :args
+      attr_accessor :options
+      attr_accessor :block
+      attr_accessor :continue_looping
+
+      def choose_looper(&loop_block)
+        timeout? ? timeout_looper(loop_block) : looper(loop_block)
+      end
+
+      def timeout_looper(loop_block)
+        Timeout.timeout(timeout) { looper(loop_block) }
+      rescue Timeout::Error
+        false
+      end
+
+      def looper(loop_block)
+        while continue_looping? do
+          loop_block.call(pop_new_message)
+        end
+      end
+
+      def continue_looping?
+        !!continue_looping
+      end
+
+      def quit_looping!
+        self.continue_looping = false
+      end
+
+      def timeout
+        options[:poll_timeout].to_i
+      end
+
+      def timeout?
+        timeout > 0
+      end
+
+      def pop_new_message
+        queue.pop built_options
+      end
+
+      def start_sleep_time
+        0.1
+      end
+
+      def sleep_time
+        tries < 30 ? (start_sleep_time * tries) : 3
+      end
+
+      def reset_tries
+        self.tries = 0
+      end
+
+      def maxed_tried?
+        tries >= max_fails if max_fails_given?
+      end
+
+      def max_fails_given?
+        max_fails > 0
+      end
+
+      def max_fails
+        options[:max_consecutive_fails].to_i
+      end
+
+      def tried
+        self.tries += 1
+      end
+
+      def break_if_nil?
+        !!options.fetch(:break_if_nil, false)
+      end
+
+      def option_keys
+        %w[break_if_nil poll_timeout max_consecutive_fails]
+      end
+
+      def my_options
+        options.select { |key,_| option_keys.include? key.to_s }
+      end
+
+      def built_options
+        options.merge default_args # intentional direction, force defaults
+      end
+
+      def default_args
+        { n: 1 }
+      end
+    end
+  end
+end