Runs safe auto correct on all files

Author: choubacha

Gemfile

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

Rakefile

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

lib/queue_bus/adapters/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module QueueBus
   module Adapters
     class Base
@@ -19,12 +21,12 @@ def redis
         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

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,47 +8,46 @@ def enabled!
         # 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)
         item = delayed_job_to_hash_with_queue(queue_name, klass, [json])
         delayed_push(epoch_seconds, item)
       end
 
-      def setup_heartbeat!(queue_name)
+      def setup_heartbeat!(_queue_name)
         raise NotImplementedError
       end
 
       protected
 
       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.
       # +timestamp+ can be either in seconds or a datetime object
       # 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 @@ def delayed_push(timestamp, item)
           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

lib/queue_bus/local.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 module QueueBus
   # only process local queues
   class Local
-
     class << self
       def publish(attributes = {})
         if ::QueueBus.local_mode == :suppress
           ::QueueBus.log_worker("Suppressed: #{attributes.inspect}")
-          return  # not doing anything
+          return # not doing anything
         end
 
         # To json and back to simlulate enqueueing
@@ -17,15 +18,15 @@ def publish(attributes = {})
 
         # looking for subscriptions, not queues
         subscription_matches(attributes).each do |sub|
-          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 }
           to_publish = bus_attr.merge(attributes || {})
           if ::QueueBus.local_mode == :standalone
             ::QueueBus.enqueue_to(sub.queue_name, sub.class_name, bus_attr.merge(attributes || {}))
-          else  # defaults to inline mode
+          else # defaults to inline mode
             sub.execute!(to_publish)
           end
         end
@@ -41,6 +42,5 @@ def subscription_matches(attributes)
         out
       end
     end
-
   end
 end

lib/queue_bus/util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'multi_json'
 
 module QueueBus
@@ -30,14 +32,14 @@ def decode(object)
         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 @@ def camelize(term)
       # 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 @@ def constantize(camel_cased_word)
           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 @@ def constantize(camel_cased_word)
       end
     end
   end
-end
+end

lib/queue_bus/version.rb

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

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

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       = ["[email protected]"]
-  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       = ['[email protected]']
+  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

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

spec/adapter/support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'redis'
 
 def reset_test_adapter

spec/adapter_spec.rb

@@ -1,14 +1,16 @@
+# 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!)
     instance = adapter_under_test_class.new
     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