redis-roc 0.5.0

data/lib/redis-roc.rb

@@ -0,0 +1,2 @@
+require 'roc/store'
+require 'roc/objects'

data/lib/roc/ext/redis_ext.rb

@@ -0,0 +1,20 @@
+class Redis
+
+  def zrevrangebyscore(key, max, min, options = {})
+    command = CommandOptions.new(options) do |c|
+      c.splat :limit
+      c.bool  :with_scores
+    end
+
+    @client.call(:zrevrangebyscore, key, max, min, *command.to_a)
+  end
+
+  def del(*keys)
+    _bool @client.call(:del, *keys)
+  end
+
+  def hdel(key, field)
+    _bool @client.call(:hdel, key, field)
+  end
+
+end

data/lib/roc/objects/base.rb

@@ -0,0 +1,81 @@
+if RUBY_VERSION.match(/^1\.8/)
+  require 'rubygems'
+end
+require 'cim_attributes'
+
+require 'roc/types/all_types'
+
+module ROC
+  class Base
+    include ROC::Types::AllTypes
+    include CIMAttributes
+
+    attr_reader :key, :options
+
+    cim_attr_accessor :storage
+
+    # key, [storage], [seed_data], [opts]
+    def initialize(key, *args)
+      @key = key
+
+      if args.last.is_a?(Hash)
+        @options = args.pop
+      end
+
+      if args.first.is_a?(ROC::Store::ROCStore)
+        @storage = args.shift
+      end
+
+      if !self.storage
+        raise ArgumentError, 'no class-level storage set, so must initialize with a Store'
+      end
+
+      if args.size > 1
+        raise ArgumentError, 'new(key, [storage], [seed_data], [opts])'
+      end
+
+      if !(seed_data = args.pop).nil?
+        seed(seed_data)
+      end
+    end
+ 
+    def seed(data)
+      if self.exists?
+        raise "#{self.key} already exists -- can't seed it"
+      else
+        self.clobber(data)
+      end
+    end
+
+    def clobber(data)
+      raise "clobber must be overriden in subclasses"
+    end
+
+    def self.delegate_methods(options)
+      raise ":on and :to required to delegate methods" unless options.has_key?(:on) && options.has_key?(:to)
+      self.const_set('DELEGATE_OPTIONS', options)
+    end
+
+    def respond_to?(method_name)
+      self.methods.include?(method_name) || (self.class.const_get('DELEGATE_OPTIONS') && self.class.const_get('DELEGATE_OPTIONS')[:on].respond_to?(method_name))
+    end
+
+    def method_missing(method_name, *args, &block)
+      if self.class.const_get('DELEGATE_OPTIONS') && 
+          (delegate_type = self.class.const_get('DELEGATE_OPTIONS')[:on]) && 
+          delegate_type.respond_to?(method_name) &&
+          !['!', '='].include?(method_name.to_s[method_name.to_s.length - 1]) # we won't delegate modifying methods
+        self.send(self.class.const_get('DELEGATE_OPTIONS')[:to]).send(method_name, *args, &block)
+      else
+        super(method_name, *args, &block)        
+      end
+    end
+
+    protected
+
+    def call(remote_method_name, *args)
+      self.storage.call(remote_method_name, self.key, *args)
+    end
+
+  end
+end

data/lib/roc/objects/float.rb

@@ -0,0 +1,32 @@
+require 'roc/objects/base'
+module ROC
+  class Float < Base
+    include ROC::Types::ScalarType
+
+    delegate_methods :on => 0.0, :to => :value
+
+    def to_float
+      self.value.to_f
+    end
+    alias to_f to_float
+
+    ## implementing scalar type required methods ##
+
+    def serialize(val)
+      val.to_s
+    end
+    
+    def deserialize(val)
+      if val.nil?
+        nil
+      elsif 'Infinity' == val
+        1.0 / 0
+      elsif '-Infinity' == val
+        -1.0 / 0
+      else
+        val.to_f
+      end
+    end
+
+  end
+end

data/lib/roc/objects/hash.rb

