ohm-zset 0.2

data/.gems

@@ -0,0 +1,15 @@
+# .gems generated gem export file. Note that any env variable settings will be missing. Append these after using a ';' field separator
+
+file-tail -v1.0.10
+minitest -v3.2.0
+nest -v1.1.1
+ohm -v1.0.2
+redis -v3.0.1
+redis -v2.2.2
+ruby2ruby -v1.3.1
+ruby_parser -v2.3.1
+scrivener -v0.0.3
+sexp_processor -v3.2.0
+sourcify -v0.5.0
+tins -v0.4.3
+uuidtools -v2.1.3

data/.gitignore

@@ -0,0 +1,2 @@
+## MAC OS
+.DS_Store

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create use 1.9.3@ohm-zset

data/CHANGELOG

@@ -0,0 +1,24 @@
+v 0.2
+
+- refactored code
+
+v 0.1.4
+
+- included option to intersect and union multiple sets with specified name
+
+v 0.1.3
+
+- included save_set, and load_set, and cleaned code
+
+v 0.1.2
+
+- included duplicate and ZSet.generate_uuid
+
+v 0.1.1
+
+- included UUID generation for keys of new ZSets for union and intersection
+
+v 0.1.0
+
+- stable
+- Ohm basic support for Redis sorted sets

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Joshua Arvin Lat
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,172 @@
+# ohm-zset
+
+Ohm Sorted Set (ZSET) support for Redis.
+
+## Basic Usage
+
+```ruby
+class Big < Ohm::Model
+  set :smalls, :Small
+  zset :zsmalls, :Small, :size
+end
+
+class Small < Ohm::Model
+  attribute :name 
+  attribute :size
+end
+
+b = Big.create
+s1 = Small.create(name: 'S1', size: 5)
+s2 = Small.create(name: 'S2', size: 4)
+s3 = Small.create(name: 'S3', size: 3)
+s4 = Small.create(name: 'S4', size: 2)
+s5 = Small.create(name: 'S5', size: 1)
+
+b.zsmalls.add_list(s1, s2, s3, s4, s5)
+
+b.zsmalls.size
+# => 5
+
+b.zsmalls.to_a.map(&:name)
+# => ['S5', 'S4', 'S3', 'S2', 'S1']
+
+b.zsmalls.to_a.map(&:size)
+# => ['1', '2', '3', '4', '5']
+```
+
+## Interacting with the elements of the set
+**Ohm-ZSET** includes *get*, *rank*, *revrank*, *score*, *range*, *revrange*, *rangebyscore*, *revrangebyscore*
+
+```ruby
+
+b.zsmalls.get(0).name
+# => 'S5'
+
+b.zsmalls.range(0, 3).to_a.map(&:name)
+# => ['S5', 'S4', 'S3', 'S2']
+
+b.zsmalls.revrange(0, 3).each do |small|
+  puts "#{small.name} - #{small.size}"
+end
+# => S1 - 5
+# => S2 - 4
+# => S3 - 3
+# => S4 - 2
+
+s6 = Small.create(name:'S6', size:3.5)
+b.zsmalls.add(s6)
+b.zsmalls.to_a.map(&:name)
+# => ['S5', 'S4', 'S3', 'S6', 'S2', 'S1']
+```
+
+You can update the score of an element by using *update*. There is also a *count* function that returns the number of elements with scores inside a specified range.
+
+## Deleting Elements
+**Ohm-ZSET** includes *delete* for deleting a single element, *clear* for deleting all elements, and *remrangebyrank* and *remrangebyscore* for deleting selected elements.
+
+```ruby
+b.zsmalls.delete(s6)
+b.zsmalls.to_a.map(&:name)
+# => ['S5', 'S4', 'S3', 'S2', 'S1']
+
+b.zsmalls.include? s6
+# => false
+
+b.zsmalls.clear
+b.zsmalls.to_a.map(&:name)
+# => []
+```
+
+It also has *destroy!* to delete the key of the sorted set.
+
+## Set Intersection and Union
+Set intersection between sorted sets and sets are allowed. You can use *intersect*, *intersect_multiple*, *union*, and *union_multiple* between sets and sorted sets.
+
+```ruby
+b.smalls.add(s1)
+b.smalls.add(s2)
+b.smalls.add(s4)
+
+# Intersect ['S5', 'S4', 'S3', 'S2', 'S1'] with ['S4', 'S2', 'S1']
+b.zsmalls.intersect(b.smalls).to_a.map(&:name)
+# => ['S4', 'S2', 'S1']
+```
+
+The sorted set allows union and intersection of multiple sets and sorted sets with weights.
+Result of intersection and union is another ZSET.
+
+It also allows intersection and union to a new set with the specified name.
+
+```ruby
+zunion = Ohm::ZSet.union_multiple('zunion', [zlittles, slittles, zlittles2, zlittles3])
+
+zunion.key
+# => 'zunion'
+```
+
+## Scoring Functions
+**Ohm-ZSET** also supports custom scoring functions. The default scoring function is ZScore::Integer.
+There are also available built-in scoring functions in the module.
+
+```ruby
+class Bigger < Ohm::Model
+  include Ohm::ZScores
+
+  zset :zlittles, :Little, :score
+
+  # Custom scoring function
+  zset :zsmalls, :Small, :value, lambda{ |x| Integer(x) + 1 }
+
+  # Built-in scoring functions
+  zset :zlittles, :Little, :score, ZScore::Float
+  zset :zbools, :Bool, :is_valid, ZScore::Boolean
+  zset :zdts, :DT, :last_login, ZScore::DateTime
+
+  # Built-in string sorting functions
+  zset :zbools2, :Bool, :name, ZScore::String
+  zset :zbools3, :Bool, :name, ZScore::StringInsensitive
+  zset :zbools4, :Bool, :name, ZScore::StringInsensitiveHigh
+end
+
+class Bool < Ohm::Model
+  attribute :name
+  attribute :is_valid
+end
+
+class DT < Ohm::Model
+  attribute :name
+  attribute :last_login
+end
+
+class Small < Ohm::Model
+  attribute :name 
+  attribute :value
+end
+
+class Little < Ohm::Model
+  attribute :name
+  attribute :score
+end
+
+```
+
+Redis allows only numerical scores so DateTime and strings objects are first converted to numbers and then stored as scores.
+
+**Note**: The string scoring algorithm is limited only to the first 9 characters because of the floating point accuracy limit.
+You can use the *starts_with* function when dealing with string sorted sets. It returns all the elements of the set with a score field value that starts with the specified string.
+
+## Saving and Loading ZSet instances by name / key
+
+```ruby
+
+sorted_set = b.zlittles
+sorted_set.save_set
+
+sorted_set_2 = Ohm::ZSet.load_set(sorted_set.key)
+sorted_set_2.add(Little.create(name: 'X1',score: 29))
+
+# sorted_set and sorted_set_2 are pointing to same ZSet instance
+```
+
+## Copyright
+Copyright (c) 2012 [Joshua Arvin Lat](http://www.joshualat.com). See LICENSE for more details.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/ohm-zset.rb

@@ -0,0 +1,406 @@
+require 'ohm'
+require 'time'
+require 'uuidtools'
+require 'sourcify'
+
+# http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+class Object 
+  def meta_def(name, &blk)
+    (class << self; self; end).instance_eval { define_method(name, &blk) }
+  end
+end
+
+module Ohm
+  class Model
+    def self.zset(name, model, *score_field)
+
+      define_method name do
+        model = Utils.const(self.class, model)
+        Ohm::ZSet.new(key[name], model.key, model, score_field)
+      end
+
+      meta_def name do
+        model = Utils.const(self, model)
+        Ohm::ZSet.new(key[name], model.key, model, score_field)
+      end
+
+    end
+  end
+
+  module Utils
+    class << self
+      def proc_to_string(function)
+        function.to_source
+      end
+
+      def string_to_proc(function)
+        eval function
+      end
+
+      def score_field_to_string(score_field)
+        string_list = []
+
+        lambda_function = score_field.each do |field|
+          break field if field.is_a? Proc
+
+          string_list.push(field.to_s)
+
+          break lambda{ |x| x.to_i } if field == score_field.last
+        end
+
+        string_list.push Ohm::Utils.proc_to_string(lambda_function)
+        string_list.join(":")
+      end
+
+      def string_to_score_field(score_field)
+        string_list = score_field.split(":")
+        return_list = []
+
+        string_list.each do |field|
+          if field.include? 'proc'
+            return_list.push Ohm::Utils.string_to_proc field
+          else
+            return_list.push field.to_sym
+          end
+        end
+
+        return_list
+      end
+    end
+  end
+
+  module ZScores
+    module ZScore
+      Integer = lambda{ |x| Integer(x) }
+      Float = lambda{ |x| Float(x) }
+      Boolean = lambda{ |x| Ohm::ZScores.boolean(x) }   
+      DateTime = lambda{ |x| Ohm::ZScores.datetime(x) }
+      String = lambda{ |x| Ohm::ZScores.string(x) }
+      StringInsensitive = lambda{ |x| Ohm::ZScores.string_insensitive(x) }
+      StringInsensitiveHigh = lambda{ |x| Ohm::ZScores.string_insensitive_high(x) }
+    end
+
+    class << self
+      def boolean(val)
+        case val
+        when "true", "1", true 
+          1
+        when "false", "0", false, nil 
+          0
+        else 
+          1
+        end
+      end
+
+      def datetime(val)
+        ::DateTime.parse(val.to_s).to_time.to_i
+      end
+
+      # scoring accurate until 9th character
+      def string(val)
+        total_score = 0
+
+        val.each_char.with_index do |c, i|
+          total_score += (c.ord-31) * ((126-32) ** (10 - i))
+          break if i == 9        
+        end
+
+        total_score.to_f
+      end
+
+      # scoring accurate until 9th character
+      def string_insensitive(val)
+        total_score = 0
+
+        val.each_char.with_index do |c, i|
+          char_ord = c.ord-31
+          if ('a'..'z').include? c
+            char_ord -= 32
+          end
+          total_score += (char_ord) * ((126-32) ** (10 - i))
+          break if i == 9        
+        end
+
+        total_score.to_f
+      end
+
+      # scoring accurate until 9th character
+      def string_insensitive_high(val)
+        total_score = 0
+
+        val.each_char.with_index do |c, i|
+          char_ord = c.ord-31
+          if ('a'..'z').include? c
+            char_ord -= 31.5
+          end
+          total_score += (char_ord) * ((126-32) ** (10 - i))
+          break if i == 9        
+        end
+
+        total_score.to_f
+      end
+    end
+  end
+
+  class ZSet < Struct.new(:key, :namespace, :model, :score_field)
+    include PipelinedFetch
+    include Enumerable
+
+    class << self
+      def intersect_multiple(new_key, sets, weights = [])
+        base_set = sets[0]
+        weights = [1.0] * sets.length if weights = []
+
+        new_set = Ohm::ZSet.new(new_key, base_set.model.key, base_set.model, base_set.score_field)
+        sets = sets.map(&:key)
+
+        Ohm.redis.zinterstore(new_key, sets, :weights => weights)
+        new_set
+      end
+
+      def load_set(name)
+        new_model, new_score_field = Ohm.redis.hmget("ZSet:" + name, "model", "score_field")
+        return nil if new_model == nil && new_score_field == nil
+
+        new_model = Ohm::Utils.const(self.class, new_model.to_sym)
+        new_score_field = Ohm::Utils.string_to_score_field new_score_field
+        return_instance = Ohm::ZSet.new(name, new_model.key, new_model, new_score_field)
+      end
+
+      def union_multiple(new_key, sets, weights = [])
+        base_set = sets[0]
+        weights = [1.0] * sets.length if weights = []
+
+        new_set = Ohm::ZSet.new(new_key, base_set.model.key, base_set.model, base_set.score_field)
+        sets = sets.map(&:key)
+
+        Ohm.redis.zunionstore(new_key, sets, :weights => weights)
+
+        new_set
+      end    
+
+      def generate_uuid
+        "ZSet:" + UUIDTools::UUID.random_create.to_s
+      end
+
+      def random_instance(model, score_field)
+        self.new_instance(Ohm::ZSet.generate_uuid, model, score_field)
+      end
+
+      def new_instance(name, model, score_field)
+        self.new(name, model.key, model, score_field)
+      end
+    end
+
+    def size
+      db.zcard(key)
+    end
+
+    def count(a = "-inf", b = "+inf")
+      return size if a == "-inf" && b == "+inf"
+
+      db.zcount(key, a, b)
+    end
+
+    def ids(a = 0, b = -1)
+      execute { |key| db.zrange(key, a, b) }
+    end
+
+    def range(a = 0, b = -1)
+      fetch(ids(a, b))
+    end
+
+    def revrange(a = 0, b = -1)
+      fetch(execute { |key| db.zrevrange(key, a, b) })
+    end
+
+    # Fetch data from Redis
+    def to_a
+      fetch(ids)
+    end
+
+    def include?(model)
+      !rank(model).nil?
+    end
+
+    def get(i)
+      range(i, i)[0] rescue nil
+    end
+
+    def each
+      to_a.each { |element| yield element }
+    end
+
+    def empty?
+      size == 0
+    end
+
+    def add(model)
+      score_value = model
+
+      lambda_function = score_field.each do |field|
+        break field if field.is_a? Proc
+
+        score_value = model.send(field)
+
+        break lambda{ |x| x.to_i } if field == score_field.last
+      end
+
+      db.zadd(key, lambda_function.call(score_value), model.id)
+    end
+
+    def add_list(*models)
+      models.each do |model|
+        add(model)
+      end
+    end
+
+    def update(model)
+      add (model)
+    end
+
+    def delete(model)
+      db.zrem(key, model.id)
+
+      model
+    end
+
+    def remrangebyrank(a, b)
+      db.zremrangebyrank(key, a, b)
+    end
+
+    def remrangebyscore(a, b)
+      db.zremrangebyscore(key, a, b)
+    end
+
+    def intersect(set, w1=1.0, w2=1.0)
+      new_key = generate_uuid
+      new_set = Ohm::ZSet.new(new_key, model.key, model, score_field)
+
+      db.zinterstore(new_set.key, [key, set.key], :weights => [w1, w2])      
+      new_set
+    end
+
+    def intersect_multiple(sets, weights = [])
+      sets = sets.map(&:key)
+      sets.push(key)
+      weights = [1.0] * sets.length if weights = []
+
+      new_key = generate_uuid
+      new_set = Ohm::ZSet.new(new_key, model.key, model, score_field)
+
+      db.zinterstore(new_set.key, sets, :weights => weights)
+
+      new_set
+    end
+
+    def intersect_multiple!(sets, weights = [])
+      weights = [1.0] * sets.length if weights = []
+      db.zinterstore(key, sets.map(&:key), :weights => weights)
+      self
+    end
+
+    def union(set, w1=1.0, w2=1.0)
+      new_key = generate_uuid
+      new_set = Ohm::ZSet.new(new_key, model.key, model, score_field)
+
+      db.zunionstore(new_set.key, [key, set.key], :weights => [w1, w2])
+
+      new_set
+    end
+
+    def union_multiple(sets, weights = [])
+      sets = sets.map(&:key)
+      sets.push(key)
+
+      weights = [1.0] * sets.length if weights = []
+      new_key = generate_uuid
+      new_set = Ohm::ZSet.new(new_key, model.key, model, score_field)
+
+      db.zunionstore(new_set.key, sets, :weights => weights)
+
+      new_set
+    end
+
+    def rank(model)
+      db.zrank(key, model.id)
+    end
+
+    def revrank(model)
+      db.zrevrank(key, model.id)
+    end
+
+    def score(model)
+      db.zscore(key, model.id).to_i
+    end
+
+    def rangebyscore(a = "-inf", b = "+inf", limit = {})
+      limit[:offset] ||= 0
+      limit[:count] ||= -1
+
+      fetch(execute { |key| db.zrangebyscore(key, a, b, :limit => [limit[:offset], limit[:count]]) })
+    end
+
+    def revrangebyscore(a = "+inf", b = "-inf", limit = {})
+      limit[:offset] ||= 0
+      limit[:count] ||= -1
+
+      fetch(execute { |key| db.zrevrangebyscore(key, a, b, :limit => [limit[:offset], limit[:count]]) })
+    end
+
+    def starts_with(query, limit = {})
+      start_query = ZScores.string(query)
+      end_query = "(" + ZScores.string(query.succ).to_s
+
+      rangebyscore(start_query, end_query, limit)
+    end
+
+    def first
+      range(0, 1)[0] rescue nil
+    end
+
+    def last
+      revrange(0, 1)[0] rescue nil
+    end
+
+    def destroy!
+      db.del(key)
+    end
+
+    def clear
+      remrangebyrank(0, -1)
+    end
+
+    def generate_uuid
+      ZSet.generate_uuid
+    end
+
+    def save_set
+      db.hmset("ZSet:" + key, *get_hmset_attrs)
+    end
+
+    def duplicate
+      intersect(self, 1.0, 0.0)
+    end
+
+    def get_hmset_attrs
+      return_list = []
+      return_list << "model" << model.to_s
+      return_list << "score_field" << Utils.score_field_to_string(score_field)
+      return_list
+    end
+
+    def expire(seconds)
+      db.expire(self.key, seconds)
+    end
+
+    private
+    def db
+      model.db
+    end
+
+    def execute
+      yield key
+    end
+  end
+end

data/lib/suppress-warnings.rb

@@ -0,0 +1,16 @@
+module Kernel
+  def suppress_warnings
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    return result
+  end
+
+  def require_suppress(library)
+    suppress_warnings{
+      require library
+    }
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,4 @@
+require "minitest/autorun"
+require_relative "../lib/ohm-zset"
+
+

data/test/unit/ohm-zset.rb

@@ -0,0 +1,663 @@
+require_relative "../helper"
+
+class Big < Ohm::Model
+  include Ohm::ZScores
+  
+  collection :smalls, :Small
+  zset :zlittles, :Little, :score, ZScore::Float
+  zset :zsmalls, :Small, :value
+  zset :zlittles2, :Little, :score
+  zset :zlittles3, :Little, :score
+  zset :zbools, :Bool, :is_valid, ZScore::Boolean
+  set :slittles, :Little
+  zset :zdts, :DT, :last_login, ZScore::DateTime
+  zset :zbools2, :Bool, :name, ZScore::String
+  zset :zbools3, :Bool, :name, ZScore::StringInsensitive
+  zset :zbools4, :Bool, :name, ZScore::StringInsensitiveHigh
+end
+
+class Bool < Ohm::Model
+  attribute :name
+  attribute :is_valid
+end
+
+class DT < Ohm::Model
+  attribute :name
+  #attribute :date_updated
+  attribute :last_login
+end
+
+class Small < Ohm::Model
+  attribute :name
+  attribute :value
+end
+
+class Little < Ohm::Model
+  attribute :name
+  attribute :score
+end
+
+def add_to_zset(model, zset_name, items, item_class)
+  z = model.send(zset_name)
+
+  items.each do |i|
+    z.send(:add, item_class.create(i))
+  end
+end
+
+def setup_big_1
+  b = Big.create
+
+  l1 = Little.create(name: 'L1', score: 1)
+  l2 = Little.create(name: 'L2', score: 2)
+  l3 = Little.create(name: 'L3', score: 3)
+  l4 = Little.create(name: 'L4', score: 4)
+
+  Big.zlittles.clear
+  Big.zlittles.add(l1)
+  Big.zlittles.add(l2)
+  Big.zlittles.add(l3)
+  Big.zlittles.add(l4)
+
+  b.slittles.add(l1)
+  b.slittles.add(l2)
+  b.slittles.add(Little.create(name: 'E3', score: 24))
+  b.slittles.add(l4)
+
+  Big.zlittles2.clear
+  Big.zlittles2.add(l2)
+  Big.zlittles2.add(l3)
+  Big.zlittles2.add(l4)
+
+  Big.zlittles3.clear
+  Big.zlittles3.add(l1)
+  Big.zlittles3.add(l4)
+  Big.zlittles3.add(Little.create(name: 'E1', score: 21))
+  Big.zlittles3.add(Little.create(name: 'E2', score: 22))
+
+  Big.zsmalls.clear
+  Big.zsmalls.add(Small.create(name: 'S1', value: 8))
+  Big.zsmalls.add(Small.create(name: 'S2', value: 7))
+  Big.zsmalls.add(Small.create(name: 'S3', value: 6))
+  Big.zsmalls.add(Small.create(name: 'S4', value: 5))
+
+  b
+end
+
+def setup_1
+  b = Big.create
+
+  l1 = Little.create(name: 'L1', score: 1)
+  l2 = Little.create(name: 'L2', score: 2)
+  l3 = Little.create(name: 'L3', score: 3)
+  l4 = Little.create(name: 'L4', score: 4)
+
+  b.slittles.add(l1)
+  b.slittles.add(l2)
+  b.slittles.add(Little.create(name: 'E3',score: 24))
+  b.slittles.add(l4)
+
+  b.zlittles.add(l1)
+  b.zlittles.add(l2)
+  b.zlittles.add(l3)
+  b.zlittles.add(l4)
+
+  b.zlittles2.add(l2)
+  b.zlittles2.add(l3)
+  b.zlittles2.add(l4)
+
+  b.zlittles3.add(l1)
+  b.zlittles3.add(l4)
+  b.zlittles3.add(Little.create(name: 'E1', score: 21))
+  b.zlittles3.add(Little.create(name: 'E2', score: 22))
+
+  b.zsmalls.add(Small.create(name: 'S1', value: 8))
+  b.zsmalls.add(Small.create(name: 'S2', value: 7))
+  b.zsmalls.add(Small.create(name: 'S3', value: 6))
+  b.zsmalls.add(Small.create(name: 'S4', value: 5))
+
+
+  b.zlittles.add(l1)
+  b.zlittles.add(l2)
+  b.zlittles.add(l3)
+  b.zlittles.add(l4)
+
+  b
+end
+
+def setup_2
+  b = Big.create
+
+  l1 = Little.create(name: 'L1', score: 1)
+  l2 = Little.create(name: 'L2', score: 2)
+  l3 = Little.create(name: 'L3', score: 3)
+  l4 = Little.create(name: 'L4', score: 4)
+
+  b.zlittles.add(l1)
+  b.zlittles.add(l2)
+  b.zlittles.add(l3)
+  b.zlittles.add(l4)
+
+  [b, l1, l2, l3, l4]
+end
+
+def setup_3
+  b = Big.create
+
+  b1 = Bool.create(name: 'B1', is_valid: "false")
+  b2 = Bool.create(name: 'B2', is_valid: "true")
+  b3 = Bool.create(name: 'B3', is_valid: "false")
+  b4 = Bool.create(name: 'B4', is_valid: "true")
+
+  b.zbools.add(b1)
+  b.zbools.add(b2)
+  b.zbools.add(b3)
+  b.zbools.add(b4)
+
+  b
+end
+
+def setup_4
+  b = Big.create
+
+  d1 = DT.create(name: 'D1', last_login: "2012-07-29 06:24:20 +0800")
+  d2 = DT.create(name: 'D2', last_login: "2012-07-29 05:24:20 +0800")
+  d3 = DT.create(name: 'D3', last_login: "2012-07-29 04:24:20 +0800")
+  d4 = DT.create(name: 'D4', last_login: "2012-08-29")
+  b.zdts.add_list(d1, d2, d3, d4)
+  b
+end
+
+def setup_5
+  b = Big.create
+
+  items = [
+    {name: 'Apple', is_valid: 'false'},
+    {name: 'Coconut', is_valid: 'true'},
+    {name: 'Dragonfruit', is_valid: 'false'},
+    {name: 'Banana', is_valid: 'true'},
+    {name: 'apples', is_valid: 'true'},
+    {name: 'coconuts', is_valid: 'true'},
+    {name: 'durians', is_valid: 'false'},
+    {name: 'bananas', is_valid: 'true'},
+    {name: 'apple', is_valid: 'true'},
+    {name: 'coconut', is_valid: 'true'},
+    {name: 'banana', is_valid: 'false'},
+    {name: 'durian', is_valid: 'true'},
+  ]
+
+  add_to_zset(b, 'zbools2', items, Bool)
+
+  b
+end
+
+def setup_6
+  b = Big.create
+
+  items = [
+    {name: 'apple', is_valid: 'false'},
+    {name: 'Coconut', is_valid: 'true'},
+    {name: 'duria', is_valid: 'false'},
+    {name: 'Banana', is_valid: 'true'},
+    {name: 'Apples', is_valid: 'true'},
+    {name: 'coconuts', is_valid: 'true'},
+    {name: 'durians', is_valid: 'false'},
+    {name: 'bananas', is_valid: 'true'},
+    {name: 'Apple', is_valid: 'true'},
+    {name: 'coconut', is_valid: 'true'},
+    {name: 'banana', is_valid: 'false'},
+    {name: 'Durian', is_valid: 'true'},
+  ]
+
+  add_to_zset(b, 'zbools3', items, Bool)
+
+  b
+end
+
+def setup_7
+  b = Big.create
+
+  items = [
+    {name: 'apple', is_valid: 'false'},
+    {name: 'Coconut', is_valid: 'true'},
+    {name: 'duria', is_valid: 'false'},
+    {name: 'Banana', is_valid: 'true'},
+    {name: 'Apples', is_valid: 'true'},
+    {name: 'coconuts', is_valid: 'true'},
+    {name: 'durians', is_valid: 'false'},
+    {name: 'bananas', is_valid: 'true'},
+    {name: 'Apple', is_valid: 'true'},
+    {name: 'coconut', is_valid: 'true'},
+    {name: 'banana', is_valid: 'false'},
+    {name: 'Durian', is_valid: 'true'},
+  ]
+
+  add_to_zset(b, 'zbools4', items, Bool)
+
+  b
+end
+
+# Tests for the class methods
+# TODO: figure out how to DRY up the class and instance method tests. Probably move the method body to a common method and test that common method instead
+describe Ohm do
+  it "can add objects and get the size for the class" do
+    setup_big_1
+
+    assert_equal 4, Big.zlittles.size
+  end
+end
+
+# Tests for the instance methods
+describe Ohm do
+  it "can add objects and get the size" do
+    b = setup_1
+
+    assert_equal 4, b.zlittles.size
+  end
+
+  it "can add objects with scores and automatically sorts them by score" do
+    b = setup_1
+
+    assert_equal ["L1", "L2", "L3", "L4"], b.zlittles.to_a.map(&:name)
+  end
+
+  it "can return a range of sorted elements" do
+    b = setup_1
+
+    assert_equal ["L2", "L3"], b.zlittles.range(1, 2).map(&:name)
+    assert_equal ["L1", "L2", "L3"], b.zlittles.range(0, 2).map(&:name)
+  end
+
+  it "can return a range of sorted elements in reverse" do
+    b = setup_1
+
+    assert_equal ["L3", "L2"], b.zlittles.revrange(1, 2).map(&:name)
+    assert_equal ["L4", "L3", "L2"], b.zlittles.revrange(0, 2).map(&:name)
+  end
+
+  it "can iterate over the elements of a specified range of the set" do
+    b = setup_1
+
+    expected_items = ["L2", "L3", "L4"]
+
+    b.zlittles.range(1, 3).each_with_index do |e, i|
+      assert_equal expected_items[i], e.name
+    end
+  end
+
+  it "can iterate over the elements of a specified range of the reverse sorted set" do
+    b = setup_1
+    expected_items = ["L3", "L2", "L1"]
+
+    b.zlittles.revrange(1, 3).each_with_index do |e, i|
+      assert_equal expected_items[i], e.name
+    end
+  end
+
+  it "can get an element with a specified index" do
+    b = setup_1
+
+    assert_equal "L3", b.zlittles.get(2).name
+    assert_nil b.zlittles.get(5)
+  end
+
+  it "can delete an element" do
+    b = setup_1
+
+    x = b.zlittles.get(2)
+    deleted_element = b.zlittles.delete(x)
+
+    assert_equal x, deleted_element
+    assert_equal 3, b.zlittles.size
+  end
+
+  it "knows if it includes a specified element" do
+    b, l1, l2, l3, l4 = setup_2
+
+    assert b.zlittles.include?(l1)
+
+    b.zlittles.delete(l2)
+
+    refute b.zlittles.include?(l2)
+    assert b.zlittles.include?(l3)
+    assert b.zlittles.include?(l4)
+    assert b.zlittles.include?(l1)
+
+    b.zlittles.add(l2)
+
+    assert b.zlittles.include?(l2)
+  end
+
+  it "can delete a range of elements by rank" do
+    b = setup_1
+    assert_equal ["L1", "L2", "L3", "L4"], b.zlittles.to_a.map(&:name)
+
+    b.zlittles.remrangebyrank(0, 1)
+    assert_equal ["L3", "L4"], b.zlittles.to_a.map(&:name)
+
+    b.zlittles.remrangebyrank(0, 0)
+    assert_equal ["L4"], b.zlittles.to_a.map(&:name)
+  end
+
+  it "can delete a range of elements by score" do
+    b = setup_1
+    assert_equal ["L1", "L2", "L3", "L4"], b.zlittles.to_a.map(&:name)
+
+    b.zlittles.remrangebyscore(2, 3)
+    assert_equal ["L1", "L4"], b.zlittles.to_a.map(&:name)
+  end
+
+  it "can allow intersection of 2 zsets" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    zintersection = b.zlittles.intersect(zlittles2)
+    zlittles3 = b.zlittles3
+    zintersection2 = b.zlittles.intersect(zlittles3)
+    zintersection3 = zintersection.intersect(zintersection2)
+    zintersection4 = zintersection.intersect(zintersection)
+
+    assert_equal ["L1", "L4"], zintersection2.to_a.map(&:name)
+    assert_equal ["L2", "L3", "L4"], zintersection.to_a.map(&:name)
+    assert_equal ["L4"], zintersection3.to_a.map(&:name)
+    assert_equal zintersection.to_a.map(&:name), zintersection4.to_a.map(&:name)
+  end
+
+  it "can allow intersection of a zset and a set" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    slittles = b.slittles
+
+    zintersection = b.zlittles.intersect(slittles)
+    zintersection2 = b.zlittles2.intersect(slittles)
+
+    assert_equal ["L1","L2","L4"], zintersection.to_a.map(&:name)
+    assert_equal ["L2","L4"], zintersection2.to_a.map(&:name)
+  end
+
+  it "can allow intersection of multiple zsets and sets" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    zlittles3 = b.zlittles3
+    slittles = b.slittles
+
+    zintersection = b.zlittles.intersect_multiple([zlittles2, zlittles3])
+
+    assert_equal ["L4"], zintersection.to_a.map(&:name)
+  end
+
+  it "can allow intersection of multiple zsets and sets to a new named set" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    zlittles3 = b.zlittles3
+    slittles = b.slittles
+    zintersection = Ohm::ZSet.intersect_multiple("zintersection", [zlittles, zlittles2, zlittles3])
+
+    assert_equal ["L4"], zintersection.to_a.map(&:name)
+    assert_equal "zintersection", zintersection.key
+  end
+
+  it "can allow union of 2 zsets" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    zunion = b.zlittles.union(zlittles2)
+
+    assert_equal ["L1","L2","L3","L4"], zunion.to_a.map(&:name)
+  end
+
+  it "can allow union of a zset and a set" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    slittles = b.slittles
+
+    zunion = b.zlittles.union(slittles)
+    zunion2 = b.zlittles2.union(slittles)
+
+    assert_equal ["E3","L1","L2","L3","L4"], zunion.to_a.map(&:name)
+  end
+
+  it "can allow union of multiple zsets and sets" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    zlittles3 = b.zlittles3
+    slittles = b.slittles
+
+    zunion = b.zlittles.union_multiple([slittles, zlittles2, zlittles3])
+
+    assert_equal ["E3","L1","L2","L3","L4","E1","E2"], zunion.to_a.map(&:name)
+  end
+
+  it "can allow union of multiple zsets and sets to a newly named set" do
+    b = setup_1
+
+    zlittles = b.zlittles
+    zlittles2 = b.zlittles2
+    zlittles3 = b.zlittles3
+    slittles = b.slittles
+
+    zunion = Ohm::ZSet.union_multiple("zunion", [zlittles, slittles, zlittles2, zlittles3])
+
+    assert_equal ["E3","L1","L2","L3","L4","E1","E2"], zunion.to_a.map(&:name)
+    assert_equal "zunion", zunion.key
+  end
+
+  it "can get the rank of an element" do
+    b, l1, l2, l3, l4 = setup_2
+
+    assert_equal 0, b.zlittles.rank(l1)
+    assert_equal 1, b.zlittles.rank(l2)
+    assert_equal 2, b.zlittles.rank(l3)
+    assert_equal 3, b.zlittles.rank(l4)
+  end
+
+  it "can get the rank of specified element from the reverse sorted list" do
+    b, l1, l2, l3, l4 = setup_2
+
+    assert_equal 3, b.zlittles.revrank(l1)
+    assert_equal 2, b.zlittles.revrank(l2)
+    assert_equal 1, b.zlittles.revrank(l3)
+    assert_equal 0, b.zlittles.revrank(l4)
+  end
+
+  it "can get the score of an element" do
+    b, l1, l2, l3, l4 = setup_2
+
+    assert_equal 1, b.zlittles.score(l1)
+    assert_equal 2, b.zlittles.score(l2)
+    assert_equal 3, b.zlittles.score(l3)
+    assert_equal 4, b.zlittles.score(l4)
+  end
+
+  it "can get a range of elements by score" do
+    b, = setup_2
+
+    assert_equal ["L1", "L2", "L3", "L4"], b.zlittles.rangebyscore(0, 4).to_a.map(&:name)
+    assert_equal ["L1", "L2"], b.zlittles.rangebyscore(1, 2).to_a.map(&:name)
+    assert_equal ["L3", "L4"], b.zlittles.rangebyscore(3, 4).to_a.map(&:name)
+    assert_equal ["L1", "L2", "L3"], b.zlittles.rangebyscore(1, 3).to_a.map(&:name)
+    assert_equal ["L1", "L2"], b.zlittles.rangebyscore(0, 4, offset: 0, count: 2).to_a.map(&:name)
+    assert_equal ["L3", "L4"], b.zlittles.rangebyscore(0, 4, offset: 2, count: 2).to_a.map(&:name)
+    assert_equal ["L2", "L3", "L4"], b.zlittles.rangebyscore(0, 4, offset: 1, count: 3).to_a.map(&:name)
+    assert_equal ["L3"], b.zlittles.rangebyscore(1, 3, offset: 2, count: 4).to_a.map(&:name)
+    assert_equal ["L1", "L2", "L3", "L4"], b.zlittles.rangebyscore(0, "+inf").to_a.map(&:name)
+    assert_equal ["L4"], b.zlittles.rangebyscore(2, "+inf", offset: 2).to_a.map(&:name)
+    assert_equal ["L1", "L2"], b.zlittles.rangebyscore("-inf", 2).to_a.map(&:name)
+    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 in reverse" do
+    b, = setup_2
+
+    assert_equal ["L4", "L3", "L2", "L1"], b.zlittles.revrangebyscore(4, 0).to_a.map(&:name)
+    assert_equal ["L2", "L1"], b.zlittles.revrangebyscore(2, 1).to_a.map(&:name)
+    assert_equal ["L4", "L3"], b.zlittles.revrangebyscore(4, 3).to_a.map(&:name)
+    assert_equal ["L3", "L2", "L1"], b.zlittles.revrangebyscore(3, 1).to_a.map(&:name)
+    assert_equal ["L4", "L3"], b.zlittles.revrangebyscore(4, 0, offset: 0, count: 2).to_a.map(&:name)
+    assert_equal ["L2", "L1"], b.zlittles.revrangebyscore(4, 0, offset: 2, count: 2).to_a.map(&:name)
+    assert_equal ["L3", "L2", "L1"], b.zlittles.revrangebyscore(4, 0, offset: 1, count: 3).to_a.map(&:name)
+    assert_equal ["L1"], b.zlittles.revrangebyscore(3, 1, offset: 2, count: 4).to_a.map(&:name)
+    assert_equal ["L4", "L3", "L2", "L1"], b.zlittles.revrangebyscore("+inf", 0).to_a.map(&:name)
+    assert_equal ["L2"], b.zlittles.revrangebyscore("+inf", 2, offset: 2).to_a.map(&:name)
+    assert_equal ["L2", "L1"], b.zlittles.revrangebyscore(2, "-inf").to_a.map(&:name)
+    assert_equal ["L2"], b.zlittles.revrangebyscore("+inf", 2, offset: 2, count: 2).to_a.map(&:name)
+  end
+
+  it "can get the number of elements between 2 given scores" do
+    b, = setup_2
+
+    assert_equal 2, b.zlittles.count(1, 2)
+    assert_equal 2, b.zlittles.count(3, 4)
+    assert_equal 4, b.zlittles.count(1, 4)
+    assert_equal 3, b.zlittles.count(2, "+inf")
+    assert_equal 4, b.zlittles.count
+    assert_equal 4, b.zlittles.count("-inf", "+inf")
+    assert_equal 2, b.zlittles.count("-inf", 2)
+  end
+
+  it "can update the sorted set properly upon updating the score of an element" do
+    b, l1, l2, l3, l4 = setup_2
+    assert_equal ["L1", "L2", "L3", "L4"], b.zlittles.to_a.map(&:name)
+
+    l1.score = 5
+    l1.save
+    b.zlittles.update(l1)
+    assert_equal ["L2", "L3", "L4", "L1"], b.zlittles.to_a.map(&:name)
+
+    l3.score = -3
+    l3.save
+    b.zlittles.update(l3)
+    assert_equal ["L3", "L2", "L4", "L1"], b.zlittles.to_a.map(&:name)
+
+  end
+
+  it "can sort elements by date" do
+    b = setup_4
+
+    assert_equal ["D3", "D2", "D1", "D4"], b.zdts.to_a.map(&:name)
+  end
+
+  it "can sort elements by name" do
+    b = setup_5
+
+    assert_equal ["Apple", "Banana", "Coconut", "Dragonfruit",
+                  "apple", "apples", "banana", "bananas",
+                  "coconut", "coconuts", "durian", "durians"],
+                  b.zbools2.to_a.map(&:name)
+  end
+
+  it "can sort elements by name (insensitive)" do
+    b = setup_6
+
+    assert_equal ["apple", "Apple", "Apples",
+                  "Banana", "banana", "bananas",
+                  "Coconut", "coconut", "coconuts",
+                  "duria", "Durian", "durians"],
+                  b.zbools3.to_a.map(&:name)
+  end
+
+  it "can sort elements by name (insensitive high)" do
+    b = setup_7
+
+    assert_equal ["Apple", "Apples", "apple",
+                  "Banana", "banana", "bananas",
+                  "Coconut", "coconut", "coconuts",
+                  "Durian", "duria", "durians"],
+                  b.zbools4.to_a.map(&:name)
+  end
+
+  it "can find elements that starts with specified string" do
+    b = setup_5
+
+    assert_equal ["durian", "durians"], b.zbools2.starts_with("du").map(&:name)
+    assert_equal ["durians"], b.zbools2.starts_with("d",offset:1,limit:1).map(&:name)
+    assert_equal ["bananas"], b.zbools2.starts_with("bananas").map(&:name)
+  end
+
+  it "can return the first and last elements" do
+    b = setup_1
+
+    assert_equal "L1", b.zlittles.first.name
+    assert_equal "L4", b.zlittles.last.name
+  end
+
+  it "can be deleted / destroyed" do
+    b = setup_1
+
+    b.zlittles.destroy!
+
+    assert_equal [], b.zlittles.to_a.map(&:name)
+  end
+
+  it "can delete all elements at once" do
+    b = setup_1
+
+    b.zlittles.clear
+
+    assert_equal [], b.zlittles.to_a.map(&:name)
+  end
+
+  it "can clone itself to another instance" do
+    b, l1, l2, l3, l4 = setup_2
+
+    clone = b.zlittles.duplicate
+
+    assert_equal ["L1", "L2", "L3", "L4"], clone.to_a.map(&:name)
+    assert_equal 1, clone.score(l1)
+    assert_equal 2, clone.score(l2)
+    assert_equal 3, clone.score(l3)
+    assert_equal 4, clone.score(l4)
+  end
+
+  it "can convert a procedure block to string and back" do
+    x = lambda { |x| x + 1 }
+    y = Ohm::Utils.proc_to_string x
+
+    assert_equal "proc { |x| (x + 1) }", y
+
+    z = Ohm::Utils.string_to_proc y
+
+    assert_equal 3, z.call(2)
+  end
+
+  it "can convert a score_field list to string and back" do
+    score_field = [:n1, :n2, :n3, lambda { |x| x + 1 }]
+    score_field_string = Ohm::Utils.score_field_to_string score_field
+
+    assert_equal "n1:n2:n3:proc { |x| (x + 1) }", score_field_string
+
+    score_field_list = Ohm::Utils.string_to_score_field score_field_string
+
+    assert_equal :n1, score_field_list[0]
+    assert_equal :n2, score_field_list[1]
+    assert_equal :n3, score_field_list[2]
+
+    assert_equal 3, score_field_list[3].call(2)
+  end
+
+  it "can save and load sets by name" do
+    b = setup_1
+
+    sorted_set = b.zlittles
+    sorted_set.save_set
+    sorted_set_2 = Ohm::ZSet.load_set(sorted_set.key)
+
+    assert_equal sorted_set_2.to_a.map(&:name), sorted_set.to_a.map(&:name)
+
+    sorted_set_2.add(Little.create(name:'X1',score:29))
+
+    assert_equal sorted_set_2.to_a.map(&:name), sorted_set.to_a.map(&:name)
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: ohm-zset
+version: !ruby/object:Gem::Version
+  version: '0.2'
+  prerelease: 
+platform: ruby
+authors:
+- Josh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ohm
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds ZSet support to Ohm
+email:
+- akosijoshualat@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gems
+- .gitignore
+- .rvmrc
+- CHANGELOG
+- LICENSE
+- README.md
+- Rakefile
+- lib/.DS_Store
+- lib/ohm-zset.rb
+- lib/suppress-warnings.rb
+- test/.DS_Store
+- test/helper.rb
+- test/unit/.DS_Store
+- test/unit/ohm-zset.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Adds ZSet support to Ohm
+test_files:
+- test/.DS_Store
+- test/helper.rb
+- test/unit/.DS_Store
+- test/unit/ohm-zset.rb