redpear 0.6.4 → 0.7.0

data/lib/redpear/connection.rb

@@ -1,28 +1,121 @@
-module Redpear::Connection
-  extend Redpear::Concern
+# == Redpear::Connection
+#
+# Abstract connection class, with support for master/slave sharding.
+# @see Redpear::Connection#initialize for examples
+#
+class Redpear::Connection
 
-  module ClassMethods
+  MASTER_METHODS = %w|
+    append auth
+    bgrewriteaof bgsave blpop brpop brpoplpush
+    config
+    decr decrby del discard
+    exec expire expireat
+    flushall flushdb getset
+    hset hsetnx hincrby hmset hdel
+    incr incrby
+    linsert lpop lpush lpushx lrem lset ltrim
+    mapped_hmset mapped_mset mapped_msetnx
+    move mset msetnx multi
+    persist pipelined psubscribe punsubscribe quit
+    rename renamenx rpop rpoplpush rpush rpushx
+    sadd save sdiffstore set setbit
+    setex setnx setrange sinterstore
+    shutdown smove spop srem subscribe
+    sunionstore sync synchronize
+    unsubscribe unwatch watch
+    zadd zincrby zinterstore zrem
+    zremrangebyrank zremrangebyscore zunionstore
+  |.freeze
 
-    # @return [Redis] the current master connection
-    def master_connection
-      @master_connection ||= (superclass.respond_to?(:master_connection) ? superclass.master_connection : Redis.current)
+  SLAVE_METHODS = %w|
+    dbsize debug get getbit getrange
+    echo exists
+    hget hmget hexists hlen hkeys hvals hgetall
+    info keys lastsave lindex llen lrange
+    mapped_hmget mapped_mget mget monitor
+    object ping publish randomkey
+    scard sdiff select sinter sismember slaveof
+    smembers sort srandmember strlen substr sunion
+    ttl type
+    zcard zcount zrange zrangebyscore zrank
+    zrevrange zrevrangebyscore zrevrank zscore
+  |.freeze
+
+  # @return [Symbol] ther current connection, either :master or :slave
+  attr_reader   :current
+  attr_accessor :master, :slave
+
+  # Constructor, accepts a master connection and an optional slave connection.
+  # Connections can be instances of Redis::Client, URL strings, or e.g.
+  # ConnectionPool objects. Examples:
+  #
+  #   # Use current redis client as master and slave
+  #   Redpear::Connection.new Redis.current
+  #
+  #   # Use current redis client as slave and a remote URL as master
+  #   Redpear::Connection.new "redis://master.host:6379", Redis.current
+  #
+  #   # Use a connection pool - https://github.com/mperham/connection_pool
+  #   slave_pool = ConnectionPool.new(:size => 5, :timeout => 5) { Redis.connect("redis://slave.host:6379") }
+  #   Redpear::Connection.new "redis://master.host:6379", slave_pool
+  #
+  # @param [Redis::Client|String|ConnectionPool] master
+  #   The master connection, defaults to `Redis.current`
+  # @param [Redis::Client|String|ConnectionPool] slave
+  #   The (optional) slave connection, defaults to master
+  def initialize(master = Redis.current, slave = nil)
+    @master = _connect(master)
+    @slave  = _connect(slave || master)
+    @transaction = nil
+  end
+
+  # @param [Symbol] name
+  #   Either :master or :slave
+  # @yield
+  #   Perform a block with the given connection
+  def on(name)
+    @current = send(name)
+    yield
+  ensure
+    @current = nil
+  end
+
+  # Run a transaction, prevents accidental transaction nesting
+  def transaction(&block)
+    if @transaction
+      yield
+    else
+      begin
+        @transaction = true
+        multi(&block)
+      ensure
+        @transaction = nil
+      end
     end
-    alias_method :connection, :master_connection
+  end
 
-    # @param [Redis] the master connection to assign
-    def master_connection=(value)
-      @master_connection = value
+  MASTER_METHODS.each do |meth|
+    define_method(meth) do |*a, &b|
+      (current || master).send(meth, *a, &b)
     end
+  end
 
