redis-roc 0.5.0

data/lib/roc/objects/set.rb

@@ -0,0 +1,148 @@
+require 'roc/objects/base'
+require 'roc/types/array_type'
+require 'roc/types/sortable_type'
+
+module ROC
+  class Set < Base
+    include ROC::Types::ArrayType
+    include ROC::Types::SortableType
+    extend ROC::Types::MethodGenerators   
+
+    nonserializing_method :sadd
+    alias add sadd
+
+    zero_arg_method :scard
+    alias card scard
+
+    nonserializing_method :sismember
+    alias ismember sismember
+    alias ismember? sismember
+    alias is_member? sismember
+    alias include? sismember
+
+    zero_arg_method :smembers
+    alias members smembers
+
+    zero_arg_method :spop
+
+    zero_arg_method :srandmember
+    alias randmmember srandmember
+    alias rand_member srandmember
+
+    nonserializing_method :srem
+    alias rem srem
+
+    def smove(other_set, val)
+      self.call :smove, other_set.key, val
+    end
+    alias move smove
+    alias move_into smove
+
+    def sinter(*other_sets)
+      self.call :sinter, *other_sets.map{|s| s.key}
+    end
+    alias inter sinter
+    alias intersect sinter
+    alias :& :sinter ## to make rdoc parser happy
+
+    def sunion(*other_sets)
+      self.call :sunion, *other_sets.map{|s| s.key}
+    end
+    alias union sunion
+    alias | sunion    
+    
+    def sdiff(*other_sets)
+      self.call :sdiff, *other_sets.map{|s| s.key}
+    end
+    alias diff sdiff
+    alias - sdiff
+
+    def sinterstore(*other_sets)
+      self.call :sinterstore, *other_sets.map{|s| s.key}
+    end
+    alias interstore sinterstore
+    alias inter_store sinterstore
+    alias set_as_intersect_of sinterstore
+
+    def sunionstore(*other_sets)
+      self.call :sunionstore, *other_sets.map{|s| s.key}
+    end
+    alias unionstore sunionstore
+    alias union_store sunionstore
+    alias set_as_union_of sunionstore
+    
+    def sdiffstore(*other_sets)
+      self.call :sdiffstore, *other_sets.map{|s| s.key}
+    end
+    alias diffstore sdiffstore
+    alias diff_store sdiffstore
+    alias set_as_diff_of sdiffstore
+
+    ## helpers
+
+    def to_hash
+      hsh = {}
+      self.smembers.each do |val|
+        hsh[val] = true
+      end
+      hsh
+    end
+    alias to_h to_hash
+
+    ## implement (if posible) destructive methods that would otherwise raise
+
+    def delete(val)
+      if self.srem(val)
+        val
+      else
+        nil
+      end
+    end
+
+    def push(*objs)
+      if 1 == objs.size
+        self.sadd(objs[0])
+      elsif objs.size > 1
+        self.storage.multi do 
+          objs.each do |obj|
+            self.sadd(obj)
+          end
+        end
+      end
+      self
+    end
+
+    def <<(obj)
+      self.push(obj)
+    end
+
+    def pop(*args)
+      if 0 == args.size
+        self.spop
+      elsif 1 == args.size
+        (self.storage.multi do
+          args[0].times do 
+            self.spop
+          end
+        end).reverse
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 1)"
+      end      
+    end
+      
+    ## implementing ArrayType ##
+
+    def clobber(vals)
+      self.storage.multi do 
+        self.forget
+        vals.each{|v| self << v}
+      end
+    end
+
+    alias values smembers
+
+    alias size scard
+    alias length scard
+
+  end
+end

data/lib/roc/objects/sorted_set.rb

