queue-bus 0.6.0 → 0.9.1

data/lib/queue_bus/tasks.rb

@@ -1,27 +1,42 @@
+# 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
+    scheduled_list = QueueBus::Application.all.flat_map do |app|
+      app.send(:subscriptions).all
+         .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
+    puts 'key, hour, minute'
+    puts scheduled_text_list.sort_by { |(_, hour, minute)| [hour.to_i, minute.to_i] }.map(&:to_csv)
   end
 
   # Preload app files if this is Rails
@@ -30,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.6.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,32 +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('json_pure')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rubocop')
+  s.add_development_dependency('timecop')
 end

data/spec/adapter/publish_at_spec.rb

@@ -1,51 +1,54 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe "Publishing an event in the future" do
+require 'spec_helper'
 
+describe 'Publishing an event in the future' do
   before(:each) do
     Timecop.freeze(now)
-    allow(QueueBus).to receive(:generate_uuid).and_return("idfhlkj")
+    allow(QueueBus).to receive(:generate_uuid).and_return('idfhlkj')
   end
   after(:each) do
     Timecop.return
   end
-  let(:delayed_attrs) { {
-                     "bus_delayed_until" => future.to_i,
-                     "bus_id" => "#{now.to_i}-idfhlkj",
-                     "bus_app_hostname" =>  `hostname 2>&1`.strip.sub(/.local/,'')} }
+  let(:delayed_attrs) do
+    {
+      'bus_delayed_until' => future.to_i,
+      'bus_id' => "#{now.to_i}-idfhlkj",
+      'bus_app_hostname' => `hostname 2>&1`.strip.sub(/.local/, '')
+    }
+  end
 
-  let(:bus_attrs) { delayed_attrs.merge({"bus_published_at" => worktime.to_i})}
-  let(:now)    { Time.parse("01/01/2013 5:00")}
+  let(:bus_attrs) { delayed_attrs.merge('bus_published_at' => worktime.to_i) }
+  let(:now)    { Time.parse('01/01/2013 5:00') }
   let(:future) { Time.at(now.to_i + 60) }
-  let(:worktime) {Time.at(future.to_i + 1)}
+  let(:worktime) { Time.at(future.to_i + 1) }
 
-  it "should add it to Redis then to the real queue" do
-    hash = {:one => 1, "two" => "here", "id" => 12 }
-    event_name = "event_name"
+  it 'should add it to Redis then to the real queue' do
+    hash = { :one => 1, 'two' => 'here', 'id' => 12 }
+    event_name = 'event_name'
     QueueBus.publish_at(future, event_name, hash)
 
-    schedule = QueueBus.redis { |redis| redis.zrange("delayed_queue_schedule", 0, 1) }
+    schedule = QueueBus.redis { |redis| redis.zrange('delayed_queue_schedule', 0, 1) }
     expect(schedule).to eq([future.to_i.to_s])
 
     val = QueueBus.redis { |redis| redis.lpop("delayed:#{future.to_i}") }
     hash = JSON.parse(val)
 
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    expect(hash["args"].size).to eq(1)
-    expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy"=>"QueueBus::Publisher", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(delayed_attrs))
-    expect(hash["queue"]).to eq("bus_incoming")
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ 'bus_class_proxy' => 'QueueBus::Publisher', 'bus_event_type' => 'event_name', 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(delayed_attrs))
+    expect(hash['queue']).to eq('bus_incoming')
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     expect(val).to eq(nil) # nothing really added
 
     Timecop.freeze(worktime)
-    QueueBus::Publisher.perform(JSON.parse(hash["args"].first))
+    QueueBus::Publisher.perform(JSON.parse(hash['args'].first))
 
-    val = QueueBus.redis { |redis| redis.lpop("queue:bus_incoming") }
+    val = QueueBus.redis { |redis| redis.lpop('queue:bus_incoming') }
     hash = JSON.parse(val)
-    expect(hash["class"]).to eq("QueueBus::Worker")
-    expect(hash["args"].size).to eq(1)
-    expect(JSON.parse(hash["args"].first)).to eq({"bus_class_proxy"=>"QueueBus::Driver", "bus_event_type"=>"event_name", "two"=>"here", "one"=>1, "id" => 12}.merge(bus_attrs))
+    expect(hash['class']).to eq('QueueBus::Worker')
+    expect(hash['args'].size).to eq(1)
+    expect(JSON.parse(hash['args'].first)).to eq({ 'bus_class_proxy' => 'QueueBus::Driver', 'bus_event_type' => 'event_name', 'two' => 'here', 'one' => 1, 'id' => 12 }.merge(bus_attrs))
   end