-    # @return [Redis] the current slave connection
-    def slave_connection
-      @slave_connection
+  SLAVE_METHODS.each do |meth|
+    define_method(meth) do |*a, &b|
+      (current || slave).send(meth, *a, &b)
     end
+  end
 
-    # @param [Redis] the slave connection to assign
-    def slave_connection=(value)
-      @slave_connection = value
+  private
+
+    def _connect(conn)
+      case conn
+      when String
+        Redis.connect(:url => conn)
+      else
+        conn
+      end
     end
 
-  end
 end

data/lib/redpear/model/expiration.rb

@@ -0,0 +1,18 @@
+module Redpear::Model::Expiration
+
+  # Expires the record.
+  # @overload expire(time)
+  #   @param [Time] time The time to expire the record at
+  # @overload expire(number)
+  #   @param [Integer] number Expire in `number` of seconds from now
+  def expire(value)
+    attributes.expire(value)
+  end
+
+  # @return [Integer] the period this record has to live.
+  # May return nil for non-expiring records and non-existing records.
+  def ttl
+    attributes.ttl
+  end
+
+end

data/lib/redpear/model/factory_girl.rb

@@ -0,0 +1,27 @@
+require 'factory_girl'
+require 'redpear/model'
+
+class Redpear::Model
+
+  # FactoryGirl module for your tests/specs. Example:
+  #
+  #   require 'redpear/model/factory_girl'
+  #
+  #   FactoryGirl.define do
+  #     factory :post do
+  #       title      { "A Title" }
+  #       created_at { Time.at(1313131313) }
+  #     end
+  #   end
+  #
+  module FactoryGirl
+
+    # @return [Boolean] always true. FactoryGirl requires it.
+    def save!
+      true
+    end
+
+  end
+  include FactoryGirl
+
+end

data/lib/redpear/model/finders.rb

@@ -0,0 +1,37 @@
+module Redpear::Model::Finders
+  extend Redpear::Concern
+
+  module ClassMethods
+
+    # @return [Integer] the number of total records
+    def count
+      members.size
+    end
+
+    # @param [String] id the ID to check
+    # @return [Boolean] true or false
+    def exists?(id)
+      !id.nil? && members.include?(id)
+    end
+
+    # @param [String] id the ID of the record to find
+    # @return [Redpear::Model] a record, or nil when not found
+    def find(id)
+      instantiate(id) if exists?(id)
+    end
+
+    # @return [Array<Redpear::Model>] all records
+    def all
+      members.map &method(:find)
+    end
+
+    # @yield over each available record
+    # @yieldparam [Redpear::Model] record
+    def find_each
+      members.each do |id|
+        yield find(id)
+      end
+    end
+
+  end
+end

data/lib/redpear/model/machinist.rb

@@ -0,0 +1,54 @@
+require 'machinist'
+require 'redpear/model'
+
+class Redpear::Model
+  extend ::Machinist::Machinable
+
+  # Used internally by Machinist
+  # @return [Class] the blueprint class
+  def self.blueprint_class
+    self::Machinist::Blueprint
+  end
+
+  # Machinist module for your tests/specs. Example:
+  #
+  #   # spec/support/blueprints.rb
+  #   require "redpear/model/machinist"
+  #
+  #   Post.blueprint do
+  #     title      { "A Title" }
+  #     created_at { 2.days.ago }
+  #   end
+  #
+  module Machinist
+
+    class Blueprint < ::Machinist::Blueprint
+
+      def make!(attributes = {})
+        make(attributes)
+      end
+
+      def lathe_class #:nodoc:
+        Lathe
+      end
+
+    end
+
+    class Lathe < ::Machinist::Lathe
+      protected
+
+      def make_one_value(attribute, args)
+        return unless block_given?
+        raise_argument_error(attribute) unless args.empty?
+        yield
+      end
+
+      def assign_attribute(key, value) #:nodoc:
+        @assigned_attributes[key.to_sym] = value
+        @object[key] = value
+      end
+
+    end
+
+  end
+end

data/lib/redpear/model.rb