@@ -0,0 +1,217 @@
+require 'roc/objects/base'
+require 'roc/types/array_type'
+require 'roc/types/sortable_type'
+
+module ROC
+  class SortedSet < Base
+    include ROC::Types::ArrayType
+    include ROC::Types::SortableType
+    extend ROC::Types::MethodGenerators   
+
+    def zadd(score, val)
+      self.call :zadd, score, val
+    end
+    alias add zadd
+
+    zero_arg_method :zcard
+    alias card zcard
+
+    def zrange(start_index, stop_index, opts={})
+      self.call :zrange, start_index, stop_index, opts
+    end
+    alias range zrange
+
+    def zrevrange(start_index, stop_index, opts={})
+      self.call :zrevrange, start_index, stop_index, opts
+    end
+    alias revrange zrevrange
+
+    def zrangebyscore(min, max, opts={})
+      self.call :zrangebyscore, min, max, opts
+    end
+    alias rangebyscore zrangebyscore
+
+    def zrevrangebyscore(max, min, opts={})
+      self.call :zrevrangebyscore, max, min, opts
+    end
+    alias revrangebyscore zrevrangebyscore
+
+    def zcount (min, max)
+      self.call :zcount, min, max
+    end
+    alias count zcount
+
+    nonserializing_method :zrank
+    alias rank zrank
+
+    nonserializing_method :zrevrank
+    alias revrank zrevrank
+
+    nonserializing_method :zscore
+    alias score zscore
+
+    def zincrby(by, val)
+      self.call :zincrby, by, val
+    end
+    alias incrby zincrby
+
+    nonserializing_method :zrem
+    alias rem zrem
+
+    def zremrangebyscore(min, max)
+      self.call :zremrangebyscore, min, max
+    end
+    alias remrangebyscore zremrangebyscore
+
+    def zremrangebyrank(start, stop)
+      self.call :zremrangebyrank, start, stop
+    end
+    alias remrangebyrank zremrangebyrank
+
+    def zinterstore(*other_sorted_sets)
+      opts = if other_sorted_sets.last.is_a?(::Hash)
+               other_sorted_sets.pop
+             else
+               {}
+             end
+        
+      self.call :zinterstore, [*other_sorted_sets].map{|s| s.key}, opts
+    end
+    alias interstore zinterstore
+    alias inter_store zinterstore
+    alias set_as_intersect_of zinterstore
+
+    def zunionstore(*other_sorted_sets)
+      opts = if other_sorted_sets.last.is_a?(::Hash)
+               other_sorted_sets.pop
+             else
+               {}
+             end
+      self.call :zunionstore, [*other_sorted_sets].map{|s| s.key}, opts
+    end
+    alias unionstore zunionstore
+    alias union_store zunionstore
+    alias set_as_union_of zunionstore
+
+    ## shortcut methods
+
+    def [](range_or_num, num=nil)
+      if range_or_num.is_a?(::Integer)
+        if num.nil?
+          self.zrange(range_or_num, range_or_num)[0]
+        elsif num >= 0
+          self.zrange(range_or_num, range_or_num + num - 1)
+        else
+          raise ArgumentError, 'second arg to [] must be a non-neg integer'
+        end
+      elsif range_or_num.is_a?(Range)
+        self.zrange(range_or_num.first, (range_or_num.exclude_end? ? range_or_num.last - 1 : range_or_num.last))
+      else
+        if num.nil?
+          self.values.slice(range_or_num)
+        else
+          self.values.slice(range_or_num, num)
+        end
+      end
+    end
+    alias slice []
+
+    def first
+      self.zrange(0, 0)[0]
+    end
+
+    def last
+      self.zrange(-1, -1)[0]
+    end
+
+    def include?(val)
+      !self.zrank(val).nil?
+    end
+    
+    def index(val)
+      self.zrank(val)
+    end
+
+    def reverse
+      self.zrevrange(0, -1)
+    end
+
+    # helpers
+
+    def decrby(by, val)
+      self.zincrby -by, val
+    end
+
+    def increment(val, by=nil)
+      self.zincrby( (by || 1), val )
+    end
+
+    def decrement(val, by=nil)
+      self.zincrby( -(by || 1), val )
+    end
+
+    def to_hash
+      hsh = {}
+      vals_with_scores = self.zrangebyscore('-inf', '+inf', :with_scores => true)
+      i = 0
+      l = vals_with_scores.size
+      while i < l
+        hsh[vals_with_scores[i]] = vals_with_scores[i+1]
+        i += 2
+      end
+      hsh
+    end
+    alias to_h to_hash
+
+    ## implement (if posible) destructive methods that would otherwise raise
+
+    def delete(val)
+      if self.zrem(val)
+        val
+      else
+        nil
+      end
+    end
+
+    def <<(val_and_score)
+      if val_and_score.is_a?(Array)
+        self.zadd *val_and_score
+      elsif val_and_score.is_a?(::Hash) && val_and_score.has_key?(:value) && val_and_score.has_key?(:score)
+        self.zadd(val_and_score[:score], val_and_score[:value])
+      else
+        raise ArgumentError, 'an Array or a Hash required'
+      end
+      self
+    end
+
+    def push(*objs)
+      if 1 == objs.size
+        self << objs[0]
+      elsif objs.size > 1
+        self.storage.multi do 
+          objs.each do |obj|
+            self << obj
+          end
+        end
+      end
+      self
+    end
+
+    ## implementing ArrayType ##
+
+    def clobber(vals)
+      self.storage.multi do 
+        self.forget
+        vals.each{|v| self << v}
+      end
+    end
+
+    def values(opts = {})
+      self.zrange(0, -1, opts)
+    end
+
+    alias size zcard
+    alias length zcard
+
+  end
+end

