philotic 0.8.1 → 1.0.1

data/lib/philotic/{dummy_event.rb → dummy_message.rb}

@@ -1,10 +1,10 @@
-require 'philotic/event'
+require 'philotic/message'
 
 module Philotic
-  class DummyEvent < Philotic::Event
+  class DummyMessage < Philotic::Message
     attr_payload :subject
     attr_payload :message
-    attr_routable :gender
+    attr_routable :hue
     attr_routable :available
   end
 end

data/lib/philotic/logging.rb

@@ -1,4 +1,4 @@
-require 'philotic/logging/event'
+require 'philotic/logging/message'
 require 'philotic/logging/logger'
 
 module Philotic

data/lib/philotic/logging/logger.rb

@@ -1,15 +1,15 @@
 require 'logger'
-require 'philotic/logging/event'
+require 'philotic/logging/message'
 
 module Philotic
   module Logging
     class Logger < ::Logger
 
-      attr_writer :event_class
+      attr_writer :message_class
       attr_accessor :connection
 
-      def event_class
-        @event_class ||= Philotic::Logging::Event
+      def message_class
+        @message_class ||= Philotic::Logging::Message
       end
 
       def add(severity, message = nil, progname = nil)
@@ -28,8 +28,8 @@ module Philotic
         end
         @logdev.write(format_message(format_severity(severity), Time.now, progname, message))
         begin
-          event = event_class.new(severity, message, progname)
-          connection.publish event if connection
+          message = message_class.new(severity, message, progname)
+          connection.publish message if connection
         rescue => e
           @logdev.write(format_message(format_severity(Logger::ERROR), Time.now, progname, e.message))
         end

data/lib/philotic/logging/{event.rb → message.rb}

@@ -1,8 +1,8 @@
-require 'philotic/event'
+require 'philotic/message'
 
 module Philotic
   module Logging
-    class Event < Philotic::Event
+    class Message < Philotic::Message
       attr_routable :severity, :progname
       attr_payload :message
 

data/lib/philotic/message.rb

@@ -0,0 +1,146 @@
+require 'philotic/constants'
+require 'philotic/singleton'
+
+module Philotic
+  class Message
+
+    attr_accessor :connection, :publish_error, :delivery_info
+    attr_writer :published
+
+    class << self
+      def attr_routable_accessors
+        @attr_routable_accessors ||= Set.new
+      end
+
+      def attr_payload_accessors
+        @attr_payload_accessors ||= Set.new
+      end
+
+      def attr_routable(*names)
+        attr_routable_accessors.merge(names)
+        attr_accessor(*names)
+      end
+
+      def attr_payload(*names)
+        attr_payload_accessors.merge(names)
+        attr_accessor(*names)
+      end
+    end
+
+    def initialize(routables={}, payloads={}, connection=nil)
+      self.timestamp         = Time.now.to_i
+      self.philotic_firehose = true
+      self.connection        = connection
+
+      # dynamically insert any passed in routables into both attr_routable
+      # and attr_payload
+      # result:  ability to arbitrarily send a easily routable hash
+      # over into the bus
+      _set_routables_or_payloads(:routable, routables)
+      _set_routables_or_payloads(:payload, payloads)
+
+      @published = false
+    end
+
+    def self.inherited(sub_class)
+      sub_class.attr_routable(*Philotic::PHILOTIC_HEADERS)
+      sub_class.attr_routable(*self.attr_routable_accessors.dup)
+      sub_class.attr_payload(*self.attr_payload_accessors.dup)
+    end
+
+    self.inherited(self)
+
+    Philotic::MESSAGE_OPTIONS.each do |message_option|
+      attr_reader message_option
+      define_method :"#{message_option}=" do |val|
+        instance_variable_set(:"@#{message_option}", val)
+        self.metadata[message_option] = val
+      end
+    end
+
+    def connection
+      @connection ||= Philotic.connection
+    end
+
+    def published?
+      !!@published
+    end
+
+    def publish
+      connection.publish self
+    end
+
+    def self.publish(*args)
+      self.new(*args).publish
+    end
+
+    def delivery_tag
+      delivery_info.try(:delivery_tag)
+    end
+
+    def payload
+      _payload_or_headers(:payload)
+    end
+
+    def headers
+      _payload_or_headers(:routable)
+    end
+
+    def attributes
+      payload.merge headers
+    end
+
+    def metadata
+      @metadata ||= {}
+    end
+
+    def metadata=(options)
+      @metadata ||= {}
+      @metadata.merge! options
+    end
+
+    private
+
+    def _payload_or_headers(payload_or_headers)
+      attribute_hash = {}
+      self.class.send("attr_#{payload_or_headers}_accessors").each do |attr|
+        attr                 = attr.to_sym
+        attribute_hash[attr] = send(attr)
+      end
+      attribute_hash
+    end
+
+    def _set_routables_or_payloads(type, attrs)
+      attrs.each do |key, value|
+        if self.respond_to?(:"#{key}=")
+          send(:"#{key}=", value)
+        elsif self.class == Philotic::Message
+          _set_message_attribute(type, key, value)
+        end
+      end
+    end
+
+    def _set_message_attribute(type, key, value)
+      self.class.send("attr_#{type}_accessors").merge([key])
+      _set_message_attribute_accessor(key, value)
+    end
+
+    def _set_message_attribute_accessor(attr, value)
+      _set_message_attribute_getter(attr)
+      _set_message_attribute_setter(attr)
+      self.send(:"#{attr}=", value)
+    end
+
+    def _set_message_attribute_getter(attr)
+      self.define_singleton_method :"#{attr}" do
+        instance_variable_get(:"@#{attr}")
+      end
+    end
+
+    def _set_message_attribute_setter(attr)
+      self.define_singleton_method :"#{attr}=" do |v|
+        instance_variable_set(:"@#{attr}", v)
+      end
+    end
+  end
+end

