redpear 0.3.0

data/lib/redpear.rb

@@ -0,0 +1,23 @@
+require "nest"
+require "redis"
+
+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 :Expiration
+  autoload :Finders
+  autoload :Index
+  autoload :Model
+  autoload :Namespace
+  autoload :Nest
+  autoload :Persistence
+  autoload :Schema
+
+end

data/lib/redpear/column.rb

@@ -0,0 +1,53 @@
+class Redpear::Column < String
+  attr_reader :type, :model
+
+  # Creates a new column.
+  # @param [Redpear::Model] model the model the column is associated with
+  # @param [String] name the column name
+  # @param [Symbol] type the column type (:string (default), :counter, :integer, :timestamp)
+  def initialize(model, name, type = nil)
+    super name.to_s
+    @model = model
+    @type  = type.to_sym if type
+  end
+
+  # Casts a value to a type
+  #
+  # @param value the value to cast
+  # @param [Symbol, #optional] type the type to cast to, defaults to the column type
+  # @return the casted value
+  def type_cast(value, type = self.type)
+    case type
+    when :counter
+      value.to_i
+    when :integer
+      Kernel::Integer(value) rescue nil if value
+    when :timestamp
+      value = type_cast(value, :integer)
+      Time.at(value) if value
+    else
+      value
+    end
+  end
+
+  # @return [String] the column name
+  def name
+    to_s
+  end
+
+  # @return [Boolean] true if the column is readable
+  def readable?
+    true
+  end
+
+  # @return [Boolean] true if the column is writable
+  def writable?
+    type != :counter
+  end
+
+  # @return [Boolean] true if the column is an index
+  def index?
+    is_a? Redpear::Index
+  end
+
+end

data/lib/redpear/concern.rb

@@ -0,0 +1,10 @@
+module Redpear::Concern
+
+  # Partially borrowed from ActiveSupport
+  def append_features(base)
+    return false if base < self
+    super
+    base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+  end
+
+end

data/lib/redpear/connection.rb

@@ -0,0 +1,17 @@
+module Redpear::Connection
+  extend Redpear::Concern
+
+  module ClassMethods
+
+    # @return [Redis] the current connection
+    def connection
+      @connection ||= (superclass.respond_to?(:connection) ? superclass.connection : Redis.current)
+    end
+
+    # @param [Redis] the connection to assign
+    def connection=(value)
+      @connection = value
+    end
+
+  end
+end

data/lib/redpear/core_ext/stringify_keys.rb

@@ -0,0 +1,17 @@
+# 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/expiration.rb

@@ -0,0 +1,27 @@
+module Redpear::Expiration
+
+  # Expires the record.
+  # @param [Time, Integer] either a Time or an Integer period (in seconds)
+  def expire(value)
+    return false unless persisted?
+
+    case value
+    when Time
+      nest.expireat(value.to_i)
+    when Integer
+      nest.expire(value)
+    when String
+      value = Kernel::Integer(value) rescue nil
+      expire(value)
+    else
+      false
+    end
+  end
+
+  # @return [Integer] the period this record has to live.
+  # May return -1 for non-expiring records and nil for non-persisted records.
+  def ttl
+    nest.ttl if persisted?
+  end
+
+end

data/lib/redpear/finders.rb

@@ -0,0 +1,51 @@
+module Redpear::Finders
+  extend Redpear::Concern
+
+  module ClassMethods
+
+    # @return [Array] the IDs of all existing records
+    def members
+      mb_nest.smembers
+    end
+
+    # @return [Integer] the number of total records
+    def count
+      members.size
+    end
+
+    # @return [Array] all records
+    def all
+      members.map {|id| find(id) }
+    end
+
+    # Finds a single record.
+    #
+    # @param id the ID of the record to retrieve
+    # @param [Hash] options additional options
+    # @option :lazy defaults to true, set to false to load the record instantly
+    # @return [Redpear::Model] a record, or nil when not found
+    def find(id, options = {})
+      record = instantiate('id' => id.to_s) # Initialize
+      if record.nest.exists         # Do we have a record key?
+        record.refresh_attributes if options[:lazy] == false
+        record
+      else                          # Must be an expired or orphaned one
+        record.destroy              # Destroy (removes from mb_nest set)
+        nil
+      end
+    end
+
+    # @param id the ID to check
+    # @return [Boolean] true or false
+    def exists?(id)
+      mb_nest.sismember(id)
+    end
+
+    def instantiate(*a)
+      new(*a).tap do |instance|
+        instance.send :instance_variable_set, :@__loaded__, false
+      end
+    end
+
+  end
+end

