redpear 0.6.4 → 0.7.0

data/lib/redpear/schema.rb

@@ -1,6 +1,9 @@
 module Redpear::Schema
-  extend Redpear::Concern
   autoload :Collection, 'redpear/schema/collection'
+  autoload :Column, 'redpear/schema/column'
+  autoload :Index, 'redpear/schema/index'
+  autoload :Score, 'redpear/schema/score'
+  extend Redpear::Concern
 
   module ClassMethods
 
@@ -9,23 +12,23 @@ module Redpear::Schema
       @columns ||= Redpear::Schema::Collection.new
     end
 
-    # @param [multiple] the column definition. Please see Redpear::Column#initialize
+    # @param [multiple] the column definition. Please see Redpear::Schema::Column#initialize
     def column(*args)
-      columns.store(Redpear::Column, self, *args).tap do |col|
+      columns.store(Redpear::Schema::Column, self, *args).tap do |col|
         __define_attribute_accessors__(col)
       end
     end
 
     # @param [multiple] the index definition. Please see Redpear::Index#initialize
     def index(*args)
-      columns.store(Redpear::Index, self, *args).tap do |col|
+      columns.store(Redpear::Schema::Index, self, *args).tap do |col|
         __define_attribute_accessors__(col)
       end
     end
 
     # @param [multiple] the sorted index definition. Please see Redpear::ZIndex#initialize
-    def zindex(*args)
-      columns.store(Redpear::ZIndex, self, *args).tap do |col|
+    def score(*args)
+      columns.store(Redpear::Schema::Score, self, *args).tap do |col|
         __define_attribute_accessors__(col)
       end
     end

data/lib/redpear/store/base.rb

@@ -0,0 +1,120 @@
+require 'securerandom'
+
+class Redpear::Store::Base
+
+  attr_reader :key, :conn
+
+  # Creates and yields over a temporary key.
+  # Useful in combination with e.g. `interstore`, `unionstore`, etc.
+  #
+  # @param [Redpear::Connection] conn
+  #   The connection
+  # @param [Hash] options
+  #   The options hash
+  # @option [String] prefix
+  #   Specify a key prefix. Example:
+  #      Base.temporary conn, :prefix => "temp:" do |c|
+  #        store.key # => temp:55ee0c1ec9530cf545bc25040beb4f292fd448af
+  #      end
+  # @yield [Redpear::Store::Base]
+  #   The temporary key
+  def self.temporary(conn, options = {})
+    store = nil
+    while !store || store.exists?
+      key   = "#{options[:prefix]}#{SecureRandom.hex(20)}"
+      store = new(key, conn)
+    end
+    yield store
+  ensure
+    store.clear if store
+  end
+
+  # Constructor
+  # @param [String] key
+  #   The storage key
+  # @param [Redpear::Connection] conn
+  #   The connection
+  def initialize(key, conn)
+    @key, @conn = key, conn
+  end
+
+  alias to_s key
+
+  # @return [String] custom inspect
+  def inspect
+    "#<#{self.class.name} #{key}: #{value.inspect}>"
+  end
+
+  # @return [Boolean] true if the record exists
+  def exists?
+    !!conn.exists(key)
+  end
+
+  # @return [Integer] remaining time-to-live in seconds (if set)
+  def ttl
+    value = conn.ttl(key).to_i
+    value if value > -1
+  end
+
+  # @return [String] type information for this record
+  def type
+    conn.type(key).to_sym
+  end
+
+  # Expires the record
+  # @overload expire(time)
+  #   @param [Time] time The time to expire the record at
+  # @overload expire(seconds)
+  #   @param [Integer] seconds Expire in `seconds` from now
+  def expire(expiration)
+    case expiration
+    when Time
+      expire_at(expiration)
+    when Integer
+      expire_in(expiration)
+    when String
+      expiration = Kernel::Integer(expiration) rescue nil
+      expire(expiration)
+    else
+      false
+    end
+  end
+
+  # Deletes the whole record
+  def purge!
+    conn.del(key) == 1
+  end
+
+  # Deletes the record and returns the value
+  def clear
+    purge!
+    value
+  end
+
+  # Expires the record
+  # @param [Time] time The time to expire the record at
+  def expire_at(time)
+    conn.expireat key, time.to_i
+  end
+
+  # Expires the record
+  # @param [Integer] seconds Expire in `seconds` from now
+  def expire_in(seconds)
+    conn.expire key, seconds.to_i
+  end
+
+  # @abstract, override in subclasses
+  def value
+    nil
+  end
+
+  private
+
+    def range_pair(range)
+      first = range.first.to_i
+      last  = range.last.to_i
+      last -= 1 if range.exclude_end?
+      [first, last]
+    end
+
+end

