bunny_hair 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c14e6ea05db60ca10bdfe42bfb32c779598a1966
+  data.tar.gz: 80ba433d1b1619d9774aaf5606dfea4a3e731e9a
+SHA512:
+  metadata.gz: 9963a9760f1506d294eb44774b9fc92b72791b8e229bb48d0a79b45d97e18ed9b3b1fdeb06b877799a7a03d7e11d60ac498fc3c8833d51a4ef9249b938f09e31
+  data.tar.gz: d8d449cb1abb2f319eab3a13d3d722e0eaf6721e11cd656446d0ec591b6f4f971647023c99074aceeac9df61902ec6700cab7fb84dd3f17113dbf319df69b779

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/.rspec

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

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2012 Thunderbolt Labs LLC
+
+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,91 @@
+# BunnyHair
+
+This mock of Bunny is **NOT** complete. It includes common interfaces but does not encompass everything.
+
+Basically it covers:
+
+* Make a channel
+* Make an exchange
+* Make a queue
+* Bind that queue to the exchange
+* Subscribe to that queue with a block
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bunny_hair'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bunny_hair
+
+## Usage
+
+To get a great idea of what is actually possible with this gem, take a gander at the [specs](spec/).
+
+### Connections
+
+Typically you'll create a connection in Bunny by simply calling `Bunny.new`, this gem is essentially no different.
+
+	BunnyHair.new # => BunnyHair::Connection.new
+
+You can assume that this object will respond to the methods you actually care about, such as `#start` and `#create_channel`
+
+### Queues
+
+When using queues all publishing will happen immediately. For example...
+
+	connection = BunnyHair.new
+	channel = connection.create_channel
+
+	queue = channel.queue('my.queue')
+
+	queue.subscribe do |info, metadata, payload|
+		puts payload
+	end
+
+	queue.publish('Your payload')
+
+### Exchanges
+
+This gem also supports the creation / usage of exchanges. You can use them normally like you would in Bunny itself.
+
+	channel = connection.create_channel
+	topic_exchange = channel.topic('activity.events')
+
+	queue = channel.queue('my.queue', auto_delete: true)
+
+	queue.subscribe do |info, metadata, payload|
+		puts payload
+	end
+
+	queue.bind(topic_exchange, routing_key: 'activity.events')
+
+	topic_exchange.publish('hello', routing_key: 'activity.events')
+
+	$ => hello
+
+### A note about exchanges
+
+Exchanges in this gem do NOT follow the logic in a normal rabbitmq exchange. For example, you may have a queue with a routing_key set to `activity.#`
+If you bind that queue to the exchange, it will not matter what you publish on that exchange, the queue object **WILL** receive it.
+If you'd like to see this gem encorporate the logic of the separate exchange types, make a PR =)
+
+
+## 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
+
+# Copyright
+
+See license.txt for details

data/Rakefile

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

data/bunny_hair.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bunny_hair/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bunny_hair"
+  spec.version       = BunnyHair::VERSION
+  spec.authors       = ["Robert Ross"]
+  spec.email         = ["roberto@thunderboltlabs.com"]
+  spec.description   = %q{A simple replacement for Bunny}
+  spec.summary       = %q{Use this gem as a replacement for Bunny to do in-memory operations}
+  spec.homepage      = "https://github.com/thunderboltlabs/bunny_hair"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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.3"
+  spec.add_development_dependency "guard-rspec", "~> 3.0.0"
+  spec.add_development_dependency "pry", "~> 0.9.12.2"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.14.1"
+end

data/lib/bunny_hair/channel.rb

@@ -0,0 +1,29 @@
+module BunnyHair
+  class Channel
+    attr_reader :connection
+
+    def initialize(connection=BunnyHair.new)
+      @connection = connection
+    end
+
+    def queue(name, options={})
+      Queue.new(name, options)
+    end
+
+    def topic(name, options={})
+      Exchange.new(connection, :topic, name, options)
+    end
+
+    def fanout(name, options={})
+      Exchange.new(connection, :fanout, name, options)
+    end
+
+    def direct(name, options={})
+      Exchange.new(connection, :direct, name, options)
+    end
+
+    def ack(*args)
+    end
+    alias acknowledge ack
+  end
+end

data/lib/bunny_hair/connection.rb

@@ -0,0 +1,25 @@
+module BunnyHair
+  class Connection
+    attr_accessor :connected
+
+    def connected?
+      !!connected
+    end
+
+    def start
+      self.connected = true
+    end
+
+    def stop
+      self.connected = false
+    end
+
+    def create_channel
+      Channel.new
+    end
+
+    def default_channel
+      @channel ||= Channel.new
+    end
+  end
+end