data/lib/philotic/publisher.rb

@@ -4,7 +4,7 @@ module Philotic
   class Publisher
 
     attr_accessor :connection
-    attr_accessor :log_event_handler
+    attr_accessor :log_message_handler
 
     def initialize(connection)
       @connection = connection
@@ -18,16 +18,16 @@ module Philotic
       connection.config
     end
 
-    def publish(event)
-      message_metadata = {headers: event.headers}
-      message_metadata.merge!(event.message_metadata) if event.message_metadata
+    def publish(message)
+      metadata = {headers: message.headers}
+      metadata.merge!(message.metadata) if message.metadata
       begin
-        event.published = _publish(event.payload, message_metadata)
+        message.published = _publish(message.payload, metadata)
       rescue => e
-        event.publish_error = e
+        message.publish_error = e
         logger.error e.message
       end
-      event
+      message
     end
 
     def normalize_payload_times(payload)
@@ -41,45 +41,45 @@ module Philotic
     end
 
     private
-    def _publish(payload, message_metadata = {})
+    def _publish(payload, metadata = {})
       if config.disable_publish
-        log_event_published(:warn, message_metadata, payload, 'attempted to publish a message when publishing is disabled.')
+        log_message_published(:warn, metadata, payload, 'attempted to publish a message when publishing is disabled.')
         return false
       end
       connection.connect!
       unless connection.connected?
-        log_event_published(:error, message_metadata, payload, 'unable to publish event, not connected to RabbitMQ')
+        log_message_published(:error, metadata, payload, 'unable to publish message, not connected to RabbitMQ')
         return false
       end
-      message_metadata = merge_metadata(message_metadata)
+      metadata = merge_metadata(metadata)
 
       payload = normalize_payload_times(payload)
 
-      connection.exchange.publish(payload.to_json, message_metadata)
-      log_event_published(:debug, message_metadata, payload, 'published event')
+      connection.exchange.publish(payload.to_json, metadata)
+      log_message_published(:debug, metadata, payload, 'published message')
       true
     end
 
-    def merge_metadata(message_metadata)
+    def merge_metadata(metadata)
       publish_defaults = {}
       Philotic::MESSAGE_OPTIONS.each do |key|
         publish_defaults[key] = config.send(key.to_s)
       end
-      message_metadata           = publish_defaults.merge message_metadata
-      message_metadata[:headers] ||= {}
-      message_metadata[:headers] = {philotic_firehose: true}.merge(message_metadata[:headers])
-      message_metadata
+      metadata           = publish_defaults.merge metadata
+      metadata[:headers] ||= {}
+      metadata[:headers] = {philotic_firehose: true}.merge(metadata[:headers])
+      metadata
     end
 
-    def on_publish_event(&block)
-      @log_event_handler = block
+    def on_publish_message(&block)
+      @log_message_handler = block
     end
 
-    def log_event_published(severity, metadata, payload, message)
-      if @log_event_handler
-        @log_event_handler.call(severity, metadata, payload, message)
+    def log_message_published(severity, metadata, payload, message)
+      if @log_message_handler
+        @log_message_handler.call(severity, metadata, payload, message)
       else
-        logger.send(severity, "#{message}; message_metadata:#{metadata}, payload:#{payload.to_json}")
+        logger.send(severity, "#{message}; metadata:#{metadata}, payload:#{payload.to_json}")
       end
     end
   end

data/lib/philotic/subscriber.rb

@@ -1,4 +1,5 @@
 require 'philotic/constants'
+require 'philotic/message'
 
 module Philotic
   class Subscriber