@@ -1,10 +1,9 @@
-require "set"
-require "redpear/core_ext/stringify_keys"
+require 'redpear'
 
 =begin
 Redis is a simple key/value store, hence storing structured data can be a
-challenge. Redpear allows you to store/find/associate "records" in a Redis DB
-very efficiently, minimising IO operations and storage space where possible.
+challenge. Redpear::Model allows you to store/find/associate "records" in a Redis
+DB very efficiently, minimising IO operations and storage space where possible.
 
 For example:
 
@@ -18,53 +17,100 @@ For example:
     index :post_id
   end
 
-Let's create a post and a comment:
-
-  post = Post.save :title => "Hi!", :body => "I'm a new post"
-  comment = Comment.save :post_id => post.id, :body => "I like this!"
-
-Redpear is VERY lightweight. Compared with other ORMs, it offers raw speed at
-the expense of convenience.
+Redpear::Model is VERY lightweight. It is optimised for raw speed at the
+expense of convenience.
 =end
 class Redpear::Model < Hash
-  include Redpear::Connection
-  include Redpear::Namespace
-  include Redpear::Persistence
-  include Redpear::Expiration
-  include Redpear::Counters
+  autoload :Finders, 'redpear/model/finders'
+  autoload :Expiration, 'redpear/model/expiration'
+
   include Redpear::Schema
-  include Redpear::Finders
+  include Finders
+  include Expiration
+
+  class << self
+
+    alias_method :create, :new
+
+    # @param [Redpear::Connection] define a custom connection
+    attr_writer :connection
+
+    # @param [String] define a custom scope
+    attr_writer :scope
+
+    # @return [Redpear::Connection] the connection
+    def connection
+      @connection ||= (superclass.respond_to?(:connection) ? superclass.connection : Redpear::Connection.new)
+    end
+
+    # @return [String] the scope of this model. Example:
+    #   Comment.scope # => "comments"
+    def scope
+      @scope ||= "#{name.split('::').last.downcase}s"
+    end
+
+    # @param [multiple] tokens
+    #   The tokens to add to the scope
+    # @return [String] the full scope.
+    # Examples:
+    #   Comment.nested_key(123) # => "comments:123"
+    #   Comment.nested_key("abc", 123) # => "comments:abc:123"
+    def nested_key(*tokens)
+      [scope, *tokens].join(':')
+    end
 
-  # Ensure we can read raw level values
-  alias_method :__fetch__, :[]
+    # @return [Redpear::Store::Set] the IDs of all existing records
+    def members
+      @_members ||= Redpear::Store::Set.new nested_key(:~), connection
+    end
+
+    # @return [Redpear::Store::Counter] the generator of primary keys
+    def pk_counter
+      @_pk_counter ||= Redpear::Store::Counter.new nested_key(:+), connection
+    end
+
+    # Runs a bulk-operation.
+    # @yield operations that should be run in the transaction
+    def transaction(&block)
+      connection.transaction(&block)
+    end
+
+    # Destroys a record. Example:
+    # @param [String] id the ID of the record to destroy
+    # @return [Redpear::Model] the destroyed record
+    def destroy(id)
+      instantiate(id).tap(&:destroy)
+    end
+
+    # Allocate an instance
+    def instantiate(id)
+      instance = allocate
+      instance.send :store, 'id', id.to_s
+      instance
+    end
+    private :instantiate
+
+  end
 
   def initialize(attrs = {})
     super()
-    @__attributes__ = {}
-    @__loaded__     = true
+    store 'id', (attrs.delete("id") || attrs.delete(:id) || self.class.pk_counter.next).to_s
     update(attrs)
+    self.class.members.add(id)
   end
 
-  # Returns the ID of the record
-  # @return [String]
+  # @return [String] the ID of this record
   def id
-    value = __fetch__("id")
-    value.to_s if value
-  end
-
-  # ID accessor
-  # @param [Object] id
-  def id=(value)
-    self["id"] = value.to_s
+    fetch 'id'
   end
 
   # Custom comparator, inspired by ActiveRecord::Base#==
   # @param [Object] other the comparison object
