queue-bus 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9002e9de95db1dfd0ed4cc3ba4196dd3d10fd46b3c2e568e12af7b0d0aa75306
-  data.tar.gz: '079f6ce144775b86c7f1e2214595a9e87e984f80f6636a2f9923f8c574d9bb83'
+  metadata.gz: 4f35ec72b2a6256350aabd9f2f6fa6591a1b625f404a3013ea73fb24876fb9e3
+  data.tar.gz: 00eb73580e6160d3932f43110c182832163ab5d3f9db34d44980b831cf4f7fdc
 SHA512:
-  metadata.gz: 1903f31f88bda747999ac8cefc2e2a8f60bafe06225d9fa3ea7b12ffee16c6e09ffcd448494edf15dd8f81d5d9576db97c815dcd78ae6526e94a487a7e3d2e40
-  data.tar.gz: a9b711c88a06812acd66210633cda67e2af46abf8db3960ba184fc54e078de2c07f85e36884317c48eb7820ed9fa66e4b8432b99edbf787e8246f48039f101c4
+  metadata.gz: 887ddce8443a1c17bc4db578a8d6b51d1a81906287db94ccd1f47681f30032cf485e1ed30e1a0feb56cc05b17162fae8f2ce28d07bad4b943a6dce7b40302c40
+  data.tar.gz: 34394be52205690b867bc2402563a9e970fa899250009481ed460f4b4909b8b8f3782bb4c5915d33eaccf6bebf2eebcedf8961628e539af6cde08646517f792f

data/.circleci/config.yml

@@ -0,0 +1,21 @@
+version: 2.1
+orbs:
+  ruby: circleci/ruby@0.1.2
+
+jobs:
+  build:
+    docker:
+      - image: circleci/ruby:2.6.3-stretch-node
+      - image: circleci/redis:4.0.12-alpine
+    executor: ruby/default
+    steps:
+      - checkout
+      - run:
+          name: Which bundler?
+          command: bundle -v
+      - ruby/bundle-install
+      - run:
+          name: Run tests
+          environment:
+            REDIS_URL: redis://127.0.0.1:6379
+          command: bundle exec rspec spec

data/CHANGELOG.md

@@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.9.1]
+
+### Added
+- Documented some of the major classes and modules
+
+### Fixed
+- Ran the rubocop autocorrect on the entire codebase.
+- Fixed issue that prevented heartbeat events from firing under certain conditions
+
 ## [0.9.0]
 
 ### Added

data/Gemfile

@@ -1,5 +1,7 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
 
 gemspec
 
-gem "rake"
+gem 'rake'

data/Rakefile

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 $LOAD_PATH.unshift 'lib'

data/lib/queue-bus.rb

@@ -1,8 +1,11 @@
-require "queue_bus/version"
-require "forwardable"
+# frozen_string_literal: true
 
-module QueueBus
+require 'queue_bus/version'
+require 'forwardable'
 
+# The main QueueBus module. Most operations you will need to execute should be executed
+# on this top level domain.
+module QueueBus
   autoload :Application,      'queue_bus/application'
   autoload :Config,           'queue_bus/config'
   autoload :Dispatch,         'queue_bus/dispatch'
@@ -22,25 +25,25 @@ module QueueBus
   autoload :Util,             'queue_bus/util'
   autoload :Worker,           'queue_bus/worker'
 
+  # A module for all adapters, current and future.
   module Adapters
     autoload :Base,           'queue_bus/adapters/base'
     autoload :Data,           'queue_bus/adapters/data'
   end
 
   class << self
-
     include Publishing
     extend Forwardable
 
     def_delegators :config, :default_app_key=, :default_app_key,
-                            :default_queue=, :default_queue,
-                            :local_mode=, :local_mode, :with_local_mode,
-                            :before_publish=, :before_publish_callback,
-                            :logger=, :logger, :log_application, :log_worker,
-                            :hostname=, :hostname,
-                            :adapter=, :adapter, :has_adapter?,
-                            :incoming_queue=, :incoming_queue,
-                            :redis, :worker_middleware_stack
+                   :default_queue=, :default_queue,
+                   :local_mode=, :local_mode, :with_local_mode,
+                   :before_publish=, :before_publish_callback,
+                   :logger=, :logger, :log_application, :log_worker,
+                   :hostname=, :hostname,
+                   :adapter=, :adapter, :has_adapter?,
+                   :incoming_queue=, :incoming_queue,
+                   :redis, :worker_middleware_stack
 
     def_delegators :_dispatchers, :dispatch, :dispatchers, :dispatcher_by_key, :dispatcher_execute
 

data/lib/queue_bus/adapters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueBus
   module Adapters
     class Base
@@ -19,12 +21,12 @@ module QueueBus
         raise NotImplementedError
       end
 
-      def enqueue(queue_name, klass, json)
+      def enqueue(_queue_name, _klass, _json)
         # enqueue the given class (Driver/Rider) in your queue
         raise NotImplementedError
       end
 
