queue-bus 0.9.0 → 0.9.1

data/lib/queue_bus/subscriber.rb

@@ -1,28 +1,33 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A mixin to configure subscriptions on a particular class
   module Subscriber
-
     def self.included(base)
       base.extend ClassMethods
     end
 
+    # The class methods that will be added to the class it's included in. Use them to
+    # configure and subscribe.
     module ClassMethods
-
       def application(app_key)
         @app_key = ::QueueBus::Application.normalize(app_key)
       end
 
       def app_key
         return @app_key if @app_key
+
         @app_key = ::QueueBus.default_app_key
         return @app_key if @app_key
+
         # module or class_name
-        val = self.name.to_s.split("::").first
+        val = name.to_s.split('::').first
         @app_key = ::QueueBus::Util.underscore(val)
       end
 
       def subscribe(method_name, matcher_hash = nil)
         queue_name   = nil
-        queue_name ||= self.instance_variable_get(:@queue) || (self.respond_to?(:queue) && self.queue)
+        queue_name ||= instance_variable_get(:@queue) || (respond_to?(:queue) && queue)
         queue_name ||= ::QueueBus.default_queue
         queue_name ||= "#{app_key}_default"
         subscribe_queue(queue_name, method_name, matcher_hash)
@@ -30,10 +35,11 @@ module QueueBus
 
       def subscribe_queue(queue_name, method_name, matcher_hash = nil)
         klass = self
-        matcher_hash ||= {"bus_event_type" => method_name}
-        sub_key = "#{self.name}.#{method_name}"
+        matcher_hash ||= { 'bus_event_type' => method_name }
+        sub_key = "#{name}.#{method_name}"
         dispatcher = ::QueueBus.dispatcher_by_key(app_key)
-        dispatcher.add_subscription(queue_name, sub_key, klass.name.to_s, matcher_hash, lambda{ |att| klass.perform(att) })
+        dispatcher.add_subscription(queue_name, sub_key, klass.name.to_s, matcher_hash,
+                                    ->(att) { klass.perform(att) })
       end
 
       def transform(method_name)
@@ -42,8 +48,8 @@ module QueueBus
 
       def perform(attributes)
         ::QueueBus.with_global_attributes(attributes) do
-          sub_key = attributes["bus_rider_sub_key"]
-          meth_key = sub_key.split(".").last
+          sub_key = attributes['bus_rider_sub_key']
+          meth_key = sub_key.split('.').last
           queue_bus_execute(meth_key, attributes)
         end
       end
@@ -52,11 +58,11 @@ module QueueBus
         args = attributes
         args = send(@transform, attributes) if @transform
         args = [args] unless args.is_a?(Array)
-        if self.respond_to?(:subscriber_with_attributes)
-          me = self.subscriber_with_attributes(attributes)
-        else
-          me = self.new
-        end
+        me = if respond_to?(:subscriber_with_attributes)
+               subscriber_with_attributes(attributes)
+             else
+               new
+             end
         me.send(key, *args)
       end
     end

data/lib/queue_bus/subscription.rb

@@ -1,29 +1,36 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A Subscription is the destination of an event.
+  #
+  # The subscription can be stored in redis but should only be executed on ruby processes that
+  # have the application loaded. In general, this is controlled by having the background workers
+  # listen to specific (and discrete) queues.
   class Subscription
-
     class << self
       def register(queue, key, class_name, matcher, block)
         Subscription.new(queue, key, class_name, matcher, block)
       end
 
       def from_redis(hash)
-        queue_name = hash["queue_name"].to_s
-        key        = hash["key"].to_s
-        class_name = hash["class"].to_s
-        matcher    = hash["matcher"]
-        return nil if key.length == 0 || queue_name.length == 0
+        queue_name = hash['queue_name'].to_s
+        key        = hash['key'].to_s
+        class_name = hash['class'].to_s
+        matcher    = hash['matcher']
+        return nil if key.empty? || queue_name.empty?
+
         Subscription.new(queue_name, key, class_name, matcher, nil)
       end
 
       def normalize(val)
