redis-unique-queue 1.0.3 → 2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 79dd06e09747ec1015a14103fd72c6e19a121b1c
-  data.tar.gz: 5851bf6cd8e38b65915bc6c449796959c2600c5a
+  metadata.gz: de78d99306d017bd477d116439e987481571fcbc
+  data.tar.gz: 313940b8fe19ff797910d5b9fb0997d4e08879f7
 SHA512:
-  metadata.gz: b202259ac4ef6ba1bea1b0785d2e40bc519c3aa9d7731b9fe1a1ae2df7ee6f07a4446cec41cbd04170d139059f4df5fab6489e69b48d19f9cd112002349aeea3
-  data.tar.gz: 9f8ae2edf1e423b50a4e159108d560f069abb2961fe6c8047b761b8ab6766526c2dfe828497979142197cb2a25c569175fa0dc740f04d2a73d76866b15f963fa
+  metadata.gz: 1f918cd173c15ea8d164aa6f7ac277752701d2af2c6e90bfbd5876b12630445ee2453a8260e449ce8fc3c779514f8a279d5c543af16fb35da550eca34827402d
+  data.tar.gz: 4f48d23ef3510e98e76cc8270c4cda303ffa8749c185767a7055b56c74130cac10abd4a3df27cc8d7b1f7b2ab7e59e64ee816d7af706d230f11f84aba1a5a178

data/README.md

@@ -1,4 +1,4 @@
-# Redis::Unique::Queue
+# RedisUniqueQueue
 
 A unique FIFO queue with atomic operations built on top of Redis. Useful if you want to enqueue data without worrying about it existing multiple times in the queue.
 
@@ -22,19 +22,19 @@ Or install it yourself as:
 You can instantiate a named queue using your default Redis configuration.
 
 ```ruby
-q = Redis::Unique::Queue.new 'jobs'
+q = RedisUniqueQueue.new 'jobs'
 ```
 
 Or you can pass in your own instance of the Redis class.
 
 ```ruby
-q = Redis::Unique::Queue.new 'jobs', Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15)
+q = RedisUniqueQueue.new 'jobs', Redis.new(:host => "10.0.1.1", :port => 6380, :db => 15)
 ```
 
 A third option is to instead pass your Redis configurations.
 
 ```ruby
-q = Redis::Unique::Queue.new 'jobs', :host => "10.0.1.1", :port => 6380, :db => 15
+q = RedisUniqueQueue.new 'jobs', :host => "10.0.1.1", :port => 6380, :db => 15
 ```
 
 ## Using the queue

data/lib/redis_unique_queue.rb