-      def enqueue_at(epoch_seconds, queue_name, klass, json)
+      def enqueue_at(_epoch_seconds, _queue_name, _klass, _json)
         # enqueue the given class (Publisher) in your queue to run at given time
         raise NotImplementedError
       end

data/lib/queue_bus/adapters/data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # a base adapter just for publishing and redis connection
 module QueueBus
   module Adapters
@@ -6,17 +8,16 @@ module QueueBus
         # nothing to do
       end
 
-      def redis=(client)
-        @redis = client
-      end
+      attr_writer :redis
 
       def redis(&block)
-        raise "no redis instance set" unless @redis
+        raise 'no redis instance set' unless @redis
+
         block.call(@redis)
       end
 
       def enqueue(queue_name, klass, json)
-        push(queue_name, :class => klass.to_s, :args => [json])
+        push(queue_name, class: klass.to_s, args: [json])
       end
 
       def enqueue_at(epoch_seconds, queue_name, klass, json)
@@ -24,7 +25,7 @@ module QueueBus
         delayed_push(epoch_seconds, item)
       end
 
-      def setup_heartbeat!(queue_name)
+      def setup_heartbeat!(_queue_name)
         raise NotImplementedError
       end
 
@@ -32,13 +33,13 @@ module QueueBus
 
       def push(queue, item)
         watch_queue(queue)
-        self.redis { |redis| redis.rpush "queue:#{queue}", ::QueueBus::Util.encode(item) }
+        redis { |redis| redis.rpush "queue:#{queue}", ::QueueBus::Util.encode(item) }
       end
 
       # Used internally to keep track of which queues we've created.
       # Don't call this directly.
       def watch_queue(queue)
-        self.redis { |redis| redis.sadd(:queues, queue.to_s) }
+        redis { |redis| redis.sadd(:queues, queue.to_s) }
       end
 
       # Used internally to stuff the item into the schedule sorted list.
@@ -46,7 +47,7 @@ module QueueBus
       # Insertion if O(log(n)).
       # Returns true if it's the first job to be scheduled at that time, else false
       def delayed_push(timestamp, item)
-        self.redis do |redis|
+        redis do |redis|
           # First add this item to the list for this timestamp
           redis.rpush("delayed:#{timestamp.to_i}", ::QueueBus::Util.encode(item))
 
@@ -56,9 +57,9 @@ module QueueBus
           redis.zadd :delayed_queue_schedule, timestamp.to_i, timestamp.to_i
         end
       end
-      
+
       def delayed_job_to_hash_with_queue(queue, klass, args)
-        {:class => klass.to_s, :args => args, :queue => queue}
+        { class: klass.to_s, args: args, queue: queue }
       end
     end
   end

data/lib/queue_bus/application.rb

@@ -1,33 +1,34 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # An Application is the top level unifier for a number of subscriptions. It allows for
+  # the toggling of an entire applications subscriptions.
   class Application
-
     class << self
-
       def all
         # note the names arent the same as we started with
-        ::QueueBus.redis { |redis| redis.smembers(app_list_key).collect{ |val| new(val) } }
+        ::QueueBus.redis { |redis| redis.smembers(app_list_key).collect { |val| new(val) } }
       end
     end
 
     attr_reader :app_key, :redis_key
 
-
     def initialize(app_key)
       @app_key = self.class.normalize(app_key)
       @redis_key = "#{self.class.app_single_key}:#{@app_key}"
       # raise error if only other chars
-      raise "Invalid application name" if @app_key.gsub("_", "").size == 0
+      raise 'Invalid application name' if @app_key.gsub('_', '').empty?
     end
 
     def subscribe(subscription_list, log = false)
       @subscriptions = nil
 
-      if subscription_list == nil || subscription_list.size == 0
+      if subscription_list.nil? || subscription_list.empty?
         unsubscribe
         return true
       end
 
-      temp_key = "temp_#{redis_key}:#{rand(999999999)}"
+      temp_key = "temp_#{redis_key}:#{rand(999_999_999)}"
 
       ::QueueBus.redis do |redis|
         redis_hash = subscription_list.to_redis
@@ -39,9 +40,7 @@ module QueueBus
         redis.rename(temp_key, redis_key)
         redis.sadd(self.class.app_list_key, app_key)
 
-        if log
-          redis.hgetall(redis_key).inspect
-        end
+        redis.hgetall(redis_key).inspect if log
       end
 
       true
@@ -68,7 +67,7 @@ module QueueBus
     def subscription_matches(attributes)
       out = subscriptions.matches(attributes)
       out.each do |sub|
-        sub.app_key = self.app_key
+        sub.app_key = app_key
       end
       out
     end
@@ -84,15 +83,15 @@ module QueueBus
     protected
 
     def self.normalize(val)
-      val.to_s.gsub(/\W/, "_").downcase
+      val.to_s.gsub(/\W/, '_').downcase
     end
 
     def self.app_list_key
-      "bus_apps"
+      'bus_apps'
     end
 
     def self.app_single_key
-      "bus_app"
+      'bus_app'
     end
 
     def event_queues
