Minor code cleanup

Author: taganaka

Gemfile

@@ -1,4 +1,6 @@
-source "http://rubygems.org"
+# frozen_string_literal: true
+
+source 'http://rubygems.org'
 
 # Specify your gem's dependencies in redis-queue.gemspec
 gemspec

Rakefile

@@ -1,9 +1,11 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = 'spec/*_spec.rb'
 end
 
-task :default => :spec
-task :test    => :spec
+task default: :spec
+task test: :spec

example/blocking.rb

@@ -1,25 +1,25 @@
-require "redis-queue"
-require "thread"
+# frozen_string_literal: true
 
+require 'redis-queue'
 redis = Redis.new
-#Create a queue that will listen for a new element for 10 seconds
-queue = Redis::Queue.new('__test', 'bp__test', :redis => redis, :timeout => 10)
-queue.clear true 
+# Create a queue that will listen for a new element for 10 seconds
+queue = Redis::Queue.new('__test', 'bp__test', redis: redis, timeout: 10)
+queue.clear true
 
 100.times { queue << rand(100) }
 
 # Simulate a delayed insert
 t = Thread.new do
   sleep 3
-   # We should use a second connection here since the first one is busy 
-   # on a blocking call
-  _redis = Redis.new
-  _queue = Redis::Queue.new('__test', 'bp__test', :redis => _redis)
-  100.times { _queue << "e_#{rand(100)}" }
+  # We should use a second connection here since the first one is busy
+  # on a blocking call
+  other_redis = Redis.new
+  other_queue = Redis::Queue.new('__test', 'bp__test', redis: other_redis)
+  100.times { other_queue << "e_#{rand(100)}" }
 end
 
-#When all elements are dequeud, process method will wait for 10 secods before exit
+# When all elements are dequeud, process method will wait for 10 secods before exit
 queue.process do |message|
-  puts "'#{message}'" 
+  puts "'#{message}'"
 end
-t.join
+t.join

example/non-blocking.rb

@@ -1,10 +1,12 @@
-require "redis-queue"
+# frozen_string_literal: true
+
+require 'redis-queue'
 
 redis = Redis.new
 
-queue = Redis::Queue.new('__test', 'bp__test', :redis => redis)
+queue = Redis::Queue.new('__test', 'bp__test', redis: redis)
 queue.clear true
 
 100.times { queue << rand(100) }
 
-queue.process(true) {|m| puts m}
+queue.process(true) { |m| puts m }

lib/redis-queue.rb

@@ -1,3 +1,5 @@
-require "redis"
-require "redis/connection/hiredis"
-require "redis/queue"
+# frozen_string_literal: true
+
+require 'redis'
+require 'redis/connection/hiredis'
+require 'redis/queue'

lib/redis/queue.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 class Redis
   class Queue
-
-    VERSION = "0.0.4"
+    VERSION = '0.0.4'
 
     def self.version
       "redis-queue version #{VERSION}"
@@ -10,7 +11,7 @@ def self.version
     def initialize(queue_name, process_queue_name, options = {})
       raise ArgumentError, 'First argument must be a non empty string'  if !queue_name.is_a?(String) || queue_name.empty?
       raise ArgumentError, 'Second argument must be a non empty string' if !process_queue_name.is_a?(String) || process_queue_name.empty?
-      raise ArgumentError, 'Queue and Process queue have the same name'  if process_queue_name == queue_name 
+      raise ArgumentError, 'Queue and Process queue have the same name' if process_queue_name == queue_name
 
       @redis = options[:redis] || Redis.current
       @queue_name = queue_name
@@ -29,48 +30,47 @@ def clear(clear_process_queue = false)
     end
 
     def empty?
-      !(length > 0)
+      length <= 0
     end
 
     def push(obj)
       @redis.lpush(@queue_name, obj)
     end
 
-    def pop(non_block=false)
-      if non_block
-        @last_message = @redis.rpoplpush(@queue_name,@process_queue_name)
-      else
-        @last_message = @redis.brpoplpush(@queue_name,@process_queue_name, @timeout)
-      end
+    def pop(non_block = false)
+      @last_message = if non_block
+                        @redis.rpoplpush(@queue_name, @process_queue_name)
+                      else
+                        @redis.brpoplpush(@queue_name, @process_queue_name, @timeout)
+                      end
       @last_message
     end
 
     def commit
       @redis.lrem(@process_queue_name, 0, @last_message)
     end
 
-    def process(non_block=false, timeout = nil)
+    def process(non_block = false, timeout = nil)
       @timeout = timeout unless timeout.nil?
       loop do
         message = pop(non_block)
         ret = yield message if block_given?
         commit if ret
         break if message.nil? || (non_block && empty?)
       end
-
     end
 
     def refill
-      while message=@redis.lpop(@process_queue_name)
+      while (message = @redis.lpop(@process_queue_name))
         @redis.rpush(@queue_name, message)
       end
       true
     end
 
-    alias :size  :length
-    alias :dec   :pop
-    alias :shift :pop
-    alias :enc   :push
-    alias :<<    :push
+    alias size  length
+    alias dec   pop
+    alias shift pop
+    alias enc   push
+    alias <<    push
   end
-end
+end

redis-queue.gemspec

@@ -1,30 +1,32 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/redis/queue', __FILE__)
+# frozen_string_literal: true
+
+require File.expand_path('lib/redis/queue', __dir__)
 
 Gem::Specification.new do |s|
-  s.name        = "redis-queue"
+  s.name        = 'redis-queue'
   s.version     = Redis::Queue::VERSION
