redis-objects 1.4.3 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a9f86f294c2283b6ceae1730dfe6f1d1c3665ac9733cd107a4aa522d8a66bda
-  data.tar.gz: 50d631298aff5bcd5b15179c1a700a56a512c4a096cedad4c3f716999dcfebea
+  metadata.gz: 831f2916f47c47d9e3fcce9f8c585327c3e0e6e56204880ddfc860c279ec0e85
+  data.tar.gz: 188263c23463afc2f68b026efb79bac230ed140fba5d164540c99bac9d4553c2
 SHA512:
-  metadata.gz: 48b37a11d5a2a5844863f2a7c559b5e38a6a96eab5d8f5393d0b688f8ffada7f8e480bb12d93869ca7a82d1fbb0fd311fc85a5f72635a4749ee771fefe834abc
-  data.tar.gz: b09b794badff0249c468b0cc33b2daa24e87ab084cc5a778eb3415894bdad6e90070f7e3da4d417c16ec867017d4c15e5d06c0ca163560e5c4513297e3698241
+  metadata.gz: 2189c5151d3f59ca67445e4f560e23f68e34c62c6a257b58bbf9eb08775420044b82680c7dc4b808769347542c27fa1f295776bd418e4bf34a1d1e1b78799843
+  data.tar.gz: a26ad235bba5d586b8076c5640d4f725806187e41345af154d929b8ba4339932d97c86fb9d4a512777052df67aeca0a3f0fcda7d22e4f55248ff78fd14e3b552

data/.gitignore

@@ -9,3 +9,5 @@ spec/redis.pid
 dump.rdb
 Gemfile.lock
 redis-objects-*.gem
+coverage/
+.DS_Store

data/.travis.yml

@@ -5,7 +5,12 @@ before_install:
   - gem install bundler
 
 rvm:
-  - 2.2
-  - 2.3.3
-  - 2.4.0
-  - 2.5.1
+  - 2.3.8
+  - 2.4.10
+  - 2.5.9
+  - 2.6.7
+  - 2.7.3
+  - 3.0.1
+
+# For code coverage reports
+script: bundle exec rake

data/CHANGELOG.rdoc

@@ -1,5 +1,42 @@
 = Changelog for Redis::Objects
 
+== 1.5.1 (10 Jul 2021)
+
+* Added double-splat for **options to account for Ruby 3.0  [Nate Wiger]
+
+* Fix ConnectionPoolProxy Ruby 3.0 compatibility Fix: https://github.com/nateware/redis-objects/pull/258 [Jean byroot Boussier]
+
+* Change Redis#exists to Redis#exists? * bump redis version to 4.2 [Alina Hryshchuk]
+
+* Local variable `dir` is not in use since 98226b95f35ef455f231692fdb679dfd61200a78 [Akira Matsuda]
+
+* Issue 249: when atomic decrbyfloat fails, increment back instead of decrementing again [Slava Samoliuk]
+
+* Update documentation to reflect ability to assign values directly [Artin Boghosian]
+
+* Allow directly assigning values of lists, hashes and sets [Artin Boghosian]
+
+
+== 1.5.0 (18 Sep 2019)
+
+* updated README on expireat  [Nate Wiger]
+
+* Add option for using a custom serializer [Tomás Rojas]
+
+* DRY up objects to enable custom prefixing when desired [Tomás Rojas]
+
+* Allow spop to return multiple members  [Evan Paul]
+
+* Rename #delete! to #redis_delete_objects [Mattias Pfeiffer]
+
+* Make deletion simpler with just 1 call to Redis [Mattias Pfeiffer]
+
+* Move `CoreCommands` inclusion to `BaseObject`  [Tomás Rojas]
+
+* Move `Enumerable` functionality to `EnumerableObject`  [Tomás Rojas]
+
+* Move `attr_reader`s to `Redis::BaseObject` [Tomás Rojas]
+
 == 1.4.3 (7 Oct 2018)
 
 * Merge pull request #235 from johnc219/fix/end-time-expiration Add expiration in seconds to obtain end_time [Nate Wiger]