-
 end

data/spec/adapter/support.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require 'redis'
 
 def reset_test_adapter
   QueueBus.send(:reset)
   QueueBus.adapter = :data
-  QueueBus.adapter.redis = Redis.new
+  QueueBus.adapter.redis = if ENV['REDIS_URL']
+                             Redis.new(url: ENV['REDIS_URL'])
+                           else
+                             Redis.new
+                           end
 end
 
 def adapter_under_test_class

data/spec/adapter_spec.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
-describe "adapter is set" do
+describe 'adapter is set' do
   it "should call it's enabled! method on init" do
     QueueBus.send(:reset)
     expect_any_instance_of(adapter_under_test_class).to receive(:enabled!)
@@ -8,7 +10,7 @@ describe "adapter is set" do
     QueueBus.send(:reset)
   end
 
-  it "should be defaulting to Data from spec_helper" do
+  it 'should be defaulting to Data from spec_helper' do
     expect(QueueBus.adapter.is_a?(adapter_under_test_class)).to eq(true)
   end
 end

data/spec/application_spec.rb

@@ -1,151 +1,151 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Application do
-    describe ".all" do
-      it "should return empty array when none" do
+    describe '.all' do
+      it 'should return empty array when none' do
         expect(Application.all).to eq([])
       end
-      it "should return registered applications when there are some" do
-        Application.new("One").subscribe(test_list(test_sub("fdksjh")))
-        Application.new("Two").subscribe(test_list(test_sub("fdklhf")))
-        Application.new("Three").subscribe(test_list(test_sub("fkld")))
+      it 'should return registered applications when there are some' do
+        Application.new('One').subscribe(test_list(test_sub('fdksjh')))
+        Application.new('Two').subscribe(test_list(test_sub('fdklhf')))
+        Application.new('Three').subscribe(test_list(test_sub('fkld')))
 
-        expect(Application.all.collect(&:app_key)).to match_array(["one", "two", "three"])
+        expect(Application.all.collect(&:app_key)).to match_array(%w[one two three])
 
-        Application.new("two").unsubscribe
-        expect(Application.all.collect(&:app_key)).to match_array(["one", "three"])
+        Application.new('two').unsubscribe
+        expect(Application.all.collect(&:app_key)).to match_array(%w[one three])
       end
     end
 
-    describe ".new" do
-      it "should have a key" do
-        expect(Application.new("something").app_key).to eq("something")
+    describe '.new' do
+      it 'should have a key' do
+        expect(Application.new('something').app_key).to eq('something')
 
-        expect(Application.new("some thing").app_key).to eq("some_thing")
-        expect(Application.new("some-thing").app_key).to eq("some_thing")
-        expect(Application.new("some_thing").app_key).to eq("some_thing")
-        expect(Application.new("Some Thing").app_key).to eq("some_thing")
+        expect(Application.new('some thing').app_key).to eq('some_thing')
+        expect(Application.new('some-thing').app_key).to eq('some_thing')
+        expect(Application.new('some_thing').app_key).to eq('some_thing')
+        expect(Application.new('Some Thing').app_key).to eq('some_thing')
       end
 
-      it "should raise an error if not valid" do
-        expect {
-          Application.new("")
-        }.to raise_error(RuntimeError, "Invalid application name")
+      it 'should raise an error if not valid' do
+        expect do
+          Application.new('')
+        end.to raise_error(RuntimeError, 'Invalid application name')
 
-        expect {
+        expect do
           Application.new(nil)
-        }.to raise_error(RuntimeError, "Invalid application name")
+        end.to raise_error(RuntimeError, 'Invalid application name')
 
-        expect {
-          Application.new("/")
-        }.to raise_error(RuntimeError, "Invalid application name")
+        expect do
+          Application.new('/')
+        end.to raise_error(RuntimeError, 'Invalid application name')
       end
     end
 
