activerabbit 0.0.1.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9312851949bab1748e88bc939dead804a6a7fbf6
+  data.tar.gz: a2fd8ec02623cc4df00597a414af1cf38b2986f6
+SHA512:
+  metadata.gz: 01562dbb951775ffe7d124e322aca6e109a85b4a88240051985ad8a4ac3219a4dce42c2f52dc7399b8c0f4fca6f3f45d965949c76c412bc39280d4b00108446f
+  data.tar.gz: f23d84c3768e817bd84a3c4a6c7195ca2726b5cd5cd06943c883d95c71f5b9189df622411b917f084abde288d027dddbdadb839d9272484a402b957628e1d31f

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+.idea
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format=documentation

data/.ruby-version

@@ -0,0 +1 @@
+2.2.4

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,49 @@
+ActiveRabbit
+============
+
+Easy to use workers for RabbitMQ + Ruby
+
+**Work in progress**
+
+## Getting Started
+Define your exchanges:
+
+```ruby
+# config/rabbit/exchanges.rb
+ActiveRabbit.configuration.exchanges.draw do
+  topic :logs
+  namespace :actions do
+    direct :login
+  end
+end
+```
+
+Define your queues:
+
+```ruby
+# config/rabbit/queues.rb
+ActiveRabbit.configuration.queues.draw do
+  queue :log_queue, bind: :logs, routing_key: '*.critical', exclusive: true
+end
+```
+
+
+Define your worker:
+
+```ruby
+# app/rabbit_consumers/log_queue_consumer.rb
+class LogQueueConsumer < ActiveRabbit::Consumer
+
+  def consume
+    puts message
+    puts message.body
+  end
+end
+```
+
+Publish to exchanges:
+
+```ruby
+message = 'Hello World!'
+ActiveRabbit.publish('actions.login', message)
+```

data/Rakefile

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

data/activerabbit.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_rabbit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "activerabbit"
+  spec.version       = ActiveRabbit::VERSION
+  spec.authors       = ['Christopher Thornton']
+  spec.email         = ['rmdirbin@gmail.com']
+  spec.summary       = %q{RabbitMQ publishers & consumers in a rails-inspired syntax}
+  # spec.description   = %q{TODO: Write a longer description. Optional.}
+  spec.homepage      = 'https://github.com/cgthornt/activerabbit'
+  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.required_ruby_version = '>= 2.0'
+
+  spec.add_dependency 'bunny',         '~> 2.0'
+  spec.add_dependency 'json'
+
+  spec.add_development_dependency 'rake', '~> 10.3.2'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'pry',   '~> 0.9'
+  spec.add_development_dependency 'awesome_print'
+end

data/example/rabbit/exchanges.rb

@@ -0,0 +1,3 @@
+ActiveRabbit.configuration.exchanges.draw do
+  direct :direct
+end

data/example/rabbit/queues.rb

@@ -0,0 +1,4 @@
+ActiveRabbit.configuration.queues.draw do
+  queue :notifications, bind: :direct
+  queue :logs, bind: :direct
+end

data/example/rabbit/sessions.yml

@@ -0,0 +1,3 @@
+development:
+  default:
+    host: localhost

data/example/run.rb

@@ -0,0 +1,27 @@
+require 'bundler/setup'
+require 'pry'
+require 'awesome_print'
+require 'activerabbit'
+
+ActiveRabbit.load_config_directory('example/rabbit')
+config = ActiveRabbit.configuration
+x = config.get_exchange(:direct)
+x.publish("I am a notification", routing_key: 'notifications')
+x.publish('I am a log', routing_key: 'logs')
+
+class FakeConsumer < ActiveRabbit::Consumer
+  bind :notifications, to: :notification_action
+  bind :logs, to: :log_action
+
+  def notification_action
+    binding.pry
+  end
+
+  def log_action
+    binding.pry
+  end
+end
+
+runner = ActiveRabbit::Runner.new(ActiveRabbit.configuration, FakeConsumer)
+
+runner.run!.wait!

data/lib/active_rabbit.rb