-        val.to_s.gsub(/\W/, "_").downcase
+        val.to_s.gsub(/\W/, '_').downcase
       end
     end
 
     attr_reader :matcher, :executor, :queue_name, :key, :class_name
-    attr_accessor :app_key  # dyanmically set on return from subscription_matches
+    attr_accessor :app_key # dyanmically set on return from subscription_matches
 
-    def initialize(queue_name, key, class_name, filters, executor=nil)
+    def initialize(queue_name, key, class_name, filters, executor = nil)
       @queue_name = self.class.normalize(queue_name)
       @key        = key.to_s
       @class_name = class_name.to_s
@@ -31,8 +38,12 @@ module QueueBus
       @executor   = executor
     end
 
+    # Executes the subscription. If this is run on a server/ruby process that did not subscribe
+    # it will error as there will not be a proc.
     def execute!(attributes)
-      attributes = attributes.with_indifferent_access if attributes.respond_to?(:with_indifferent_access)
+      if attributes.respond_to?(:with_indifferent_access)
+        attributes = attributes.with_indifferent_access
+      end
       ::QueueBus.with_global_attributes(attributes) do
         executor.call(attributes)
       end
@@ -44,12 +55,11 @@ module QueueBus
 
     def to_redis
       out = {}
-      out["queue_name"] = queue_name
-      out["key"]        = key
-      out["class"]      = class_name
-      out["matcher"]    = matcher.to_redis
+      out['queue_name'] = queue_name
+      out['key']        = key
+      out['class']      = class_name
+      out['matcher']    = matcher.to_redis
       out
     end
-
   end
 end

data/lib/queue_bus/subscription_list.rb

@@ -1,11 +1,23 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # Manages a set of subscriptions.
+  #
+  # The subscriptions are stored in redis but not by this class. Instead this class uses two
+  # functions `to_redis` and `from_redis` to facilitate serialization without accessing redis
+  # directly.
+  #
+  # To create a new SubscriptionList, use the static function `from_redis` and pass
+  # it a hash that came from redis.
+  #
+  # To get a value fro redis, take your loaded SubscriptionList and call `to_redis` on it. The
+  # returned value can be used to store in redis.
   class SubscriptionList
-
     class << self
       def from_redis(redis_hash)
         out = SubscriptionList.new
-        
-        redis_hash.each do |key, value|
+
+        redis_hash.each do |_key, value|
           sub = Subscription.from_redis(value)
           out.add(sub) if sub
         end
@@ -21,29 +33,35 @@ module QueueBus
       end
       out
     end
-    
+
     def initialize
       @subscriptions = {}
     end
-    
+
     def add(sub)
-      raise "Duplicate key: #{sub.key} already exists " \
-            "in the #{sub.queue_name} queue!" if @subscriptions.key?(sub.key)
+      if @subscriptions.key?(sub.key)
+        raise "Duplicate key: #{sub.key} already exists " \
+              "in the #{sub.queue_name} queue!"
+      end
       @subscriptions[sub.key] = sub
     end
-    
+
     def size
       @subscriptions.size
     end
-    
+
+    def empty?
+      size.zero?
+    end
+
     def key(key)
       @subscriptions[key.to_s]
     end
-    
+
     def all
       @subscriptions.values
     end
-    
+
     def matches(attributes)
       out = []
       all.each do |sub|
@@ -52,4 +70,4 @@ module QueueBus
       out
     end
   end
-end
+end

data/lib/queue_bus/task_manager.rb

@@ -1,27 +1,29 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A helper class for executing Rake tasks.
   class TaskManager
-
     attr_reader :logging
-    
+
     def initialize(logging)
       @logging = logging
     end