-  # @return [Boolean] true, if +other+ is persisted and ID 
+  # @return [Boolean] true, if +other+ is persisted and ID
   def ==(other)
     case other
     when Redpear::Model
-      other.instance_of?(self.class) && persisted? && other.id == id
+      other.instance_of?(self.class) && other.id == id
     else
       super
     end
@@ -76,57 +122,134 @@ class Redpear::Model < Hash
     id.hash
   end
 
-  # Attribute reader with type-casting
+  # Reads and (caches) a single value
+  # @param [String] name
+  #   The name of the attributes
   # @return [Object]
+  #   The attribute value
   def [](name)
-    __ensure_loaded__
-    name = name.to_s
-    @__attributes__[name] ||= begin
-      column = self.class.columns.lookup[name]
-      value  = super(name)
-      column ? column.type_cast(value) : value
+    return if frozen?
+
+    column = self.class.columns[name]
+    return super if column.nil? || key?(column)
+
+    value = case column
+    when Redpear::Schema::Score
+      column.members[id]
+    when Redpear::Schema::Column
+      attributes[column]
     end
+
+    store column, column.type_cast(value)
   end
 
-  # Attribute writer
+  # Write a single attribute
   # @param [String] name
+  #   The name of the attributes
   # @param [Object] value
+  #   The value to store
   def []=(name, value)
-    __ensure_loaded__
-    name = name.to_s
-    @__attributes__.delete(name)
-    super
+    column = self.class.columns[name] || return
+    delete column.to_s
+    store_attribute attributes, column, value
   end
 
-  # Returns a Hash with attributes
-  # @param [Boolean] clean
-  #   If true, only actual values will be returned (without nils), defaults to false
+  # Increments the value of a counter attribute
+  # @param [String] name
+  #   The column name to increment
+  # @param [Integer] by
+  #   Increment by this value
+  def increment(name, by = 1)
+    column = self.class.columns[name]
+    return false unless column && column.type == :counter
+
+    store column, attributes.increment(column, by)
+  end
+
+  # Decrements the value of a counter attribute
+  # @param [String|Symbol] name
+  #   The column name to decrement
+  # @param [Integer] by
+  #   Decrement by this value
+  def decrement(name, by = 1)
+    increment name, -by
+  end
+
+  # Bulk-updates the model
   # @return [Hash]
-  def to_hash(clean = false)
-    __ensure_loaded__
-    attrs = clean ? reject {|_, v| v.nil? } : self
-    {}.update(attrs)
+  def update(hash)
+    clear
+    self.class.transaction do
+      bulk = {}
+      hash.each do |name, value|
+        column = self.class.columns[name] || next
+        store_attribute bulk, column, value
+      end
+      attributes.merge! bulk
+    end
+    self
+  end
+
+  # Clear all the cached attributes, but keep ID
+  # @return [Hash] self
+  def clear
+    value = self.id
+    super
+  ensure
+    store 'id', value
+  end
+
+  # Returns the attributes store
+  # @return [Redpear::Store::Hash] attributes
+  def attributes
+    @_attributes ||= Redpear::Store::Hash.new self.class.nested_key("", id), self.class.connection
+  end
+
+  # Return lookups, relevant to this record
+  # @return [Array<Redpear::Store::Enumerable>] the lookups this record is related to
+  def lookups
+    @_lookups ||= [self.class.members] + self.class.columns.indicies.map {|i| i.for(self) }
+  end
+
+  # Destroy the record.
+  # @return [Boolean] true if successful
+  def destroy
+    lookups # Build before transaction
+    self.class.transaction do
+      lookups.each {|l| l.delete(id) }
+      attributes.purge!
+    end
+    freeze
   end
 
   # Show information about this record
   # @return [String]
   def inspect
-    __ensure_loaded__
     "#<#{self.class.name} #{super}>"
   end
 
-  # Bulk-update attributes
-  # @param [Hash] attrs
-  def update(attrs)
-    attrs = (attrs ? attrs.stringify_keys : {})
-    attrs["id"] = attrs["id"].to_s if attrs["id"]
-    super
+  # Cache a key/value pair
+  def store(key, value)
+    super key.to_s, value
   end
 
