redpear 0.6.4 → 0.7.0

data/lib/redpear/store/set.rb

@@ -0,0 +1,147 @@
+class Redpear::Store::Set < Redpear::Store::Enumerable
+  include Enumerable
+
+  # @yield over a field-value pair
+  # @yieldparam [String] field
+  # @yieldparam [String] value
+  def each(&block)
+    members.each(&block)
+  end
+
+  # @return [Set] all members
+  def all
+    members.to_set
+  end
+  alias_method :to_set, :all
+  alias_method :value, :all
+
+  # @return [Array] the array of members
+  def members
+    conn.smembers(key) || []
+  end
+  alias_method :to_a, :members
+
+  # @return [Integer] the number of items in the set
+  def length
+    conn.scard key
+  end
+  alias_method :size, :length
+
+  # Adds a single value. Chainable example:
+  #   set << 'a' << 'b'
+  # @param [String] value
+  #   A value to add
+  def add(value)
+    conn.sadd key, value
+    self
+  end
+  alias_method :<<, :add
+
+  # @param [String] value
+  #   A value to delete
+  def delete(value)
+    conn.srem key, value
+  end
+  alias_method :remove, :delete
+
+  # @return [Boolean] true, if value is included
+  def include?(value)
+    !!conn.sismember(key, value)
+  end
+  alias_method :member?, :include?
+
+  # @return [Boolean] true, if empty
+  def empty?
+    length.zero?
+  end
+
+  # Removes a random value
+  # @return [String] the removed value
+  def pop
+    conn.spop key
+  end
+
+  # Subtracts values using other sets
+  # @param [multiple] others
+  #   The other sets
+  # @return [Array] remaining values
+  def diff(*others)
+    conn.sdiff key, *others.map(&:to_s)
+  end
+  alias_method :-, :diff
+
+  # Store the result of a diff in a new +target+ key
+  # @param [String] target
+  #   The target key
+  # @param [multiple] others
+  #   The other sets
+  # @return [Redpear::Store::Set] the result set
+  def diffstore(target, *others)
+    conn.sdiffstore target.to_s, key, *others.map(&:to_s)
+    self.class.new target.to_s, conn
+  end
+
+  # Merges values of two sets
+  # @param [multiple] others
+  #   The other sets
+  # @return [Array] union
+  def union(*others)
+    conn.sunion key, *others.map(&:to_s)
+  end
+  alias_method :+, :union
+  alias_method :|, :union
+  alias_method :merge, :union
+
+  # Store the result of a union in a new +target+ key
+  # @param [Redpear::Store::Set] other
+  #   The other set
+  # @param [multiple] others
+  #   The other sets
+  # @return [Redpear::Store::Set] the result set
+  def unionstore(target, *others)
+    conn.sunionstore target.to_s, key, *others.map(&:to_s)
+    self.class.new target.to_s, conn
+  end
+
+  # @param [multiple] other
+  #   The other sets
+  # @return [Array] the intersection +other+ set
+  def inter(*others)
+    conn.sinter key, *others.map(&:to_s)
+  end
+  alias_method :intersect, :inter
+  alias_method :inter, :inter
+  alias_method :&, :inter
+
+  # Store the result of an intersection in a new +target+ key
+  # @param [String] target
+  #   The target key
+  # @param [multiple] others
+  #   The other sets
+  # @return [Redpear::Store::Set] the result set
+  def interstore(target, *others)
+    conn.sinterstore target.to_s, key, *others.map(&:to_s)
+    self.class.new target.to_s, conn
+  end
+
+  # @return [String] a random member
+  def random
+    conn.srandmember key
+  end
+
+  # Comparator
+  # @return [Boolean] true if contains same members as other
+  def ==(other)
+    other.respond_to?(:to_set) && other.to_set == to_set
+  end
+
+  # Move a value to +target+ set
+  # @param [String] target
+  #   The key of the target set
+  # @param [String] value
+  #   The value to move
+  def move(target, value)
+    conn.smove key, target.to_s, value
+  end
+
+end

data/lib/redpear/store/sorted_set.rb

