queue-bus 0.9.0 → 0.9.1

data/spec/driver_spec.rb

@@ -1,92 +1,94 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Driver do
     before(:each) do
-      Application.new("app1").subscribe(test_list(test_sub("event1"), test_sub("event2"), test_sub("event3")))
-      Application.new("app2").subscribe(test_list(test_sub("event2","other"), test_sub("event4", "more")))
-      Application.new("app3").subscribe(test_list(test_sub("event[45]"), test_sub("event5"), test_sub("event6")))
+      Application.new('app1').subscribe(test_list(test_sub('event1'), test_sub('event2'), test_sub('event3')))
+      Application.new('app2').subscribe(test_list(test_sub('event2', 'other'), test_sub('event4', 'more')))
+      Application.new('app3').subscribe(test_list(test_sub('event[45]'), test_sub('event5'), test_sub('event6')))
       Timecop.freeze
     end
     after(:each) do
       Timecop.return
     end
 
-    let(:bus_attrs) { {"bus_driven_at" => Time.now.to_i, "bus_rider_class_name"=>"::QueueBus::Rider", "bus_class_proxy" => "::QueueBus::Rider"} }
+    let(:bus_attrs) { { 'bus_driven_at' => Time.now.to_i, 'bus_rider_class_name' => '::QueueBus::Rider', 'bus_class_proxy' => '::QueueBus::Rider' } }
 
-    describe ".subscription_matches" do
-      it "return empty array when none" do
-        expect(Driver.subscription_matches("bus_event_type" => "else").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
-        expect(Driver.subscription_matches("bus_event_type" => "event").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to eq([])
+    describe '.subscription_matches' do
+      it 'return empty array when none' do
+        expect(Driver.subscription_matches('bus_event_type' => 'else').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
+        expect(Driver.subscription_matches('bus_event_type' => 'event').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to eq([])
       end
-      it "should return a match" do
-        expect(Driver.subscription_matches("bus_event_type" => "event1").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app1", "event1", "default", "::QueueBus::Rider"]])
-        expect(Driver.subscription_matches("bus_event_type" => "event6").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app3", "event6", "default", "::QueueBus::Rider"]])
+      it 'should return a match' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event1').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app1', 'event1', 'default', '::QueueBus::Rider']])
+        expect(Driver.subscription_matches('bus_event_type' => 'event6').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app3', 'event6', 'default', '::QueueBus::Rider']])
       end
-      it "should match multiple apps" do
-        expect(Driver.subscription_matches("bus_event_type" => "event2").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app1", "event2", "default", "::QueueBus::Rider"], ["app2", "event2", "other", "::QueueBus::Rider"]])
+      it 'should match multiple apps' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event2').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app1', 'event2', 'default', '::QueueBus::Rider'], ['app2', 'event2', 'other', '::QueueBus::Rider']])
       end
-      it "should match multiple apps with patterns" do
-        expect(Driver.subscription_matches("bus_event_type" => "event4").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app3", "event[45]", "default", "::QueueBus::Rider"], ["app2", "event4", "more", "::QueueBus::Rider"]])
+      it 'should match multiple apps with patterns' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event4').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app3', 'event[45]', 'default', '::QueueBus::Rider'], ['app2', 'event4', 'more', '::QueueBus::Rider']])
       end
-      it "should match multiple events in same app" do
-        expect(Driver.subscription_matches("bus_event_type" => "event5").collect{|s| [s.app_key, s.key, s.queue_name, s.class_name]}).to match_array([["app3", "event[45]", "default", "::QueueBus::Rider"], ["app3", "event5", "default", "::QueueBus::Rider"]])
+      it 'should match multiple events in same app' do
+        expect(Driver.subscription_matches('bus_event_type' => 'event5').collect { |s| [s.app_key, s.key, s.queue_name, s.class_name] }).to match_array([['app3', 'event[45]', 'default', '::QueueBus::Rider'], ['app3', 'event5', 'default', '::QueueBus::Rider']])
       end
     end
 