@@ -0,0 +1,42 @@
+require 'bunny'
+require 'active_rabbit/version'
+require 'logger'
+
+module ActiveRabbit
+  autoload :Bundle,        'active_rabbit/bundle'
+  autoload :Configuration, 'active_rabbit/configuration'
+  autoload :Consumer,      'active_rabbit/consumer'
+  autoload :Loggable,      'active_rabbit/loggable'
+  autoload :Message,       'active_rabbit/message'
+  autoload :Runner,        'active_rabbit/runner'
+  autoload :Util,          'active_rabbit/util'
+
+  class << self
+    attr_writer :logger
+
+    def version
+      VERSION
+    end
+
+    def logger
+      @logger = Logger.new(STDOUT)
+    end
+
+    def configuration
+      @default_bundle ||= Bundle.new
+    end
+
+    def load_config_directory(directory_path)
+      configuration.load_directory(directory_path)
+    end
+
+    def temporarily_taint_configuration(bundle)
+      raise ArgumentError, 'No block given' unless block_given?
+      original_bundle = configuration
+      @default_bundle = bundle
+      yield
+    ensure
+      @default_bundle = original_bundle
+    end
+  end
+end

data/lib/active_rabbit/bundle.rb

@@ -0,0 +1,73 @@
+require 'thread'
+
+module ActiveRabbit
+
+  # A giant blob of configuration objects into a single package
+  class Bundle
+    LOAD_DIRECTORY_MUTEX = Mutex.new
+
+    # @return [SessionLoader]
+    attr_accessor :session_loader
+
+    # @return [Exchange::ExchangeContext]
+    attr_accessor :exchange_context
+
+    # @return [Queue::QueueContext]
+    attr_accessor :queue_context
+
+    attr_reader :loaded_sessions
+
+    attr_accessor :environment
+
+    alias_method :exchanges, :exchange_context
+    alias_method :queues, :queue_context
+
+    def initialize(environment: nil)
+      @exchange_context = Configuration::Exchange::ExchangeContext.new
+      @queue_context = Configuration::Queue::QueueContext.new
+      @session_loader = Configuration::SessionLoader.new
+      @loaded_sessions = {}
+      @environment = environment || ENV['ACTIVERABBIT_ENV'] || 'development'
+    end
+
+    def load_directory(directory_path)
+      LOAD_DIRECTORY_MUTEX.synchronize do
+        ActiveRabbit.temporarily_taint_configuration(self) do
+          glob = File.join(directory_path, '**', '*.rb')
+          Dir[glob].each do |file|
+            require File.expand_path(file)
+          end
+
+          config_file = File.join(directory_path, 'sessions.yml')
+          if File.exist?(config_file)
+            session_loader.load_yaml_file!(config_file, environment)
+          end
+        end
+      end
+    end
+
+    def get_session(name)
+      loaded_sessions[name] ||= session_loader.to_session(name).tap do |session|
+        session.start
+      end
+    end
+
+    def get_channel(name, thread = Thread.current)
+      thread["activerabbit_bundle_#{name}"] ||= get_session(name).create_channel
+    end
+
+    def get_exchange(qualified_name)
+      exchange_value = exchange_context.search_values!(qualified_name)
+      exchange_value.to_exchange(self)
+    end
+
+    def get_and_bind_queue(qualified_name)
+      queue_value = queue_context.search_values!(qualified_name)
+      queue_value.get_and_bind_queue(self)
+    end
+
+    def publish(qualified_name, message, publish_options = {})
+      get_exchange(qualified_name).publish(message, publish_options)
+    end
+  end
+end

data/lib/active_rabbit/configuration.rb

@@ -0,0 +1,8 @@
+module ActiveRabbit
+  module Configuration
+    autoload :Context,       'active_rabbit/configuration/context'
+    autoload :Exchange,      'active_rabbit/configuration/exchange'
+    autoload :SessionLoader, 'active_rabbit/configuration/session_loader'
+    autoload :Queue,         'active_rabbit/configuration/Queue'
+  end
+end

data/lib/active_rabbit/configuration/context.rb

