redis-objects 1.4.3 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a9f86f294c2283b6ceae1730dfe6f1d1c3665ac9733cd107a4aa522d8a66bda
-  data.tar.gz: 50d631298aff5bcd5b15179c1a700a56a512c4a096cedad4c3f716999dcfebea
+  metadata.gz: 1645ef709707def1356b48d10f02ed09c7cffc5e83568dc3b2d14c030fdff3d7
+  data.tar.gz: f1ef896dfaa12b573631417eaae3039bf16fd0d07ea4019956aa002c24a057f5
 SHA512:
-  metadata.gz: 48b37a11d5a2a5844863f2a7c559b5e38a6a96eab5d8f5393d0b688f8ffada7f8e480bb12d93869ca7a82d1fbb0fd311fc85a5f72635a4749ee771fefe834abc
-  data.tar.gz: b09b794badff0249c468b0cc33b2daa24e87ab084cc5a778eb3415894bdad6e90070f7e3da4d417c16ec867017d4c15e5d06c0ca163560e5c4513297e3698241
+  metadata.gz: a9d492b56d5c712d5c33d19ac682fd45eb937ead9dba84d7123346a40aaf88020dd6be82c8697342a130470f8a23bf0d3cc701e6691cf15e685efc1aec64737a
+  data.tar.gz: c5033f81a4d8c9aba6798aca9bf49cf5613217b6ef388252df92fe099111b4a85c0709e96fc64fcfe2bb0cc54720a536f2b08ea6c49976d44604347d7049b978

data/.travis.yml

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

data/CHANGELOG.rdoc

@@ -1,5 +1,25 @@
 = Changelog for Redis::Objects
 
+== 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

@@ -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
@@ -550,20 +550,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

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

@@ -5,13 +5,14 @@ class Redis
       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 +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()
@@ -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.rb

@@ -173,8 +173,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/objects/version.rb

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

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

data/lib/redis/value.rb

@@ -6,11 +6,6 @@ class Redis
   # Class representing a simple value.  You can use standard Ruby operations on it.
   #
   class Value < BaseObject
-    require 'redis/helpers/core_commands'
-    include Redis::Helpers::CoreCommands
-
-    attr_reader :key, :options
-
     def value=(val)
       allow_expiration do
         if val.nil?

data/spec/redis_objects_custom_serializer.rb