@@ -17,18 +18,14 @@ module Philotic
       connection.config
     end
 
-    def subscription_callback(queue, &block)
+    def subscription_callback(&block)
       lambda do |delivery_info, metadata, payload|
         hash_payload = JSON.parse payload
 
-        event = {
-            payload:       hash_payload,
-            headers:       metadata[:headers],
-            delivery_info: delivery_info,
-            attributes:    metadata[:headers] ? hash_payload.merge(metadata[:headers]) : hash_payload
-        }
+        message = Philotic::Message.new(metadata[:headers], hash_payload)
+        message.delivery_info = delivery_info
 
-        instance_exec(event, metadata, queue, &block)
+        instance_exec(message, &block)
       end
     end
 
@@ -40,7 +37,7 @@ module Philotic
 
       queue = initialize_queue(subscription_settings)
 
-      queue.subscribe(subscription_settings[:subscribe_options], &subscription_callback(queue, &block))
+      queue.subscribe(subscription_settings[:subscribe_options], &subscription_callback(&block))
 
     end
 
@@ -53,7 +50,7 @@ module Philotic
 
     def get_subscription_settings(subscription, subscribe_options)
 
-      if subscription.is_a? String
+      if [Symbol, String].include? subscription.class
         queue_name    = subscription
         subscription  = subscribe_options
         queue_options = Philotic::DEFAULT_NAMED_QUEUE_OPTIONS
@@ -79,11 +76,11 @@ module Philotic
     end
 
     def acknowledge(message, up_to_and_including=false)
-      connection.channel.acknowledge(message[:delivery_info].delivery_tag, up_to_and_including)
+      connection.channel.acknowledge(message.delivery_tag, up_to_and_including)
     end
 
     def reject(message, requeue=true)
-      connection.channel.reject(message[:delivery_info].delivery_tag, requeue)
+      connection.channel.reject(message.delivery_tag, requeue)
     end
 
     def subscribe_to_any(options = {})

data/lib/philotic/version.rb

@@ -1,3 +1,3 @@
 module Philotic
-  VERSION = '0.8.1'
+  VERSION = '1.0.1'
 end

data/philotic.gemspec

@@ -16,20 +16,17 @@ Gem::Specification.new do |gem|
   gem.version       = Philotic::VERSION
   gem.licenses      = ['MIT']
 
-
   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 'bundler', '>= 1.6'
+  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 'awesome_print', '>= 1.2'
   gem.add_dependency 'bunny', '>= 1.6'
-  gem.add_dependency 'json', '~> 1.8'
+  gem.add_dependency 'json', '>= 1.8'
 end

data/philotic_queues.yml.example

@@ -1,19 +1,19 @@
-available_or_male:
-  gender: Male
+available_or_mauve:
+  hue: Mauve
   available: true
   x-match: any
   
-available_male:
-  gender: Male
+available_mauve:
+  hue: Mauve
   available: true
   x-match: all
   
-available_or_female:
-  gender: Female
+available_or_fuchsia:
+  hue: Fuchsia
   available: true
   x-match: any
   
-available_female:
-  gender: Female
+available_fuchsia:
+  hue: Fuchsia
   available: true
   x-match: all

data/spec/philotic/connection_spec.rb

@@ -1,5 +1,7 @@
 require 'spec_helper'
 
+require 'philotic/connection'
+
 describe Philotic::Connection do
 
 

data/spec/philotic/consumer_spec.rb