@@ -0,0 +1,179 @@
+require "redis"
+
+class RedisUniqueQueue
+	attr_reader :name
+
+	VERSION = "2.0"
+
+	class InvalidNameException < StandardError; end;
+	class InvalidRedisConfigException < StandardError; end;
+
+	def initialize(name, redis_or_options = {}, more_options = {})
+		name = name.to_s if name.kind_of? Symbol
+
+		raise InvalidNameException.new unless name.kind_of?(String) && name.size > 0
+		@name = name
+		@redis = if redis_or_options.kind_of?(Redis)
+			         redis_or_options
+			       elsif redis_or_options.kind_of? Hash
+				       ::Redis.new redis_or_options
+			       elsif defined?(ActiveSupport::Cache::RedisStore) && redis_or_options.kind_of?(ActiveSupport::Cache::RedisStore)
+				       @pooled = redis_or_options.data.kind_of?(ConnectionPool)
+				       redis_or_options.data
+			       elsif defined?(ConnectionPool) && redis_or_options.kind_of?(ConnectionPool)
+				       @pooled = true
+				       redis_or_options
+			       else
+				       raise InvalidRedisConfigException.new
+		         end
+
+		if more_options.kind_of?(Hash) && more_options[:expire]
+			expire more_options[:expire]
+		end
+	end
+
+	def push data
+		[block_on_atomic_attempt { attempt_atomic_push_multi(data) }].flatten.first
+	end
+
+	def push_multi *values
+		if values.size > 0
+			block_on_atomic_attempt { attempt_atomic_push_multi(*values) }
+		end
+	end
+
+	def pop
+		block_on_atomic_attempt { attempt_atomic_pop }
+	end
+
+	def pop_all
+		block_on_atomic_attempt { attempt_atomic_pop_all }
+	end
+
+	def pop_multi amount
+		block_on_atomic_attempt { attempt_atomic_pop_multi amount }
+	end
+
+	def front
+		with { |redis| redis.zrange(name, 0, 0).first }
+	end
+
+	def back
+		with { |redis| redis.zrevrange(name, 0, 0).first }
+	end
+
+	def remove data
+		with { |redis| redis.zrem name, data }
+	end
+
+	def remove_item_by_index index
+		with { |redis| redis.zremrangebyrank name, index, index }
+	end
+
+	def size
+		with { |redis| redis.zcard name }
+	end
+
+	def all
+		peek 0, size
+	end
+
+	def peek index, amount = 1
+		with { |redis| redis.zrange name, index, index + amount - 1 }
+	end
+
+	def include? data
+		!with { |redis| redis.zscore(name, data).nil? }
+	end
+
+	def clear
+		with { |redis| redis.del name }
+		[]
+	end
+
+	def expire seconds
+		with { |redis| redis.expire name, seconds }
+	end
+
+	private
+
+	def max_score
+		with { |redis| redis.zscore name, back }
+	end
+
+	def attempt_atomic_push_multi *values
+		with do |redis|
+			success = redis.watch(name) do
+				score = [Time.now.to_f, max_score].compact.max
+				values = values.first if 1 == values.size && values.first.kind_of?(Array)
+				scored_values = []
+				values.each_with_index do |value, i|
+					scored_values << [score + i, value]
+				end
+				redis.multi do |multi|
+					multi.zadd name, scored_values
+				end
+			end
+
+			[success, values]
+		end
+	end
+
+	def attempt_atomic_pop_multi amount
+		attempt_atomic_read_write lambda { peek 0, amount }, lambda { |multi, read_result| multi.zremrangebyrank name, 0, amount - 1 }
+	end
+
+	def attempt_atomic_pop_all
+		attempt_atomic_read_write lambda { all }, lambda { |multi, read_result| multi.del name }
+	end
+
+	def attempt_atomic_pop
+		read = lambda do
+			with{|redis| redis.zrangebyscore(name, 0, max_score, :with_scores => false, :limit => [0, 1]).first}
+		end
+
+		write = lambda do |multi, read_result|
+			multi.zrem name, read_result
+		end
+
+		attempt_atomic_read_write read, write
+	end
+
+	def block_on_atomic_attempt
+		begin
+			success, result = yield
+		end while !success && result
+		result
+	end
+
+	def attempt_atomic_read_write read_op, write_op
+		result = nil
+		success = with do |redis|
+			redis.watch(name) do
+				result = read_op.call
+				if result
+					redis.multi do |multi|
+						write_op.call multi, result
+					end
+				end
+			end
+		end
+
+		[success, result]
+	end
+
+	private
+
+	def with(&block)
+		if pooled?
+			@redis.with(&block)
+		else
+			block.call(@redis)
+		end
+	end
+
+	def pooled?
+		!!@pooled
+	end
+end
+

data/redis-unique-queue.gemspec

@@ -1,11 +1,11 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'redis/unique/queue'
+require 'redis_unique_queue'
 
 Gem::Specification.new do |spec|
   spec.name          = "redis-unique-queue"
-  spec.version       = Redis::Unique::Queue::VERSION
+  spec.version       = RedisUniqueQueue::VERSION
   spec.authors       = ["Misha Conway"]
   spec.email         = ["mishaAconway@gmail.com"]
   spec.summary       = %q{A unique queue with atomic operations implemented in Redis}