-    describe ".perform" do
-      let(:attributes) { {"x" => "y", "bus_class_proxy" => "ResqueBus::Driver"} }
+    describe '.perform' do
+      let(:attributes) { { 'x' => 'y', 'bus_class_proxy' => 'ResqueBus::Driver' } }
 
       before(:each) do
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to eq([])
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app1_default") }).to be_nil
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app2_default") }).to be_nil
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app3_default") }).to be_nil
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to eq([])
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app1_default') }).to be_nil
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app2_default') }).to be_nil
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app3_default') }).to be_nil
       end
 
-      it "should do nothing when empty" do
-        Driver.perform(attributes.merge("bus_event_type" => "else"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to eq([])
+      it 'should do nothing when empty' do
+        Driver.perform(attributes.merge('bus_event_type' => 'else'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to eq([])
       end
 
-      it "should queue up the riders in redis" do
-        expect(QueueBus.redis { |redis| redis.lpop("queue:app1_default") }).to be_nil
-        Driver.perform(attributes.merge("bus_event_type" => "event1"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default"])
+      it 'should queue up the riders in redis' do
+        expect(QueueBus.redis { |redis| redis.lpop('queue:app1_default') }).to be_nil
+        Driver.perform(attributes.merge('bus_event_type' => 'event1'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['default'])
 
-        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        expect(hash["class"]).to eq("QueueBus::Worker")
-        expect(hash["args"].size).to eq(1)
-        expect(JSON.parse(hash["args"].first)).to eq({"bus_rider_app_key"=>"app1", "x" => "y", "bus_event_type" => "event1", "bus_rider_sub_key"=>"event1", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
+        expect(hash['class']).to eq('QueueBus::Worker')
+        expect(hash['args'].size).to eq(1)
+        expect(JSON.parse(hash['args'].first)).to eq({ 'bus_rider_app_key' => 'app1', 'x' => 'y', 'bus_event_type' => 'event1', 'bus_rider_sub_key' => 'event1', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
       end
 
-      it "should queue up to multiple" do
-        Driver.perform(attributes.merge("bus_event_type" => "event4"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default", "more"])
+      it 'should queue up to multiple' do
+        Driver.perform(attributes.merge('bus_event_type' => 'event4'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(%w[default more])
 
-        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:more") })
-        expect(hash["class"]).to eq("QueueBus::Worker")
-        expect(hash["args"].size).to eq(1)
-        expect(JSON.parse(hash["args"].first)).to eq({"bus_rider_app_key"=>"app2", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event4", "bus_rider_queue" => "more"}.merge(bus_attrs))
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:more') })
+        expect(hash['class']).to eq('QueueBus::Worker')
+        expect(hash['args'].size).to eq(1)
+        expect(JSON.parse(hash['args'].first)).to eq({ 'bus_rider_app_key' => 'app2', 'x' => 'y', 'bus_event_type' => 'event4', 'bus_rider_sub_key' => 'event4', 'bus_rider_queue' => 'more' }.merge(bus_attrs))
 
-        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        expect(hash["class"]).to eq("QueueBus::Worker")
-        expect(hash["args"].size).to eq(1)
-        expect(JSON.parse(hash["args"].first)).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event4", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        hash = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
+        expect(hash['class']).to eq('QueueBus::Worker')
+        expect(hash['args'].size).to eq(1)
+        expect(JSON.parse(hash['args'].first)).to eq({ 'bus_rider_app_key' => 'app3', 'x' => 'y', 'bus_event_type' => 'event4', 'bus_rider_sub_key' => 'event[45]', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
       end
 
-      it "should queue up to the same" do
-        Driver.perform(attributes.merge("bus_event_type" => "event5"))
-        expect(QueueBus.redis { |redis| redis.smembers("queues") }).to match_array(["default"])
+      it 'should queue up to the same' do
+        Driver.perform(attributes.merge('bus_event_type' => 'event5'))
+        expect(QueueBus.redis { |redis| redis.smembers('queues') }).to match_array(['default'])
 
-        expect(QueueBus.redis { |redis| redis.llen("queue:default") }).to eq(2)
+        expect(QueueBus.redis { |redis| redis.llen('queue:default') }).to eq(2)
 
-        pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
-        pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop("queue:default") })
+        pop1 = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
+        pop2 = JSON.parse(QueueBus.redis { |redis| redis.lpop('queue:default') })
 
-        pargs1 = JSON.parse(pop1["args"].first)
-        pargs2 = JSON.parse(pop2["args"].first)
-        if pargs1["bus_rider_sub_key"] == "event5"
+        pargs1 = JSON.parse(pop1['args'].first)
+        pargs2 = JSON.parse(pop2['args'].first)
+        if pargs1['bus_rider_sub_key'] == 'event5'
           hash1 = pop1
           hash2 = pop2
           args1 = pargs1
@@ -98,11 +100,11 @@ module QueueBus
           args2 = pargs1
         end
 
-        expect(hash1["class"]).to eq("QueueBus::Worker")
-        expect(args1).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event5", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        expect(hash1['class']).to eq('QueueBus::Worker')
+        expect(args1).to eq({ 'bus_rider_app_key' => 'app3', 'x' => 'y', 'bus_event_type' => 'event5', 'bus_rider_sub_key' => 'event5', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
 
-        expect(hash2["class"]).to eq("QueueBus::Worker")
-        expect(args2).to eq({"bus_rider_app_key"=>"app3", "x" => "y", "bus_event_type" => "event5", "bus_rider_sub_key"=>"event[45]", "bus_rider_queue" => "default"}.merge(bus_attrs))
+        expect(hash2['class']).to eq('QueueBus::Worker')
+        expect(args2).to eq({ 'bus_rider_app_key' => 'app3', 'x' => 'y', 'bus_event_type' => 'event5', 'bus_rider_sub_key' => 'event[45]', 'bus_rider_queue' => 'default' }.merge(bus_attrs))
       end
     end
   end

data/spec/heartbeat_spec.rb

@@ -1,42 +1,44 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Heartbeat do
     def now_attributes
       {
-        "epoch_seconds" => (Time.now.to_i / 60) * 60, # rounded
-        "epoch_minutes" => Time.now.to_i / 60,
-        "epoch_hours"   => Time.now.to_i / (60*60),
-        "epoch_days"    => Time.now.to_i / (60*60*24),
-        "minute" => Time.now.min,
-        "hour"   => Time.now.hour,
-        "day"    => Time.now.day,
-        "month"  => Time.now.month,
-        "year"   => Time.now.year,
-        "yday"   => Time.now.yday,
-        "wday"   => Time.now.wday
+        'epoch_seconds' => (Time.now.to_i / 60) * 60, # rounded
+        'epoch_minutes' => Time.now.to_i / 60,
+        'epoch_hours' => Time.now.to_i / (60 * 60),
+        'epoch_days' => Time.now.to_i / (60 * 60 * 24),
+        'minute' => Time.now.min,
+        'hour' => Time.now.hour,
+        'day' => Time.now.day,
+        'month' => Time.now.month,
+        'year' => Time.now.year,
+        'yday' => Time.now.yday,
+        'wday' => Time.now.wday
       }
     end
-    
-    it "should publish the current time once" do
-      Timecop.freeze "12/12/2013 12:01:19" do
-        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
+
+    it 'should publish the current time once' do
+      Timecop.freeze '12/12/2013 12:01:19' do
+        expect(QueueBus).to receive(:publish).with('heartbeat_minutes', now_attributes)
         Heartbeat.perform
       end
-      
-      Timecop.freeze "12/12/2013 12:01:40" do
+
+      Timecop.freeze '12/12/2013 12:01:40' do
         Heartbeat.perform
       end
     end
-    
-    it "should publish a minute later" do
-      Timecop.freeze "12/12/2013 12:01:19" do
-        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
+
+    it 'should publish a minute later' do
+      Timecop.freeze '12/12/2013 12:01:19' do
+        expect(QueueBus).to receive(:publish).with('heartbeat_minutes', now_attributes)
         Heartbeat.perform
       end
-      
-      Timecop.freeze "12/12/2013 12:02:01" do
-        expect(QueueBus).to receive(:publish).with("heartbeat_minutes", now_attributes)
+
+      Timecop.freeze '12/12/2013 12:02:01' do
+        expect(QueueBus).to receive(:publish).with('heartbeat_minutes', now_attributes)
         Heartbeat.perform
       end
     end

data/spec/integration_spec.rb

@@ -1,53 +1,54 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
-  describe "Integration" do
-    it "should round trip attributes" do      
-      write1 = Subscription.new("default", "key1", "MyClass1", {"bus_event_type" => "event_one"})
-      write2 = Subscription.new("else_ok", "key2", "MyClass2", {"bus_event_type" => /^[ab]here/})  #regex
-    
-      expect(write1.matches?("bus_event_type" => "event_one")).to  eq(true)
-      expect(write1.matches?("bus_event_type" => "event_one1")).to eq(false)
-      expect(write1.matches?("bus_event_type" => "aevent_one")).to eq(false)
-      
-      expect(write2.matches?("bus_event_type" => "ahere")).to eq(true)
-      expect(write2.matches?("bus_event_type" => "bhere")).to eq(true)
-      expect(write2.matches?("bus_event_type" => "qhere")).to eq(false)
-      expect(write2.matches?("bus_event_type" => "abhere")).to eq(false)
-      expect(write2.matches?("bus_event_type" => "[ab]here")).to eq(false)
-    
+  describe 'Integration' do
+    it 'should round trip attributes' do
+      write1 = Subscription.new('default', 'key1', 'MyClass1', 'bus_event_type' => 'event_one')
+      write2 = Subscription.new('else_ok', 'key2', 'MyClass2', 'bus_event_type' => /^[ab]here/) # regex
+
+      expect(write1.matches?('bus_event_type' => 'event_one')).to  eq(true)
+      expect(write1.matches?('bus_event_type' => 'event_one1')).to eq(false)
+      expect(write1.matches?('bus_event_type' => 'aevent_one')).to eq(false)
+
+      expect(write2.matches?('bus_event_type' => 'ahere')).to eq(true)
+      expect(write2.matches?('bus_event_type' => 'bhere')).to eq(true)
+      expect(write2.matches?('bus_event_type' => 'qhere')).to eq(false)
+      expect(write2.matches?('bus_event_type' => 'abhere')).to eq(false)
+      expect(write2.matches?('bus_event_type' => '[ab]here')).to eq(false)
+
       write = SubscriptionList.new
       write.add(write1)
       write.add(write2)
-    
-      app = Application.new("test")
+
+      app = Application.new('test')
       app.subscribe(write)
-    
-      reset_test_adapter  # reset to make sure we read from redis
-      app = Application.new("test")
+
+      reset_test_adapter # reset to make sure we read from redis
+      app = Application.new('test')
       read = app.send(:subscriptions)
-    
+
       expect(read.size).to eq(2)
-      read1 = read.key("key1")
-      read2 = read.key("key2")
+      read1 = read.key('key1')
+      read2 = read.key('key2')
       expect(read1).not_to be_nil
       expect(read2).not_to be_nil
-      
-      expect(read1.queue_name).to eq("default")
-      expect(read1.class_name).to eq("MyClass1")
-      expect(read2.queue_name).to eq("else_ok")
-      expect(read2.class_name).to eq("MyClass2")
-      
-      expect(read1.matches?("bus_event_type" => "event_one")).to  eq(true)
-      expect(read1.matches?("bus_event_type" => "event_one1")).to eq(false)
-      expect(read1.matches?("bus_event_type" => "aevent_one")).to eq(false)
-      
-      expect(read2.matches?("bus_event_type" => "ahere")).to eq(true)
-      expect(read2.matches?("bus_event_type" => "bhere")).to eq(true)
-      expect(read2.matches?("bus_event_type" => "qhere")).to eq(false)
-      expect(read2.matches?("bus_event_type" => "abhere")).to eq(false)
-      expect(read2.matches?("bus_event_type" => "[ab]here")).to eq(false)
-      
+
+      expect(read1.queue_name).to eq('default')
+      expect(read1.class_name).to eq('MyClass1')
+      expect(read2.queue_name).to eq('else_ok')
+      expect(read2.class_name).to eq('MyClass2')
+
+      expect(read1.matches?('bus_event_type' => 'event_one')).to  eq(true)
+      expect(read1.matches?('bus_event_type' => 'event_one1')).to eq(false)
+      expect(read1.matches?('bus_event_type' => 'aevent_one')).to eq(false)
+
+      expect(read2.matches?('bus_event_type' => 'ahere')).to eq(true)
+      expect(read2.matches?('bus_event_type' => 'bhere')).to eq(true)
+      expect(read2.matches?('bus_event_type' => 'qhere')).to eq(false)
+      expect(read2.matches?('bus_event_type' => 'abhere')).to eq(false)
+      expect(read2.matches?('bus_event_type' => '[ab]here')).to eq(false)
     end
   end
-end
+end

data/spec/matcher_spec.rb

@@ -1,143 +1,145 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module QueueBus
   describe Matcher do
-    it "should already return false on empty filters" do
+    it 'should already return false on empty filters' do
       matcher = Matcher.new({})
-      expect(matcher.matches?({})).to  eq(false)
+      expect(matcher.matches?({})).to eq(false)
       expect(matcher.matches?(nil)).to  eq(false)
-      expect(matcher.matches?("name" => "val")).to eq(false)
+      expect(matcher.matches?('name' => 'val')).to eq(false)
     end
 
-    it "should not crash if nil inputs" do
-      matcher = Matcher.new("name" => "val")
+    it 'should not crash if nil inputs' do
+      matcher = Matcher.new('name' => 'val')
       expect(matcher.matches?(nil)).to eq(false)
     end
 
-    it "string filter to/from redis" do
-      matcher = Matcher.new("name" => "val")
-      expect(matcher.matches?("name" => "val")).to   eq(true)
-      expect(matcher.matches?("name" => " val")).to  eq(false)
-      expect(matcher.matches?("name" => "zval")).to  eq(false)
+    it 'string filter to/from redis' do
+      matcher = Matcher.new('name' => 'val')
+      expect(matcher.matches?('name' => 'val')).to   eq(true)
+      expect(matcher.matches?('name' => ' val')).to  eq(false)
+      expect(matcher.matches?('name' => 'zval')).to  eq(false)
     end
 
-    it "regex filter" do
-      matcher = Matcher.new("name" => /^[cb]a+t/)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+    it 'regex filter' do
+      matcher = Matcher.new('name' => /^[cb]a+t/)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
     end
 
-    it "present filter" do
-      matcher = Matcher.new("name" => :present)
-      expect(matcher.matches?("name" => "")).to eq(false)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
+    it 'present filter' do
+      matcher = Matcher.new('name' => :present)
+      expect(matcher.matches?('name' => '')).to eq(false)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
     end
 
-    it "blank filter" do
-      matcher = Matcher.new("name" => :blank)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "   s ")).to eq(false)
+    it 'blank filter' do
+      matcher = Matcher.new('name' => :blank)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '   s ')).to eq(false)
     end
 
-    it "nil filter" do
-      matcher = Matcher.new("name" => :nil)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "")).to eq(false)
-      expect(matcher.matches?("name" => "  ")).to eq(false)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
+    it 'nil filter' do
+      matcher = Matcher.new('name' => :nil)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '')).to eq(false)
+      expect(matcher.matches?('name' => '  ')).to eq(false)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
     end
 
-    it "key filter" do
-      matcher = Matcher.new("name" => :key)
-      expect(matcher.matches?("name" => nil)).to eq(true)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
+    it 'key filter' do
+      matcher = Matcher.new('name' => :key)
+      expect(matcher.matches?('name' => nil)).to eq(true)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
     end
 
-    it "empty filter" do
-      matcher = Matcher.new("name" => :empty)
-      expect(matcher.matches?("name" => nil)).to eq(false)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(false)
-      expect(matcher.matches?("name" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "   s ")).to eq(false)
+    it 'empty filter' do
+      matcher = Matcher.new('name' => :empty)
+      expect(matcher.matches?('name' => nil)).to eq(false)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(false)
+      expect(matcher.matches?('name' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '   s ')).to eq(false)
     end
 
-    it "value filter" do
-      matcher = Matcher.new("name" => :value)
-      expect(matcher.matches?("name" => nil)).to eq(false)
-      expect(matcher.matches?("other" => "bear")).to eq(false)
-      expect(matcher.matches?("name" => "")).to eq(true)
-      expect(matcher.matches?("name" => "  ")).to eq(true)
-      expect(matcher.matches?("name" => "bear")).to eq(true)
-      expect(matcher.matches?("name" => "   s ")).to eq(true)
+    it 'value filter' do
+      matcher = Matcher.new('name' => :value)
+      expect(matcher.matches?('name' => nil)).to eq(false)
+      expect(matcher.matches?('other' => 'bear')).to eq(false)
+      expect(matcher.matches?('name' => '')).to eq(true)
+      expect(matcher.matches?('name' => '  ')).to eq(true)
+      expect(matcher.matches?('name' => 'bear')).to eq(true)
+      expect(matcher.matches?('name' => '   s ')).to eq(true)
     end
 
-    it "multiple filters" do
-      matcher = Matcher.new("name" => /^[cb]a+t/, "state" => "sleeping")
-      expect(matcher.matches?("state" => "sleeping", "name" => "cat")).to  eq(true)
-      expect(matcher.matches?("state" => "awake", "name" => "cat")).to     eq(false)
-      expect(matcher.matches?("state" => "sleeping", "name" => "bat")).to  eq(true)
-      expect(matcher.matches?("state" => "sleeping", "name" => "bear")).to eq(false)
-      expect(matcher.matches?("state" => "awake", "name" => "bear")).to    eq(false)
+    it 'multiple filters' do
+      matcher = Matcher.new('name' => /^[cb]a+t/, 'state' => 'sleeping')
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'cat')).to  eq(true)
+      expect(matcher.matches?('state' => 'awake', 'name' => 'cat')).to     eq(false)
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'bat')).to  eq(true)
+      expect(matcher.matches?('state' => 'sleeping', 'name' => 'bear')).to eq(false)
+      expect(matcher.matches?('state' => 'awake', 'name' => 'bear')).to    eq(false)
     end
 
-    it "regex should go back and forth into redis" do
-      matcher = Matcher.new("name" => /^[cb]a+t/)
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+    it 'regex should go back and forth into redis' do
+      matcher = Matcher.new('name' => /^[cb]a+t/)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
 
-      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis = QueueBus.redis { |redis| redis.get("temp1") }
+      QueueBus.redis { |redis| redis.set('temp1', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp1') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
-
-      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis = QueueBus.redis { |redis| redis.get("temp2") }
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
+
+      QueueBus.redis { |redis| redis.set('temp2', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp2') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(true)
-      expect(matcher.matches?("name" => "bat")).to eq(true)
-      expect(matcher.matches?("name" => "caaaaat")).to eq(true)
-      expect(matcher.matches?("name" => "ct")).to eq(false)
-      expect(matcher.matches?("name" => "bcat")).to eq(false)
+      expect(matcher.matches?('name' => 'cat')).to eq(true)
+      expect(matcher.matches?('name' => 'bat')).to eq(true)
+      expect(matcher.matches?('name' => 'caaaaat')).to eq(true)
+      expect(matcher.matches?('name' => 'ct')).to eq(false)
+      expect(matcher.matches?('name' => 'bcat')).to eq(false)
     end
 
-    it "special value should go back and forth into redis" do
-      matcher = Matcher.new("name" => :blank)
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+    it 'special value should go back and forth into redis' do
+      matcher = Matcher.new('name' => :blank)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
 
-      QueueBus.redis { |redis| redis.set("temp1", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis= QueueBus.redis { |redis| redis.get("temp1") }
+      QueueBus.redis { |redis| redis.set('temp1', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp1') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
 
-      QueueBus.redis { |redis| redis.set("temp2", QueueBus::Util.encode(matcher.to_redis) ) }
-      redis= QueueBus.redis { |redis| redis.get("temp2") }
+      QueueBus.redis { |redis| redis.set('temp2', QueueBus::Util.encode(matcher.to_redis)) }
+      redis = QueueBus.redis { |redis| redis.get('temp2') }
       matcher = Matcher.new(QueueBus::Util.decode(redis))
-      expect(matcher.matches?("name" => "cat")).to eq(false)
-      expect(matcher.matches?("name" => "")).to    eq(true)
+      expect(matcher.matches?('name' => 'cat')).to eq(false)
+      expect(matcher.matches?('name' => '')).to    eq(true)
     end
   end
 end