@@ -0,0 +1,123 @@
+module ActiveRabbit::Configuration
+  class Context
+    attr_reader :parent_context
+
+    attr_reader :default_options
+
+    attr_reader :child_contexes
+
+    attr_reader :namespace_name
+
+    attr_reader :config_values
+
+    def initialize(namespace_name = nil, parent_context = nil, default_options = {})
+      @parent_context = parent_context
+      @default_options = default_options
+      @child_contexes = {}
+      @config_values = {}
+      @namespace_name = normalize_name(namespace_name) if namespace_name
+      if parent_context && parent_context.namespace_name && !parent_context.namespace_name.empty?
+        @namespace_name = "#{parent_context.namespace_name}.#{@namespace_name}"
+        @default_options = parent_context.default_options.merge!(default_options)
+      end
+      @default_options = default_default_options.merge(@default_options)
+    end
+
+    def default_default_options
+      {
+        session: :default
+      }
+    end
+
+    def qualify_name(name)
+      name = normalize_name(name)
+      if namespace_name && !namespace_name.empty?
+        "#{namespace_name}.#{name}"
+      else
+        name
+      end
+    end
+
+    def normalize_name(name)
+      if name.is_a?(Symbol)
+        name.to_s.gsub('_', '-')
+      elsif name.is_a?(String)
+        name
+      else
+        raise ArgumentError, "Expected String or Symbol, got #{name.class.name}"
+      end
+    end
+
+    def add_config_value(unqualified_name, value)
+      config_values[qualify_name(unqualified_name)] = value
+    end
+
+    def effective_options(options = {})
+      default_options.merge(options)
+    end
+
+    def parent_context?
+      !parent_context.nil?
+    end
+
+    def defaults(options = {})
+      default_options.merge!(options)
+    end
+
+    def namespace(name, default_options = {}, &block)
+      raise ArgumentError, 'block not given' unless block_given?
+      name = normalize_name(name)
+      context = self.class.new(name, self, default_options)
+      context.configure(&block)
+      child_contexes[name] = context
+    end
+
+    # Given a fully qualified value, i.e. "some.namespace.some-value",
+    # returns that value, or nil
+    def search_values(fully_qualified_name)
+      search_pieces(normalize_name(fully_qualified_name).split('.'))
+    end
+
+    def search_values!(fully_qualified_name)
+      search_values(fully_qualified_name) || raise(ArgumentError, "Unknown value '#{fully_qualified_name}'")
+    end
+
+    def search_pieces(fully_qualified_name_array)
+      # Last item
+      if !fully_qualified_name_array.any?
+        return nil
+      elsif fully_qualified_name_array.size == 1
+        item = fully_qualified_name_array[0]
+        return config_values[item]
+      else
+        search = fully_qualified_name_array.shift
+        if(context =  child_contexes[search])
+          return context.search_pieces(fully_qualified_name_array)
+        else
+          return null
+        end
+      end
+    end
+
+    def configure(&block)
+      instance_eval(&block)
+    end
+    alias_method :draw, :configure
+
+    def flatten_contexes
+      all_contexes = [this]
+      child_contexes.values.each do |child|
+        all_contexes.concat(child.flatten_contexes)
+      end
+      all_contexes
+    end
+
+    def all_values
+      values = config_values.dup
+      child_contexes.values.each do |child|
+        values.merge!(child.all_values)
+      end
+      values
+    end
+  end
+end

data/lib/active_rabbit/configuration/exchange.rb

@@ -0,0 +1,27 @@
+module ActiveRabbit::Configuration
+  module Exchange
+    class ExchangeContext < Context
+      def exchange(name, type, options = {})
+        # TODO: allow overriding name outside of convention
+        add_config_value(name, Value.new(qualify_name(name), type.to_sym, effective_options(options)))
+      end
+
+      def direct(name, options = {})
+        exchange(name, :direct, options)
+      end
+
+      def topic(name, options = {})
+        exchange(name, :topic, options)
+      end
+    end
+
+    # Maps to a Bunny::Exchange
+    class Value < Struct.new(:name, :type, :options)
+      def to_exchange(bundle)
+        Bunny::Exchange.new(
+            bundle.get_channel(options.fetch(:session)),
+            type, name, options)
+      end
+    end
+  end
+end

data/lib/active_rabbit/configuration/queue.rb

@@ -0,0 +1,77 @@
+module ActiveRabbit::Configuration
+  module Queue
+    class QueueContext < Context
+      def queue(name, options = {})
+        options = {routing_key: name.to_s}.merge(options.dup)
+        queue_name = options.delete(:name) || qualify_name(name)
+        value = Value.new(queue_name, effective_options(options))
+        add_config_value(name, value)
+      end
+
+      def durable(name, options = {})
+        queue(name, options.merge(durable: true))
+      end
+
+      def temporary(name, options = {})
+        queue(name, options.merge(exclusive: true, name: ''))
+      end
+    end
+
+    class Value < Struct.new(:queue_name, :options)
+      QUEUE_ONLY_KEYS = [:durable, :auto_delete, :exclusive, :arguments]
+
+      def qualified_exchange_name
+        @qualified_exchange_name ||= (options[:bind] || options[:exchange] || options[:x]).to_s
+      end
+
+      def routing_key
+        options[:routing_key]
+      end
+
+      def queue_only_options
+        ActiveRabbit::Util.hash_only_keys(options, *QUEUE_ONLY_KEYS)
+      end
+
+      def bind_only_options
+        ActiveRabbit::Util.hash_except_keys(options, *QUEUE_ONLY_KEYS)
+      end
+
+      def to_queue(bundle)
+        get_channel(bundle).queue(queue_name, queue_only_options)
+      end
+
+      def get_channel(bundle)
+        bundle.get_channel(options.fetch(:session))
+      end
+
+      def bind(queue, exchange)
+        queue.bind(exchange, bind_only_options)
+      end
+
+      def get_exchange(bundle)
+        if qualified_exchange_name.nil?
+          raise ArgumentError, 'No exchange name set; ensure in your exchange definition your queue is bound to an exchange'
+        end
+
+        exchange_value = bundle.exchange_context.search_values(qualified_exchange_name)
+
+        if exchange_value.nil?
+          raise ArgumentError, "Unknown exchange name '#{qualified_exchange_name}'; perhaps it is not defined?"
+        end
+
+        if exchange_value.options[:session] != options[:session]
+          raise ArgumentError, "Queue session does not match binded queue's session"
+        end
+
+        exchange_value.to_exchange(bundle)
+      end
+
+      def get_and_bind_queue(bundle)
+        queue = to_queue(bundle)
+        exchange = get_exchange(bundle)
+        bind(queue, exchange)
+        queue
+      end
+    end
+  end
+end