@@ -0,0 +1,134 @@
+require 'roc/objects/base'
+module ROC
+  class Hash < Base
+    extend ROC::Types::MethodGenerators   
+
+    delegate_methods :on => {}, :to => :to_hash
+
+    nonserializing_method :hdel
+
+    nonserializing_method :hexists
+    alias key? hexists
+    alias has_key? hexists
+    alias member? hexists
+    alias include? hexists
+
+    nonserializing_method :hget
+    alias get hget
+    alias [] hget
+
+    zero_arg_method :hgetall
+    alias getall hgetall
+
+    def hincrby(field, increment)
+      self.call :hincrby, field, increment
+    end
+    alias incrby hincrby
+
+    zero_arg_method :hkeys
+    alias keys hkeys
+
+    zero_arg_method :hlen
+    alias len hlen
+    alias length hlen
+    alias size hlen
+
+    def hmget(*fields)
+      self.call :hmget, *fields
+    end
+    alias mget hmget
+
+    def hmset(*pairs)
+      self.call :hmset, *pairs
+    end
+    alias mset hmset
+    
+    def hset(field, val)
+      self.call :hset, field, val
+    end
+    alias set hset
+    alias []= hset
+    alias store hset
+
+    def hsetnx(field, val)
+      self.call :hsetnx, field, val
+    end
+    alias setnx hsetnx
+
+    zero_arg_method :hvals
+    alias vals hvals
+    alias values hvals
+
+    # shortcuts/helpers
+
+    alias values_at hmget
+
+    def has_value?(val)
+      self.values.include?(val)
+    end
+    alias value? has_value?
+
+    def empty?
+      0 == self.hlen
+    end
+
+    def decrby(field, by)
+      self.hincrby field, -by
+    end
+
+    def increment(field, by=nil)
+      self.hincrby field, (by || 1)
+    end
+
+    def decrement(field, by=nil)
+      self.hincrby field, -(by || 1)
+    end
+
+    ## implement (if posible) destructive methods that would otherwise raise
+
+    def merge!(hsh)
+      raise ArgumentError, 'block version not supported' if block_given?
+      self.hmset(*hsh.to_a.flatten)
+      self
+    end
+    alias update merge!
+
+    def delete(field)
+      val = self.hget(field)
+      self.hdel(field)
+      val
+    end
+
+    def replace(hsh)
+      self.clobber(hsh)
+      self
+    end
+
+    def clear
+      self.replace({})
+    end
+
+    def delete_if
+      raise NotImplementedError
+    end
+
+    def shift
+      raise NotImplementedError
+    end
+
+    ## implementing for delegate
+
+    alias to_hash getall
+    alias to_h getall
+
+    def clobber(data)
+      self.storage.multi do 
+        self.forget
+        if data.size > 0
+          self.merge!(data)          
+        end
+      end
+    end
+
+  end
+end

data/lib/roc/objects/integer.rb

@@ -0,0 +1,51 @@
+require 'roc/objects/base'
+module ROC
+  class Integer < Base
+    include ROC::Types::ScalarType
+
+    delegate_methods :on => 0, :to => :value
+
+    def to_integer
+      self.value.to_i
+    end
+    alias to_int to_integer
+    alias to_i to_integer
+
+    ## implemeting redis methods ##
+
+    def increment(by=nil)
+      if by.nil?
+        self.call :incr
+      else
+        self.call :incrby, by
+      end
+    end
+    alias incr increment
+    alias incrby increment
+
+    def decrement(by=nil)
+      if by.nil?
+        self.call :decr
+      else
+        self.call :decrby, by
+      end
+    end
+    alias decr decrement
+    alias decrby decrement
+
+    ## implementing scalar type required methods ##
+
+    def serialize(val)
+      val.to_s
+    end
+    
+    def deserialize(val)
+      if val.nil?
+        nil
+      else
+        val.to_i
+      end
+    end
+
+  end
+end

data/lib/roc/objects/list.rb