@@ -0,0 +1,198 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'redis/objects'
+
+class CustomSerializer
+  class << self
+    attr_accessor :dump_called, :load_called, :dump_args, :load_args
+  end
+
+  def self.dump(value, *args, **kargs)
+    @dump_called = true
+    @dump_args = [args, kargs]
+    Marshal.dump(value)
+  end
+
+  def self.load(value, *args, **kargs)
+    @load_called = true
+    @load_args = [args, kargs]
+    Marshal.load(value)
+  end
+
+  def self.reset!
+    @dump_called = nil
+    @load_called = nil
+  end
+end
+
+describe 'with custom serialization' do
+  before do
+    CustomSerializer.reset!
+  end
+
+  describe Redis::Value do
+    before do
+      @value = Redis::Value.new(
+        'spec/value_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @value.clear
+    end
+
+    it 'uses custom serializer' do
+      @value.value = { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @value.value.should == { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @value.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @value.value = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @value.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @value.value = 1
+      @value.value.should == 1
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::List do
+    before do
+      @list = Redis::List.new(
+        'spec/list_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @list.clear
+    end
+
+    it 'uses custom serializer' do
+      @list << { json: 'data' }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @list.should == [{ json: 'data' }]
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @list.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @list << 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @list.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @list << 1
+      @list.values.should == [1]
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::HashKey do
+    before do
+      @hash = Redis::HashKey.new(
+        'spec/hash_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @hash.clear
+    end
+
+    it 'uses custom serializer' do
+      @hash['a'] = 1
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @hash.value.should == { 'a' => 1 }
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @hash.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @hash['a'] = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @hash.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @hash['a'] = 1
+      @hash.value.should == { 'a' => 1 }
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::Set do
+    before do
+      @set = Redis::Set.new(
+        'spec/set_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @set.clear
+    end
+
+    it 'uses custom serializer' do
+      @set << 'a'
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @set.members.should == ['a']
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @set.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @set << 'a'
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @set.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @set << 'a'
+      @set.members.should == ['a']
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+
+  describe Redis::SortedSet do
+    before do
+      @set = Redis::SortedSet.new(
+        'spec/zset_custom_serializer',
+        marshal: true,
+        serializer: CustomSerializer
+      )
+      @set.clear
+    end
+
+    it 'uses custom serializer' do
+      @set['a'] = 1
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == nil
+      @set.members.should == ['a']
+      CustomSerializer.dump_called.should == true
+      CustomSerializer.load_called.should == true
+    end
+
+    it 'passes extra arguments to dump' do
+      @set.options[:marshal_dump_args] = ['some', { extra: 'arguments' }]
+      @set['a'] = 1
+      CustomSerializer.dump_args.should == [['some'], { extra: 'arguments' }]
+    end
+
+    it 'passes extra arguments to load' do
+      @set.options[:marshal_load_args] = ['some', { extra: 'arguments' }]
+      @set['a'] = 1
+      @set.members.should == ['a']
+      CustomSerializer.load_args.should == [['some'], { extra: 'arguments' }]
+    end
+  end
+end

data/spec/redis_objects_model_spec.rb

@@ -1009,8 +1009,15 @@ describe Redis::Objects do
   end
 
   it "should allow deleting the entire object" do
-    @roster.redis.keys.select { |key| key.match(/^roster:/)}.count.should > 0
-    @roster.delete!.should > 0
-    @roster.redis.keys.select { |key| key.match(/^roster:/)}.count.should == 0
+    (@roster.redis.keys & @roster.redis_instance_keys).count.should > 0
+    @roster.redis_delete_objects.should > 0
+    (@roster.redis.keys & @roster.redis_instance_keys).count.should == 0
+  end
+
+  it "should be able to return all instance keys" do
+    @roster.redis_instance_keys.include?('roster:1:player_stats').should == true
+    @roster.redis_instance_keys.include?('players:my_rank:user1').should == true
+    @roster.redis_instance_keys.include?('roster:1:player_stats').should == true
+    @roster.redis_instance_keys.include?('players:all_stats').should == false
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: redis-objects
 version: !ruby/object:Gem::Version
-  version: 1.4.3
+  version: 1.5.0
 platform: ruby
 authors:
 - Nate Wiger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-07 00:00:00.000000000 Z
+date: 2019-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -140,6 +140,7 @@ files:
 - lib/redis-objects.rb
 - lib/redis/base_object.rb
 - lib/redis/counter.rb
+- lib/redis/enumerable_object.rb
 - lib/redis/hash_key.rb
 - lib/redis/helpers/core_commands.rb
 - lib/redis/list.rb
@@ -162,6 +163,7 @@ files:
 - spec/redis_namespace_compat_spec.rb
 - spec/redis_objects_active_record_spec.rb
 - spec/redis_objects_conn_spec.rb
+- spec/redis_objects_custom_serializer.rb
 - spec/redis_objects_instance_spec.rb
 - spec/redis_objects_model_spec.rb
 - spec/spec_helper.rb
@@ -184,8 +186,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Map Redis types directly to Ruby objects
@@ -194,6 +195,7 @@ test_files:
 - spec/redis_namespace_compat_spec.rb
 - spec/redis_objects_active_record_spec.rb
 - spec/redis_objects_conn_spec.rb
+- spec/redis_objects_custom_serializer.rb
 - spec/redis_objects_instance_spec.rb
 - spec/redis_objects_model_spec.rb
 - spec/spec_helper.rb