-    describe "#read_redis_hash" do
-      it "should handle old and new values" do
-
-        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "new_one", QueueBus::Util.encode("queue_name" => "x", "bus_event_type" => "event_name") ) }
-        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "old_one", "oldqueue_name") }
-        app = Application.new("myapp")
+    describe '#read_redis_hash' do
+      it 'should handle old and new values' do
+        QueueBus.redis { |redis| redis.hset('bus_app:myapp', 'new_one', QueueBus::Util.encode('queue_name' => 'x', 'bus_event_type' => 'event_name')) }
+        QueueBus.redis { |redis| redis.hset('bus_app:myapp', 'old_one', 'oldqueue_name') }
+        app = Application.new('myapp')
         val = app.send(:read_redis_hash)
-        expect(val).to eq({"new_one" => {"queue_name" => "x", "bus_event_type" => "event_name"}, "old_one" => "oldqueue_name"})
+        expect(val).to eq('new_one' => { 'queue_name' => 'x', 'bus_event_type' => 'event_name' }, 'old_one' => 'oldqueue_name')
       end
     end
 
-    describe "#subscribe" do
-      let(:sub1) { test_sub("event_one", "default") }
-      let(:sub2) { test_sub("event_two", "default") }
-      let(:sub3) { test_sub("event_three", "other") }
-      it "should add array to redis" do
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-        Application.new("myapp").subscribe(test_list(sub1, sub2))
-
-        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}",
-                                                                  "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"})
-        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_one", "event_two"])
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
+    describe '#subscribe' do
+      let(:sub1) { test_sub('event_one', 'default') }
+      let(:sub2) { test_sub('event_two', 'default') }
+      let(:sub3) { test_sub('event_three', 'other') }
+      it 'should add array to redis' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+        Application.new('myapp').subscribe(test_list(sub1, sub2))
+
+        expect(QueueBus.redis { |redis| redis.hgetall('bus_app:myapp') }).to eq('event_two' => '{"queue_name":"default","key":"event_two","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_two"}}',
+                                                                                'event_one' => '{"queue_name":"default","key":"event_one","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_one"}}')
+        expect(QueueBus.redis { |redis| redis.hkeys('bus_app:myapp') }).to match_array(%w[event_one event_two])
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to match_array(['myapp'])
       end
-      it "should add string to redis" do
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-        Application.new("myapp").subscribe(test_list(sub1))
+      it 'should add string to redis' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+        Application.new('myapp').subscribe(test_list(sub1))
 
-        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}"})
-        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_one"])
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
+        expect(QueueBus.redis { |redis| redis.hgetall('bus_app:myapp') }).to eq('event_one' => '{"queue_name":"default","key":"event_one","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_one"}}')
+        expect(QueueBus.redis { |redis| redis.hkeys('bus_app:myapp') }).to match_array(['event_one'])
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to match_array(['myapp'])
       end
-      it "should multiple queues to redis" do
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
-        Application.new("myapp").subscribe(test_list(sub1, sub2, sub3))
-        expect(QueueBus.redis { |redis| redis.hgetall("bus_app:myapp") }).to eq({"event_two"=>"{\"queue_name\":\"default\",\"key\":\"event_two\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_two\"}}", "event_one"=>"{\"queue_name\":\"default\",\"key\":\"event_one\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_one\"}}",
-                                                                  "event_three"=>"{\"queue_name\":\"other\",\"key\":\"event_three\",\"class\":\"::QueueBus::Rider\",\"matcher\":{\"bus_event_type\":\"event_three\"}}"})
-        expect(QueueBus.redis { |redis| redis.hkeys("bus_app:myapp") }).to match_array(["event_three", "event_two", "event_one"])
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to match_array(["myapp"])
+      it 'should multiple queues to redis' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
+        Application.new('myapp').subscribe(test_list(sub1, sub2, sub3))
+        expect(QueueBus.redis { |redis| redis.hgetall('bus_app:myapp') }).to eq('event_two' => '{"queue_name":"default","key":"event_two","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_two"}}', 'event_one' => '{"queue_name":"default","key":"event_one","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_one"}}',
+                                                                                'event_three' => '{"queue_name":"other","key":"event_three","class":"::QueueBus::Rider","matcher":{"bus_event_type":"event_three"}}')
+        expect(QueueBus.redis { |redis| redis.hkeys('bus_app:myapp') }).to match_array(%w[event_three event_two event_one])
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to match_array(['myapp'])
       end
 
-      it "should do nothing if nil or empty" do
-
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+      it 'should do nothing if nil or empty' do
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
 