data/lib/redpear/index.rb

@@ -0,0 +1,24 @@
+class Redpear::Index < Redpear::Column
+
+  # @return [Redpear::Nest] the namespace of the index. Example:
+  #
+  #   index = Comment.columns.lookup["post_id"]
+  #   index.namespace # => "comments:post_id"
+  #
+  def namespace
+    model.namespace[self]
+  end
+
+  # @return [Redpear::Nest] the nest for a specific value. Example:
+  #
+  #   index = Comment.columns.lookup["post_id"]
+  #   index.nest(123) # => "comments:post_id:123"
+  #   index.nest(nil) # => nil
+  #   index.nest("")  # => nil
+  #
+  def nest(value)
+    return nil if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    namespace[value]
+  end
+
+end

data/lib/redpear/machinist.rb

@@ -0,0 +1,50 @@
+require 'machinist'
+
+# Machinist module for your tests/specs. Example:
+#
+#   # spec/support/blueprints.rb
+#   require "redpear/machinist"
+#
+#   Post.blueprint do
+#     title      { "A Title" }
+#     created_at { 2.days.ago }
+#   end
+#
+module Redpear::Machinist
+
+  class Blueprint < Machinist::Blueprint
+
+    def make!(attributes = {})
+      make(attributes).tap &:save
+    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.load key => value
+    end
+
+  end
+end
+
+class Redpear::Model #:nodoc:
+  extend Machinist::Machinable
+
+  def self.blueprint_class
+    Redpear::Machinist::Blueprint
+  end
+end

data/lib/redpear/model.rb

@@ -0,0 +1,109 @@
+require "set"
+require "redpear/core_ext/stringify_keys"
+
+=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.
+
+For example:
+
+  class Post < Redpear::Model
+    column :title
+    column :body
+  end
+
+  class Comment < Redpear::Model
+    column :body
+    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.
+=end
+class Redpear::Model < Hash
+  include Redpear::Connection
+  include Redpear::Namespace
+  include Redpear::Persistence
+  include Redpear::Expiration
+  include Redpear::Schema
+  include Redpear::Finders
+
+  # Ensure we can read raw level values
+  alias_method :__fetch__, :[]
+
+  def initialize(attrs = {})
+    super()
+    @__attributes__ = {}
+    @__loaded__     = true
+    update(attrs)
+  end
+
+  # Every record needs an ID
+  def id
+    value = __fetch__("id")
+    value.to_s if value
+  end
+
+  # Custom comparator
+  def ==(other)
+    case other
+    when Redpear::Model
+      other.instance_of?(self.class) && to_hash(true) == other.to_hash(true)
+    else
+      super
+    end
+  end
+
+  # Attribute reader with type-casting
+  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
+    end
+  end
+
+  # Attribute writer
+  def []=(name, value)
+    __ensure_loaded__
+    name = name.to_s
+    @__attributes__.delete(name)
+    super
+  end
+
+  # Returns a Hash with attributes
+  def to_hash(clean = false)
+    __ensure_loaded__
+    attrs = clean ? reject {|_, v| v.nil? } : self
+    {}.update(attrs)
+  end
+
+  # Show information about this record
+  def inspect
+    __ensure_loaded__
+    "#<#{self.class.name} #{super}>"
+  end
+
+  # Bulk-update attributes
+  def update(attrs)
+    attrs = (attrs ? attrs.stringify_keys : {})
+    attrs["id"] = attrs["id"].to_s if attrs["id"]
+    super
+  end
+  alias_method :load, :update
+
+  private
+
+    def __ensure_loaded__
+      refresh_attributes unless @__loaded__
+    end
+
+end

data/lib/redpear/namespace.rb