data/lib/bunny_hair/consumer.rb

@@ -0,0 +1,33 @@
+module BunnyHair
+  class Consumer
+
+    # This interface has been stolen from Bunny itself
+    # https://github.com/ruby-amqp/bunny/blob/master/lib/bunny/consumer.rb
+    # specific commit: https://github.com/ruby-amqp/bunny/blob/f7844397ffcb1ef8b7a377c59335a154a6adfc26/lib/bunny/consumer.rb
+    attr_reader   :queue
+    attr_accessor :consumer_tag
+    attr_reader   :arguments
+    attr_reader   :no_ack
+    attr_reader   :exclusive
+
+    def initialize(queue)
+      @queue = queue || raise(ArgumentError, "queue is nil")
+
+      self.queue.consumers << self
+    end
+
+    def on_delivery(&block)
+      @on_delivery = block
+      self
+    end
+
+    def cancel
+      queue.consumers.delete(self)
+    end
+
+    def call(*args)
+      @on_delivery.call(*args) if @on_delivery
+    end
+    alias handle_delivery call
+  end
+end

data/lib/bunny_hair/exchange.rb

@@ -0,0 +1,39 @@
+require 'ostruct'
+
+module BunnyHair
+  class Exchange
+    attr_reader :name, :options, :connection, :type
+
+    def initialize(connection, type, name, options={})
+      @connection = connection
+      @name = name
+      @type = type
+      @options = options
+    end
+
+    def queues
+      @queues ||= []
+    end
+
+    def channel
+      Channel.new
+    end
+
+    def publish(message, options={})
+      queues.each do |queue|
+        queue.receive(OpenStruct.new, OpenStruct.new, message)
+      end
+    end
+
+    def method_missing(method, *args)
+      method_name  = method.to_s
+      is_predicate = false
+
+      if method_name =~ /^(.*)\?$/
+        return !!options[method_name.gsub('?', '').to_sym]
+      end
+
+      super
+    end
+  end
+end

data/lib/bunny_hair/queue.rb

@@ -0,0 +1,56 @@
+module BunnyHair
+  class Queue
+    attr_reader :name, :options, :message_count, :exchange, :messages
+
+    def initialize(name, options={})
+      @name = name
+      @options = options
+      @message_count = 0
+    	@messages ||= []
+    end
+
+    def consumers
+      @consumers ||= []
+    end
+
+    def bind(exchange, options={})
+      @exchange = exchange
+      exchange.queues << self
+    end
+
+    def delete
+			@exchange.queues.delete_if { |q| q.name == name }
+    end
+
+    def pop
+			@messages.pop
+    end
+
+    def subscribe(opts = {}, &block)
+      consumer = Consumer.new(self)
+      consumer.on_delivery(&block)
+
+      consumer
+    end
+
+    def receive(metadata, info, payload)
+      metadata ||= OpenStruct.new
+      info ||= OpenStruct.new
+
+      @messages << [metadata, info, payload]
+      @message_count += 1
+
+      consumers.each do |subscription|
+        subscription.call(info, metadata, payload)
+      end
+    end
+
+    def publish(payload)
+      receive(nil, nil, payload)
+    end
+
+    def auto_delete?
+      !!options[:auto_delete]
+    end
+  end
+end

data/lib/bunny_hair/version.rb

@@ -0,0 +1,3 @@
+module BunnyHair
+  VERSION = "0.0.9"
+end

data/lib/bunny_hair.rb

@@ -0,0 +1,13 @@
+require "bunny_hair/version"
+
+module BunnyHair
+  autoload :Connection, 'bunny_hair/connection'
+  autoload :Exchange, 'bunny_hair/exchange'
+  autoload :Channel, 'bunny_hair/channel'
+  autoload :Queue, 'bunny_hair/queue'
+  autoload :Consumer, 'bunny_hair/consumer'
+
+  def self.new(*)
+    Connection.new
+  end
+end