data/lib/active_rabbit/configuration/session_loader.rb

@@ -0,0 +1,24 @@
+require 'yaml'
+
+module ActiveRabbit::Configuration
+
+  # Specifies a bunch of Bunny configurations
+  class SessionLoader < Hash
+    alias_method :define, :[]=
+
+    def load_yaml_file!(path_to_yaml, env)
+      results = YAML.load_file(path_to_yaml).fetch(env.to_s)
+      merge!(results)
+    end
+
+    def default
+      self['default']
+    end
+
+    def to_session(name)
+      value = fetch(name.to_s)
+      return value if value.is_a?(Bunny::Session)
+      Bunny::Session.new(value)
+    end
+  end
+end

data/lib/active_rabbit/consumer.rb

@@ -0,0 +1,39 @@
+module ActiveRabbit
+  class Consumer
+    class Binding < Struct.new(:queue_name, :method_name)
+    end
+
+    class << self
+      def bind(*queue_names, to:)
+        bindings.concat(queue_names.map do |queue_name|
+          Binding.new(queue_name, to)
+        end.to_a)
+      end
+
+      def bindings
+        @bindings ||= []
+      end
+
+      def process_message!(channel, method, message)
+        self.new(channel, message).send(method)
+      end
+    end
+
+    attr_reader :message, :_channel
+
+    def initialize(channel, message)
+      @message = message
+      @_channel = channel
+    end
+
+    def ack!(multiple = false)
+      _channel.acknowledge(message.delivery_info.delivery_tag, multiple)
+    end
+
+    def params
+      message.params
+    end
+
+
+  end
+end

data/lib/active_rabbit/loggable.rb

@@ -0,0 +1,11 @@
+module ActiveRabbit
+  module Loggable
+    def logger
+      ActiveRabbit.logger
+    end
+
+    def self.included(base)
+      base.extend Loggable
+    end
+  end
+end

data/lib/active_rabbit/message.rb

@@ -0,0 +1,32 @@
+require 'json'
+
+module ActiveRabbit
+  class Message
+    attr_reader :delivery_info, :properties, :body
+
+    def initialize(delivery_info, properties, body)
+      @delivery_info = delivery_info
+      @properties = properties
+      @body = body
+    end
+
+    def params
+      defined?(@params) ? @params : @params = calculate_params
+    end
+
+    def content_type
+      properties[:content_type].to_s.downcase
+    end
+
+    def routing_key
+      delivery_info[:routing_key]
+    end
+
+    protected
+
+    # TODO: allow parsing of other param types
+    def calculate_params
+      content_type == 'application/json' ? JSON.parse(body) : nil
+    end
+  end
+end

data/lib/active_rabbit/runner.rb