-  private
-
-    def __ensure_loaded__
-      refresh_attributes unless @__loaded__
+  # Store an attribute in target
+  def store_attribute(target, column, value)
+    value = column.encode_value(value)
+
+    case column
+    when Redpear::Schema::Score
+      column.members[id] = value    unless value.nil?
+    when Redpear::Schema::Index
+      column.members(value).add(id) unless value.nil?
+      target[column] = value
+    when Redpear::Schema::Column
+      target[column] = value
     end
 
+    value
+  end
+  protected :store, :store_attribute
+  private   :fetch, :delete, :delete_if, :keep_if, :merge!, :reject!, :select!, :replace
+
 end

data/lib/redpear/schema/collection.rb

@@ -1,7 +1,7 @@
 # Stores the column information
 class Redpear::Schema::Collection < Array
 
-  # @param [multiple] the column definition. Please see Redpear::Column#initialize
+  # @param [multiple] the column definition. Please see Redpear::Schema::Column#initialize
   def store(klass, *args)
     reset!
     klass.new(*args).tap do |col|
@@ -14,16 +14,16 @@ class Redpear::Schema::Collection < Array
     @names ||= lookup.keys
   end
 
-  # @return [Array] the names of the indices only
-  def indices
-    @indices ||= select(&:index?)
-  end
-
   # @return [Hash] the column lookup, indexed by name
   def lookup
     @lookup ||= inject({}) {|r, c| r.update c.to_s => c }
   end
 
+  # @return [Array] only the index columns
+  def indicies
+    @indicies ||= to_a.select {|i| i.is_a?(Redpear::Schema::Index) }
+  end
+
   # @param [String] the column name
   # @return [Boolean] if name is part of the collection
   def include?(name)
@@ -31,7 +31,7 @@ class Redpear::Schema::Collection < Array
   end
 
   # @param [String] the column name
-  # @return [Redpear::Column] the column for the given name
+  # @return [Redpear::Schema::Column] the column for the given name
   def [](name)
     lookup[name.to_s]
   end

data/lib/redpear/{column.rb → schema/column.rb}

@@ -1,4 +1,4 @@
-class Redpear::Column < String
+class Redpear::Schema::Column < String
   attr_reader :type, :model
 
   # Creates a new column.
@@ -35,6 +35,17 @@ class Redpear::Column < String
     end
   end
 
+  # Encodes a value, for storage
+  # @return [Object] the encoded value
+  def encode_value(value)
+    case value
+    when Time
+      value.to_i
+    else
+      value
+    end
+  end
+
   # @return [String] the column name
   def name
     to_s
@@ -50,9 +61,4 @@ class Redpear::Column < String
     true
   end
 
-  # @return [Boolean] true if the column is an index
-  def index?
-    is_a? Redpear::Index
-  end
-
 end

data/lib/redpear/schema/index.rb

@@ -0,0 +1,22 @@
+class Redpear::Schema::Index < Redpear::Schema::Column
+
+  # @param [Redpear::Model] record the owner record
+  # @return [Redpear::Store::Set] the set holding the IDs for `record's` index
+  def for(record)
+    members record.send(name)
+  end
+
+  # @param [String] index value
+  # @return [Redpear::Store::Set] the set holding the IDs for the given `foreign_key`
+  def members(value)
+    value = '_' if value.nil?
+    Redpear::Store::Set.new nested_key(name, value), model.connection
+  end
+
+  private
+
+    def nested_key(*tokens)
+      model.nested_key(:~, *tokens)
+    end
+
+end

data/lib/redpear/schema/score.rb

@@ -0,0 +1,13 @@
+class Redpear::Schema::Score < Redpear::Schema::Index
+
+  # @return [Redpear::Store::Set] the set holding the IDs for `record's` index
+  def for(*)
+    members
+  end
+
+  # @return [Redpear::Store::SortedSet] the sorted set holding the pairs
+  def members(*)
+    @members ||= Redpear::Store::SortedSet.new nested_key(name), model.connection
+  end
+
+end