data/spec/redis_unique_queue_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe RedisUniqueQueue do
+	let(:redis) { Redis.new }
+	let(:name) { "some_queue" }
+	let(:queue) { described_class.new(name, redis) }
+
+	before do
+		redis.flushall
+	end
+
+	context "instance methods" do
+		describe '#push' do
+			it 'should push items to the queue' do
+				expect(queue.size).to eq(0)
+				queue.push('a')
+				queue.push('b')
+				queue.push('c')
+				expect(queue.size).to eq(3)
+				expect(queue.all).to eq(%w(a b c))
+			end
+		end
+
+		describe '#push_multi' do
+			it 'should push multiple items to the queue' do
+				expect(queue.size).to eq(0)
+				queue.push_multi('a', 'b', 'c')
+				expect(queue.size).to eq(3)
+				expect(queue.all).to eq(%w(a b c))
+			end
+		end
+
+		context do
+			before do
+				expect(queue.size).to eq(0)
+				queue.push('a')
+				queue.push('b')
+				queue.push('c')
+				expect(queue.size).to eq(3)
+			end
+
+			describe '#pop' do
+				it 'should pop single items from the queue' do
+					expect(queue.pop).to eq('a')
+					expect(queue.size).to eq(2)
+
+					expect(queue.pop).to eq('b')
+					expect(queue.size).to eq(1)
+
+					expect(queue.pop).to eq('c')
+					expect(queue.size).to eq(0)
+				end
+			end
+
+			describe '#pop_all' do
+				it 'should pop all items from the queue' do
+					expect(queue.pop_all).to eq(%w(a b c))
+					expect(queue.size).to eq(0)
+				end
+			end
+
+			describe '#pop_multi' do
+				it 'should pop multiple items from the queue' do
+					expect(queue.pop_multi(2)).to eq(%w(a b))
+					expect(queue.size).to eq(1)
+				end
+			end
+
+			describe '#front' do
+				it 'shows the front of the queue' do
+					expect(queue.front).to eq('a')
+				end
+			end
+
+			describe '#back' do
+				it 'shows the back of the queue' do
+					expect(queue.back).to eq('c')
+				end
+			end
+
+			describe '#remove' do
+				it 'removes single items from the queue' do
+					queue.remove('b')
+					expect(queue.size).to eq(2)
+					expect(queue.all).to eq(%w(a c))
+				end
+			end
+
+			describe '#remove_item_by_index' do
+				it 'removes single items by index' do
+					queue.remove_item_by_index(1)
+					expect(queue.size).to eq(2)
+					expect(queue.all).to eq(%w(a c))
+				end
+			end
+
+			describe '#size' do
+				it 'returns the size of the queue' do
+				  expect(queue.size).to eq(3)
+				end
+			end
+
+			describe '#all' do
+				it 'returns all of the items in the queue' do
+				  expect(queue.all).to eq(%w(a b c))
+				end
+			end
+
+			describe '#peek' do
+				it 'allows you to peek at items in the queue without mutating the queue' do
+				  expect(queue.peek(0,1)).to eq(%w(a))
+					expect(queue.peek(1,1)).to eq(%w(b))
+				  expect(queue.peek(2,1)).to eq(%w(c))
+				  expect(queue.peek(3,1)).to eq([])
+
+				  expect(queue.peek(0,2)).to eq(%w(a b))
+				  expect(queue.peek(0,3)).to eq(%w(a b c))
+				  expect(queue.peek(0,4)).to eq(%w(a b c))
+
+				  expect(queue.peek(1,2)).to eq(%w(b c))
+				  expect(queue.peek(1,3)).to eq(%w(b c))
+
+					expect(queue.size).to eq(3)
+					expect(queue.all).to eq(%w(a b c))
+				end
+			end
+
+			describe '#include?' do
+				it 'indicates if an item is in the queue or not' do
+				  expect(queue.include?('a')).to be true
+				  expect(queue.include?('A')).to be false
+
+				  expect(queue.include?('b')).to be true
+				  expect(queue.include?('B')).to be false
+
+				  expect(queue.include?('c')).to be true
+				  expect(queue.include?('C')).to be false
+				end
+			end
+
+			describe '#clear' do
+				it 'empties the queue' do
+				  queue.clear
+					expect(queue.size).to eq(0)
+					expect(queue.all).to eq([])
+				end
+			end
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+RSpec.configure do |config|
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-unique-queue
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: '2.0'
 platform: ruby
 authors:
 - Misha Conway
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-17 00:00:00.000000000 Z
+date: 2019-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,8 +64,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/redis/unique/queue.rb
+- lib/redis_unique_queue.rb
 - redis-unique-queue.gemspec
