jackrabbit 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb590a46a8d61eff7c99222aa45c28a8de948b4b
+  data.tar.gz: 931c3bfb9cd1226d9e1238a1726c61f542f3acca
+SHA512:
+  metadata.gz: 544a4435206ab23db02b379eb9147fe5bae330c07cd5d06887ae35a1ea6d42fc601258c2f3404ae10c215646adfe294280da558d12260b1fb74cef31d97f776b
+  data.tar.gz: 735ddd4f5271293742248425cf5aab872e864f2289fe73556e4c578dde07278ea216d602d8622a2dd55839c01056905c3d3a1e2fbad32a8a8a06680186843865

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Robert Ross
+
+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 @@
+# Jackrabbit
+
+Jackrabbit makes interacting with RabbitMQ a little nicer.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jackrabbit'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jackrabbit
+
+## Usage
+
+### Configuration
+
+Jackrabbit has an assumption that you're working with 1 exchange most of the time. It does allow you to work with multiple. But configuration on the class pertains to 1 exchange.
+
+    Jackrabbit.config do |c|
+      c.exchange_type = 'topic'
+      c.exchange_name = 'my.exchange'
+      c.exchange_options = {}
+
+      c.connection = Bunny.new
+      c.connection.start
+    end
+
+Jackrabbit will use the Bunny gem connection you pass in. You must have called #start on it yourself however.
+The reason for this is because in specs you can swap the connection out for something like [BunnyHair](http://github.com/thunderboltlabs/bunny_hair) which tries to mimick Bunny but in memory.
+
+### Clients
+
+Calling `Jackrabbit.new` will return a `Jackrabbit::Client` object. This is the object you'll be interfacing the most with.
+
+    client = Jackrabbit.new
+    #=> Jackrabbit::Client
+
+### Bonded Queues
+
+With the client object you can create queues that are bonded to your exchange automatically. This is handy since binding queues become tedious when you do it a lot. For example:
+
+    client.bonded_queue('my.queue.name', binding: { routing_key: 'key.#' }) do |message|
+      puts message.payload
+      puts message.delivery_info
+      puts message.message
+    end
+
+When you pass a block to the bonded queue this is the block that is called for each message that the queue receives. It is your consumer.
+
+### Messages
+
+In the subscription block from bonded queue, you aren't given info, delivery, and payload arguments like the Bunny gem provides. Instead you get a single object that incapsulates all of them and gives some nice behavior.
+
+For example, message acknowledgements become very simple.
+
+    client.bonded_queue('my.queue.name', binding: { routing_key: 'key.#' }, subscription: { ack: true}) do |message|
+      puts message.payload
+
+      # acknowledge the message to RabbitMQ
+      message.acknowledge!
+    end
+
+Passing in the additional key of `subscription: { ack: true }` details that you want to explicitly ack messages.
+
+### Publishing Messages
+
+Along with subscriptions, you can also publish messages to your client object.
+
+    client = Jackrabbit.new
+    
+    client.publish('my message')
+    client.publish('my message', routing_key: 'my.routing.key')
+    
+This will publish the message **to the exchange, not a queue**.
+
+### Multiple Exchanges
+
+There might be an instance that you want to maybe use a different connection with a different exchange. To do this you can instantiate clients manually with a separate configuration.
+
+    config = Jackrabbit::Config.new
+    config.exchange_type = 'direct'
+    config.exchange_name = 'direct.exchange'
+    config.connection = Bunny.new
+
+    client = Jackrabbit::Client.new(config)
+
+Now your client object will interact with the other exchange you've detailed.
+
+## Contributing
+
+1. Fork it ( https://github.com/bobbytables/jackrabbit/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/jackrabbit.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jackrabbit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jackrabbit"
+  spec.version       = Jackrabbit::VERSION
+  spec.authors       = ["Robert Ross"]
+  spec.email         = ["robert@creativequeries.com"]
+  spec.summary       = %q{Work with RabbitMQ in a more sane way}
+  spec.description   = %q{Jackrabbit simplifies doing very common tasks with RabbitMQ}
+  spec.homepage      = "http://github.com/bobbytables/jackrabbit'"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'rspec', '~> 3.0.0.rc1'
+  spec.add_development_dependency 'bunny_hair', '~> 0.0.10'
+end

data/lib/core_ext.rb

@@ -0,0 +1,201 @@
+# Stolen from rails
+
+unless defined?(Module::DelegationError)
+  class Module
+    # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
+    # option is not used.
+    class DelegationError < NoMethodError; end
+
+    # Provides a +delegate+ class method to easily expose contained objects'
+    # public methods as your own.
+    #
+    # ==== Options
+    # * <tt>:to</tt> - Specifies the target object
+    # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
+    # * <tt>:allow_nil</tt> - if set to true, prevents a +NoMethodError+ to be raised
+    #
+    # The macro receives one or more method names (specified as symbols or
+    # strings) and the name of the target object via the <tt>:to</tt> option
+    # (also a symbol or string).
+    #
+    # Delegation is particularly useful with Active Record associations:
+    #
+    #   class Greeter < ActiveRecord::Base
+    #     def hello
+    #       'hello'
+    #     end
+    #
+    #     def goodbye
+    #       'goodbye'
+    #     end
+    #   end
+    #
+    #   class Foo < ActiveRecord::Base
+    #     belongs_to :greeter
+    #     delegate :hello, to: :greeter
+    #   end
+    #
+    #   Foo.new.hello   # => "hello"
+    #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+    #
+    # Multiple delegates to the same target are allowed:
+    #
+    #   class Foo < ActiveRecord::Base
+    #     belongs_to :greeter
+    #     delegate :hello, :goodbye, to: :greeter
+    #   end
+    #
+    #   Foo.new.goodbye # => "goodbye"
+    #
+    # Methods can be delegated to instance variables, class variables, or constants
+    # by providing them as a symbols:
+    #
+    #   class Foo
+    #     CONSTANT_ARRAY = [0,1,2,3]
+    #     @@class_array  = [4,5,6,7]
+    #
+    #     def initialize
+    #       @instance_array = [8,9,10,11]
+    #     end
+    #     delegate :sum, to: :CONSTANT_ARRAY
+    #     delegate :min, to: :@@class_array
+    #     delegate :max, to: :@instance_array
+    #   end
+    #
+    #   Foo.new.sum # => 6
+    #   Foo.new.min # => 4
+    #   Foo.new.max # => 11
+    #
+    # It's also possible to delegate a method to the class by using +:class+:
+    #
+    #   class Foo
+    #     def self.hello
+    #       "world"
+    #     end
+    #
+    #     delegate :hello, to: :class
+    #   end
+    #
+    #   Foo.new.hello # => "world"
+    #
+    # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+    # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+    # delegated to.
+    #
+    #   Person = Struct.new(:name, :address)
+    #
+    #   class Invoice < Struct.new(:client)
+    #     delegate :name, :address, to: :client, prefix: true
+    #   end
+    #
+    #   john_doe = Person.new('John Doe', 'Vimmersvej 13')
+    #   invoice = Invoice.new(john_doe)
+    #   invoice.client_name    # => "John Doe"
+    #   invoice.client_address # => "Vimmersvej 13"
+    #
+    # It is also possible to supply a custom prefix.
+    #
+    #   class Invoice < Struct.new(:client)
+    #     delegate :name, :address, to: :client, prefix: :customer
+    #   end
+    #
+    #   invoice = Invoice.new(john_doe)
+    #   invoice.customer_name    # => 'John Doe'
+    #   invoice.customer_address # => 'Vimmersvej 13'
+    #
+    # If the target is +nil+ and does not respond to the delegated method a
+    # +NoMethodError+ is raised, as with any other value. Sometimes, however, it
+    # makes sense to be robust to that situation and that is the purpose of the
+    # <tt>:allow_nil</tt> option: If the target is not +nil+, or it is and
+    # responds to the method, everything works as usual. But if it is +nil+ and
+    # does not respond to the delegated method, +nil+ is returned.
+    #
+    #   class User < ActiveRecord::Base
+    #     has_one :profile
+    #     delegate :age, to: :profile
+    #   end
+    #
+    #   User.new.age # raises NoMethodError: undefined method `age'
+    #
+    # But if not having a profile yet is fine and should not be an error
+    # condition:
+    #
+    #   class User < ActiveRecord::Base
+    #     has_one :profile
+    #     delegate :age, to: :profile, allow_nil: true
+    #   end
+    #
+    #   User.new.age # nil
+    #
+    # Note that if the target is not +nil+ then the call is attempted regardless of the
+    # <tt>:allow_nil</tt> option, and thus an exception is still raised if said object
+    # does not respond to the method:
+    #
+    #   class Foo
+    #     def initialize(bar)
+    #       @bar = bar
+    #     end
+    #
+    #     delegate :name, to: :@bar, allow_nil: true
+    #   end
+    #
+    #   Foo.new("Bar").name # raises NoMethodError: undefined method `name'
+    #
+    # The target method must be public, otherwise it will raise +NoMethodError+.
+    #
+    def delegate(*methods)
+      options = methods.pop
+      unless options.is_a?(Hash) && to = options[:to]
+        raise ArgumentError, 'Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, to: :greeter).'
+      end
+
+      prefix, allow_nil = options.values_at(:prefix, :allow_nil)
+
+      if prefix == true && to =~ /^[^a-z_]/
+        raise ArgumentError, 'Can only automatically set the delegation prefix when delegating to a method.'
+      end
+
+      method_prefix = \
+        if prefix
+          "#{prefix == true ? to : prefix}_"
+        else
+          ''
+        end
+
+      file, line = caller.first.split(':', 2)
+      line = line.to_i
+
+      to = to.to_s
+      to = 'self.class' if to == 'class'
+
+      methods.each do |method|
+        # Attribute writer methods only accept one argument. Makes sure []=
+        # methods still accept two arguments.
+        definition = (method =~ /[^\]]=$/) ? 'arg' : '*args, &block'
+
+        # The following generated method calls the target exactly once, storing
+        # the returned value in a dummy variable.
+        #
+        # Reason is twofold: On one hand doing less calls is in general better.
+        # On the other hand it could be that the target has side-effects,
+        # whereas conceptually, from the user point of view, the delegator should
+        # be doing one call.
+
+        exception = %(raise DelegationError, "#{self}##{method_prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+
+        method_def = [
+          "def #{method_prefix}#{method}(#{definition})",
+          "  _ = #{to}",
+          "  if !_.nil? || nil.respond_to?(:#{method})",
+          "    _.#{method}(#{definition})",
+          "  else",
+          "    #{exception unless allow_nil}",
+          "  end",
+          "end"
+        ].join ';'
+
+        module_eval(method_def, file, line)
+      end
+    end
+  end
+end

data/lib/jackrabbit.rb

@@ -0,0 +1,17 @@
+require 'core_ext'
+
+module Jackrabbit
+  autoload :Exchange, 'jackrabbit/exchange'
+  autoload :Config, 'jackrabbit/config'
+  autoload :Client, 'jackrabbit/client'
+  autoload :MessageReceiver, 'jackrabbit/message_receiver'
+  autoload :Message, 'jackrabbit/message'
+
+  def self.config(&block)
+    Config.default(&block)
+  end
+
+  def self.new
+    Client.new
+  end
+end

data/lib/jackrabbit/client.rb

@@ -0,0 +1,50 @@
+module Jackrabbit
+  class Client
+    InvalidExchangeType = Class.new(StandardError)
+
+    attr_reader :config
+    delegate :connection, to: :config
+
+    def initialize(config = Jackrabbit.config)
+      @config = config
+    end
+
+    def channel
+      connection.default_channel
+    end
+
+    def exchange
+      if %w(fanout direct topic).include?(config.exchange_type)
+        @exchange ||= channel.send(config.exchange_type, config.exchange_name, config.exchange_options)
+      else
+        raise InvalidExchangeType, "The exchange type '#{config.exchange_type}' is invalid"
+      end
+    end
+
+    def publish(message, options = {})
+      exchange.publish(message, options)
+    end
+
+    def bonded_queue(name, options = {}, &block)
+      queue_opts, binding_opts, sub_options = split_options(options)
+
+      queue = channel.queue(name, queue_opts)
+      receiver = MessageReceiver.new(channel, &block)
+
+      queue.bind(exchange, binding_opts)
+
+      queue.subscribe(sub_options) do |info, message, payload|
+        receiver.handle(info, message, payload)
+      end
+    end
+
+    private
+
+    def split_options(options)
+      binding_options = options.delete(:binding) || {}
+      sub_options = options.delete(:subscription) || {}
+
+      return [options, binding_options, sub_options]
+    end
+  end
+end

data/lib/jackrabbit/config.rb

@@ -0,0 +1,16 @@
+module Jackrabbit
+  class Config
+    def self.default(&block)
+      (@default ||= new).tap do |config|
+        yield config if block_given?
+      end
+    end
+
+    attr_accessor :exchange_name, :exchange_type, :connection
+    attr_accessor :exchange_options
+
+    def initialize
+      @exchange_options = {}
+    end
+  end
+end

data/lib/jackrabbit/exchange.rb

@@ -0,0 +1,4 @@
+module Jackrabbit
+  class Exchange
+  end
+end

data/lib/jackrabbit/message.rb

@@ -0,0 +1,16 @@
+module Jackrabbit
+  class Message
+    attr_reader :info, :message, :payload, :channel
+
+    def initialize(info, message, payload, channel)
+      @info = info
+      @message = message
+      @payload = payload
+      @channel = channel
+    end
+
+    def acknowledge!
+      channel.acknowledge(info.delivery_tag, false)
+    end
+  end
+end

data/lib/jackrabbit/message_receiver.rb

@@ -0,0 +1,21 @@
+module Jackrabbit
+  class MessageReceiver
+    attr_reader :channel, :options, :handler
+
+    def initialize(channel, options = {}, &block)
+      @channel = channel
+      @options = options
+      handle_with(&block) if block_given?
+    end
+
+    def handle(info, message, payload)
+      @handler.call Message.new(info, message, payload, channel)
+    end
+
+    private
+
+    def handle_with(&block)
+      @handler = block
+    end
+  end
+end

data/lib/jackrabbit/version.rb

@@ -0,0 +1,3 @@
+module Jackrabbit
+  VERSION = "0.0.2"
+end

data/spec/lib/jackrabbit/client_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+require 'jackrabbit'
+
+describe Jackrabbit::Client do
+  subject(:client) { Jackrabbit::Client.new(config) }
+
+  let(:config) do
+    Jackrabbit::Config.new.tap do |config|
+      config.exchange_name = 'bunk'
+      config.exchange_type = 'topic'
+      config.connection = BunnyHair.new
+    end
+  end
+
+  describe '#config' do
+    it 'is defaulted to the global config' do
+      client = Jackrabbit::Client.new
+      expect(client.config).to be(Jackrabbit.config)
+    end
+
+    it 'can be injected in on initialization' do
+      config = double
+      client = Jackrabbit::Client.new(config)
+      expect(client.config).to be(config)
+    end
+  end
+
+  describe '#channel' do
+    it 'returns the default channel' do
+      expect(client.channel).to_not be_nil
+    end
+  end
+
+  describe '#exchange' do
+    it 'returns an exchange' do
+      expect(client.exchange.name).to eq('bunk')
+      expect(client.exchange.type).to eq(:topic)
+    end
+
+    it 'raises an error when the config specifies an incorrect type' do
+      config.exchange_type = 'nothin'
+      expect { client.exchange }.to raise_error(Jackrabbit::Client::InvalidExchangeType)
+    end
+  end
+
+  describe '#publish' do
+    it 'pushes a message onto the exchange' do
+      expect(client.exchange).to receive(:publish).with(
+        'message', anything
+      ).and_call_original
+
+      client.publish('message')
+    end
+
+    it 'publishes with options passed' do
+      expect(client.exchange).to receive(:publish).with(
+        'payload', routing_key: 'bunk'
+      ).and_call_original
+
+      client.publish('payload', routing_key: 'bunk')
+    end
+  end
+
+  describe '#bonded_queue' do
+    def test_queues
+      client.channel.test_queues
+    end
+
+    it 'creates a queue' do
+      client.bonded_queue('name')
+      expect(test_queues[0].name).to eq('name')
+    end
+
+    it 'creates a queue with options set' do
+      client.bonded_queue('name', durable: true, exclusive: true, auto_delete: true)
+      expect(test_queues[0]).to be_auto_delete
+      expect(test_queues[0].options[:durable]).to be_truthy
+      expect(test_queues[0].options[:exclusive]).to be_truthy
+    end
+
+    it 'creates a consumer for the queue' do
+      client.bonded_queue('name')
+      expect(test_queues.first.consumers.size).to be(1)
+    end
+
+    it 'handles the messages in the block when the exchange gets a message' do
+      assertion = double('foo', asserted: false)
+      client.bonded_queue('bunk') do |message|
+        assertion.asserted(message)
+      end
+
+      client.publish('message')
+
+      expect(assertion).to have_received(:asserted).with(instance_of(Jackrabbit::Message)).once
+    end
+
+    context 'binding' do
+      it 'passes binding options to the queue binding' do
+        queue = BunnyHair::Queue.new('bunk')
+        allow(client.channel).to receive(:queue).and_return(queue)
+        expect(queue).to receive(:bind).with(client.exchange, routing_key: 'bunk')
+
+        client.bonded_queue('foo', binding: { routing_key: 'bunk' })
+      end
+    end
+
+    context 'subscriptions' do
+      it 'passes subscription options to the queue subscription' do
+        queue = BunnyHair::Queue.new('bunk')
+        allow(client.channel).to receive(:queue).and_return(queue)
+        expect(queue).to receive(:subscribe).with(ack: true)
+
+        client.bonded_queue('foo', subscription: { ack: true })
+      end
+    end
+  end
+end

data/spec/lib/jackrabbit/config_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'jackrabbit'
+
+describe Jackrabbit::Config do
+  def has_a_setting_for(setting)
+    value = 'bunk'
+    expect(subject).to respond_to("#{setting}=")
+    subject.send("#{setting}=", value)
+
+    expect(subject.send(setting)).to be(value)
+  end
+
+  describe '.default' do
+    it 'returns a default instance of the config' do
+      config = Jackrabbit::Config.default
+      expect(config).to be_instance_of(Jackrabbit::Config)
+      expect(config).to be(Jackrabbit::Config.default)
+    end
+
+    it 'yields the instance to a block when passed in' do
+      expect {|b| Jackrabbit::Config.default(&b) }.to yield_with_args(instance_of(Jackrabbit::Config))
+    end
+  end
+
+  describe 'Settings' do
+    it { has_a_setting_for(:exchange_name) }
+    it { has_a_setting_for(:exchange_type) }
+    it { has_a_setting_for(:exchange_options) }
+    it { has_a_setting_for(:connection) }
+  end
+
+  describe 'Sane Defaults' do
+    it 'defaults the exchange options to an empty hash' do
+      config = Jackrabbit::Config.new
+      expect(config.exchange_options).to eq({})
+    end
+  end
+end

data/spec/lib/jackrabbit/exchange_spec.rb

@@ -0,0 +1,2 @@
+require 'spec_helper'
+require 'jackrabbit'

data/spec/lib/jackrabbit/message_receiver_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'jackrabbit'
+
+describe Jackrabbit::MessageReceiver do
+  let(:channel) { double('channel') }
+  let(:handler) do
+    Proc.new do |message|
+    end
+  end
+
+  describe '#initialize' do
+    it 'returns a message reciever instance' do
+      instance = Jackrabbit::MessageReceiver.new(channel, {}, &Proc.new {})
+      expect(instance.channel).to be(channel)
+      expect(instance.options).to eq({})
+      expect(instance.handler).to respond_to(:call)
+    end
+  end
+
+  describe '#handle' do
+    let(:assertion) { double('assertion', asserted: false) }
+    subject(:receiver) do
+      Jackrabbit::MessageReceiver.new(channel) do |message|
+        assertion.asserted(message)
+      end
+    end
+
+    it 'calls to the handler block' do
+      receiver.handle('info', 'message', 'payload')
+      expect(assertion).to have_received(:asserted)
+    end
+
+    it 'calls the handler block with a message object with the correct properties set' do
+      expect(assertion).to receive(:asserted) do |message|
+        expect(message.info).to eq('info')
+        expect(message.message).to eq('message')
+        expect(message.payload).to eq('payload')
+        expect(message.channel).to be(channel)
+      end
+
+      receiver.handle('info', 'message', 'payload')
+    end
+  end
+end

data/spec/lib/jackrabbit/message_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Jackrabbit::Message do
+  describe '#acknowledge!' do
+    let(:channel) { double('channel', acknowledge: false) }
+    let(:info) { double('info', delivery_tag: 1) }
+
+    subject(:message) { Jackrabbit::Message.new(info, double, double, channel) }
+
+    it 'acknowledges the message to the channel' do
+      expect(channel).to receive(:acknowledge).with(info.delivery_tag, false)
+      message.acknowledge!
+    end
+  end
+end

data/spec/lib/jackrabbit_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'jackrabbit'
+
+describe Jackrabbit do
+  describe '.config' do
+    it 'returns the default configuration object' do
+      config = double
+      allow(Jackrabbit::Config).to receive(:default).and_return(config)
+
+      expect(Jackrabbit.config).to be(config)
+    end
+
+    it 'yields the default configuration' do
+      expect {|b| Jackrabbit.config(&b) }.to yield_with_args(Jackrabbit::Config.default)
+    end
+  end
+
+  describe '.new' do
+    it 'returns a Jackrabbit::Client object' do
+      expect(Jackrabbit.new).to be_instance_of(Jackrabbit::Client)
+    end
+
+    it 'returns a client with the config set' do
+      client = Jackrabbit.new
+      expect(client.config).to be(Jackrabbit.config)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'jackrabbit'
+require 'bunny_hair'
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification
+name: jackrabbit
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Robert Ross
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc1
+- !ruby/object:Gem::Dependency
+  name: bunny_hair
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.10
+description: Jackrabbit simplifies doing very common tasks with RabbitMQ
+email:
+- robert@creativequeries.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- jackrabbit.gemspec
+- lib/core_ext.rb
+- lib/jackrabbit.rb
+- lib/jackrabbit/client.rb
+- lib/jackrabbit/config.rb
+- lib/jackrabbit/exchange.rb
+- lib/jackrabbit/message.rb
+- lib/jackrabbit/message_receiver.rb
+- lib/jackrabbit/version.rb
+- spec/lib/jackrabbit/client_spec.rb
+- spec/lib/jackrabbit/config_spec.rb
+- spec/lib/jackrabbit/exchange_spec.rb
+- spec/lib/jackrabbit/message_receiver_spec.rb
+- spec/lib/jackrabbit/message_spec.rb
+- spec/lib/jackrabbit_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/bobbytables/jackrabbit'
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Work with RabbitMQ in a more sane way
+test_files:
+- spec/lib/jackrabbit/client_spec.rb
+- spec/lib/jackrabbit/config_spec.rb
+- spec/lib/jackrabbit/exchange_spec.rb
+- spec/lib/jackrabbit/message_receiver_spec.rb
+- spec/lib/jackrabbit/message_spec.rb
+- spec/lib/jackrabbit_spec.rb
+- spec/spec_helper.rb