data/spec/lib/bunny_hair/channel_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe BunnyHair::Channel do
+  subject(:channel) { BunnyHair::Channel.new }
+  let(:connection) { BunnyHair.new }
+
+  describe '#initialize' do
+    it 'accepts a connection' do
+      instance = described_class.new(connection)
+      expect(instance.connection).to be(connection)
+    end
+  end
+
+  describe '#queue' do
+    it 'returns a queue' do
+      expect(channel.queue('queue')).to be_kind_of(BunnyHair::Queue)
+    end
+
+    it 'returns a queue with a name' do
+      queue = channel.queue('my name')
+      expect(queue.name).to eq('my name')
+    end
+
+    it 'returns a queue with the options set' do
+      options = { auto_delete: true }
+      queue = channel.queue('queue', options)
+      expect(queue.options).to eq(options)
+    end
+  end
+
+  describe '#topic' do
+    it 'returns a topic exchange' do
+      exchange = channel.topic('my.topic.exchange', durable: true)
+      expect(exchange.name).to eq('my.topic.exchange')
+      expect(exchange.type).to be(:topic)
+      expect(exchange).to be_durable
+    end
+  end
+
+  describe '#fanout' do
+    it 'returns a fanout exchange' do
+      exchange = channel.fanout('my.fanout.exchange', durable: true)
+      expect(exchange.name).to eq('my.fanout.exchange')
+      expect(exchange.type).to be(:fanout)
+      expect(exchange).to be_durable
+    end
+  end
+
+  describe '#direct' do
+    it 'returns a direct exchange' do
+      exchange = channel.direct('my.direct.exchange', durable: true)
+      expect(exchange.name).to eq('my.direct.exchange')
+      expect(exchange.type).to be(:direct)
+      expect(exchange).to be_durable
+    end
+  end
+
+  describe '#ack' do
+    it { should respond_to :ack }
+  end
+end

data/spec/lib/bunny_hair/connection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe BunnyHair::Connection do
+  subject(:connection) { BunnyHair::Connection.new }
+
+  describe '#connected?' do
+    it 'returns true when start is called' do
+      connection.start
+      expect(connection).to be_connected
+    end
+
+    it 'returns false when started and stopped' do
+      connection.start
+      connection.stop
+
+      expect(connection).to_not be_connected
+    end
+
+    it 'returns false when never stopped' do
+      expect(connection).to_not be_connected
+    end
+  end
+
+  describe '#create_channel' do
+    it 'returns a channel' do
+      expect(connection.create_channel).to be_kind_of BunnyHair::Channel
+    end
+  end
+
+  describe '#default_channel' do
+    it 'returns a single channel' do
+      expect(connection.default_channel).to be_kind_of BunnyHair::Channel
+      object_1, object_2 = connection.default_channel, connection.default_channel 
+      expect(object_1).to eq object_2
+    end
+  end
+end

data/spec/lib/bunny_hair/consumer_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe BunnyHair::Consumer do
+  describe '#cancel' do
+    let(:queue) { BunnyHair::Queue.new('queue.name') }
+    subject(:consumer) { BunnyHair::Consumer.new(queue) }
+
+    it 'removes itself from the queues list of consumers' do
+      queue.consumers << consumer
+
+      consumer.cancel
+
+      expect(queue.consumers).to_not include(consumer)
+    end
+  end
+end

data/spec/lib/bunny_hair/exchange_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe BunnyHair::Exchange do
+  subject(:exchange) { BunnyHair::Exchange.new(connection, :topic, 'my.exchange', durable: true) }
+  let(:connection) { BunnyHair.new }
+
+  describe '#initialize' do
+    subject(:exchange) { BunnyHair::Exchange.new(connection, :direct, 'chickens', durable: true) }
+
+    it 'accepts a connection' do
+      expect { exchange }.to_not \
+        raise_exception
+    end
+
+    it 'accepts a type' do
+      expect(exchange.type).to be(:direct)
+    end
+
+    it 'accepts a name' do
+      expect(exchange.name).to eq('chickens')
+    end
+
+    it 'accepts options' do
+      expect(exchange.options).to eq(durable: true)
+    end
+  end
+
+  describe '#queues' do
+    it 'returns an array' do
+      expect(exchange.queues).to be_kind_of Array
+    end
+
+    it 'returns a memoized array' do
+      original = exchange.queues
+      expect(original).to be(exchange.queues)
+    end
+  end
+
+  describe '#channel' do
+    it 'returns a channel' do
+      expect(exchange.channel).to be_kind_of BunnyHair::Channel
+    end
+  end
+
+  describe '#publish' do
+    let(:queue) { double('queue', receive: true) }
+    before { exchange.queues << queue }
+
+    it 'calls #receive on all queues stored' do
+      exchange.publish('hello', {})
+      expect(queue).to have_received(:receive).with(instance_of(OpenStruct), instance_of(OpenStruct), 'hello').once
+    end
+  end
+
+  context 'predicate methods' do
+    it { should be_durable }
+    it { should_not be_full_of_crap }
+  end
+end