@@ -0,0 +1,79 @@
+# Namespace organization for models. Example:
+#
+#   class Comment < Model
+#     index :post_id
+#   end
+#   instance = Comment.save(:post_id => 2)
+#
+#   Comment.connection.keys
+#   # => ['comments:1', 'comments:+', 'comments:*', 'comments:post_id:2']
+#
+#   # Instance nesting
+#   instance.nest                  # => 'comments:1'
+#   instance.nest.mapped_hmget_all # => { "post_id" => "2" }
+#
+#   # Member nesting
+#   Comment.mb_nest               # "comments:*"
+#   Comment.mb_nest.smembers      # => #<Set: {1}>
+#
+#   # PK nesting
+#   Comment.pk_nest               # "comments:+"
+#   Comment.pk_nest.get           # 1 = last ID
+#
+#   # Index nesting
+#   Comment.columns["post_id"].nest(2) # "comments:post_id:2"
+#   Comment.columns["post_id"].nest(2).smembers # #<Set: {1}>
+#
+module Redpear::Namespace
+  extend Redpear::Concern
+
+  module ClassMethods
+
+    # @return [Redpear::Nest] the namespace of this model, Example:
+    #
+    #   Comment.namespace # => "comments":Nest
+    #
+    def namespace
+      @namespace ||= Redpear::Nest.new(scope, connection)
+    end
+
+    # @return [String] the scope of this model. Example:
+    #
+    #   Comment.scope # => "comments"
+    #
+    # Override if you want to use a differnet scope schema.
+    def scope
+      @scope ||= "#{name.split('::').last.downcase}s"
+    end
+
+    # @return [Redpear::Nest] the nest for the members store. Example:
+    #
+    #   Comment.mb_nest # => 'comments:*'
+    #   Comment.mb_nest.smembers # => [1, 2, 3]
+    #
+    def mb_nest
+      @mb_nest ||= namespace["*"]
+    end
+
+    # @return [Redpear::Nest] the nest for the primary-key incrementor. Example:
+    #
+    #   Comment.pk_nest # => 'comments:+'
+    #   Comment.pk_nest.get # => 0
+    #   Comment.pk_nest.incr # => 1
+    #
+    def pk_nest
+      @pk_nest ||= namespace["+"]
+    end
+
+  end
+
+  # @return [Redpear::Nest] the nest for the current record. Example:
+  #
+  #   comment.nest # => 'comments:123'
+  #   Comment.new.nest # => 'comments:_'
+  #
+  def nest
+    self.class.namespace[id || '_']
+  end
+
+end

data/lib/redpear/nest.rb

@@ -0,0 +1,13 @@
+class Redpear::Nest < ::Nest
+
+  [:mapped_hmget, :mapped_hmset].each do |meth|
+    define_method(meth) do |*args, &block|
+      redis.send(meth, self, *args, &block)
+    end
+  end
+
+  def mapped_hmget_all
+    mapped_hmget *hkeys
+  end
+
+end

data/lib/redpear/persistence.rb

@@ -0,0 +1,134 @@
+# Redpear's persistence methods
+module Redpear::Persistence
+  extend Redpear::Concern
+
+  module ClassMethods
+
+    # Runs a bulk-operation.
+    # @yield [] operations that should be run in the transaction
+    def transaction(&block)
+      connection.multi(&block)
+    end
+
+    # Create or update a record. Example:
+    #
+    #   Post.save :body => "Hello World!" # => creates a new Post
+    #   Post.save :id => 3, :body => "Hello World!" # => updates an existing Post
+    #
+    def save(*args)
+      new(*args).tap(&:save)
+    end
+
+    # Destroys a record. Example:
+    # @param id the ID of the record to destroy
+    # @return [Redpear::Model] the destroyed record
+    def destroy(id)
+      new('id' => id).tap(&:destroy)
+    end
+
+    # Generates the next ID
+    def next_id
+      pk_nest.incr.to_s
+    end
+
+  end
+
+  # Returns true for new records
+  def new_record?
+    !id
+  end
+
+  # Returns true for existing records
+  def persisted?
+    !new_record?
+  end
+
+  # Reloads the record (destructive)
+  def reload
+    replace self.class.find(id, :lazy => false) if persisted?
+    self
+  end
+
+  # Load attributes from DB (destructive)
+  def refresh_attributes
+    update nest.mapped_hmget(*self.class.columns.names) if persisted?
+    @__loaded__ = true
+    self
+  end
+
+  # Saves the record.
+  #
+  # @param [Hash] options additional options
+  # @option options [Integer|Date] :expire expiration period or timestamp
+  # @yield [record] Additional block, applied as part of the save transaction
+  # @return [Redpear::Model] the saved record
+  def save(options = {}, &block)
+    before_save
+    update "id" => self.class.next_id unless persisted?
+
+    transaction do
+      nest.mapped_hmset __persistable_attributes__
+      __relevant_sets__.each {|s| s.sadd(id) }
+      expire options[:expire]
+      yield(self) if block
+    end
+  ensure
+    after_save
+  end
+
+  # Destroy the record.
+  # @return [Boolean] true or false
+  def destroy
+    return false unless persisted?
+
+    transaction do
+      nest.del
+      __relevant_sets__.each {|s| s.srem(id) }
+    end
+
+    true
+  end
+
+  protected
+
+    # Run in a DB transaction, returns self
+    def transaction(&block)
+      self.class.transaction(&block)
+      self
+    end
+
+    # "Cheap" callback, override in subclasses
+    def before_save
+    end
+
+    # "Cheap" callback, override in subclasses
+    def after_save
+    end
+
+  private
+
+    # Attributes that can be persisted
+    def __persistable_attributes__
+      result = {}
+      each do |key, value|
+        next if key == "id"
+        result[key] = __persistable_value__(value)
+      end
+      result
+    end
+
+    def __persistable_value__(value)
+      case value
+      when Time
+        value.to_i
+      else
+        value
+      end
+    end
+
+    # Return relevant set nests
+    def __relevant_sets__
+      @__relevant_sets__ ||= [self.class.mb_nest] + self.class.columns.indices.map {|i| i.nest self[i] }.compact
+    end
+
+end