+- spec/redis_unique_queue_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/MishaConway/ruby-redis-unique-queue
 licenses:
 - MIT
@@ -86,8 +88,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: A unique queue with atomic operations implemented in Redis
-test_files: []
+test_files:
+- spec/redis_unique_queue_spec.rb
+- spec/spec_helper.rb

data/lib/redis/unique/queue.rb

@@ -1,155 +0,0 @@
-require "redis"
-
-class Redis
-  module Unique
-    class Queue
-      attr_reader :name
-
-      VERSION = "1.0.3"
-
-      class InvalidNameException < StandardError; end;
-      class InvalidRedisConfigException < StandardError; end;
-
-      def initialize(name, redis_or_options = {})
-        name = name.to_s if name.kind_of? Symbol
-
-        raise InvalidNameException.new unless name.kind_of?(String) && name.size > 0
-        @name  = name
-        @redis = if redis_or_options.kind_of? Redis
-                   redis_or_options
-                 elsif redis_or_options.kind_of? Hash
-                   Redis.new redis_or_options
-                 else
-                  raise InvalidRedisConfigException.new
-                 end
-      end
-
-      def push data
-        [block_on_atomic_attempt{ attempt_atomic_push_multi(data) }].flatten.first
-      end
-
-      def push_multi *values
-        if values.size > 0
-          block_on_atomic_attempt{ attempt_atomic_push_multi(*values) }
-        end
-      end
-
-      def pop
-        block_on_atomic_attempt{ attempt_atomic_pop }
-      end
-
-      def pop_all
-        block_on_atomic_attempt{ attempt_atomic_pop_all }
-      end
-
-      def pop_multi amount
-        block_on_atomic_attempt{ attempt_atomic_pop_multi amount }
-      end
-
-      def front
-        @redis.zrange(name, 0, 0).first
-      end
-
-      def back
-        @redis.zrevrange(name, 0, 0).first
-      end
-
-      def remove data
-        @redis.zrem name, data
-      end
-
-      def remove_item_by_index index
-        @redis.zremrangebyrank name, index, index
-      end
-
-      def size
-        @redis.zcard name
-      end
-
-      def all
-        peek 0, size
-      end
-
-      def peek index, amount=1
-        @redis.zrange name, index, index + amount - 1
-      end
-
-      def include? data
-        !@redis.zscore(name, data).nil?
-      end
-
-      def clear
-        @redis.del name
-        []
-      end
-
-      def expire seconds
-        @redis.expire name, seconds
-      end
-
-      private
-
-      def max_score
-        @redis.zscore name, back
-      end
-
-      def attempt_atomic_push_multi *values
-        success = @redis.watch(name) do
-          score = [Time.now.to_f, max_score].compact.max
-          values = values.first if 1 == values.size && values.first.kind_of?(Array)
-          scored_values = []
-          values.each_with_index do |value, i|
-            scored_values << [score + i, value]
-          end
-          @redis.multi do |multi|
-            multi.zadd name, scored_values
-          end
-        end
-
-        [success, values]
-      end
-
-      def attempt_atomic_pop_multi amount
-        attempt_atomic_read_write lambda{ peek 0, amount }, lambda{  |multi, read_result| multi.zremrangebyrank name, 0, amount - 1 }
-      end
-
-      def attempt_atomic_pop_all
-        attempt_atomic_read_write lambda{ all }, lambda{ |multi, read_result| multi.del name}
-      end
-
-      def attempt_atomic_pop
-        read = lambda do
-          @redis.zrangebyscore(name, 0, max_score, :with_scores => false, :limit => [0, 1]).first
-        end
-
-        write = lambda do |multi, read_result|
-          multi.zrem name, read_result
-        end
-
-        attempt_atomic_read_write read, write
-      end
-
-      def block_on_atomic_attempt
-        begin
-          success, result = yield
-        end while !success && result
-        result
-      end
-
-      def attempt_atomic_read_write read_op, write_op
-
-        result  = nil
-        success = @redis.watch(name) do
-          result = read_op.call
-          if result
-            @redis.multi do |multi|
-              write_op.call multi, result
-            end
-          end
-        end
-
-        [success, result]
-      end
-    end
-  end
-end