data/README.md

@@ -1,7 +1,8 @@
 Redis::Objects - Map Redis types directly to Ruby objects
 =========================================================
 
-[![Build Status](https://travis-ci.org/nateware/redis-objects.png)](https://travis-ci.org/nateware/redis-objects)
+[![Build Status](https://app.travis-ci.com/nateware/redis-objects.svg?branch=master)](https://travis-ci.com/github/nateware/redis-objects)
+[![Code Coverage](https://codecov.io/gh/nateware/redis-objects/branch/master/graph/badge.svg)](https://codecov.io/gh/nateware/redis-objects)
 [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=MJF7JU5M7F8VL)
 
 This is **not** an ORM. People that are wrapping ORM’s around Redis are missing the point.
@@ -9,7 +10,7 @@ This is **not** an ORM. People that are wrapping ORM’s around Redis are missin
 The killer feature of Redis is that it allows you to perform _atomic_ operations
 on _individual_ data structures, like counters, lists, and sets.  The **atomic** part is HUGE.
 Using an ORM wrapper that retrieves a "record", updates values, then sends those values back,
-_removes_ the atomicity, cutting the nuts off the major advantage of Redis.  Just use MySQL, k?
+_removes_ the atomicity, and thus the major advantage of Redis.  Just use MySQL, k?
 
 This gem provides a Rubyish interface to Redis, by mapping [Redis data types](http://redis.io/commands)
 to Ruby objects, via a thin layer over the `redis` gem.  It offers several advantages
@@ -144,6 +145,7 @@ Familiar Ruby array operations Just Work (TM):
 @team.on_base.shift
 @team.on_base.length  # 1
 @team.on_base.delete('player2')
+@team.on_base = ['player1', 'player2']  # ['player1', 'player2']
 ~~~
 
 Sets work too:
@@ -157,6 +159,15 @@ Sets work too:
   puts player
 end
 player = @team.outfielders.detect{|of| of == 'outfielder2'}
+@team.outfielders = ['outfielder1', 'outfielder3']  # ['outfielder1', 'outfielder3']
+~~~
+
+Hashes work too:
+
+~~~ruby
+@team.pitchers_faced['player1'] = 'pitcher2'
+@team.pitchers_faced['player2'] = 'pitcher1'
+@team.pitchers_faced = { 'player1' => 'pitcher2', 'player2' => 'pitcher1' }
 ~~~
 
 And you can do unions and intersections between objects (kinda cool):
@@ -550,20 +561,40 @@ Use :expiration and :expireat options to set default expiration.
 
 ~~~ruby
 value :value_with_expiration, :expiration => 1.hour
-value :value_with_expireat, :expireat => Time.now + 1.hour
+value :value_with_expireat, :expireat => lambda { Time.now + 1.hour }
 ~~~
 
-:warning: `expireat` is evaluated at class load time.
-In this example, it will be one hour after evaluating class, not after one hour after setting value.
+:warning: In the above example, `expiration` is evaluated at class load time.
+In this example, it will be one hour after loading the class, not after one hour
+after setting a value. If you want to expire one hour after setting the value,
+please use `:expireat` with `lambda`.
+
+Custom serialization
+--------------------
+You can customize how values are serialized by setting `serializer: CustomSerializer`.
+The default is `Marshal` from the standard lib, but it can be anything that responds to `dump` and
+`load`. `JSON` and `YAML` are popular options.
 
-If you want to expire one hour after setting the value. please use `lambda`.
+If you need to pass extra arguments to `dump` or `load`, you can set
+`marshal_dump_args: { foo: 'bar' }` and `marshal_load_args: { foo: 'bar' }` respectively.
 
 ~~~ruby
-value :value_with_expireat, :expireat => lambda { Time.now + 1.hour }
+class CustomSerializer
+  def self.dump(value)
+    # custom code for serializing
+  end
+
+  def self.load(value)
+    # custom code for deserializing
+  end
+end
+
+@account = Account.create!(params[:account])
+@newest  = Redis::Value.new('custom_serializer', marshal: true, serializer: CustomSerializer)
+@newest.value = @account.attributes
 ~~~
 
 Author
 =======
-Copyright (c) 2009-2013 [Nate Wiger](http://nateware.com).  All Rights Reserved.
+Copyright (c) 2009-2019 [Nate Wiger](http://nateware.com).  All Rights Reserved.
 Released under the [Artistic License](http://www.opensource.org/licenses/artistic-license-2.0.php).
-

data/lib/redis/base_object.rb

@@ -1,6 +1,12 @@
+require 'redis/helpers/core_commands'
+
 class Redis
   # Defines base functionality for all redis-objects.
   class BaseObject
+    include Redis::Helpers::CoreCommands
+
+    attr_reader :key, :options
+
     def initialize(key, *args)
       @key     = key.is_a?(Array) ? key.flatten.join(':') : key
       @options = args.last.is_a?(Hash) ? args.pop : {}

data/lib/redis/counter.rb

@@ -9,10 +9,6 @@ class Redis
   # class to define a counter.
   #
   class Counter < BaseObject
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
       @options[:start] ||= @options[:default] || 0
@@ -106,7 +102,7 @@ class Redis
     def decrbyfloat(by=1.0, &block)
       allow_expiration do
         val = redis.incrbyfloat(key, -by).to_f
-        block_given? ? rewindable_block(:incrbyfloat, -by, val, &block) : val
+        block_given? ? rewindable_block(:incrbyfloat, by, val, &block) : val
       end
     end
 
@@ -116,7 +112,7 @@ class Redis
     alias_method :to_i, :value
 
     def nil?
-      !redis.exists(key)
+      !redis.exists?(key)
     end
 
     ##

data/lib/redis/enumerable_object.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/base_object'
+
+class Redis
+  #
+  # Class representing a Redis enumerable type (list, set, sorted set, or hash).
+  #
+  class EnumerableObject < BaseObject
+    include Enumerable
+
+    # Iterate through each member. Redis::Objects mixes in Enumerable,
+    # so you can also use familiar methods like +collect+, +detect+, and so forth.
+    def each(&block)
+      value.each(&block)
+    end
+
+    def sort(options={})
+      return super() if block_given?
+      options[:order] = "asc alpha" if options.keys.count == 0  # compat with Ruby
+      val = redis.sort(key, **options)
+      val.is_a?(Array) ? val.map{|v| unmarshal(v)} : val
+    end
+
+    # ActiveSupport's core extension `Enumerable#as_json` implementation is incompatible with ours.
+    def as_json(*)
+      to_hash
+    end
+  end
+end

data/lib/redis/hash_key.rb

@@ -1,16 +1,10 @@
-require File.dirname(__FILE__) + '/base_object'
+require File.dirname(__FILE__) + '/enumerable_object'
 
 class Redis
   #
   # Class representing a Redis hash.
   #
-  class HashKey < BaseObject
-    require 'enumerator'
-    include Enumerable
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
+  class HashKey < EnumerableObject
     def initialize(key, *args)
       super
       @options[:marshal_keys] ||= {}
@@ -74,11 +68,6 @@ class Redis
     alias_method :clone, :all
     alias_method :value, :all
 
-    # Enumerate through all fields. Redis: HGETALL
-    def each(&block)
-      all.each(&block)
-    end
-
     # Enumerate through each keys. Redis: HKEYS
     def each_key(&block)
       keys.each(&block)
@@ -101,11 +90,6 @@ class Redis
       true if size == 0
     end
 
-    # Clears the dict of all keys/values. Redis: DEL
-    def clear
-      redis.del(key)
-    end
-
     # Set keys in bulk, takes a hash of field/values {'field1' => 'val1'}. Redis: HMSET
     def bulk_set(*args)
       raise ArgumentError, "Argument to bulk_set must be hash of key/value pairs" unless args.last.is_a?(::Hash)
@@ -139,24 +123,20 @@ class Redis
       hsh
     end
 
-    # Get values in bulk, takes an array of keys as arguments.
+    # Get values in bulk, takes an array of fields as arguments.
     # Values are returned in a collection in the same order than their keys in *keys Redis: HMGET
-    def bulk_values(*keys)
-      get_keys = *keys.flatten
-      return [] if get_keys.empty?
-      res = redis.hmget(key, get_keys)
-      get_keys.inject([]){|collection, k| collection << unmarshal(res.shift, options[:marshal_keys][k])}
+    def bulk_values(*fields)
+      get_fields = *fields.flatten
+      return [] if get_fields.empty?
+      res = redis.hmget(key, get_fields)
+      get_fields.collect{|k| unmarshal(res.shift, options[:marshal_keys][k])}
     end
 
     # Increment value by integer at field. Redis: HINCRBY
     def incrby(field, by=1)
       allow_expiration do
         ret = redis.hincrby(key, field, by)
-        unless ret.is_a? Array
-          ret.to_i
-        else
-          nil
-        end
+        ret.to_i
       end
     end
     alias_method :incr, :incrby
@@ -171,11 +151,7 @@ class Redis
     def incrbyfloat(field, by=1.0)
       allow_expiration do
         ret = redis.hincrbyfloat(key, field, by)
-        unless ret.is_a? Array
-          ret.to_f
-        else
-          nil
-        end
+        ret.to_f
       end
     end
 
@@ -183,9 +159,5 @@ class Redis
     def decrbyfloat(field, by=1.0)
       incrbyfloat(field, -by)
     end
-
-    def as_json(*)
-      to_hash
-    end
   end
 end

data/lib/redis/helpers/core_commands.rb

@@ -2,16 +2,21 @@ class Redis
   module Helpers
     # These are core commands that all types share (rename, etc)
     module CoreCommands
-      def exists?
+      def exists
         redis.exists key
       end
-      
+
+      def exists?
+        redis.exists? key
+      end
+
+      # Delete key. Redis: DEL
       def delete
         redis.del key
       end
       alias_method :del, :delete
       alias_method :clear, :delete
-      
+
       def type
         redis.type key
       end
@@ -29,7 +34,7 @@ class Redis
         @key = dest if ret && setkey
         ret
       end
-    
+
       def expire(seconds)
         redis.expire key, seconds
       end
@@ -50,20 +55,19 @@ class Redis
         redis.move key, dbindex
       end
 
-      def sort(options={})
-        options[:order] = "asc alpha" if options.keys.count == 0  # compat with Ruby
-        val = redis.sort(key, options)
-        val.is_a?(Array) ? val.map{|v| unmarshal(v)} : val
+      def serializer
+        options[:serializer] || Marshal
       end
 
       def marshal(value, domarshal=false)
         if options[:marshal] || domarshal
-          Marshal.dump(value)
+          dump_args = options[:marshal_dump_args] || []
+          serializer.dump(value, *(dump_args.is_a?(Array) ? dump_args : [dump_args]))
         else
           value
         end
       end
- 
+
       def unmarshal(value, domarshal=false)
         if value.nil?
           nil
@@ -73,7 +77,8 @@ class Redis
           elsif !value.is_a?(String)
             value
           else
-            Marshal.load(value) 
+            load_args = options[:marshal_load_args] || []
+            serializer.load(value, *(load_args.is_a?(Array) ? load_args : [load_args]))
           end
         else
           value

data/lib/redis/list.rb

@@ -1,18 +1,11 @@
-require File.dirname(__FILE__) + '/base_object'
+require File.dirname(__FILE__) + '/enumerable_object'
 
 class Redis
   #
   # Class representing a Redis list.  Instances of Redis::List are designed to
   # behave as much like Ruby arrays as possible.
   #
-  class List < BaseObject
-    require 'enumerator'
-    include Enumerable
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
+  class List < EnumerableObject
     # Works like push.  Can chain together: list << 'a' << 'b'
     def <<(value)
       push(value) # marshal in push()
@@ -123,12 +116,6 @@ class Redis
       redis.lrem(key, count, marshal(name))  # weird api
     end
 
-    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
-    # so you can also use familiar methods like +collect+, +detect+, and so forth.
-    def each(&block)
-      values.each(&block)
-    end
-
     # Return a range of values from +start_index+ to +end_index+.  Can also use
     # the familiar list[start,end] Ruby syntax. Redis: LRANGE
     def range(start_index, end_index)
@@ -169,9 +156,5 @@ class Redis
     def to_s
       values.join(', ')
     end
-
-    def as_json(*)
-      to_hash
-    end
   end
 end

data/lib/redis/lock.rb

@@ -11,7 +11,6 @@ class Redis
   class Lock < BaseObject
     class LockTimeout < StandardError; end #:nodoc:
 
-    attr_reader :key, :options
     def initialize(key, *args)
       super(key, *args)
       @options[:timeout] ||= 5
@@ -19,13 +18,6 @@ class Redis
       redis.setnx(key, @options[:start]) unless @options[:start] == 0 || @options[:init] === false
     end
 
-    # Clear the lock.  Should only be needed if there's a server crash
-    # or some other event that gets locks in a stuck state.
-    def clear
-      redis.del(key)
-    end
-    alias_method :delete, :clear
-
     def value
       nil
     end

data/lib/redis/objects/connection_pool_proxy.rb

@@ -9,6 +9,7 @@ class Redis
       def method_missing(name, *args, &block)
         @pool.with { |x| x.send(name, *args, &block) }
       end
+      ruby2_keywords :method_missing if respond_to?(:ruby2_keywords, true)
 
       def respond_to_missing?(name, include_all = false)
         @pool.with { |x| x.respond_to?(name, include_all) }

data/lib/redis/objects/hashes.rb

@@ -26,6 +26,15 @@ class Redis
                   )
                 )
             end
+
+            define_method(:"#{name}=") do |values|
+              hash_key = public_send(name)
+
+              redis.pipelined do
+                hash_key.clear
+                hash_key.bulk_set(values)
+              end
+            end
           end
 
           if options[:global]

data/lib/redis/objects/lists.rb

@@ -26,6 +26,15 @@ class Redis
                   )
                 )
             end
+
+            define_method(:"#{name}=") do |values|
+              list = public_send(name)
+
+              redis.pipelined do
+                list.clear
+                list.push(*values)
+              end
+            end
           end
 
           if options[:global]

data/lib/redis/objects/sets.rb

@@ -26,6 +26,15 @@ class Redis
                   )
                 )
             end
+
+            define_method(:"#{name}=") do |values|
+              set = public_send(name)
+
+              redis.pipelined do
+                set.clear
+                set.merge(*values)
+              end
+            end
           end
 
           if options[:global]

data/lib/redis/objects/version.rb

@@ -1,5 +1,5 @@
 class Redis
   module Objects
-    VERSION = "1.4.3"
+    VERSION = "1.6.0"
   end
 end

data/lib/redis/objects.rb

@@ -46,8 +46,6 @@ class Redis
   #
   #
   module Objects
-    dir = File.expand_path(__FILE__.sub(/\.rb$/,''))
-
     autoload :Counters,   'redis/objects/counters'
     autoload :Lists,      'redis/objects/lists'
     autoload :Locks,      'redis/objects/locks'
@@ -173,8 +171,15 @@ class Redis
       def redis()         self.class.redis end
       def redis_objects() self.class.redis_objects end
 
-      def delete!
-        redis.del(redis_objects.keys.map { |k| send(k) }.reject(&:nil?).map { |obj| obj.key })
+      def redis_delete_objects
+        redis.del(redis_instance_keys)
+      end
+
+      def redis_instance_keys
+        redis_objects
+          .reject { |_, value| value[:global] }
+          .keys
+          .collect { |name| redis_field_key(name) }
       end
 
       def redis_options(name) #:nodoc:

data/lib/redis/set.rb

@@ -1,17 +1,10 @@
-require File.dirname(__FILE__) + '/base_object'
+require File.dirname(__FILE__) + '/enumerable_object'
 
 class Redis
   #
   # Class representing a set.
   #
-  class Set < BaseObject
-    require 'enumerator'
-    include Enumerable
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
+  class Set < EnumerableObject
     # Works like add.  Can chain together: list << 'a' << 'b'
     def <<(value)
       add(value)
@@ -27,8 +20,8 @@ class Redis
     end
 
     # Remove and return a random member.  Redis: SPOP
-    def pop
-      unmarshal redis.spop(key)
+    def pop(count = nil)
+      unmarshal redis.spop(key, count)
     end
 
     # return a random member.  Redis: SRANDMEMBER
@@ -74,12 +67,6 @@ class Redis
       res
     end
 
-    # Iterate through each member of the set.  Redis::Objects mixes in Enumerable,
-    # so you can also use familiar methods like +collect+, +detect+, and so forth.
-    def each(&block)
-      members.each(&block)
-    end
-
     # Return the intersection with another set.  Can pass it either another set
     # object or set name.  Also available as & which is a bit cleaner:
     #
@@ -185,10 +172,6 @@ class Redis
       members.join(', ')
     end
 
-    def as_json(*)
-      to_hash
-    end
-
     private
 
     def keys_from_objects(sets)

data/lib/redis/sorted_set.rb

@@ -1,17 +1,10 @@
-require File.dirname(__FILE__) + '/base_object'
+require File.dirname(__FILE__) + '/enumerable_object'
 
 class Redis
   #
   # Class representing a sorted set.
   #
-  class SortedSet < BaseObject
-    # require 'enumerator'
-    # include Enumerable
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
+  class SortedSet < EnumerableObject
     # How to add values using a sorted set.  The key is the member, eg,
     # "Peter", and the value is the score, eg, 163.  So:
     #    num_posts['Peter'] = 163
@@ -124,7 +117,7 @@ class Redis
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
 
-      redis.zrangebyscore(key, min, max, args).map{|v| unmarshal(v) }
+      redis.zrangebyscore(key, min, max, **args).map{|v| unmarshal(v) }
     end
 
     # Returns all the elements in the sorted set at key with a score between max and min
@@ -140,7 +133,7 @@ class Redis
                 options[:offset] || options[:limit] || options[:count]
       args[:with_scores] = true if options[:withscores] || options[:with_scores]
 
-      redis.zrevrangebyscore(key, max, min, args).map{|v| unmarshal(v) }
+      redis.zrevrangebyscore(key, max, min, **args).map{|v| unmarshal(v) }
     end
 
     # Remove all elements in the sorted set at key with rank between start and end. Start and end are
@@ -229,7 +222,7 @@ class Redis
     def interstore(name, *sets)
       allow_expiration do
         opts = sets.last.is_a?(Hash) ? sets.pop : {}
-        redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+        redis.zinterstore(key_from_object(name), keys_from_objects([self] + sets), **opts)
       end
     end
 
@@ -265,7 +258,7 @@ class Redis
     def unionstore(name, *sets)
       allow_expiration do
         opts = sets.last.is_a?(Hash) ? sets.pop : {}
-        redis.zunionstore(key_from_object(name), keys_from_objects([self] + sets), opts)
+        redis.zunionstore(key_from_object(name), keys_from_objects([self] + sets), **opts)
       end
     end