cottontail 0.1.5 → 2.0.0.pre.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fffe7fed426e7be9c4107730b1ca60cf85d6e976
+  data.tar.gz: 93d238e96dafe0b22e3497e41ac9f8041a3b7401
+SHA512:
+  metadata.gz: 6cf61ebc80120a7a4351a11c2a86b541c38bb9c93b0af68d84cfcb184c069b2eb00e2fc9e711e9ff8014736ee15da54a7c3c83a9f490de36ce4e7cb546d9c5f5
+  data.tar.gz: 62be0c8eac7b7abc0ac355c8c8e1a2bedd9f3817810b9bb349783ae2c2b58ec56062a10d5b3a283513cf757ff556f4adc1021cd8052fae2e16c3f4a1f684e2ea

data/.gitignore

@@ -1,4 +1,9 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,4 @@
+AllCops:
+  Exclude:
+    - '*.gemspec'
+    - 'Rakefile'

data/.travis.yml

@@ -0,0 +1,15 @@
+sudo: false
+
+language: ruby
+rvm:
+  - ruby-2.2.3
+
+script: "bundle exec rspec"
+cache: bundler
+
+services:
+  - rabbitmq
+
+notifications:
+  on_success: change
+  on_failure: change

data/Gemfile

@@ -1,4 +1,15 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in cottontail.gemspec
 gemspec
+
+group :development, :test do
+  gem 'rubocop'
+  gem 'byebug'
+
+  gem 'rspec-core', '~> 3'
+  gem 'rspec-expectations', '~> 3'
+
+  gem 'simplecov', require: false, platform: :ruby_21
+  gem 'coveralls', require: false, platform: :ruby_21
+end

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Rudolf Schmidt
+Copyright (c) 2012-2015 Rudolf Schmidt
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -2,6 +2,11 @@
 
 This library is a wrapper around the popular AMQP bunny gem. It is inspired by Sinatra to easily consume messages on different routing keys.
 