data/lib/redpear/schema.rb

@@ -0,0 +1,34 @@
+module Redpear::Schema
+  extend Redpear::Concern
+  autoload :Collection, 'redpear/schema/collection'
+
+  module ClassMethods
+
+    # @return [Redpear::Schema::Collection] the columns of this model
+    def columns
+      @columns ||= Redpear::Schema::Collection.new
+    end
+
+    # @param [multiple] the column definition. Please see Redpear::Column#initialize
+    def column(*args)
+      columns.column(self, *args).tap do |col|
+        __define_attribute_accessors__(col)
+      end
+    end
+
+    # @param [multiple] the index definition. Please see Redpear::Column#initialize
+    def index(*args)
+      columns.index(self, *args).tap do |col|
+        __define_attribute_accessors__(col)
+      end
+    end
+
+    private
+
+      def __define_attribute_accessors__(col)
+        define_method(col.name) { self[col.name] } if col.readable?
+        define_method("#{col.name}=") {|v| self[col.name] = v } if col.writable?
+      end
+
+  end
+end

data/lib/redpear/schema/collection.rb

@@ -0,0 +1,48 @@
+# Stores the column information
+class Redpear::Schema::Collection < Array
+
+  # @param [multiple] the column definition. Please see Redpear::Column#initialize
+  def column(*args)
+    reset!
+    Redpear::Column.new(*args).tap do |col|
+      self << col
+    end
+  end
+
+  # @param [multiple] the index definition. Please see Redpear::Column#initialize
+  def index(*args)
+    reset!
+    Redpear::Index.new(*args).tap do |col|
+      self << col
+    end
+  end
+
+  # @return [Array] the names of the columns
+  def names
+    @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
+
+  # @param [String] the column name
+  # @return [Redpear::Column] the column for the given name
+  def [](name)
+    lookup[name.to_s]
+  end
+
+  # Resets indexes and lookups
+  def reset!
+    instance_variables.each do |name|
+      instance_variable_set name, nil
+    end
+  end
+
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: redpear
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Dimitrij Denissenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-24 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &13539180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *13539180
+- !ruby/object:Gem::Dependency
+  name: nest
+  requirement: &13533640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *13533640
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &13533060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13533060
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &13532580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13532580
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &13531860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13531860
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: &13529820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13529820
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: &13528760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *13528760
+- !ruby/object:Gem::Dependency
+  name: machinist
+  requirement: &13527200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0.beta
+  type: :development
+  prerelease: false
+  version_requirements: *13527200
+description: Simple, elegant & efficient ORM for Redis
+email: dimitrij@blacksquaremedia.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/redpear.rb
+- lib/redpear/connection.rb
+- lib/redpear/schema/collection.rb
+- lib/redpear/core_ext/stringify_keys.rb
+- lib/redpear/concern.rb
+- lib/redpear/namespace.rb
+- lib/redpear/nest.rb
+- lib/redpear/finders.rb
+- lib/redpear/persistence.rb
+- lib/redpear/expiration.rb
+- lib/redpear/column.rb
+- lib/redpear/model.rb
+- lib/redpear/index.rb
+- lib/redpear/schema.rb
+- lib/redpear/machinist.rb
+homepage: https://github.com/bsm/redpear
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.6.0
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Redpear, a Redis ORM
+test_files: []