-  s.authors     = ["Francesco Laurita"]
-  s.email       = ["[email protected]"]
-  s.homepage    = "https://github.com/taganaka/redis-queue"
-  s.summary     = %q{A distributed queue based on Redis}
-  s.description = %q{
+  s.authors     = ['Francesco Laurita']
+  s.email       = ['[email protected]']
+  s.homepage    = 'https://github.com/taganaka/redis-queue'
+  s.summary     = 'A distributed queue based on Redis'
+  s.description = '
     Adds Redis::Queue class which can be used as Distributed-Queue based on Redis.
     Redis is often used as a messaging server to implement processing of background jobs or other kinds of messaging tasks.
     It implements Reliable-queue pattern decribed here: http://redis.io/commands/rpoplpush
-  }
+  '
 
-  s.licenses    = ["MIT"]
+  s.licenses = ['MIT']
 
-  s.rubyforge_project = "redis-queue"
+  s.rubyforge_project = 'redis-queue'
 
   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_runtime_dependency 'redis', '>= 3.3.5', '< 5'
   s.add_runtime_dependency 'hiredis', '~> 0.6'
+  s.add_runtime_dependency 'redis', '>= 3.3.5', '< 5'
 
   s.add_development_dependency 'rspec', '~> 2.13', '>= 2.13.0'
 end

spec/redis_queue_spec.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
-require "timeout"
+require 'timeout'
 
 describe Redis::Queue do
   before(:all) do
     @redis = Redis.new
     @queue = Redis::Queue.new('__test', 'bp__test')
-    @queue.clear true 
+    @queue.clear true
   end
 
   after(:all) do
@@ -22,34 +24,34 @@
   end
 
   it 'should add an element to the queue' do
-    @queue << "a"
+    @queue << 'a'
     @queue.size.should be == 1
   end
 
   it 'should return an element from the queue' do
     message = @queue.pop(true)
-    message.should be == "a"
+    message.should be == 'a'
   end
 
-  it 'should remove the element from bp_queue if commit is called' do 
+  it 'should remove the element from bp_queue if commit is called' do
     @redis.llen('bp__test').should be == 1
     @queue.commit
     @redis.llen('bp__test').should be == 0
   end
 
   it 'should implements fifo pattern' do
     @queue.clear
-    payload = %w(a b c d e)
-    payload.each {|e| @queue << e}
+    payload = %w[a b c d e]
+    payload.each { |e| @queue << e }
     test = []
-    while e=@queue.pop(true)
+    while (e = @queue.pop(true))
       test << e
     end
     payload.should be == test
   end
 
   it 'should remove all of the elements from the main queue' do
-    %w(a b c d e).each {|e| @queue << e}
+    %w[a b c d e].each { |e| @queue << e }
     @queue.size.should be > 0
     @queue.pop(true)
     @queue.clear
@@ -62,25 +64,25 @@
   end
 
   it 'should prcess a message' do
-    @queue << "a"
-    @queue.process(true){|m|m.should be == "a"; true}
+    @queue << 'a'
+    @queue.process(true) { |m| m.should be == 'a'; true }
   end
 
   it 'should prcess a message leaving it into the bp_queue' do
-    @queue << "a"
-    @queue << "a"
-    @queue.process(true){|m|m.should be == "a"; false}
-    @redis.lrange('bp__test',0, -1).should be == ['a', 'a']
+    @queue << 'a'
+    @queue << 'a'
+    @queue.process(true) { |m| m.should be == 'a'; false }
+    @redis.lrange('bp__test', 0, -1).should be == %w[a a]
   end
 
   it 'should refill a main queue' do
     @queue.clear(true)
-    @queue << "a"
-    @queue << "a"
-    @queue.process(true){|m|m.should be == "a"; false}
-    @redis.lrange('bp__test',0, -1).should be == ['a', 'a']
+    @queue << 'a'
+    @queue << 'a'
+    @queue.process(true) { |m| m.should be == 'a'; false }
+    @redis.lrange('bp__test', 0, -1).should be == %w[a a]
     @queue.refill
-    @redis.lrange('__test',0, -1).should be == ['a', 'a']
+    @redis.lrange('__test', 0, -1).should be == %w[a a]
     @redis.llen('bp__test').should be == 0
   end
 
@@ -89,32 +91,30 @@
     2.times { @queue << rand(100) }
     is_ok = true
     begin
-      Timeout::timeout(3) {
-        @queue.process(false, 2) {|m| true}
-      }
-    rescue Timeout::Error => e
+      Timeout.timeout(3) do
+        @queue.process(false, 2) { |_m| true }
+      end
+    rescue Timeout::Error => _e
       is_ok = false
     end
-    
-    is_ok.should be_true
 
+    is_ok.should be_truthy
   end
 
   it 'should honor the timeout param in the initializer' do
     redis = Redis.new
-    queue = Redis::Queue.new('__test_tm', 'bp__test_tm', :redis => redis, :timeout => 2)
+    queue = Redis::Queue.new('__test_tm', 'bp__test_tm', redis: redis, timeout: 2)
     queue.clear true
 
     is_ok = true
     begin
-      Timeout::timeout(4) {
+      Timeout.timeout(4) do
         queue.pop
-      }
-    rescue Timeout::Error => e
+      end
+    rescue Timeout::Error => _e
       is_ok = false
     end
     queue.clear
-    is_ok.should be_true
+    is_ok.should be_truthy
   end
-
-end
+end

spec/spec_helper.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler'
 require 'rspec'
 
-
 RSpec.configure do |config|
-  config.color_enabled = true
+  config.color = true
 end
 
-$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'redis-queue'
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'redis-queue'