+[![Gem Version](https://badge.fury.io/rb/cottontail.svg)](https://badge.fury.io/rb/cottontail)
+[![Build Status](https://travis-ci.org/rudionrails/cottontail.svg?branch=master)](https://travis-ci.org/rudionrails/cottontail)
+[![Code Climate](https://codeclimate.com/github/rudionrails/cottontail/badges/gpa.svg)](https://codeclimate.com/github/rudionrails/cottontail)
+[![Coverage Status](https://coveralls.io/repos/rudionrails/cottontail/badge.svg?branch=master&service=github)](https://coveralls.io/github/rudionrails/cottontail?branch=master)
+
 ## Installation
 
 System wide:
@@ -22,30 +27,25 @@ When using this gem, you should already be familiar with RabbitMQ and, idealy, B
 
 ```ruby
 require 'cottontail'
-require 'bunny'
-
-class Worker < Cottontail::Base
-  # configure the Bunny client with the default connection (host: "localhost", port: 5672) 
-  # and with logging.
-  client :logging => true
 
-  # Declare `test` direct exchange which is bound to all queues of the type `topic`
-  exchange "test", :type => :topic
+class Worker
+  include Cottontail::Consumer
 
-  # Declare a durable `test` queue
-  queue "test", :durable => true
+  session ENV['RABBITMQ_URL'] do |session, worker|
+    channel = session.create_channel
 
+    queue = channel.queue('', durable: true)
+    worker.subscribe(queue, exclusive: true, ack: false)
+  end
 
-  # Consume messages on the routing key: `message.received`.Within the provided block 
-  # you have access to seleral methods. See Cottontail::Helpers for more details.
-  route "message.received" do
-    puts "This is the payload #{payload.inspect}"
+  consume do |delivery_info, properties, payload|
+    logger.info payload.inspect
   end
 end
 
-# The following will start Cottontail right away. You need to be aware that it 
+# The following will start Cottontail right away. You need to be aware that it
 # will enter the Bunny subscribe loop, so it will block the process.
-Worker.run
+Worker.start
 ```
 
 To run it, you may start it like the following code example. However, you should use a more sophisticated solution for daemonizing your processes in a production environment. See http://www.ruby-toolbox.com/categories/daemonizing for futher inspiration.
@@ -54,4 +54,4 @@ To run it, you may start it like the following code example. However, you should
 ruby worker.rb &
 ```
 
-Copyright &copy; 2012 Rudolf Schmidt, released under the MIT license
+Copyright &copy; 2012-2015 Rudolf Schmidt, released under the MIT license

data/Rakefile

@@ -1 +1 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'

data/cottontail.gemspec

@@ -6,6 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "cottontail"
   s.version     = Cottontail::VERSION
   s.authors     = ["Rudolf Schmidt"]
+  s.license     = 'MIT'
 
   s.homepage    = "http://github.com/rudionrails/cottontail"
   s.summary     = %q{Sinatra inspired wrapper around the AMQP Bunny gem}
@@ -18,5 +19,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "bunny"
+  s.add_runtime_dependency "bunny", "~> 2"
+  s.add_runtime_dependency "yell", ">= 2", "<= 3"
+  s.add_runtime_dependency "activesupport", ">= 3", "<= 4"
 end

data/lib/cottontail.rb

@@ -1,298 +1,10 @@
-require 'logger'
-require 'bunny'
+require 'yell'
 
-module Cottontail
-  class RouteNotFound < StandardError; end
+require File.dirname(__FILE__) + '/cottontail/configurable'
+require File.dirname(__FILE__) + '/cottontail/consumer'
 
-  module Helpers
-    # The last_error is accessable within an error block.
-    #
-    # last_error will be set once an exception was raise
-    attr_reader :last_error
+module Cottontail #:nodoc:
+  include Cottontail::Configurable
 
-    # A RabbitMQ message retrieved by Bunny usually contains the following information:
-    #   header [Qrack::Protocol::Header] The header of the message including size, properties, etc.
-    #   payload [String] The message sent through RabbitMQ
-    #   delivery_details [Hash] Includes the exchange, routing_key, etc
-    #
-    # This is the original message from the queue (not be confused with the payload sent via RabitMQ).
-    attr_reader :message
-
-    # Accessor to the message's payload
-    def payload; message[:payload]; end
-
-    # Accessor to the message's header
-    def header; message[:header]; end
-
-    # Accessor to the message's delivery details
-    def delivery_details; message[:delivery_details]; end
-
-    # Accessor to the delivery detail's routing key
-    def routing_key; delivery_details[:routing_key]; end
-  end
-
-  class Base
-    include Helpers
-
-    class << self
-      attr_reader :routes
-
-      # Conveniently set the client
-      def client( *args, &block )
-        set :client, args, &block
-      end
-
-      # Conveniently set the exchange
-      def exchange( *args, &block )
-        set :exchange, args, &block
-      end
-
-      # Conveniently set the queue
-      def queue( *args, &block )
-        set :queue, args, &block
-      end
-
-      # Set runtime configuration
-      #
-      # @example
-      #   set :logger, Logger.new(STDOUT)
-      #   set(:logger) { Logger.new(STDOUT) } # will be called on first usage
-      def set( key, value = nil, &block )
-        @settings[ key ] = block ? block : value
-      end
-
-      # Override the standard subscribe loop
-      #
-      # @example
-      #   subscribe :ack => false do |message|
-      #     puts "Received #{message.inspect}"
-      #     route! message
-      #   end
-      def subscribe( options = {}, &block )
-        set :subscribe, [ options, compile!("subscribe", &block) ]
-      end
-
-      # Defines routing on class level
-      #
-      # @example
-      #   route "message.sent" do
-      #     ... stuff to do ...
-      #   end
-      def route( key, options = {}, &block )
-        @routes[key] = [ options, compile!("route_#{key}", &block) ]
-      end
-
-      # Define error handlers
-      #
-      # @example Generic route
-      #   error do
-      #     puts "an error occured"
-      #   end
-      #
-      # @example Error on specific Exception
-      #   error RouteNotFound do
-      #     puts "Route not found for #{routing_key.inspect}"
-      #   end
-      def error( *codes, &block )
-        codes << :default if codes.empty? # the default error handling
-
-        compiled = compile!("error_#{codes.join("_")}", &block)
-        codes.each { |c| @errors[c] = compiled }
-      end
-
-      # Route on class level (handy for testing)
-      #
-      # @example
-      #   route! :payload => "some message", :routing_key => "v2.message.sent"
-      def route!( message )
-        new.route!( message )
-      end
-
-
-      # Retrieve the settings
-      #
-      # In case a block was given to a settings, it will be called upon first execution and set
-      # as the setting's value.
-      def settings( key )
-        if @settings[key].is_a? Proc
-          @settings[key] = @settings[key].call
-        end
-
-        @settings[key]
-      end
-
-      # Retrieve the error block for the passed Exception class
-      #
-      # If no class matches, the default will be returned in case it has been set (else nil).
-      def error_for( klass )
-        @errors[klass] || @errors[:default]
-      end
-
-      # convenience method to start the instance
-      def run; new.run; end
-
-      # Reset the class
-      def reset!
-        @settings = {}
-
-        @errors = {}
-        @routes = {}
-
-        # default logger
-        set :logger, Logger.new(STDOUT)
-
-        # retry settings
-        set :retries, true
-        set :delay_on_retry, 2
-
-        # default subscribe loop
-        set :subscribe, [{}, proc { |m| route! m }]
-
-        # default bunny options
-        client
-        exchange  "default"
-        queue     "default"
-      end
-
-
-      private
-
-        def inherited( subclass )
-          subclass.reset!
-          super
-        end
-
-        # compiles a given proc to an unbound method to be called later on a different binding
-        def compile!( name, &block )
-          define_method name, &block
-          method = instance_method name
-          remove_method name
-
-          block.arity == 0 ? proc { |a,p| method.bind(a).call } : proc { |a,*p| method.bind(a).call(*p) }
-        end
-
-    end
-
-
-    def initialize
-      reset!
-    end
-
-    # Starts the consumer service and enters the subscribe loop.
-    def run
-      # establish connection and bind routing keys
-      logger.debug "[Cottontail] Connecting to client: #{settings(:client).inspect}"
-      @client = Bunny.new( *settings(:client) )
-      @client.start
-
-      logger.debug "[Cottontail] Declaring exchange: #{settings(:exchange).inspect}"
-      exchange = @client.exchange( *settings(:exchange) )
-
-      logger.debug "[Cottontail] Declaring queue: #{settings(:queue).inspect}"
-      queue = @client.queue( *settings(:queue) )
-
-      routes.keys.each do |key| 
-        logger.debug "[Cottontail] Binding #{key.inspect}"
-        queue.bind( exchange, :key => key )
-      end
-
-      # enter the subscribe loop
-      subscribe!( queue )
-    rescue Exception => e
-      @client.stop if @client
-      reset!
-
-      logger.error "#{e.class}: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
-
-      # raise when no retries are defined
-      raise( e, caller ) unless settings(:retries)
-
-      logger.debug "[Cottontail] Going to retry in #{settings(:delay_on_retry)} seconds..."
-      sleep settings(:delay_on_retry) if settings(:delay_on_retry)
-      retry
-    end
-
-    # Performs the routing of the given AMQP message
-    #
-    # The method will raise an error if no route was found or an exception 
-    # was raised within matched routing block.
-    def route!( message )
-      @message = message
-
-      options, block = routes[routing_key]
-
-      raise Cottontail::RouteNotFound.new(routing_key) if block.nil?
-      block.call(self)
-    end
-
-
-    private
-
-      # Retrieve routes
-      def routes; self.class.routes; end
-
-      # Retrieve settings
-      def settings(key); self.class.settings(key); end
-
-      # Conveniently access the logger
-      def logger; settings(:logger); end
-
-      # Reset the instance
-      def reset!
-        @client = nil
-
-        prepare_client_settings!
-      end
-
-      # Handles the subscribe loop on the queue.
-      def subscribe!( queue )
-        logger.debug "[Cottontail] Entering subscribe loop"
-
-        options, block = settings(:subscribe)
-        queue.subscribe( options ) do |m|
-          with_error_handling!( m, &block )
-        end
-      end
-
-      # Gracefully handles the given message.
-      #
-      # @param [Message] m The RabbitMQ message to be handled
-      def with_error_handling!( m, &block )
-        block.call(self, m)
-      rescue Exception => err
-        @last_error = err
-
-        if block = self.class.error_for(err.class)
-          block.call(self)
-        else
-          # if no defined exception handling block could be found, then re-raise
-          raise( err, caller )
-        end
-      ensure
-        @last_error = nil # unset error after handling
-      end
-
-      # The bunny gem itself is not able to handle multiple hosts - although multiple RabbitMQ instances may run in parralel.
-      #
-      # You may pass :hosts as option when settings the client in order to cycle through them in case a connection was lost.
-      def prepare_client_settings!
-        return {} unless options = settings(:client).first
-
-        if hosts = options[:hosts]
-          host, port = hosts.shift
-          hosts << [host, port]
-
-          options.merge!( :host => host, :port => port )
-        end
-
-        options
-      end
-
-    public
-
-      # === Perform the initial setup
-      reset!
-
-  end
+  set :logger, -> { Yell.new(:stdout, colors: true) }
 end
-