@@ -0,0 +1,204 @@
+require 'roc/objects/base'
+require 'roc/types/array_type'
+require 'roc/types/sortable_type'
+
+module ROC
+  class List < Base
+    include ROC::Types::ArrayType
+    include ROC::Types::SortableType
+    extend ROC::Types::MethodGenerators   
+
+    def lrange(start_index, stop_index)
+      self.call :lrange, start_index, stop_index
+    end
+    alias range lrange
+
+    zero_arg_method :llen
+    alias len llen
+
+    nonserializing_method :rpush
+
+    nonserializing_method :rpushx
+    alias pushx rpushx
+
+    nonserializing_method :lpush
+
+    nonserializing_method :lpushx
+    alias unshiftx lpushx
+
+    zero_arg_method :rpop
+
+    zero_arg_method :lpop
+
+    def lset(index, val)
+      self.call :lset, index, val
+    end
+    alias set lset
+    
+    nonserializing_method :lindex
+    alias index lindex
+
+    def lrem(count, val)
+      self.call :lrem, count, val
+    end
+    alias rem lrem
+
+    def ltrim(start_index, stop_index)
+      self.call :ltrim, start_index, stop_index
+    end
+    alias trim ltrim
+
+    def rpoplpush(other_list=self)
+      self.call :rpoplpush, other_list.key
+    end
+
+    def linsert(where, pivot, value)
+      self.call :linsert, where, pivot, value
+    end
+
+    def linsert_before(pivot, value)
+      self.linsert('before', pivot, value)
+    end
+    alias insert_before linsert_before
+
+    def linsert_after(pivot, value)
+      self.linsert('after', pivot, value)
+    end
+    alias insert_after linsert_after
+
+
+    ## shortcut methods
+
+    def [](range_or_num, num=nil)
+      if range_or_num.is_a?(::Integer)
+        if num.nil?
+          self.lindex(range_or_num)
+        elsif num >= 0
+          self.lrange(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.lrange(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.lindex(0)
+    end
+
+    def last
+      self.lindex(-1)
+    end
+
+    def []=(*args)
+      case args.size
+      when 1
+        raise ArgumentError, 'index required'
+      when 2
+        if args[0].is_a?(::Integer)
+          self.lset(*args)
+        else
+          raise ArgumentError, 'range assignment not supported in []='
+        end
+      when 3
+        raise ArgumentError, 'multiple index assignment not supported in []='
+      else
+        raise ArgumentError, 'wrong number of args'
+      end
+    end
+
+    ## implement (if posible) destructive methods that would otherwise raise
+
+    def delete(val)
+      count = self.lrem(0, val)
+      if count > 0
+        val
+      else
+        nil
+      end
+    end
+
+    def push(*objs)
+      if 1 == objs.size
+        self.rpush(objs[0])
+      elsif objs.size > 1
+        self.storage.multi do 
+          objs.each do |obj|
+            self.rpush(obj)
+          end
+        end
+      end
+      self
+    end
+
+    def <<(obj)
+      self.push(obj)
+    end
+
+    def unshift(*objs)
+      if 1 == objs.size
+        self.lpush(objs[0])
+      elsif objs.size > 1
+        self.storage.multi do 
+          objs.reverse.each do |obj|
+            self.lpush(obj)
+          end
+        end
+      end
+      self
+    end
+
+    def pop(*args)
+      if 0 == args.size
+        self.rpop
+      elsif 1 == args.size
+        (self.storage.multi do
+          args[0].times do 
+            self.rpop
+          end
+        end).reverse
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 1)"
+      end      
+    end
+
+    def shift(*args)
+      if 0 == args.size
+        self.lpop
+      elsif 1 == args.size
+        (self.storage.multi do
+          args[0].times do 
+            self.lpop
+          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
+
+    def values
+      self.lrange(0, -1)
+    end
+
+    alias size llen
+    alias length llen
+
+  end
+end

data/lib/roc/objects/lock.rb

@@ -0,0 +1,53 @@
+module ROC
+  class Lock < Time
+
+    def lock(expires_time)
+      aquired_lock = false
+      if self.setnx(expires_time)
+        aquired_lock = true
+      else
+        locked_until = self.value
+        if locked_until.nil? || (locked_until < ::Time.now) ##ttl of 0 is not yet expired
+          # only say we got the lock if we manage to update it first
+          if self.getset(expires_time) == locked_until
+            aquired_lock = true
+          end
+        end
+      end
+      aquired_lock
+    end
+
+    def locked?
+      locked_until = self.value
+      !locked_until.nil? && (locked_until >= ::Time.now) ##ttl of 0 is not yet expired
+    end
+    
+    def unlock
+      self.forget
+    end
+
+    def when_locked(expires_time, poll_ms=100)
+      until self.lock(expires_time)
+        sleep(poll_ms.to_f / 1000)
+      end
+      begin
+        yield
+      ensure
+        self.unlock
+      end
+    end
+
+    def locking_if_necessary(expires_time)
+      obtained_lock = self.lock(expires_time)
+      begin
+        yield
+      ensure
+        if obtained_lock
+          self.unlock
+        end
+      end      
+    end
+
+  end
+end
+