data/lib/roc/objects/string.rb

@@ -0,0 +1,116 @@
+require 'roc/objects/base'
+require 'roc/types/scalar_type'
+
+module ROC
+  class String < Base
+    include ROC::Types::ScalarType
+    extend ROC::Types::MethodGenerators
+
+    delegate_methods :on => '', :to => :value
+
+    attr_reader :encoding
+
+    def to_string
+      self.value.to_s
+    end
+    alias to_s to_string
+
+    ## redis methods ##
+
+    nonserializing_method :append
+    alias << append
+    alias concat append
+
+    def getrange(first_index, last_index)
+      self.call :getrange, first_index, last_index
+    end
+    alias substr getrange
+    alias substring getrange
+
+    nonserializing_method :getbit
+
+    def setbit(index, val)
+      self.call :setbit, index, val
+    end
+
+    def setrange(start_index, val)
+      self.call :setrange, start_index, val
+    end
+    alias splice setrange
+
+    zero_arg_method :strlen
+    alias bytesize strlen
+
+    ## shortcut methods
+
+    def getbyte(ind)
+      val = self.getrange(ind, ind)
+      if val.nil? || ('' == val)
+        nil
+      else
+        val.bytes.to_a[0]
+      end
+    end
+
+    def setbyte(ind, int)
+      self.setrange(ind, int.chr)
+      int
+    end
+
+    def empty?
+      0 == self.strlen
+    end
+
+    def chr
+      self.getrange(0, 0)
+    end
+
+    ## implement (if posible) destructive methods that would otherwise raise
+
+    def replace(val)
+      self.set(val)
+      val
+    end
+
+    def clear
+      self.replace('')
+    end
+
+    def force_encoding(enc)
+      @encoding = enc
+    end
+
+    ## raise destructive methods if not implemted
+
+    def insert(ind, val)
+      raise NotImplementedError
+    end
+
+    ## implementing scalar type required methods ##
+
+    def serialize(val)
+      ## use the encoding of the first val were sent unless expicitly set
+      if @encoding.nil?
+        @encoding = if val.respond_to?(:encoding)
+                          val.encoding
+                        else
+                          'US-ASCII'
+                        end
+      end
+      if val.respond_to?(:encode)
+        val.encode(@encoding)
+      else
+        val
+      end
+    end
+    
+    def deserialize(val)
+      if @encoding.nil? || !val.respond_to?(:force_encoding)
+        val
+      else
+        val.force_encoding(@encoding)
+      end
+    end
+
+  end
+end

data/lib/roc/objects/time.rb

@@ -0,0 +1,62 @@
+require 'roc/objects/base'
+module ROC
+  class Time < Base
+    include ROC::Types::ScalarType
+
+    delegate_methods :on => ::Time.now, :to => :value
+
+    def to_time
+      v = self.value
+      if v.nil?
+        ::Time.at(0)
+      else
+        v
+      end
+    end
+
+    def to_s
+      self.to_time.to_s
+    end
+
+    ## implement (if posible) destructive methods that would otherwise raise
+
+    def localtime(offset=nil)
+      if (0 == ::Time.now.method(:localtime).arity) && !offset.nil?
+        raise ArgumentError, "1.8 Time#localtime doesn't take an arg"
+      else
+        @offset = offset
+      end
+      self
+    end
+
+    ## implementing scalar type required methods ##
+
+    def serialize(val)
+      if ::Time.now.respond_to?(:nsec)
+        val.to_i.to_s + '.' + val.nsec.to_s ##strait to_f loses precision
+      else
+        val.to_i.to_s + '.' + val.usec.to_s ##strait to_f loses precision
+      end
+    end
+
+    def deserialize(val)
+      if val.nil?
+        nil
+      else
+        parts = val.split('.')
+        t = if ::Time.now.respond_to?(:nsec)
+              ::Time.at(parts[0].to_i, (parts[1].to_i / 1000))
+            else
+              ::Time.at(parts[0].to_i, parts[1].to_i)
+            end
+        if defined?(@offset)
+          if ::Time.now.method(:localtime).arity > 0
+            t.localtime(@offset)
+          end
+        end
+        t
+      end
+    end
+
+  end
+end