data/lib/redpear/store/counter.rb

@@ -0,0 +1,44 @@
+class Redpear::Store::Counter < Redpear::Store::Value
+
+  # @return [Integer] the value
+  def get
+    super.to_i
+  end
+
+  # Sets the value
+  # @param [Integer] the value to set
+  def set(value)
+    super Kernel::Integer(value)
+  end
+
+  undef_method :append
+  undef_method :<<
+
+  # Increments the value
+  # @param [Integer] by
+  #   The increment, defaults to 1
+  def increment(by = 1)
+    case by
+    when 1
+      conn.incr(key)
+    else
+      conn.incrby(key, by)
+    end
+  end
+  alias_method :next, :increment
+
+  # Decrements the value
+  # @param [Integer] by
+  #   The decrement, defaults to 1
+  def decrement(by = 1)
+    case by
+    when 1
+      conn.decr(key)
+    else
+      conn.decrby(key, by)
+    end
+  end
+  alias_method :previous, :decrement
+  alias_method :prev, :decrement
+
+end

data/lib/redpear/store/enumerable.rb

@@ -0,0 +1,8 @@
+class Redpear::Store::Enumerable < Redpear::Store::Base
+  include ::Enumerable
+
+  # Returns the array as the record's value
+  # @see Redpear::Store::Base#value
+  alias_method :value, :to_a
+
+end

data/lib/redpear/store/hash.rb

@@ -0,0 +1,120 @@
+class Redpear::Store::Hash < Redpear::Store::Enumerable
+
+  # @yield over a field-value pair
+  # @yieldparam [String] field
+  # @yieldparam [String] value
+  def each(&block)
+    all.each(&block)
+  end
+
+  # @return [Hash] all pairs
+  def all
+    conn.hgetall(key) || {}
+  end
+  alias_method :to_hash, :all
+  alias_method :value, :all
+
+  # @param [String] field
+  #   The field to delete
+  def delete(field)
+    conn.hdel key, field
+  end
+
+  # @return [Boolean] true, if field exists
+  def key?(field)
+    !!conn.hexists(key, field)
+  end
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+  alias_method :include?, :key?
+
+  # @return [Boolean] true, if empty
+  def empty?
+    length.zero?
+  end
+
+  # @param [String] field
+  #   The field to fetch
+  # @return [String] value stored in +field+
+  def fetch(field)
+    conn.hget key, field
+  end
+  alias_method :[], :fetch
+
+  # @param [String] field
+  #   The field to store at
+  # @param [String] value
+  #   The value to store
+  # @param [Hash] options
+  #   The value to store
+  def store(field, value, options = {})
+    if value.nil?
+      delete field
+    else
+      conn.hset key, field, value
+    end
+  end
+  alias_method :[]=, :store
+
+  # @return [Array] all keys
+  def keys
+    conn.hkeys key
+  end
+
+  # @return [Array] all values
+  def values
+    conn.hvals key
+  end
+
+  # @return [Intege] the number of pairs in the hash
+  def length
+    conn.hlen key
+  end
+  alias_method :size, :length
+
+  # @param [String] field
+  #   The field to increment
+  # @param [Integer] value
+  #   The increment value, defaults to 1
+  def increment(field, value = 1)
+    conn.hincrby key, field, value
+  end
+
+  # @param [String] field
+  #   The field to decrement
+  # @param [Integer] value
+  #   The decrement value, defaults to 1
+  def decrement(field, value = 1)
+    increment(field, -value)
+  end
+
+  # @param [multiple] fields
+  #   The field to return
+  # @return [Array] values
+  def values_at(*fields)
+    conn.hmget key, *fields
+  end
+
+  # @param [Hash] hash
+  #   The pairs to update
+  def update(hash)
+    merge!(hash)
+    to_hash
+  end
+
+  # @param [Hash] hash
+  #   The pairs to merge
+  def merge!(hash)
+    hash = hash.reject do |field, value|
+      delete(field) if value.nil?
+    end
+    conn.hmset key, *hash.flatten
+  end
+
+  # Comparator
+  # @return [Boolean] true if same as `other`
+  def ==(other)
+    other.respond_to?(:to_hash) && other.to_hash == to_hash
+  end
+
+end