data/spec/lib/bunny_hair/queue_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe BunnyHair::Queue do
+  let(:channel) { BunnyHair.new.create_channel }
+  subject(:queue) { BunnyHair::Queue.new('queue.name') }
+  let(:exchange) { BunnyHair::Exchange.new(channel, :direct, 'my.exchange') }
+
+  describe '#consumers' do
+    it 'returns an array' do
+      expect(queue.consumers).to be_kind_of Array
+    end
+
+    it 'returns a memoized array' do
+      original = queue.consumers
+      expect(original).to be(queue.consumers)
+    end
+  end
+
+  describe '#bind' do
+    it 'attaches the queue to the exchange given' do
+      queue.bind(exchange, routing_key: 'hello.world')
+      expect(exchange).to have(1).queues
+    end
+  end
+
+  describe '#subscribe' do
+    it 'stores the subscription block' do
+      queue.subscribe do |metadata, info, payload|
+        "hello"
+      end
+
+      expect(queue).to have(1).consumers
+    end
+
+    it 'accepts options' do
+      expect do
+        queue.subscribe(ack: false) do |info, message, payload|
+          "hello"
+        end
+      end.to_not raise_error
+    end
+
+    it 'returns a consumer object' do
+      consumer = queue.subscribe do |i, m, p|
+        "hello"
+      end
+
+      expect(consumer).to be_kind_of(BunnyHair::Consumer)
+      expect(queue.consumers).to include(consumer)
+    end
+  end
+
+  describe '#delete' do
+		it 'removes queues' do
+      queue.bind(exchange, routing_key: 'hello.world')
+      queue.delete
+      expect(exchange).to have(0).queues
+		end
+	end
+
+  describe '#pop' do
+		it 'gets the last message on the queue' do
+			queue.receive({}, {}, 'hello')
+			message = queue.pop
+			expect(message[2]).to eq 'hello'
+		end
+  end
+
+  describe '#receive' do
+    let(:stunt_devil) { double('un diablo', fall: true) }
+
+    it 'runs all subscriptions with the information' do
+      queue.subscribe do |metadata, info, payload|
+        stunt_devil.fall(payload)
+      end
+
+      queue.receive({}, {}, 'hello')
+      expect(stunt_devil).to have_received(:fall).with('hello')
+    end
+  end
+
+  describe '#publish' do
+    let(:service) { double('service', payload: true) }
+
+    it 'accepts a payload' do
+      expect { queue.publish('payload') }.to_not raise_error
+    end
+
+    it 'calls the subscription with the payload' do
+      queue.subscribe do |delivery_info, metadata, payload|
+        service.payload(payload)
+      end
+
+      queue.publish('payload')
+      expect(service).to have_received(:payload).with('payload')
+    end
+  end
+
+  describe '#message_count' do
+    it 'stores how many messages it has received' do
+      3.times { queue.receive({}, {}, 'hello') }
+      expect(queue.message_count).to be(3)
+    end
+  end
+end

data/spec/lib/bunny_hair_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe BunnyHair do
+  describe '.new' do
+    it 'returns a connection object' do
+      instance = BunnyHair.new
+      expect(instance).to be_kind_of BunnyHair::Connection
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'bunny_hair'
+require 'pry'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: bunny_hair
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- Robert Ross
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12.2
+- !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: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+description: A simple replacement for Bunny
+email:
+- roberto@thunderboltlabs.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bunny_hair.gemspec
+- lib/bunny_hair.rb
+- lib/bunny_hair/channel.rb
+- lib/bunny_hair/connection.rb
+- lib/bunny_hair/consumer.rb
+- lib/bunny_hair/exchange.rb
+- lib/bunny_hair/queue.rb
+- lib/bunny_hair/version.rb
+- spec/lib/bunny_hair/channel_spec.rb
+- spec/lib/bunny_hair/connection_spec.rb
+- spec/lib/bunny_hair/consumer_spec.rb
+- spec/lib/bunny_hair/exchange_spec.rb
+- spec/lib/bunny_hair/queue_spec.rb
+- spec/lib/bunny_hair_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/thunderboltlabs/bunny_hair
+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: Use this gem as a replacement for Bunny to do in-memory operations
+test_files:
+- spec/lib/bunny_hair/channel_spec.rb
+- spec/lib/bunny_hair/connection_spec.rb
+- spec/lib/bunny_hair/consumer_spec.rb
+- spec/lib/bunny_hair/exchange_spec.rb
+- spec/lib/bunny_hair/queue_spec.rb
+- spec/lib/bunny_hair_spec.rb
+- spec/spec_helper.rb