@@ -116,6 +115,5 @@ module QueueBus
       end
       out
     end
-
   end
 end

data/lib/queue_bus/dispatch.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 # Creates a DSL for apps to define their blocks to run for event_types
 
 module QueueBus
+  # A Dispatch object can be used to declare an application along with it's various subscriptions.
   class Dispatch
-
     attr_reader :app_key, :subscriptions
-    
+
     def initialize(app_key)
       @app_key = Application.normalize(app_key)
       @subscriptions = SubscriptionList.new
     end
-    
+
     def size
       @subscriptions.size
     end
-    
+
     def subscribe(key, matcher_hash = nil, &block)
-      dispatch_event("default", key, matcher_hash, block)
+      dispatch_event('default', key, matcher_hash, block)
     end
-    
+
     # allows definitions of other queues
     def method_missing(method_name, *args, &block)
       if args.size == 1 && block
@@ -28,7 +30,7 @@ module QueueBus
         super
       end
     end
-    
+
     def execute(key, attributes)
       sub = subscriptions.key(key)
       if sub
@@ -41,17 +43,17 @@ module QueueBus
     def subscription_matches(attributes)
       out = subscriptions.matches(attributes)
       out.each do |sub|
-        sub.app_key = self.app_key
+        sub.app_key = app_key
       end
       out
     end
-    
+
     def dispatch_event(queue, key, matcher_hash, block)
       # if not matcher_hash, assume key is a event_type regex
-      matcher_hash ||= { "bus_event_type" => key }
-      add_subscription("#{app_key}_#{queue}", key, "::QueueBus::Rider", matcher_hash, block)
+      matcher_hash ||= { 'bus_event_type' => key }
+      add_subscription("#{app_key}_#{queue}", key, '::QueueBus::Rider', matcher_hash, block)
     end
-    
+
     def add_subscription(queue_name, key, class_name, matcher_hash = nil, block)
       sub = Subscription.register(queue_name, key, class_name, matcher_hash, block)
       subscriptions.add(sub)

data/lib/queue_bus/dispatchers.rb

@@ -1,26 +1,33 @@
+# frozen_string_literal: true
+
 module QueueBus
+  # A collection of Dispatches
+  #
+  # Each Dispatch is an application with it's own set of subscriptions. This is a master object
+  # that provides some basic controls over the set of applications.
   class Dispatchers
-    def dispatch(app_key=nil, &block)
+    # Fetches a dispatch for the application key and binds the provided block to it.
+    def dispatch(app_key = nil, &block)
       dispatcher = dispatcher_by_key(app_key)
       dispatcher.instance_eval(&block)
       dispatcher
     end
-    
+
     def dispatchers
       @dispatchers ||= {}
       @dispatchers.values
     end
-    
+
     def dispatcher_by_key(app_key)
       app_key = Application.normalize(app_key || ::QueueBus.default_app_key)
       @dispatchers ||= {}
       @dispatchers[app_key] ||= Dispatch.new(app_key)
     end
-    
+
     def dispatcher_execute(app_key, key, attributes)
       @dispatchers ||= {}
       dispatcher = @dispatchers[app_key]
-      dispatcher.execute(key, attributes) if dispatcher
+      dispatcher&.execute(key, attributes)
     end
   end
 end

data/lib/queue_bus/driver.rb

@@ -1,7 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
-  # fans out an event to multiple queues
+  # Fans out an event to multiple queues
+  #
+  # When a single event is broadcast, it may have zero to many subscriptions attached to it.
+  # The Driver is what is run in order to look up the subscription matches and enqueue each
+  # of the jobs. It uses the class_name supplied by the subscription to know which class will
+  # be performed.
   class Driver
-
     class << self
       def subscription_matches(attributes)
         out = []
@@ -12,24 +18,23 @@ module QueueBus
         out
       end
 
-      def perform(attributes={})
-        raise "No attributes passed" if attributes.empty?
+      def perform(attributes = {})
+        raise 'No attributes passed' if attributes.empty?
 
         ::QueueBus.log_worker("Driver running: #{attributes.inspect}")
 
         subscription_matches(attributes).each do |sub|
           ::QueueBus.log_worker("  ...sending to #{sub.queue_name} queue with class #{sub.class_name} for app #{sub.app_key} because of subscription: #{sub.key}")
 
-          bus_attr = {  "bus_driven_at" => Time.now.to_i,
-                        "bus_rider_queue" => sub.queue_name,
-                        "bus_rider_app_key" => sub.app_key,
-                        "bus_rider_sub_key" => sub.key,
-                        "bus_rider_class_name" => sub.class_name}
+          bus_attr = {  'bus_driven_at' => Time.now.to_i,
+                        'bus_rider_queue' => sub.queue_name,
+                        'bus_rider_app_key' => sub.app_key,
+                        'bus_rider_sub_key' => sub.key,
+                        'bus_rider_class_name' => sub.class_name }
           bus_attr = bus_attr.merge(attributes || {})
           ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr)
         end
       end
     end
-
   end
 end