-        Application.new("myapp").subscribe(nil)
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+        Application.new('myapp').subscribe(nil)
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
 
-        Application.new("myapp").subscribe([])
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+        Application.new('myapp').subscribe([])
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
       end
 
-      it "should call unsubscribe" do
-        app = Application.new("myapp")
+      it 'should call unsubscribe' do
+        app = Application.new('myapp')
         expect(app).to receive(:unsubscribe)
         app.subscribe([])
       end
     end
 
-    describe "#unsubscribe" do
-      it "should remove items" do
-        QueueBus.redis { |redis| redis.sadd("bus_apps", "myapp") }
-        QueueBus.redis { |redis| redis.sadd("bus_apps", "other") }
-        QueueBus.redis { |redis| redis.hset("bus_app:myapp", "event_one", "myapp_default") }
+    describe '#unsubscribe' do
+      it 'should remove items' do
+        QueueBus.redis { |redis| redis.sadd('bus_apps', 'myapp') }
+        QueueBus.redis { |redis| redis.sadd('bus_apps', 'other') }
+        QueueBus.redis { |redis| redis.hset('bus_app:myapp', 'event_one', 'myapp_default') }
 
-        Application.new("myapp").unsubscribe
+        Application.new('myapp').unsubscribe
 
-        expect(QueueBus.redis { |redis| redis.smembers("bus_apps") }).to eq(["other"])
-        expect(QueueBus.redis { |redis| redis.get("bus_app:myapp") }).to be_nil
+        expect(QueueBus.redis { |redis| redis.smembers('bus_apps') }).to eq(['other'])
+        expect(QueueBus.redis { |redis| redis.get('bus_app:myapp') }).to be_nil
       end
     end
 
-    describe "#subscription_matches" do
-      it "should return if it is there" do
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+    describe '#subscription_matches' do
+      it 'should return if it is there' do
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        subs = test_list(test_sub("one_x"), test_sub("one_y"), test_sub("one"), test_sub("two"))
-        Application.new("myapp").subscribe(subs)
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+        subs = test_list(test_sub('one_x'), test_sub('one_y'), test_sub('one'), test_sub('two'))
+        Application.new('myapp').subscribe(subs)
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"two").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "two", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one", "default", "::QueueBus::Rider"]])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'two').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'two', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one', 'default', '::QueueBus::Rider']])
       end
 
-      it "should handle * wildcards" do
-        subs = test_list(test_sub("one.+"), test_sub("one"), test_sub("one_.*"), test_sub("two"))
-        Application.new("myapp").subscribe(subs)
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+      it 'should handle * wildcards' do
+        subs = test_list(test_sub('one.+'), test_sub('one'), test_sub('one_.*'), test_sub('two'))
+        Application.new('myapp').subscribe(subs)
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one.+", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one.+","default", "::QueueBus::Rider"], ["myapp", "one_.*", "default", "::QueueBus::Rider"]])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'onex').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one.+', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one_x').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one.+', 'default', '::QueueBus::Rider'], ['myapp', 'one_.*', 'default', '::QueueBus::Rider']])
       end
 
-      it "should handle actual regular expressions" do
-        subs = test_list(test_sub(/one.+/), test_sub("one"), test_sub(/one_.*/), test_sub("two"))
-        Application.new("myapp").subscribe(subs)
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"three").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+      it 'should handle actual regular expressions' do
+        subs = test_list(test_sub(/one.+/), test_sub('one'), test_sub(/one_.*/), test_sub('two'))
+        Application.new('myapp').subscribe(subs)
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'three').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
 
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"onex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"donex").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "one" ,"default", "::QueueBus::Rider"]])
-        expect(Application.new("myapp").subscription_matches("bus_event_type"=>"one_x").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["myapp", "(?-mix:one.+)", "default", "::QueueBus::Rider"], ["myapp", "(?-mix:one_.*)", "default", "::QueueBus::Rider"]])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'onex').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', '(?-mix:one.+)', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'donex').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', '(?-mix:one.+)', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', 'one', 'default', '::QueueBus::Rider']])
+        expect(Application.new('myapp').subscription_matches('bus_event_type' => 'one_x').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['myapp', '(?-mix:one.+)', 'default', '::QueueBus::Rider'], ['myapp', '(?-mix:one_.*)', 'default', '::QueueBus::Rider']])
       end
     end
   end