-    
+
     def subscribe!
       count = 0
       ::QueueBus.dispatchers.each do |dispatcher|
         subscriptions = dispatcher.subscriptions
-        if subscriptions.size > 0
-          count += subscriptions.size
-          log "Subscribing #{dispatcher.app_key} to #{subscriptions.size} subscriptions"
-          app = ::QueueBus::Application.new(dispatcher.app_key)
-          app.subscribe(subscriptions, logging)
-          log "  ...done"
-        end
+        next if subscriptions.empty?
+
+        count += subscriptions.size
+        log "Subscribing #{dispatcher.app_key} to #{subscriptions.size} subscriptions"
+        app = ::QueueBus::Application.new(dispatcher.app_key)
+        app.subscribe(subscriptions, logging)
+        log '  ...done'
       end
       count
     end
-    
+
     def unsubscribe!
       count = 0
       ::QueueBus.dispatchers.each do |dispatcher|
@@ -29,10 +31,10 @@ module QueueBus
         app = ::QueueBus::Application.new(dispatcher.app_key)
         app.unsubscribe
         count += 1
-        log "  ...done"
+        log '  ...done'
       end
     end
-    
+
     def queue_names
       # let's not talk to redis in here. Seems to screw things up
       queues = []
@@ -41,12 +43,12 @@ module QueueBus
           queues << sub.queue_name
         end
       end
-      
+
       queues.uniq
     end
-    
+
     def log(message)
       puts(message) if logging
     end
   end
-end
+end

data/lib/queue_bus/tasks.rb

@@ -1,36 +1,40 @@
+# frozen_string_literal: true
+
 # require 'queue_bus/tasks'
-# will give you these tasks
+# A useful set of rake tasks for managing your bus
 
+# rubocop:disable Metrics/BlockLength
 namespace :queuebus do
-
-  desc "Subscribes this application to QueueBus events"
-  task :subscribe => [ :preload ] do
+  desc 'Subscribes this application to QueueBus events'
+  task subscribe: [:preload] do
     manager = ::QueueBus::TaskManager.new(true)
     count = manager.subscribe!
-    raise "No subscriptions created" if count == 0
+    raise 'No subscriptions created' if count == 0
   end
 
-  desc "Unsubscribes this application from QueueBus events"
-  task :unsubscribe => [ :preload ] do
+  desc 'Unsubscribes this application from QueueBus events'
+  task unsubscribe: [:preload] do
     manager = ::QueueBus::TaskManager.new(true)
     count = manager.unsubscribe!
-    puts "No subscriptions unsubscribed" if count == 0
+    puts 'No subscriptions unsubscribed' if count == 0
   end
 
-  desc "List QueueBus queues that need worked"
-  task :queues => [ :preload ] do
+  desc 'List QueueBus queues that need worked'
+  task queues: [:preload] do
     manager = ::QueueBus::TaskManager.new(false)
     queues = manager.queue_names + ['bus_incoming']
-    puts queues.join(", ")
+    puts queues.join(', ')
   end
 
-  desc "list time based subscriptions"
-  task :list_scheduled => [ :preload ] do
+  desc 'list time based subscriptions'
+  task list_scheduled: [:preload] do
     scheduled_list = QueueBus::Application.all.flat_map do |app|
       app.send(:subscriptions).all
-        .select { |s| s.matcher.filters['bus_event_type'] == 'heartbeat_minutes'  }
+         .select { |s| s.matcher.filters['bus_event_type'] == 'heartbeat_minutes' }
+    end
+    scheduled_text_list = scheduled_list.collect do |e|
+      [e.key, e.matcher.filters['hour'] || '*', e.matcher.filters['minute'] || '*']
     end
-    scheduled_text_list = scheduled_list.collect { |e| [ e.key, e.matcher.filters['hour'] || "*", e.matcher.filters['minute'] || "*" ] }
     puts 'key, hour, minute'
     puts scheduled_text_list.sort_by { |(_, hour, minute)| [hour.to_i, minute.to_i] }.map(&:to_csv)
   end