@@ -0,0 +1,239 @@
+class Redpear::Store::SortedSet < Redpear::Store::Enumerable
+  include Enumerable
+
+  # @yield over a field-score pair
+  # @yieldparam [String] field
+  # @yieldparam [String] score
+  def each(&block)
+    all.each(&block)
+  end
+
+  # @param [Hash] options
+  # @option [Boolean] with_scores
+  #   Return with scores, defaults to true
+  # @return [Array] all elements
+  def all(options = {})
+    slice(0..-1, options)
+  end
+  alias_method :to_a, :all
+
+  # @return [Integer] the number of items in the set
+  def length
+    conn.zcard key
+  end
+  alias_method :size, :length
+
+  # @param [Range] range
+  # @return [Integer] the number of items within given score `range`
+  def count(range)
+    conn.zcount key, *range_pair(range)
+  end
+
+  # Adds a single member.
+  # @param [String] member
+  #   A member to add
+  # @param [Integer] score
+  #   The score
+  def add(member, score)
+    conn.zadd key, score, member
+    self
+  end
+  alias_method :[]=, :add
+
+  # Determines the score of a member
+  # @param [String] member
+  # @return [Integer] the score for the given `member`
+  def score(member)
+    number = conn.zscore(key, member)
+    number.to_f if number
+  end
+  alias_method :[], :score
+
+  # Determines the index of a member (based on ascending scores)
+  # @param [String] member
+  # @return [Integer] the index for the given `member`
+  def index(member)
+    number = conn.zrank(key, member)
+    number.to_i if number
+  end
+  alias_method :rank, :index
+
+  # Determines the reverse index of a member (based on descending scores)
+  # @param [String] member
+  # @return [Integer] the index for the given `member`
+  def rindex(member)
+    number = conn.zrevrank(key, member)
+    number.to_i if number
+  end
+  alias_method :rrank, :rindex
+
+  # @param [String] member
+  #   The `member` to delete
+  def delete(member)
+    conn.zrem key, member
+  end
+
+  # @return [Boolean] true, if member is included
+  def include?(member)
+    !!conn.zscore(key, member)
+  end
+  alias_method :member?, :include?
+
+  # @return [Boolean] true, if empty
+  def empty?
+    length.zero?
+  end
+
+  # Returns a slice of members between index +range+, with the lower index returned first
+  # @param [Range] range
+  #   The index range of the elements
+  # @param [Hash] options
+  # @option [Boolean] with_scores
+  #   Return with scores, defaults to true
+  # @return [Array] the members
+  def slice(range, options = {})
+    start, finish = range_pair(range)
+    fetch_range :zrange, start, finish, options
+  end
+  alias_method :top, :slice
+
+  # Returns a slice of members between rindex +range+, with the higher index returned first
+  # @param [Range] range
+  #   The rindex range of the elements
+  # @param [Hash] options
+  # @option [Boolean] with_scores
+  #   Return with scores, defaults to true
+  # @return [Array] the members
+  def rslice(range, options = {})
+    start, finish = range_pair(range)
+    fetch_range :zrevrange, start, finish, options
+  end
+  alias_method :bottom, :rslice
+
+  # Selects members between a score +range+. Lower scores returned first
+  # @param [Range] range
+  #   The score range of the elements
+  # @param [Hash] options
+  # @option [Boolean] with_scores
+  #   Return with scores, defaults to true
+  # @option [Integer] limit
+  #   Limit the results
+  # @return [Array] the members
+  def select(range, options = {})
+    start, finish = range_pair(range)
+    fetch_range :zrangebyscore, start, finish, options
+  end
+
+  # Selects members between a score +range+. Higher scores returned first
+  # @param [Range] range
+  #   The score range of the elements
+  # @param [Hash] options
+  # @option [Boolean] with_scores
+  #   Return with scores, defaults to true
+  # @option [Integer] limit
+  #   Limit the results
+  # @return [Array] the members
+  def rselect(range, options = {})
+    start, finish = range_pair(range)
+    fetch_range :zrevrangebyscore, finish, start, options
+  end
+
+  # Comparator
+  # @return [Boolean] true if contains same members as other
+  def ==(other)
+    other.respond_to?(:to_a) && other.to_a == to_a
+  end
+
+  # @param [Integer] index
+  # @param [Hash] options
+  # @option [Boolean] with_scores
+  #   Return with scores, defaults to true
+  # @return [Array] member + score for given `index`.
+  def at(index, options = {})
+    slice(index..index, options).first
+  end
+
+  # @return [String] member with the lowest index
+  def first(count = 0)
+    if count > 0
+      slice(0..(count-1), :with_scores => false)
+    else
+      at(0, :with_scores => false)
+    end
+  end
+
+  # @return [String] member with the highest index
+  def last(count = 0)
+    if count > 0
+      slice(-count..-1, :with_scores => false)
+    else
+      at(-1, :with_scores => false)
+    end
+  end
+
+  # @return [Float] the lowest score
+  def minimum
+    _, score = at(0); score
+  end
+
+  # @return [Float] the higest score
+  def maximum
+    _, score = at(-1); score
+  end
+
+  # Store the result of a union in a new +target+ key
+  # @param [Redpear::Store::Set] other
+  #   The other set
+  # @param [multiple] others
+  #   The other sets
+  # @param [Hash] options
+  # @option [Array] weights
+  # @option [Symbol] aggregate
+  # @return [Redpear::Store::Set] the result set
+  def unionstore(target, *others)
+    opts = others.last.is_a?(Hash) ? others.pop : {}
+    conn.zunionstore target.to_s, [key] + others.map(&:to_s), opts
+    self.class.new target.to_s, conn
+  end
+
+  # Store the result of an intersection in a new +target+ key
+  # @param [String] target
+  #   The target key
+  # @param [multiple] others
+  #   The other sets
+  # @param [Hash] options
+  # @option [Array] weights
+  # @option [Symbol] aggregate
+  # @return [Redpear::Store::SortedSet] the result set
+  def interstore(target, *others)
+    opts = others.last.is_a?(Hash) ? others.pop : {}
+    conn.zinterstore target.to_s, [key] + others.map(&:to_s), opts
+    self.class.new target.to_s, conn
+  end
+
+  # @param [String] member
+  #   The member to increment
+  # @param [Integer] by
+  #   The increment, defaults to 1
+  def increment(member, by = 1)
+    conn.zincrby(key, by, member).to_f
+  end
+
+  # @param [String] member
+  #   The member to decrement
+  # @param [Integer] by
+  #   The decrement, defaults to 1
+  def decrement(member, by = 1)
+    increment member, -by
+  end
+
+  private
+
+    def fetch_range(method, start, finish, options = {})
+      options[:limit]       = [options[:offset] || 0, options[:limit]] if options[:offset] || options[:limit]
+      options[:with_scores] = true unless options.key?(:with_scores)
+      result = conn.send method, key, start, finish, options
+      options[:with_scores] ? result.each_slice(2).map {|m,s| [m, s.to_f] } : result
+    end
+
+end

