redis-objects-legacy 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 21b943720cf2d5afd7c5c0b3c56a153e985bb07be87acfa052d9e49767e465ef
+  data.tar.gz: b84df11fc241e8dbf20442d99ff0e311af4bb41754e5cd1fd21f7b8c6cc551ef
+SHA512:
+  metadata.gz: 605ca6256f9cd704b7543082278ca01c7cc507983cfbebc30de724a9b40f50a0867ba83db22d44ab57167f98f8f18817894b214b5385e81616edde3a0eb4152d
+  data.tar.gz: 653417a26755edc0047a6a589b9f1f0ef06f080d09999d09e3899cf92ebbb5989670f7d19a6bf9c1549c9aee82ae332e222a4a17f8f24551fa36aa7074886a67

data/.gitignore

@@ -0,0 +1,12 @@
+.*.swp
+*.gemspec
+nbproject
+pkg/
+spec/*.sqlite3
+.rvmrc
+spec/redis.pid
+.bundle/
+dump.rdb
+Gemfile.lock
+redis-objects-*.gem
+coverage/

data/.travis.yml

@@ -0,0 +1,16 @@
+language: ruby
+
+# This intended to fix bundler bug in Ruby 1.9.3 (see https://github.com/travis-ci/travis-ci/issues/5239)
+before_install:
+  - gem install bundler
+
+rvm:
+  - 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/ATOMICITY.rdoc

@@ -0,0 +1,154 @@
+= An Atomic Rant
+
+== Brush Up Your Resume
+
+You are probably not handling atomic operations properly in your app, and 
+probably have some nasty lurking race conditions.  The worst part is these
+will get worse as your user count increases, are difficult to reproduce,
+and usually happen to your most critical pieces of code.  (And no, your
+rspec tests can't catch them either.)
+
+Let's assume you're writing an app to enable students to enroll in courses.
+You need to ensure that no more than 30 students can sign up for a given course.
+In your enrollment code, you have something like this:
+
+    @course = Course.find(1)
+    if @course.num_students < 30
+      @course.course_students.create!(:student_id => 101)
+      @course.num_students += 1
+      @course.save!
+    else
+      # course is full
+    end
+    
+You're screwed.  You now have 32 people in your 30 person class, and you have
+no idea what happened.
+
+"Well no duh," you're saying, "even the {ActiveRecord docs mention locking}[http://api.rubyonrails.org/classes/ActiveRecord/Locking/Pessimistic.html],
+so I'll just use that."
+
+    @course = Course.find(1, :lock => true)
+    if @course.num_students < 30
+      # ...
+
+Nice try, but now you've introduced other issues.  Any other piece of code
+in your entire app that needs to update _anything_ about the course - maybe
+the course name, or start date, or location - is now serialized.  If you need high
+concurrency, you're still screwed.
+
+You think, "ah-ha, the problem is having a separate counter!"
+
+    @course = Course.find(1)
+    if @course.course_students.count < 30
+      @course.course_students.create!(:student_id => 101)
+    else
+      # course is full
+    end
+
+Nope.  Still screwed.
+
+== The Root Down
+
+It's worth understanding the root issue, and how to address it.
+
+Race conditions arise from the difference in time between *evaluating* and *altering*
+a value.  In our example, we fetched the record, then checked the value, then
+changed it.  The more lines of code between those operations, and the higher your user
+count, the bigger the window of opportunity for other clients to get the data in an
+inconsistent state.
+
+Sometimes race conditions don't matter in practice, since often a user is
+only operating their own data.  This has a race condition, but is probably ok:
+
+    @post = Post.create(:user_id => @user.id, :title => "Whattup", ...)
+    @user.total_posts += 1  # update my post count
+
+But this _would_ be problematic:
+
+    @post = Post.create(:user_id => @user.id, :title => "Whattup", ...)
+    @blog.total_posts += 1  # update post count across all users
+
+As multiple users could be adding posts concurrently.
+
+In a traditional RDBMS, you can increment counters atomically (but not return them)
+by firing off an update statement that self-references the column:
+
+    update users set total_posts = total_posts + 1 where id = 372
+
+You may have seen {ActiveRecord's increment_counter class method}[http://api.rubyonrails.org/classes/ActiveRecord/Base.html#M002278],
+which wraps this functionality.  But outside of being cumbersome, this has
+the side effect that your object is no longer in sync with the DB, so you
+get other issues:
+
+    Blog.increment_counter :total_posts, @blog.id
+    if @blog.total_posts == 1000
+      # the 1000th poster - award them a gold star!
+
+The DB says 1000, but your @blog object still says 999, and the right person
+doesn't get their gold star.  Sad faces all around.
+
+== A Better Way
+
+Bottom line: Any operation that could alter a value *must* return that value in
+the _same_ _operation_ for it to be atomic.  If you do a separate get then set,
+or set then get, you're open to a race condition.  There are very few systems that
+support an "increment and return" type operation, and Redis is one of them
+(Oracle sequences are another).
+
+When you think of the specific things that you need to ensure, many of these will
+reduce to numeric operations:
+
+* Ensuring there are no more than 30 students in a course
+* Getting more than 2 but less than 6 people in a game
+* Keeping a chat room to a max of 50 people
+* Correctly recording the total number of blog posts
+* Only allowing one piece of code to reorder a large dataset at a time
+
+All except the last one can be implemented with counters.  The last one 
+will need a carefully placed lock.
+
+The best way I've found to balance atomicity and concurrency is, for each value,
+actually create two counters:
+
+* A counter you base logic on (eg, +slots_taken+)
+* A counter users see (eg, +current_students+)
+
+The reason you want two counters is you'll need to change the value of the logic
+counter *first*, _before_ checking it, to address any race conditions.  This means
+the value can get wonky momentarily (eg, there could be 32 +slots_taken+ for a 30-person
+course).  This doesn't affect its function - indeed, it's part of what makes it work - but
+does mean you don't want to display it.
+
+So, taking our +Course+ example:
+
+    class Course < ActiveRecord::Base
+      include Redis::Atoms
+      
+      counter :slots_taken
+      counter :current_students
+    end
+
+Then:
+
+    @course = Course.find(1)
+    @course.slots_taken.increment do |val|
+      if val <= @course.max_students
+        @course.course_students.create!(:student_id => 101)
+        @course.current_students.increment
+      end
+    end
+
+Race-condition free.  And, with the separate +current_students+ counter, your
+views get consistent information about the course, since it will only be
+incremented on success.  There is still a race condition where +current_students+
+could be less than the real number of +CourseStudent+ records, but since you'll be
+displaying these values in a view (after that block completes) you shouldn't see
+this manifest in real-world usage.
+
+Now you can sleep soundly, without fear of getting fired at 3am via an angry
+phone call from your boss.  (At least, not about this...)
+
+== Author
+
+Copyright (c) 2009 {Nate Wiger}[http://nate.wiger.org].  All Rights Reserved.
+Rant released under {Creative Commons}[http://creativecommons.org/licenses/by/3.0/legalcode].

data/CHANGELOG.rdoc

@@ -0,0 +1,362 @@
+= 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]
+
+* Merge pull request #193 from Galathius/Galathius-patch-1 Doesn't set default value to redis when just try read [Galathius]
+
+* Merge pull request #194 from oggy/pop-shift-n Add support for popping/shifting multiple elements from a List. [oggy]
+
+* Merge pull request #199 from bf4/fix_hashkey_hmget_empty_collection Fixes case of hmget empty collection [bf4]
+
+* Merge pull request #200 from liukgg/master Add method "mget" to improve efficiency for fetching values of  multiple objects  [liukgg]
+
+* Fixes case of hmget empty collection to return nil or raise the appropriate error [Benjamin Fleischer]
+
+* Merge pull request #189 from mneumark/add_delete_whole_object_method Add @object.delete! whole object delete method [mneumark]
+
+* fix some tests for changes in AR 4.2  [nateware]
+
+* Add support for popping/shifting multiple elements from a List like ruby's array [George Ogata]
+
+* Merge pull request #187 from rossta/bug_fix_to_json Add more complete #to_json and #as_json to also address recursion bugs [Ross Kaffenberger]
+
+* Doesn't set default value to redis if just try to read  [Ilya Kamenko]
+
+* Add specs for #as_json  [Ross Kaffenberger]
+
+* Implement BaseObject#as_json and #to_json in terms of #to_hash  [Ross Kaffenberger]
+
+* Add delete! method to Redis::Objects [Micah Neumark]
+
+* Implement #value, #to_json for Redis::BaseObject to fix previous situations where #to_json would hang [Ross Kaffenberger]
+
+* Reproduce blocking #to_json call issue #134 When using ActiveSupport's Object#to_json [Ross Kaffenberger]
+
+== 1.2.1 (1 Nov 2015)
+
+* Fixed use of #tap which caused issues with pipelined calls [Ross Kaffenberger]
+
+* Removed setnx on get some value with default option [Ilya Kamenko]
+
+== 1.2.0 (30 Apr 2015)
+
+* New expiration implementation to address edge cases and missing methods [Ross Kaffenberger]
+
+* Add support for expiration/expireat on HashKey#update [Ross Kaffenberger]
+
+* Make locks with 0 timeout possible [Jean Boussier]
+
+* Update hdel methods to support deleting multiple keys [Star]
+
+== 1.1.0 (21 Jan 2015)
+
+* Support connection_pool usage via a proxy object [Jared Jenkins]
+
+* Fix typo on :counter usage [Kevin Bongart]
+
+* Use parent redis_id_field if present [Arnaud Lavrard]
+
+* Fetch the objects options through a redis_options method [Arnaud Lavrard]
+
+== 1.0.1 (14 Oct 2014)
+
+* Array handling for unmarshal [dreyks]
+
+* Test against Ruby 2.1 / 2.2 on Travis CI [tricknotes]
+
+* Redis::Set#randmember method accept count as optional parameter [xeviknal]
+
+== 1.0.0 (25 Jul 2014)
+
+* Fix expiration filter to handle atomic blocks, remove method aliasing [nateware]
+
+* Fix incrbyfloat to actually return a float [james-lawrence]
+
+* Allow false as default: value (bugfix) [james-lawrence]
+
+* Allow unionstore and interstore between sorted sets and sets [jrdi]
+
+* Add syntax highlighting to README.md [bartolsthoorn]
+
+== 0.9.1 (25 Mar 2014)
+
+* Fix bad marshal calls in SortedSet [Fleurer, nateware]
+
+* Handle marshalling/unmarshalling of nil values [anujdas]
+
+* Add :default as synonym to :start for Counter [Fleurer]
+
+== 0.9.0 (6 Feb 2014)
+
+* Ensure we don't double-unmarshal values, which could be a security issue [markijbema, nateware]
+
+* Support a custom redis connection per redis key [hfwang]
+
+* HashKey#fetch now behaves more similarly to Ruby [datapimp]
+
+* Add incrbyfloat and decrbyfloat for values and hashes [nateware]
+
+* Add support for @sorted_set.merge and variadic zadd [hfwang]
+
+* Add support for srandmember for sets [LYY]
+
+* Handle @set << [] in an intelligent way [kitchen]
+
+* Add multi-unshift functionality [nateware]
+
+* Additional test coverage for @sorted_set.merge and other ops [nateware]
+
+== 0.8.0 (9 Nov 2013)
+
+* Refactor to modular include/extend approach to enable hooking and remove evals [nateware]
+
+* Custom id field via redis_id_field :whatever [liuming]
+
+* Support marshaling of sorted set key names for incr/decr [hfwang]
+
+* Add support for pushing multiple values into a list [scranton]
+
+* Fix problematic typo in HashKey#fill [johnmaxwell]
+
+* Fix wrong parameter order for revrangebyscore method [FoGhost]
+
+* Convert to using Bundler from Jeweler to manage gem [nateware]
+
+== 0.7.0 (27 Feb 2013)
+
+* Enable inheritance of Redis::Objects models [rossta]
+
+* Finally fix require/autoload so "require 'redis/foo'" is not needed [nateware]
+
+* Redis::Objects.redis= now properly sets subclass handles as expected [nateware]
+
+* Add lib/redis-objects.rb for easier Gemfile require [notEthan]
+
+* Fix wrong readme line, fix some indentation [giglemad]
+
+== 0.6.1 (13 Dec 2012)
+
+* Fixed error that incorrectly specified activerecord as a gem dep [nateware]
+
+== 0.6.0 (13 Dec 2012)
+
+* Add +@set.merge()+ method to add multiple members at once [hfwang]
+
+* Add +insert+ method to Redis::List instances [giglemad]
+
+* Updated APIs for recent redis-server sort API compat [nateware]
+
+* Add HashKey#bulk_values for fetching values in the same order than the given keys [aspgems]
+
+* Lists now handle the insert command
+
+* Changed +@sset.score+ method on SortedSet to return nil for invalid members [hkarthik]
+
+* Test using redis-objects counters and fix when AR passes a string
+
+* Add LSET to lists [neonlex]
+
+* Fix interstore/unionstore for redis 2.6 [david]
+
+* Redis-rb 3.0.0 support [seomoz]
+
+* group_set_with_scores is no longer needed.
+
+== 0.5.2 (13 Jun 2012)
+
+* Added Redis::SortedSet#member? method [Karl Varga]
+
+* Added +ttl+ method to CoreCommands [Karl Varga]
+
+== 0.5.1 (23 May 2011)
+
+* Fixed super class delegation conflicts with Redis Counters vs ActiveRecord [Tim Aßmann]
+
+* Added zcount method to SortedSet [dunedain289]
+
+* Updated redis-objects to look for Redis.current and prefer it over global $redis variable [Jean Boussier]
+
+* Updated URLs to reflect new redis.io website [Jérémy Lecour]
+
+== 0.5.0 (8 Nov 2010)
+
+* Incompatible change: Had to rename Redis::Hash to Redis::HashKey due to internal conflicts with Redis lib and Ruby [Nate Wiger]
+
+* Fixed AR counter override so that Redis::Objects doesn't hide AR counters [Mattias Pfeiffer]
+
+* Fixed delete problem with Redis::List and complex values [Esdras Mayrink]
+
+* Fix Redis::HashKey to support complex (marshaled) types [Mattias Pfeiffer]
+
+* Group results of SortedSet#rangebyscore and #revrangebyscore if :withscores option is passed [Szymon Nowak]
+
+* Updated Redis DEL semantics per API change [Gabe da Silveira]
+
+== 0.4.1 (23 Aug 2010)
+
+* Fixes for Ruby 1.8 failures due to missing flatten() [Gabe da Silveira]
+
+* Enable subclasses of classes mixing in Redis::Objects to automatically pick up objects from their superclasses [Gabe da Silveira]
+
+* Renamed prefix() and field_key() to redis_prefix() and redis_field_key() to prevent gem conflicts [Jason Meinzer]
+
+* Fixed a typo in delete_if and added missing test coverage [Julio Capote, Nate Wiger]
+
+== 0.4.0 (11 Aug 2010)
+
+* Full support for redis hashes via new Redis::Hash class [Julio Capote, Nate Wiger]
+
+* Now dependent on redis-rb client 2.0.4 or later.  Should still be backwards compatible with redis-server 1.x
+
+* Fixes to sets and sorted sets to bring them up to speed with redis-rb 2.0 from tomstuart [Tom Stuart]
+
+* Incompatible change: Update list[x,y] and sorted_set[x,y] to work consistently with Ruby in all cases [Tom Stuart]
+
+* Refactoring to make constructors common across all object types from dbalatero [David Balatero]
+
+* Renamed :withscores option to :with_scores for consistency with redis-rb 2.0, but kept backwards compat [Tom Stuart, Nate Wiger]
+
+== 0.3.2 (21 Jul 2010)
+
+* New "maxlength" option to Redis::List can create length-limited lists (eg, like a ring buffer) from dbalatero [David Balatero]
+
+* Fix score conversions in Redis::SortedSet (scores are floats, not ints) from tomstuart [Tom Stuart]
+
+* Switched from rspec to bacon for tests
+
+== 0.3.1 (1 Jun 2010)
+
+* Integrated fixes for sorted_set deletions from capotej [Julio Capote]
+
+== 0.3.0 (14 Apr 2010)
+
+* Due to Ruby 1.9 bugs and performance considerations, marshaling of data types is now OFF by default.  You must say :marshal => true for any objects that you want serialization enabled on. [Nate Wiger]
+
+* Sorted Set class changed slightly due to feedback. You can now get an individual element back via @set['item'] since it acts like a Hash.
+
+== 0.2.4 (9 Apr 2010)
+
+* Added sorted set support via Redis::SortedSet [Nate Wiger]
+
+== 0.2.3 (18 Feb 2010)
+
+* Added lock expiration to Redis::Lock [Ben VandenBos]
+
+* Fixed some bugs [Ben VandenBos]
+
+* Added lock tests and test helpers [Ben VandenBos]
+
+== 0.2.2 (14 Dec 2009)
+
+* Added @set.diff(@set2) with "^" and "-" synonyms (oversight). [Nate Wiger]
+
+* Implemented Redis core commands in all data types, such as rename. [Nate Wiger]
+
+* Renamed Redis::Serialize to Redis::Helpers::Serialize to keep Redis:: cleaner. [Nate Wiger]
+
+* More spec coverage. [Nate Wiger]
+
+== 0.2.1 (27 Nov 2009)
+
+* First worthwhile public release, with good spec coverage and functionality. [Nate Wiger]

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis-objects-legacy.gemspec
+gemspec