@@ -41,3 +45,4 @@ namespace :queuebus do
     require 'queue-bus'
   end
 end
+# rubocop:enable Metrics/BlockLength

data/lib/queue_bus/util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'multi_json'
 
 module QueueBus
@@ -30,14 +32,14 @@ module QueueBus
         raise DecodeException, e.message, e.backtrace
       end
     end
-    
+
     def underscore(camel_cased_word)
       word = camel_cased_word.to_s.dup
       word.gsub!('::', '/')
       # word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
       word.downcase!
       word
     end
@@ -53,11 +55,11 @@ module QueueBus
       # string = string.sub(/^[a-z\d]*/) { inflections.acronyms[$&] || $&.capitalize }
       string = string.sub(/^[a-z\d]*/) { $&.capitalize }
       # string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
-      string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }
-      string.gsub!(/\//, '::')
+      string.gsub!(%r{(?:_|(/))([a-z\d]*)}i) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }
+      string.gsub!(%r{/}, '::')
       string
     end
-    
+
     def constantize(camel_cased_word)
       names = camel_cased_word.split('::')
       names.shift if names.empty? || names.first.empty?
@@ -75,6 +77,7 @@ module QueueBus
           constant = constant.ancestors.inject do |const, ancestor|
             break const    if ancestor == Object
             break ancestor if ancestor.const_defined?(name, false)
+
             const
           end
 
@@ -84,4 +87,4 @@ module QueueBus
       end
     end
   end
-end
+end

data/lib/queue_bus/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueBus
-  VERSION = "0.9.0"
+  VERSION = '0.9.1'
 end

data/lib/queue_bus/worker.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module QueueBus
   class Worker
-
     def self.perform(json)
       klass = nil
       attributes = ::QueueBus::Util.decode(json)
       begin
-        class_name = attributes["bus_class_proxy"]
+        class_name = attributes['bus_class_proxy']
         klass = ::QueueBus::Util.constantize(class_name)
       rescue NameError
         # not there anymore

data/queue-bus.gemspec

@@ -1,33 +1,34 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "queue_bus/version"
+# frozen_string_literal: true
+
+$:.push File.expand_path('lib', __dir__)
+require 'queue_bus/version'
 
 Gem::Specification.new do |s|
-  s.name        = "queue-bus"
+  s.name        = 'queue-bus'
   s.version     = QueueBus::VERSION
-  s.authors     = ["Brian Leonard"]
-  s.email       = ["brian@bleonard.com"]
-  s.homepage    = ""
-  s.summary     = %q{A simple event bus on top of background queues}
-  s.description = %q{A simple event bus on top of common background queues. Publish and subscribe to events as they occur using what you already have.}
+  s.authors     = ['Brian Leonard']
+  s.email       = ['brian@bleonard.com']
+  s.homepage    = ''
+  s.summary     = 'A simple event bus on top of background queues'
+  s.description = 'A simple event bus on top of common background queues. Publish and subscribe to events as they occur using what you already have.'
 
-  s.rubyforge_project = "queue-bus"
+  s.rubyforge_project = 'queue-bus'
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ['lib']
 
-  s.add_dependency("multi_json")
-  s.add_dependency("redis")
+  s.add_dependency('multi_json')
+  s.add_dependency('redis')
 
   # if using resque
   # s.add_development_dependency('resque', ['>= 1.10.0', '< 2.0'])
   # s.add_development_dependency('resque-scheduler', '>= 2.0.1')
   # s.add_development_dependency('resque-retry')
 
-  s.add_development_dependency("rspec")
-  s.add_development_dependency("timecop")
-  s.add_development_dependency("json_pure")
-  s.add_development_dependency("rubocop")
+  s.add_development_dependency('json_pure')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rubocop')
+  s.add_development_dependency('timecop')
 end