data/lib/redpear/store/list.rb

@@ -0,0 +1,144 @@
+class Redpear::Store::List < Redpear::Store::Enumerable
+
+  # @yield over each item in the list
+  # @yieldparam [String] item
+  def each(&block)
+    all.each(&block)
+  end
+
+  # @return [Array] all items
+  def all
+    slice(0..-1)
+  end
+  alias_method :to_a, :all
+
+  # Returns a slice of the list
+  # @overload slice(index)
+  #   Returns the item at `index`
+  #   @param [Integer] index
+  #   @return [String] item
+  # @overload slice(start, length)
+  #   Returns from `length` items from `start`
+  #   @param [Integer] start
+  #   @param [Integer] length
+  #   @return [Array] items
+  # @overload slice(range)
+  #   Returns items from range
+  #   @param [Range] range
+  #   @return [Array] items
+  def slice(start, length = nil)
+    case start
+    when Integer
+      if length
+        range(start, start + length - 1)
+      else
+        conn.lindex(key, start) rescue nil
+      end
+    when Range
+      range *range_pair(start)
+    else
+      []
+    end
+  end
+  alias_method :[], :slice
+
+  # Destructive slice. Returns specified range and removes other items.
+  # @overload slice(start, length)
+  def slice!(start, length = nil)
+    case start
+    when Range
+      trim *range_pair(start)
+    else
+      trim(start, start + length - 1)
+    end
+    to_a
+  end
+
+  # @param [Integer] start
+  # @param [Integer] finish
+  # @return [Array] items
+  def range(start, finish)
+    conn.lrange(key, start, finish) || []
+  end
+
+  # @param [Integer] start
+  # @param [Integer] finish
+  def trim(start, finish)
+    conn.ltrim(key, start, finish)
+  end
+
+  # @return [Integer] the number of items in the set
+  def length
+    conn.llen key
+  end
+  alias_method :size, :length
+
+  # Appends a single item. Chainable example:
+  #   list << 'a' << 'b'
+  # @param [String] item
+  #   A item to add
+  def push(item)
+    conn.rpush key, item
+    self
+  end
+  alias_method :<<, :push
+
+  # Removes the last item
+  # @return [String] the removed item
+  def pop
+    conn.rpop key
+  end
+
+  # Prepends a single item.
+  # @param [String] item
+  #   A item to add
+  def unshift(item)
+    conn.lpush key, item
+    self
+  end
+
+  # Removes the first item
+  # @return [String] the removed item
+  def shift
+    conn.lpop key
+  end
+
+  # Removes the last item and prepends it to `target`
+  # @param [Redpear::Store::List] target
+  def pop_unshift(target)
+    conn.rpoplpush key, target.to_s
+  end
+
+  # Comparator
+  # @param [#to_a] other
+  # @return [Boolean] true if items match
+  def ==(other)
+    other.respond_to?(:to_a) && other.to_a == to_a
+  end
+
+  # Remove `item` from list
+  # @param [String] item
+  # @param [Integer] count
+  #   The number of items to remove.
+  #   When =0 - remove all occurences
+  #   When >0 - remove the first `count` items
+  #   When <0 - remove the last `count` items
+  def delete(item, count = 0)
+    conn.lrem key, count, item
+  end
+
+  # Insert `item` before `pivot`
+  # @param [String] pivot
+  # @param [String] item
+  def insert_before(pivot, item)
+    conn.linsert key, :before, pivot, item
+  end
+
+  # Insert `item` after `pivot`
+  # @param [String] pivot
+  # @param [String] item
+  def insert_after(pivot, item)
+    conn.linsert key, :after, pivot, item
+  end
+
+end

