ohm-zset 0.4 → 0.5

data/README.md

@@ -197,5 +197,12 @@ sorted_set_2.add(Little.create(name: 'X1',score: 29))
 # sorted_set and sorted_set_2 are pointing to same ZSet instance
 ```
 
+## Updating gem
+```
+
+gem build ohm-zset.gemspec
+gem push ohm-zset-0.X.gem
+```
+
 ## Copyright
 Copyright (c) 2012 [Joshua Arvin Lat](http://www.joshualat.com). See LICENSE for more details.

data/lib/ohm-zset.rb

@@ -209,10 +209,18 @@ module Ohm
       fetch(ids(a, b))
     end
 
+    def range_with_score(a = 0, b = -1)
+      _return = process_range_with_score { db.zrange(key, a, b, with_scores: true) }
+    end
+
     def revrange(a = 0, b = -1)
       fetch(execute { |key| db.zrevrange(key, a, b) })
     end
 
+    def revrange_with_score(a = 0, b = -1)
+      _return = process_range_with_score { db.zrevrange(key, a, b, with_scores: true) }
+    end
+
     # Fetch data from Redis
     def to_a
       fetch(ids)
@@ -344,6 +352,13 @@ module Ohm
       fetch(execute { |key| db.zrangebyscore(key, a, b, :limit => [limit[:offset], limit[:count]]) })
     end
 
+    def rangebyscore_with_score(a = "-inf", b = "+inf", limit = {})
+      limit[:offset] ||= 0
+      limit[:count] ||= -1
+
+      _return = process_range_with_score { db.zrangebyscore(key, a, b, with_scores: true, :limit => [limit[:offset], limit[:count]]) }
+    end
+
     def revrangebyscore(a = "+inf", b = "-inf", limit = {})
       limit[:offset] ||= 0
       limit[:count] ||= -1
@@ -351,6 +366,13 @@ module Ohm
       fetch(execute { |key| db.zrevrangebyscore(key, a, b, :limit => [limit[:offset], limit[:count]]) })
     end
 
+    def revrangebyscore_with_score(a = "+inf", b = "-inf", limit = {})
+      limit[:offset] ||= 0
+      limit[:count] ||= -1
+
+      _return = process_range_with_score { db.zrevrangebyscore(key, a, b, with_scores: true, :limit => [limit[:offset], limit[:count]]) }
+    end
+
     def starts_with(query, limit = {})
       start_query = ZScores.string(query)
       end_query = "(" + ZScores.string(query.succ).to_s
@@ -405,5 +427,27 @@ module Ohm
     def execute
       yield key
     end
+
+    def process_range_with_score
+      _result = execute { |key| yield }
+
+      _ids = []
+      _scores = []
+
+      _result.each do |_id, _score|
+        _ids << _id
+        _scores << _score
+      end
+
+      _objects = fetch(_ids)
+
+      _return = []
+
+      _objects.each_with_index do |_object, i|
+        _return << {item: _object, score: _scores[i]}
+      end
+
+      _return
+    end
   end
 end

data/lib/ohm-zset/version.rb

@@ -1,5 +1,5 @@
 module Ohm
   module Zset
-    VERSION = "0.4"
+    VERSION = "0.5"
   end
 end

data/test/unit/ohm-zset.rb

@@ -286,8 +286,34 @@ describe Ohm do
     end
   end
 
+  it "can return the elements of a specified range of the set with scores" do
+    b = setup_1
+
+    expected_items = [{item: 'L2', score: 2.0},
+                      {item: 'L3', score: 3.0},
+                      {item: 'L4', score: 4.0}]
+
+    b.zlittles.range_with_score(1, 3).each_with_index do |e, i|
+      assert_equal expected_items[i][:item], e[:item].name
+      assert_equal expected_items[i][:score], e[:score]
+    end
+  end
+
   it "can iterate over the elements of a specified range of the reverse sorted set" do
     b = setup_1
+    
+    expected_items = [{item: 'L3', score: 3.0},
+                      {item: 'L2', score: 2.0},
+                      {item: 'L1', score: 1.0}]
+
+    b.zlittles.revrange_with_score(1, 3).each_with_index do |e, i|
+      assert_equal expected_items[i][:item], e[:item].name
+      assert_equal expected_items[i][:score], e[:score]
+    end
+  end
+
+  it "can iterate over the elements of a specified range of the reverse sorted set with scores" do
+    b = setup_1
     expected_items = ["L3", "L2", "L1"]
 
     b.zlittles.revrange(1, 3).each_with_index do |e, i|
@@ -499,6 +525,28 @@ describe Ohm do
     assert_equal ["L4"], b.zlittles.rangebyscore(2, "+inf", offset: 2, count: 2).to_a.map(&:name)
   end
 
+  it "can get a range of elements by score with scores" do
+    b, = setup_2
+
+    _l1 = {item: 'L1', score: 1.0}
+    _l2 = {item: 'L2', score: 2.0}
+    _l3 = {item: 'L3', score: 3.0}
+    _l4 = {item: 'L4', score: 4.0}
+
+    assert_equal [_l1, _l2, _l3, _l4], b.zlittles.rangebyscore_with_score(0, 4).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l1, _l2], b.zlittles.rangebyscore_with_score(1, 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l3, _l4], b.zlittles.rangebyscore_with_score(3, 4).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l1, _l2, _l3], b.zlittles.rangebyscore_with_score(1, 3).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l1, _l2], b.zlittles.rangebyscore_with_score(0, 4, offset: 0, count: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l3, _l4], b.zlittles.rangebyscore_with_score(0, 4, offset: 2, count: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l2, _l3, _l4], b.zlittles.rangebyscore_with_score(0, 4, offset: 1, count: 3).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l3], b.zlittles.rangebyscore_with_score(1, 3, offset: 2, count: 4).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l1, _l2, _l3, _l4], b.zlittles.rangebyscore_with_score(0, "+inf").to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l4], b.zlittles.rangebyscore_with_score(2, "+inf", offset: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l1, _l2], b.zlittles.rangebyscore_with_score("-inf", 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l4], b.zlittles.rangebyscore_with_score(2, "+inf", offset: 2, count: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+  end
+
   it "can get a range of elements by score in reverse" do
     b, = setup_2
 
@@ -516,6 +564,28 @@ describe Ohm do
     assert_equal ["L2"], b.zlittles.revrangebyscore("+inf", 2, offset: 2, count: 2).to_a.map(&:name)
   end
 
+  it "can get a range of elements by score in reverse with scores" do
+    b, = setup_2
+
+    _l1 = {item: 'L1', score: 1.0}
+    _l2 = {item: 'L2', score: 2.0}
+    _l3 = {item: 'L3', score: 3.0}
+    _l4 = {item: 'L4', score: 4.0}
+
+    assert_equal [_l4, _l3, _l2, _l1], b.zlittles.revrangebyscore_with_score(4, 0).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l2, _l1], b.zlittles.revrangebyscore_with_score(2, 1).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l4, _l3], b.zlittles.revrangebyscore_with_score(4, 3).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l3, _l2, _l1], b.zlittles.revrangebyscore_with_score(3, 1).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l4, _l3], b.zlittles.revrangebyscore_with_score(4, 0, offset: 0, count: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l2, _l1], b.zlittles.revrangebyscore_with_score(4, 0, offset: 2, count: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l3, _l2, _l1], b.zlittles.revrangebyscore_with_score(4, 0, offset: 1, count: 3).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l1], b.zlittles.revrangebyscore_with_score(3, 1, offset: 2, count: 4).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l4, _l3, _l2, _l1], b.zlittles.revrangebyscore_with_score("+inf", 0).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l2], b.zlittles.revrangebyscore_with_score("+inf", 2, offset: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l2, _l1], b.zlittles.revrangebyscore_with_score(2, "-inf").to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+    assert_equal [_l2], b.zlittles.revrangebyscore_with_score("+inf", 2, offset: 2, count: 2).to_a.collect{|x| {item: x[:item].name, score: x[:score]}}
+  end
+
   it "can get the number of elements between 2 given scores" do
     b, = setup_2
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm-zset
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: '0.5'
   prerelease: 
 platform: ruby
 authors:
@@ -46,7 +46,6 @@ files:
 - lib/ohm-zset.rb
 - lib/ohm-zset/version.rb
 - lib/suppress-warnings.rb
-- ohm-zset-0.2.gem
 - ohm-zset.gemspec
 - test/.DS_Store
 - test/helper.rb