redis-objects 1.3.1 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ae3bd1cf4a81eca5bbb34a027f066b2dcbd233d5
-  data.tar.gz: 03ec3b26287e799061232c37a9604b0b65e52219
+SHA256:
+  metadata.gz: 5c7bc592d203647a8b7e9fd574a78eec1ec466e85fef95d30fac6d831f5d086a
+  data.tar.gz: e89a8a50ddac32cc8b0fd5692697c21620ef97bac6f28c1841c0e50e9a833429
 SHA512:
-  metadata.gz: af1e410ca8fdb1251e4b67c6ff6e051a76ea78804c729b82cc7ba90ced750cc9139c9fbf86d78b2e79476a55c66a7c59733c150f6ff9adb9a9e16bf94ee7daf7
-  data.tar.gz: 9e8deeb4e39b6ccf713f461eae512870c3fac18d211984583d3ad10814b231515d724aee6c22b9cecd7306b29d2e20f68de77f4f794c3deae3b6fa4d74153a1b
+  metadata.gz: 7a91ab932b94a4a36ab4da40d173804b71c46b21c28e917acefb5f1720da1dd60fe3e4c0d06e124c172118789c31fa11f0f4b96b7b27da97cbd8f7a90f01dd6c
+  data.tar.gz: d92e900d1fcec537a439e99ad7d311a83ad23c1e5c28ecc84e8922a0c7da56b4fdcfc9cadcb48aca382c4a6c8045dd24ecbeb81d681aa4fcad2c9d13b3cf9a8f

data/.travis.yml

@@ -5,9 +5,7 @@ before_install:
   - gem install bundler
 
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1
-  - 2.2
   - 2.3.3
   - 2.4.0
+  - 2.5.1
+  - 2.6.4

data/CHANGELOG.rdoc

@@ -1,5 +1,104 @@
 = 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]
+
+* Merge pull request #223 from artinboghosian/compress-redis-value Allow compression of value stored in Redis::Value to save memory on R… [Nate Wiger]
+
+* Merge pull request #224 from artinboghosian/sorted-set-missing-operations Fix set operation methods on SortedSets [Nate Wiger]
+
+* Merge pull request #233 from tmattia/master Add SortedSet#count alias so it's consistent with Set#count [Nate Wiger]
+
+* Merge pull request #236 from nateware/revert-220-threadsafe Revert "Make Redis::Objects.connection thread-safe" [Nate Wiger]
+
+* Revert "Make Redis::Objects.connection thread-safe"  [Nate Wiger]
+
+== 1.4.2 (29 Aug 2018)
+
+* Merge pull request #227 from D-system/optimise_lock Optimise lock [Nate Wiger]
+
+* Merge pull request #228 from D-system/travis_ruby_2.5 Travis: test against ruby 2.5 [Nate Wiger]
+
+* Travis: test against ruby 2.5  [Thomas Brennetot]
+
+* Lock: update comment  [Thomas Brennetot]
+
+* Lock: add backward compatibility  [Thomas Brennetot]
+
+* Use SET with the NX and the expiration option in a single request  [Thomas Brennetot]
+
+* Merge pull request #218 from edwardbako/list_pushed_count Return count of lpush & rpush commands [Nate Wiger]
+
+* Merge pull request #220 from gammons/threadsafe Make Redis::Objects.connection thread-safe [Nate Wiger]
+
+* Make Redis::Objects.connection threadsafe  [Grant Ammons]
+
+* Return count of lpush & rpush commands  [Edward Bako]
+
+* Removed support for versions of Ruby < 2.2  [Nate Wiger]
+
+== 1.4.1 (Unreleased)
+
+* Buggy release that was removed
+
+== 1.4.0 (7 Dec 2017)
+
+* Bumped dependency to redis.rb 4.0 [Nate Wiger]
+
+== 1.3.1 (29 Aug 2017)
+
+* Merge pull request #213 from onk/feature/proc_expireat Allow to set proc for expireat [Nate Wiger]
+
+* Merge pull request #212 from yuzixun/hotfix/counter modify Counter#nil? [Nate Wiger]
+
+* Merge pull request #207 from i2bskn/improve_bulk_get Reduce query to Redis. [Nate Wiger]
+
+* Merge pull request #209 from yuzixun/hotfix/hash_key/bulk_related fix error when fields/keys is an array [Nate Wiger]
+
+* Use pre-calculated symbols for instance_variable_(get|set) for performance #211  [Nate Wiger]
+
+* Weird inheriting from version AR::Migration thingy  [Nate Wiger]
+
+* Reduce query to Redis. Don't query to Redis if #bulk_get/#bulk_values arguments is empty. [i2bskn]
+
 == 1.3.0 (11 Mar 2017)
 
 * handle two Redis::Counter objects adding/subtracting  [Nate Wiger]

data/README.md

@@ -9,7 +9,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 +144,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 +158,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):
@@ -261,6 +271,18 @@ Complex data is no problem with :marshal => true:
 puts @newest.value['username']
 ~~~
 
+Compress data to save memory usage on Redis with :compress => true:
+
+~~~ruby
+@account = Account.create!(params[:account])
+@marshaled_value = Redis::Value.new('marshaled', :marshal => true, :compress => true)
+@marshaled_value.value = @account.attributes
+@unmarshaled_value = Redis::Value.new('unmarshaled', :compress => true)
+@unmarshaled_value = 'Really Long String'
+puts @marshaled_value.value['username']
+puts @unmarshaled_value.value
+~~~
+
 Lists
 -----
 Lists work just like Ruby arrays:
@@ -538,20 +560,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`.
 
-If you want to expire one hour after setting the value. please use `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 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)
@@ -183,9 +167,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

@@ -3,15 +3,16 @@ class Redis
     # These are core commands that all types share (rename, etc)
     module CoreCommands
       def exists?
-        redis.exists key
+        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 +30,7 @@ class Redis
         @key = dest if ret && setkey
         ret
       end
-    
+
       def expire(seconds)
         redis.expire key, seconds
       end
@@ -50,20 +51,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 +73,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()
@@ -29,8 +22,9 @@ class Redis
     # Add a member to the end of the list. Redis: RPUSH
     def push(*values)
       allow_expiration do
-        redis.rpush(key, values.map{|v| marshal(v) })
+        count = redis.rpush(key, values.map{|v| marshal(v) })
         redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
+        count
       end
     end
 
@@ -62,8 +56,9 @@ class Redis
     # Add a member to the start of the list. Redis: LPUSH
     def unshift(*values)
       allow_expiration do
-        redis.lpush(key, values.map{|v| marshal(v) })
+        count = redis.lpush(key, values.map{|v| marshal(v) })
         redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
+        count
       end
     end
 
@@ -121,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)
@@ -167,9 +156,5 @@ class Redis
     def to_s
       values.join(', ')
     end
-
-    def as_json(*)
-      to_hash
-    end
   end
 end