philotic 0.0.1 → 0.1.0

data/lib/philotic/routable.rb

@@ -11,46 +11,6 @@ module Philotic
       base.extend ClassMethods
     end
 
-    def payload
-      attribute_hash = {}
-      self.class.attr_payload_readers.each do |attr|
-        attr = attr.to_sym
-        attribute_hash[attr] = send(attr)
-      end
-      attribute_hash
-    end
-
-    def headers
-      attribute_hash = {}
-      self.class.attr_routable_readers.each do |attr|
-        attr = attr.to_sym
-        attribute_hash[attr] = send(attr)
-      end
-      attribute_hash
-    end
-
-    def attributes
-      attribute_hash = {}
-      (self.class.attr_payload_readers + self.class.attr_routable_readers).each do |attr|
-        attr = attr.to_sym
-        attribute_hash[attr] = send(attr)
-      end
-      attribute_hash
-    end
-
-    def message_metadata
-      @message_metadata ||= {}
-    end
-
-    def message_metadata= options
-      @message_metadata ||= {}
-      @message_metadata.merge! options
-    end
-
-    def publish &block
-      Philotic::Publisher.publish(self, &block)
-    end
-
     module ClassMethods
       def attr_payload_reader *names
         attr_payload_readers.concat(names)
@@ -101,6 +61,46 @@ module Philotic
         attr_routable_writers.concat(names)
         attr_accessor(*names)
       end
+
+      def publish(*args, &block)
+        self.new(*args).publish(&block)
+      end
+    end
+
+    def payload
+      _payload_or_headers(:payload)
+    end
+
+    def headers
+      _payload_or_headers(:routable)
+    end
+
+    def attributes
+      payload.merge headers
+    end
+
+    def message_metadata
+      @message_metadata ||= {}
+    end
+
+    def message_metadata= options
+      @message_metadata ||= {}
+      @message_metadata.merge! options
+    end
+
+    def publish &block
+      Philotic::Publisher.publish(self, &block)
+    end
+
+    private
+
+    def _payload_or_headers(payload_or_headers)
+      attribute_hash = {}
+      self.class.send("attr_#{payload_or_headers}_readers").each do |attr|
+        attr                 = attr.to_sym
+        attribute_hash[attr] = send(attr)
+      end
+      attribute_hash
     end
   end
 end

data/lib/philotic/subscriber.rb

@@ -1,67 +1,86 @@
 module Philotic
   class Subscriber