@@ -0,0 +1,186 @@
+require 'spec_helper'
+
+require 'philotic/consumer'
+require 'philotic/connection'
+require 'philotic/subscriber'
+
+
+describe Philotic::Consumer do
+  let(:named_queue) { :named_queue }
+  let(:anonymous_subscription) { {
+    header_1: :value_1,
+    header_2: :value_2,
+    header_3: :value_3,
+  } }
+  subject { Class.new Philotic::Consumer }
+
+  describe '.subscribe_to' do
+    it 'sets the class variable @subscription' do
+
+      expect(subject.subscription).not_to be
+
+      subject.subscribe_to named_queue
+      expect(subject.subscription).to eq named_queue
+
+      subject.subscribe_to anonymous_subscription
+      expect(subject.subscription).to eq anonymous_subscription
+    end
+  end
+
+  describe '.ack_messages' do
+    it 'sets the class variable @ack_messages' do
+      expect(subject.ack_messages?).not_to be true
+      subject.ack_messages
+      expect(subject.ack_messages?).to be true
+    end
+  end
+
+  describe '.exclusive' do
+    it 'sets the class variable @exclusive' do
+      expect(subject).not_to be_exclusive
+      subject.exclusive
+      expect(subject).to be_exclusive
+    end
+  end
+
+  describe '.requeueable_errors' do
+    it 'maintains a set of requeueable errors' do
+      expect(subject.requeueable_errors).to be_empty
+      expect(subject.requeueable_errors(RuntimeError).size).to be 1
+      expect(subject.requeueable_errors).to include(RuntimeError)
+
+      expect(subject.requeueable_errors(RuntimeError, NotImplementedError).size).to be 2
+      expect(subject.requeueable_errors).to include(NotImplementedError)
+
+
+      # don't allow dupes
+      expect(subject.requeueable_errors(RuntimeError, NotImplementedError).size).to be 2
+
+    end
+  end
+
+  describe '.rejectable_errors' do
+    it 'maintains a set of rejectable errors' do
+      expect(subject.rejectable_errors).to be_empty
+      expect(subject.rejectable_errors(RuntimeError).size).to be 1
+      expect(subject.rejectable_errors).to include(RuntimeError)
+
+      expect(subject.rejectable_errors(RuntimeError, NotImplementedError).size).to be 2
+      expect(subject.rejectable_errors).to include(NotImplementedError)
+
+
+      # don't allow dupes
+      expect(subject.rejectable_errors(RuntimeError, NotImplementedError).size).to be 2
+
+    end
+  end
+
+  describe '.subscribe' do
+    let (:connection) { instance_double Philotic::Connection }
+    let (:consumer_instance) { instance_double subject }
+    it 'proxies to, and returns, a new instance' do
+      expect(Philotic).to receive(:connection).and_return(connection)
+      expect(subject).to receive(:new).and_return(consumer_instance)
+      expect(consumer_instance).to receive(:subscribe)
+
+      expect(subject.subscribe).to be consumer_instance
+    end
+  end
+
+  describe '#subscription_options' do
+    it 'returns a hash with the exclusive and manual_ack options' do
+      expect(subject.subscription_options).to match({manual_ack: false, exclusive: false})
+
+      subject.ack_messages
+      expect(subject.subscription_options).to match({manual_ack: true, exclusive: false})
+
+      subject.exclusive
+      expect(subject.subscription_options).to match({manual_ack: true, exclusive: true})
+    end
+  end
+
+  describe '#subscribe' do
+    it 'proxies to Philotic::Subscriber#subscribe' do
+      subject.subscribe_to named_queue
+      subject.ack_messages
+      subject.exclusive
+
+      expect_any_instance_of(Philotic::Subscriber).to receive(:subscribe).with(named_queue, manual_ack: true, exclusive: true)
+
+      subject.subscribe
+    end
+  end
+
+  describe '#consume' do
+    subject { (Class.new(Philotic::Consumer)).new(nil) }
+
+    it 'raises an error unless the inheriting class redefines it' do
+      expect { subject.consume(nil) }.to raise_error(NotImplementedError)
+
+      subject.define_singleton_method :consume do |message|
+        # no op
+      end
+
+      expect { subject.consume(nil) }.to_not raise_error
+    end
+  end
+
+  describe '#_consume' do
+    subject { (Class.new(Philotic::Consumer)).new(nil) }
+    let(:message) { instance_double Philotic::Message }
+
+    it 'proxies to #consume' do
+      expect(subject).to receive(:consume).with(message)
+
+      subject.send(:_consume, message)
+    end
+
+    it 'acknowledges messages when @ack_messages is set' do
+      subject.class.ack_messages
+
+      subject.define_singleton_method :consume do |message|
+        # no op
+      end
+
+      expect(subject).to receive(:acknowledge).with(message)
+
+      subject.send(:_consume, message)
+    end
+
+    it 'requeues messages when @ack_messages is set and a requeueable error is thrown' do
+      subject.class.ack_messages
+      subject.class.requeueable_errors(RuntimeError)
+
+      subject.define_singleton_method :consume do |message|
+        raise RuntimeError.new 'oops'
+      end
+
+      expect(subject).to receive(:reject).with(message, true)
+
+      subject.send(:_consume, message)
+    end
+
+    it 'rejects messages when @ack_messages is set and a rejectable error is thrown' do
+      subject.class.ack_messages
+      subject.class.rejectable_errors(RuntimeError)
+
+      subject.define_singleton_method :consume do |message|
+        raise RuntimeError.new 'oops'
+      end
+
+      expect(subject).to receive(:reject).with(message, false)
+
+      subject.send(:_consume, message)
+    end
+
+    it 'raises all non-requeueable and non-rejectable errors' do
+      subject.class.ack_messages
+
+      subject.define_singleton_method :consume do |message|
+        raise RuntimeError.new 'oops'
+      end
+
+      expect {subject.send(:_consume, message)}.to raise_error RuntimeError
+    end
+  end
+end