data/lib/roc/objects.rb

@@ -0,0 +1,11 @@
+require 'roc/objects/string'
+require 'roc/objects/integer'
+require 'roc/objects/float'
+require 'roc/objects/time'
+require 'roc/objects/lock'
+
+require 'roc/objects/list'
+require 'roc/objects/set'
+require 'roc/objects/sorted_set'
+
+require 'roc/objects/hash'

data/lib/roc/store/object_initializers.rb

@@ -0,0 +1,74 @@
+module ROC
+  module Store
+    module ObjectInitializers
+
+      def init(klass, key, *seed_data_and_options)
+        klass.new(key, self, *seed_data_and_options)
+      end
+
+      def find(key)
+        if klass = class_for_key(key)
+          init(klass, key)
+        else
+          nil
+        end
+      end
+
+      def class_for_key(key)
+        case t = self.call(:type, key)
+        when 'string'
+          ROC::String
+        when 'list'
+          ROC::List
+        when 'set'
+          ROC::Set
+        when 'zset'
+          ROC::SortedSet
+        when 'hash'
+          ROC::Hash
+        when 'none'
+          nil
+        else
+          raise "unknown type: #{t}"
+        end
+      end
+      
+      def init_string(key, *seed_data_and_options)
+        init(ROC::String, key, *seed_data_and_options)
+      end
+      
+      def init_integer(key, *seed_data_and_options)
+        init(ROC::Integer, key, *seed_data_and_options)
+      end
+      
+      def init_float(key, *seed_data_and_options)
+        init(ROC::Float, key, *seed_data_and_options)
+      end
+      
+      def init_time(key, *seed_data_and_options)
+        init(ROC::Time, key, *seed_data_and_options)
+      end
+
+      def init_lock(key, *seed_data_and_options)
+        init(ROC::Lock, key, *seed_data_and_options)
+      end
+      
+      def init_list(key, *seed_data_and_options)
+        init(ROC::List, key, *seed_data_and_options)
+      end
+      
+      def init_set(key, *seed_data_and_options)
+        init(ROC::Set, key, *seed_data_and_options)
+      end
+      
+      def init_sorted_set(key, *seed_data_and_options)
+        init(ROC::SortedSet, key, *seed_data_and_options)
+      end
+      
+      def init_hash(key, *seed_data_and_options)
+        init(ROC::Hash, key, *seed_data_and_options)
+      end
+
+    end
+  end
+end

data/lib/roc/store/redis_eval.rb

@@ -0,0 +1,7 @@
+class Redis
+  
+  def eval(script, num_key_args, *args)
+    @client.call(:eval, script, num_key_args, *args)
+  end
+
+end

data/lib/roc/store/redis_store.rb

@@ -0,0 +1,76 @@
+if RUBY_VERSION.match(/^1\.8/)
+  require 'rubygems'
+end
+require 'redis'
+require 'roc/ext/redis_ext'
+require 'roc/store/roc_store'
+require 'roc/store/object_initializers'
+
+require 'forwardable'
+
+module ROC
+  module Store
+    class RedisStore < ROCStore
+      include ObjectInitializers
+      extend Forwardable
+
+      attr_reader :connection
+
+      def initialize(connection)
+        if connection.is_a?(Redis)
+          @connection = connection
+        else
+          @connection = Redis.connect(connection)
+        end
+      end
+
+      def call(method_name, *args)
+        self.connection.send method_name, *args
+      end
+
+      def_delegators :connection, :watch, :unwatch, :flushdb
+
+      def multi
+        @in_multi = true
+        if block_given?          
+          ret = self.connection.multi do
+            yield
+          end           
+          @in_multi = false
+        else
+          ret = self.connection.multi
+        end
+        ret
+      end
+
+      def exec
+        ret = self.connection.exec
+        if @in_multi
+          @in_multi = false
+        end
+        ret
+      end
+
+      def discard
+        ret = self.connection.discard
+        if @in_multi
+          @in_multi = false
+        end
+        ret
+      end
+
+      def in_multi?
+        !!@in_multi
+      end
+
+      def inspect
+        "<#{self.class} @connection=#{self.connection.inspect}>"
+      end
+
+      def enable_eval
+        require 'roc/store/redis_eval'
+      end
+
+    end
+  end
+end