-    def self.subscribe(options = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
-      if Philotic.connected?
-        _subscribe(options, subscribe_options, &block)
-      else
-        Philotic.connect! do
-          _subscribe(options, subscribe_options, &block)
-        end
+    class Metadata
+      attr_accessor :attributes
+
+      def initialize(attributes)
+        self.attributes = attributes
       end
     end
 
-    def self.subscribe_to_any_of(options = {}, &block)
-      arguments = options[:arguments] || {}
-      queue_options = options[:queue_options] || {}
-
-      arguments['x-match'] = 'any'
+    def self.subscription_callback
+      lambda do |delivery_info, metadata, payload|
+        hash_payload = JSON.parse payload
 
-      self.subscribe(options, &block)
+        event = {
+            payload:       hash_payload,
+            headers:       metadata[:headers],
+            delivery_info: delivery_info,
+            attributes:    metadata[:headers] ? hash_payload.merge(metadata[:headers]) : hash_payload
+        }
+        yield(Metadata.new(metadata), event)
+      end
     end
 
-    def self.subscribe_to_all_of(options = {}, &block)
-      arguments = options[:arguments] || {}
-      queue_options = options[:queue_options] || {}
+    def self.subscribe(subscription = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
+      Philotic.connect!
+      @exchange = Philotic::Connection.exchange
+
+      subscription_settings = get_subscription_settings subscription, subscribe_options
+
+      q = Philotic::Connection.channel.queue(subscription_settings[:queue_name], subscription_settings[:queue_options])
 
-      arguments['x-match'] = 'all'
+      q.bind(@exchange, arguments: subscription_settings[:arguments]) if subscription_settings[:arguments]
+
+      q.subscribe(subscription_settings[:subscribe_options], &subscription_callback(&block))
 
-      self.subscribe(options, &block)
     end
 
-    private
-    def self._subscribe(options = {}, subscribe_options = Philotic::DEFAULT_SUBSCRIBE_OPTIONS, &block)
-      @@exchange = Philotic::Connection.exchange
+    def self.get_subscription_settings(subscription, subscribe_options)
 
-      if options.is_a? String
-        queue_name = options
+      if subscription.is_a? String
+        queue_name    = subscription
+        subscription  = subscribe_options
         queue_options = Philotic::DEFAULT_NAMED_QUEUE_OPTIONS
-      else
-        queue_name = options[:queue_name] || ""
 
-        queue_options = Philotic::DEFAULT_ANONYMOUS_QUEUE_OPTIONS.merge(options[:queue_options] || {})
-        subscribe_options = subscribe_options.merge(options[:subscribe_options]) if options[:subscribe_options]
-        arguments = options[:arguments] || options
+      else
+        queue_name           = subscription[:queue_name] || ''
+        queue_options        = Philotic::DEFAULT_ANONYMOUS_QUEUE_OPTIONS
+        subscribe_options    = subscribe_options.merge(subscription[:subscribe_options]) if subscription[:subscribe_options]
+        arguments            = subscription[:arguments] || subscription
         arguments['x-match'] ||= 'all'
       end
 
-      queue_options[:auto_delete] ||= true if queue_name == ""
+      queue_options.merge!(subscription[:queue_options] || {})
 
-      callback = Proc.new do |metadata, payload|
-        hash_payload = JSON.parse payload
+      queue_options[:auto_delete] ||= true if queue_name == ''
 
-        event = {
-            payload: hash_payload,
-            headers: metadata.attributes[:headers],
-            attributes: metadata.attributes[:headers] ? hash_payload.merge(metadata.attributes[:headers]) : hash_payload
-        }
-        block.call(metadata, event)
-      end
-      q = AMQP.channel.queue(queue_name, queue_options)
+      {
+          queue_name:        queue_name,
+          queue_options:     queue_options,
+          arguments:         arguments,
+          subscribe_options: subscribe_options,
+      }
+    end
 
-      q.bind(@@exchange, arguments: arguments) if arguments
+    def self.acknowledge(message, up_to_and_including=false)
+      Philotic::Connection.channel.acknowledge(message[:delivery_info].delivery_tag, up_to_and_including)
+    end
 
-      q.subscribe(subscribe_options, &callback)
+    def self.reject(message, requeue=true)
+      Philotic::Connection.channel.reject(message[:delivery_info].delivery_tag, requeue)
+    end
 
+    def self.subscribe_to_any(options = {})
+      if block_given?
+        self.subscribe(options.merge(:'x-match' => :any), &Proc.new)
+      end
+    end
+
+    def self.endure
+      while true
+        Thread.pass
+      end
     end
   end
-end
+end

data/lib/philotic/tasks/init_queues.rb

@@ -9,20 +9,10 @@ namespace :philotic do
     require 'philotic'
 
     @filename = args[:filename]
-    queues = YAML.load_file(@filename)
-
-    EM.run do
-      def init_queues queues, index = 0
-        Philotic.initialize_named_queue!("#{queues.keys.sort[index]}", queues[queues.keys.sort[index]]) do |q|
-          if index == queues.size - 1
-            Philotic::Connection.close { EM.stop }
-          else
-            init_queues queues, index + 1
-          end
-        end
-      end
-
-      init_queues queues
+    queues    = YAML.load_file(@filename)
+    Philotic.connect!
+    queues.each_pair do |queue_name, queue_options|
+      Philotic.initialize_named_queue!(queue_name, queue_options)
     end
   end
 end

data/lib/philotic/version.rb

@@ -1,3 +1,3 @@
 module Philotic
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/philotic.gemspec

@@ -2,23 +2,34 @@
 require File.expand_path('../lib/philotic/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ['Nathan Keyes']
-  gem.email         = ['nkeyes@gmail.com']
-  gem.description   = %q{Lightweight, opinionated wrapper for using RabbitMQ headers exchanges}
-  gem.summary       = %q{Lightweight, opinionated wrapper for using RabbitMQ headers exchanges}
-  gem.homepage      = 'https://github.com/nkeyes/philotic'
+  gem.authors     = ['Nathan Keyes']
+  gem.email       = ['nkeyes@gmail.com']
+  gem.description = %q{Lightweight, opinionated wrapper for using RabbitMQ headers exchanges}
+  gem.summary     = %q{Lightweight, opinionated wrapper for using RabbitMQ headers exchanges}
+  gem.homepage    = 'https://github.com/nkeyes/philotic'
 
   gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.executables   = gem.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.name          = 'philotic'
   gem.require_paths = ['lib']
   gem.version       = Philotic::VERSION
-  gem.licenses       = ['MIT']
+  gem.licenses      = ['MIT']
 
-  gem.add_dependency 'activesupport', '~> 4.0'
-  gem.add_dependency 'activerecord', '~> 4.0'
-  gem.add_dependency 'amqp', '~> 1.2'
+
+  gem.add_development_dependency 'codeclimate-test-reporter'
+  gem.add_development_dependency 'bundler', '~> 1.6'
+  gem.add_development_dependency 'evented-spec', '~> 0.9'
+  gem.add_development_dependency 'pry', '~> 0.10'
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec', '~> 3.1'
+  gem.add_development_dependency 'rspec-its', '~> 1.1'
+  gem.add_development_dependency 'timecop', '~> 0.7'
+  gem.add_development_dependency 'simplecov'
+
+  gem.add_dependency 'activesupport', '>= 3.2'
+  gem.add_dependency 'activerecord', '>= 3.2'
   gem.add_dependency 'awesome_print', '~> 1.2'
+  gem.add_dependency 'bunny', '~> 1.2.1'
   gem.add_dependency 'json', '~> 1.8'
 end

data/spec/philotic/config_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Philotic::Config do
+
+  describe '.defaults' do
+  end
+
+  describe '.load' do
+  end
+
+  describe '.load_file' do
+  end
+
+  describe '.parse_rabbit_uri' do
+    let(:url) { 'amqp://user:pass@host:12345/vhost' }
+    before do
+      Philotic::Config.rabbit_url = url
+    end
+    subject { lambda { Philotic::Config.parse_rabbit_uri } }
+
+    it do
+      should change {
+        [
+            Philotic::Config.rabbit_user,
+            Philotic::Config.rabbit_password,
+            Philotic::Config.rabbit_host,
+            Philotic::Config.rabbit_port,
+            Philotic::Config.rabbit_vhost,
+        ]
+      }
+             .to [
+                     'user',
+                     'pass',
+                     'host',
+                     12345,
+                     'vhost',
+                 ]
+    end
+  end
+end

data/spec/philotic/connection_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Philotic::Connection do
+
+  describe '.config' do
+    its(:config) { should eq Philotic::Config }
+  end
+
+  describe '.connect!' do
+    context 'not connected' do
+      context 'success' do
+        specify do
+          expect(subject).to receive(:connected?).and_return(false, true)
+          expect(subject).to receive(:start_connection!)
+          expect(subject).to receive(:set_exchange_return_handler!)
+
+          subject.connect!
+
+        end
+      end
+
+      context 'failure' do
+        specify do
+          expect(subject).to receive(:connected?).and_return(false, false)
+          expect(subject).to receive(:start_connection!)
+          expect(subject).not_to receive(:set_exchange_return_handler!)
+          expect(Philotic.logger).to receive(:error)
+
+          subject.connect!
+
+        end
+      end
+    end
+
+    context 'not connected' do
+      context 'success' do
+        specify do
+          expect(subject).to receive(:connected?).and_return(true)
+          expect(subject).not_to receive(:start_connection!)
+          expect(subject).not_to receive(:set_exchange_return_handler!)
+
+          subject.connect!
+
+        end
+      end
+    end
+  end
+
+  describe '.start_connection!' do
+    let(:connection) { double }
+    specify do
+      expect(Bunny).to receive(:new).with(Philotic::Config.rabbit_url, Philotic::Connection.connection_settings).and_return(connection)
+      expect(connection).to receive(:start)
+
+      Philotic::Connection.start_connection!
+    end
+  end
+end

data/spec/philotic/event_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+# create 'deep' inheritance to test self.inherited
+class TestEventParent < Philotic::Event
+end
+class TestEvent < TestEventParent
+end
+
+describe Philotic::Event do
+  let(:event) { TestEvent.new }
+  subject { event }
+
+  Philotic::Routable::ClassMethods.instance_methods.sort.each do |method_name|
+    specify { expect(subject.class.methods).to include method_name.to_sym }
+  end
+
+  Philotic::MESSAGE_OPTIONS.each do |method_name|
+    specify { expect(subject.methods).to include method_name.to_sym }
+    specify { expect(subject.methods).to include "#{method_name}=".to_sym }
+  end
+
+  Philotic::PHILOTIC_HEADERS.each do |method_name|
+    specify { expect(subject.methods).to include method_name.to_sym }
+    specify { expect(subject.methods).to include "#{method_name}=".to_sym }
+  end
+
+  describe 'message_metadata' do
+    it 'should have a timestamp' do
+      Timecop.freeze
+      expect(subject.message_metadata).to eq(timestamp: Time.now.to_i)
+    end
+
+    it 'should reflect changes in the event properties' do
+      expect(subject.message_metadata[:app_id]).to eq nil
+      subject.app_id = 'ANSIBLE'
+      expect(subject.message_metadata[:app_id]).to eq 'ANSIBLE'
+    end
+  end
+  describe 'headers' do
+    it 'should include :philotic_product' do
+      expect(subject.headers.keys).to include :philotic_product
+    end
+  end
+  
+  context 'generic event' do
+    let(:headers) do
+      {
+          header1: 'h1',
+          header2: 'h2',
+          header3: 'h3',
+      }
+    end
+
+    let(:payloads) do
+      {
+          payload1: 'h1',
+          payload2: 'h2',
+          payload3: 'h3',
+      }
+    end
+    it 'builds an event with dynamic headers and payloads' do
+      event = Philotic::Event.new(headers, payloads)
+
+      expect(event.headers).to include(headers)
+      expect(event.payload).to eq payloads
+
+    end
+  end
+end