@@ -0,0 +1,68 @@
+require 'set'
+
+module ActiveRabbit
+  class Runner
+    include Loggable
+
+    attr_reader :bundle
+
+    attr_reader :consumer_klasses
+
+    attr_reader :bunny_consumers
+
+    def initialize(bundle, consumer_klasses)
+      @bundle = bundle
+      @consumer_klasses = Util.array_wrap(consumer_klasses)
+      @bunny_consumers = []
+    end
+
+    def run!
+      consumer_klasses.each do |klass|
+        run_consumer_klass(klass)
+      end
+      self
+    end
+
+    def wait!
+      logger.info 'Joining worker threads. INTERRUPT or Ctrl-C to exit'
+      joined = Set.new
+      bunny_consumers.each do |bunny_consumer|
+        channel = bunny_consumer.channel
+        next if joined.include?(channel)
+        joined << channel
+        channel.work_pool.join
+      end
+    rescue Interrupt => _
+      puts 'Exiting...'
+    end
+
+    protected
+
+    def run_consumer_klass(klass)
+      unless klass.bindings.any?
+        logger.warn "Consumer #{klass.name} does not bind to any queues; ignoring"
+        return
+      end
+
+      klass.bindings.each do |binding|
+        run_binding(klass, binding)
+      end
+    end
+
+    def run_binding(consumer_klass, binding)
+      unless consumer_klass.instance_methods(false).include?(binding.method_name)
+        raise "#{consumer_klass.name} does not define a method #{binding.method_name}"
+      end
+
+      queue_value = bundle.queue_context.search_values!(binding.queue_name)
+      queue = bundle.get_and_bind_queue(binding.queue_name)
+      bunny_consumer = queue.subscribe do |delivery_info,properties,body|
+        message = ActiveRabbit::Message.new(delivery_info, properties, body)
+        consumer_klass.process_message!(queue.channel, binding.method_name, message)
+      end
+      logger.info "Bound #{consumer_klass.name}##{binding.method_name} to queue '#{queue_value.queue_name}' (rabbitmq name: #{queue.name})"
+      @bunny_consumers << bunny_consumer
+    end
+
+  end
+end

data/lib/active_rabbit/util.rb

@@ -0,0 +1,54 @@
+# Because we don't want to import ActiveSupport
+module ActiveRabbit::Util
+  def self.hash_only_keys(hash, *only_keys)
+    new_hash = {}
+    union_keys = hash.keys | only_keys
+    union_keys.each do |key|
+      new_hash[key] = hash[key]
+    end
+    return new_hash
+  end
+
+  def self.hash_except_keys(hash, *except_keys)
+    new_hash = {}
+    new_keys = hash.keys - except_keys
+    new_keys.each do |key|
+      new_hash[key] = hash[key]
+    end
+    return new_hash
+  end
+
+  def self.string_underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+
+  def self.string_camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+    else
+      lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+    end
+  end
+
+  def self.string_constantize(camel_cased_word)
+    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+      raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+    end
+
+    Object.module_eval("::#{$1}", __FILE__, __LINE__)
+  end
+
+  def self.array_wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/lib/active_rabbit/version.rb

@@ -0,0 +1,3 @@
+module ActiveRabbit
+  VERSION = '0.0.1.beta1'
+end

data/lib/activerabbit.rb

@@ -0,0 +1 @@
+require 'active_rabbit'

data/spec/lib/active_rabbit/configuration/exchange_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe ActiveRabbit::Configuration::Exchange do
+
+  it 'supports a configuration block' do
+    context = ActiveRabbit::Configuration::Exchange::ExchangeContext.new
+    context.configure do
+      direct 'top-level'
+      namespace :my_namespace do
+        direct 'nested'
+      end
+    end
+
+    binding.pry
+
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+# Here for the future
+
+require 'active_rabbit'
+
+require 'pry'
+require 'awesome_print'

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: activerabbit
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta1
+platform: ruby
+authors:
+- Christopher Thornton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bunny
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  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'
+description: 
+email:
+- rmdirbin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- README.md
+- Rakefile
+- activerabbit.gemspec
+- example/rabbit/exchanges.rb
+- example/rabbit/queues.rb
+- example/rabbit/sessions.yml
+- example/run.rb
+- lib/active_rabbit.rb
+- lib/active_rabbit/bundle.rb
+- lib/active_rabbit/configuration.rb
+- lib/active_rabbit/configuration/context.rb
+- lib/active_rabbit/configuration/exchange.rb
+- lib/active_rabbit/configuration/queue.rb
+- lib/active_rabbit/configuration/session_loader.rb
+- lib/active_rabbit/consumer.rb
+- lib/active_rabbit/loggable.rb
+- lib/active_rabbit/message.rb
+- lib/active_rabbit/runner.rb
+- lib/active_rabbit/util.rb
+- lib/active_rabbit/version.rb
+- lib/activerabbit.rb
+- spec/lib/active_rabbit/configuration/exchange_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/cgthornt/activerabbit
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: RabbitMQ publishers & consumers in a rails-inspired syntax
+test_files:
+- spec/lib/active_rabbit/configuration/exchange_spec.rb
+- spec/spec_helper.rb