data/lib/redpear/store/lock.rb

@@ -0,0 +1,108 @@
+class Redpear::Store::Lock < Redpear::Store::Base
+  class LockTimeout < ::StandardError; end
+
+  class << self
+
+    # Default lock options. Override via e.g.:
+    #
+    #   Redpear::Store::Lock.default_options[:lock_timeout] = 5
+    #
+    # @return [Hash] default options
+    def default_options
+      @default_options ||= { :lock_timeout => 2, :wait_timeout => 2 }
+    end
+
+  end
+
+  # @return [Float] the current lock timestamp
+  def current
+    value.to_f
+  end
+
+  # @return [String] the current lock value
+  def value
+    conn.get key
+  end
+
+  # Creates a lock and yields a transaction. Example:
+  #
+  #   sender    = Redpear::Store::Hash.new "accounts:sender", connection
+  #   recipient = Redpear::Store::Hash.new "accounts:recipient", connection
+  #   lock      = Redpear::Store::Lock.new "locks:transfer", connection
+  #
+  #   lock.lock do
+  #     sender.decrement 'balance', 100
+  #     recipient.increment 'balance', 100
+  #   end
+  #
+  # @param [Hash] options
+  # @option [Integer] lock_timeout
+  #   Hold the lock for a maximum of `lock_timeout` seconds. Defaults to 2.
+  # @option [Integer] wait_timeout
+  #   Wait for `wait_timeout` seconds to obtain a lock, before timing out. Defaults to 2.
+  # @yield [] processes the block within the lock
+  def lock(options = {})
+    options   = self.class.default_options.merge(options)
+    result    = nil
+    timestamp = nil
+    timeout   = to_time(options[:wait_timeout])
+
+    while !timestamp && timeout > Time.now
+      timestamp = to_time(options[:lock_timeout]).to_f
+
+      if lock_obtained?(timestamp) || expired_lock_obtained?(timestamp)
+        result = yield
+      else
+        timestamp = nil # Unset
+        sleep 0.1
+      end
+    end
+
+    unless timestamp
+      raise LockTimeout, "Could not acquire lock on '#{key}'. Timed out."
+    end
+
+    result
+  ensure
+    purge! if timestamp && timestamp > Time.now.to_f
+  end
+
+  protected
+
+    # @param [Float] timestamp
+    #   The timestamp to set for the lock
+    # @return [Boolean]
+    #   True, if timestamp could be set and the lock was obtained
+    def lock_obtained?(timestamp)
+      conn.setnx key, timestamp
+    end
+
+    # @param [Float] timestamp
+    #   The timestamp to set for the lock
+    # @return [Boolean]
+    #   True, if key is set to an expired value and we can replace it
+    #   with our `timestamp`
+    def expired_lock_obtained?(timestamp)
+      exists? && past?(value) && past?(conn.getset(key, timestamp))
+    end
+
+    # @return [Boolean] true, if timestamp has expired and is in the past
+    def past?(timestamp)
+      timestamp = timestamp.to_f if timestamp.is_a?(String)
+      timestamp < Time.now.to_f
+    end
+
+  private
+
+    def to_time(value)
+      case value
+      when Time
+        value
+      when Numeric
+        Time.now + value
+      else
+        Time.now + 5
+      end
+    end
+
+end