data/lib/redpear/store/value.rb

@@ -0,0 +1,66 @@
+class Redpear::Store::Value < Redpear::Store::Base
+
+  # Deletes the value
+  # @see Redpear::Store::Base#purge!
+  alias_method :delete, :purge!
+
+  # @return [String] the value
+  def get
+    conn.get(key)
+  end
+
+  # @see #get
+  def value
+    get
+  end
+
+  # Sets the value
+  # @param [String] the value to set
+  def set(value)
+    conn.set(key, value)
+  end
+
+  # @see #set
+  def value=(*a)
+    set(*a)
+  end
+
+  # @see #set
+  def replace(*a)
+    set(*a)
+  end
+
+  # Appends a `value`
+  # @param [Integer] value
+  #   The value to append
+  def append(value)
+    conn.append(key, value)
+    self
+  end
+  alias_method :<<, :append
+
+  # Comparator
+  # @param [String] other
+  # @return [Boolean] true, if equals `other`
+  def ==(other)
+    value == other
+  end
+
+  # @return [Boolean] true, if value is nil
+  def nil?
+    value.nil?
+  end
+
+  # @return [Boolean] true, if responds to `method`
+  def respond_to?(method, *a)
+    super || (value || "").respond_to?(method, *a)
+  end
+
+  protected
+
+    def method_missing(method, *a, &b)
+      base = (value || "")
+      base.respond_to?(method) ? base.send(method, *a, &b) : super
+    end
+
+end

data/lib/redpear/store.rb

@@ -0,0 +1,11 @@
+module Redpear::Store
+  autoload :Base, 'redpear/store/base'
+  autoload :Counter, 'redpear/store/counter'
+  autoload :Enumerable, 'redpear/store/enumerable'
+  autoload :Hash, 'redpear/store/hash'
+  autoload :List,  'redpear/store/list'
+  autoload :Lock,  'redpear/store/lock'
+  autoload :Set,  'redpear/store/set'
+  autoload :SortedSet,  'redpear/store/sorted_set'
+  autoload :Value,  'redpear/store/value'
+end

data/lib/redpear.rb

@@ -1,27 +1,12 @@
 require "redis"
 require "date"
+require "set"
+require "securerandom"
 
 module Redpear
-
-  def self.autoload(const, path = nil)
-    path ||= "redpear/#{const.to_s.downcase}"
-    super const, path
-  end
-
-  autoload :Column
-  autoload :Concern
-  autoload :Connection
-  autoload :Counters
-  autoload :Expiration
-  autoload :Finders
-  autoload :Index
-  autoload :Members
-  autoload :Model
-  autoload :Namespace
-  autoload :Nest
-  autoload :Persistence
-  autoload :Schema
-  autoload :ZIndex
-  autoload :ZMembers
-
+  autoload :Concern,    "redpear/concern"
+  autoload :Connection, "redpear/connection"
+  autoload :Model,      "redpear/model"
+  autoload :Schema,     "redpear/schema"
+  autoload :Store,      "redpear/store"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redpear
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-06 00:00:00.000000000Z
+date: 2012-01-31 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &27432700 !ruby/object:Gem::Requirement
+  requirement: &22040360 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *27432700
+  version_requirements: *22040360
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &27432320 !ruby/object:Gem::Requirement
+  requirement: &22039760 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27432320
+  version_requirements: *22039760
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &27431860 !ruby/object:Gem::Requirement
+  requirement: &22038240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27431860
+  version_requirements: *22038240
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &27461340 !ruby/object:Gem::Requirement
+  requirement: &22036720 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27461340
+  version_requirements: *22036720
 - !ruby/object:Gem::Dependency
-  name: fakeredis
-  requirement: &27460920 !ruby/object:Gem::Requirement
+  name: shoulda-matchers
+  requirement: &22035080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27460920
+  version_requirements: *22035080
 - !ruby/object:Gem::Dependency
-  name: shoulda-matchers
-  requirement: &27460500 !ruby/object:Gem::Requirement
+  name: machinist
+  requirement: &22033100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *22033100
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: &22032660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,7 +87,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *27460500
+  version_requirements: *22032660
 description: Simple, elegant & efficient ORM for Redis
 email: dimitrij@blacksquaremedia.com
 executables: []
@@ -85,23 +96,27 @@ extra_rdoc_files: []
 files:
 - lib/redpear.rb
 - lib/redpear/connection.rb
+- lib/redpear/schema/column.rb
+- lib/redpear/schema/index.rb
 - lib/redpear/schema/collection.rb
-- lib/redpear/core_ext/stringify_keys.rb
+- lib/redpear/schema/score.rb
 - lib/redpear/concern.rb
-- lib/redpear/zmembers.rb
-- lib/redpear/namespace.rb
-- lib/redpear/nest.rb
-- lib/redpear/finders.rb
-- lib/redpear/zindex.rb
-- lib/redpear/persistence.rb
-- lib/redpear/expiration.rb
-- lib/redpear/column.rb
+- lib/redpear/store.rb
+- lib/redpear/model/factory_girl.rb
+- lib/redpear/model/finders.rb
+- lib/redpear/model/expiration.rb
+- lib/redpear/model/machinist.rb
+- lib/redpear/store/lock.rb
+- lib/redpear/store/enumerable.rb
+- lib/redpear/store/counter.rb
+- lib/redpear/store/hash.rb
+- lib/redpear/store/base.rb
+- lib/redpear/store/value.rb
+- lib/redpear/store/list.rb
+- lib/redpear/store/set.rb
+- lib/redpear/store/sorted_set.rb
 - lib/redpear/model.rb
-- lib/redpear/index.rb
-- lib/redpear/members.rb
 - lib/redpear/schema.rb
-- lib/redpear/counters.rb
-- lib/redpear/machinist.rb
 homepage: https://github.com/bsm/redpear
 licenses: []
 post_install_message: 
@@ -113,7 +128,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/redpear/core_ext/stringify_keys.rb

@@ -1,17 +0,0 @@
-# Hash stringify_keys extension. "Borrowed" from ActiveSupport.
-class Hash
-
-  # Return a new hash with all keys converted to strings.
-  def stringify_keys
-    dup.stringify_keys!
-  end
-
-  # Destructively convert all keys to strings.
-  def stringify_keys!
-    keys.each do |key|
-      self[key.to_s] = delete(key) unless key.is_a?(String)
-    end
-    self
-  end
-
-end unless Hash.new.respond_to?(:symbolize_keys)

data/lib/redpear/counters.rb

@@ -1,26 +0,0 @@
-module Redpear::Counters
-
-  # Increments the value of a counter attribute
-  # @param [String|Symbol] column
-  #   The column name to increment
-  # @param [Integer] by
-  #   Increment by this value
-  def increment!(column, by = 1)
-    return false unless persisted?
-
-    col = self.class.columns[column]
-    return false unless col && col.type == :counter
-
-    self[col.name] = nest.hincrby(col.name, by).to_i
-  end
-
-  # Decrements the value of a counter attribute
-  # @param [String|Symbol] column
-  #   The column name to decrement
-  # @param [Integer] by
-  #   Decrement by this value
-  def decrement!(column, by = 1)
-    increment!(column, -by)
-  end
-
-end