redis-model 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+*~
+/coverage
+/pkg

data/README.markdown

@@ -0,0 +1,46 @@
+## redis-model
+
+Minimal model support for [redis-rb](http://github.com/ezmobius/redis-rb). 
+Directly maps ruby properties to `model_name:id:field_name` keys in redis. 
+Scalar, list and set properties are supported.
+
+Values can be marshaled to/from `Integer`, `Float`, `DateTime`, `JSON`. See `Redis::Model::Marshal` for more info.
+
+### Define
+
+    require 'redis/model'
+    
+    class User < Redis::Model
+      value :name,      :string
+      value :created,   :datetime
+      value :profile,   :json
+      
+      list  :posts,     :json
+      
+      set   :followers, :int
+    end
+
+### Write
+
+    u = User.with_key(1)
+    u.name = 'Joe'                      # set user:1:name Joe
+    u.created = DateTime.now            # set user:1:created 2009-10-05T12:09:56+0400
+    u.profile = {                       # set user:1:profile {"sex":"M","about":"Lorem","age":23}
+      :age => 23,                       
+      :sex => 'M',                      
+      :about => 'Lorem'                 
+    }                                   
+    u.posts << {                        # rpush user:1:posts {"title":"Hello world!","text":"lorem"}
+        :title => "Hello world!",
+        :text  => "lorem"
+    }           
+    u.followers << 2                    # sadd user:1:followers 2
+
+### Read
+
+    u = User.with_key(1)
+    p u.name                            # get user:1:name
+    p u.created.strftime('%m/%d/%Y')    # get user:1:created
+    p u.posts[0,20]                     # lrange user:1:posts 0 20
+    p u.posts[0]                        # lindex user:1:posts 0
+    p u.followers.has_key?(2)           # sismember user:1:followers 2

data/Rakefile

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-fs --color)
+end
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "redis-model"
+    gemspec.summary = "Minimal models for Redis"
+    gemspec.description = "Minimal model support for redis-rb. Directly maps ruby properties to model_name:id:field_name keys in redis. Scalar, list and set properties are supported."
+    gemspec.email = "voloko@gmail.com"
+    gemspec.homepage = "http://github.com/voloko/redis-model"
+    gemspec.authors = ["Vladimir Kolesnikov"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bench.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'benchmark'
+$:.push File.join(File.dirname(__FILE__), 'lib')
+require 'redis/model'
+
+n = 20000
+
+class TestModel < Redis::Model
+  value :foo
+  list  :bar
+end
+
+@r = Redis.new#(:debug => true)
+@r['foo'] = "The first line we sent to the server is some text"
+
+Benchmark.bmbm do |x|
+  x.report("set (model)") do
+    n.times do |i|
+      m = TestModel.with_key(i)
+      m.foo = "The first line we sent to the server is some text";
+      m.foo
+    end
+  end
+
+  x.report("push+trim (model)") do
+    n.times do |i|
+      m = TestModel.with_key(i)
+      m.bar << i
+      m.bar.trim 0, 30
+    end
+  end
+end
+
+@r.keys('*').each do |k|
+  @r.delete k
+end

data/examples/model.rb

@@ -0,0 +1,40 @@
+require 'rubygems'
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'redis/model'
+
+
+class User < Redis::Model
+  value :name,      :string
+  value :created,   :datetime
+  value :profile,   :json
+  
+  list  :posts,     :json
+  
+  set   :followers, :int
+end
+
+
+
+u = User.with_key(1)
+u.delete
+u.name = 'Joe'                    
+u.created = DateTime.now          
+u.profile = {                     
+  :age => 23,                     
+  :sex => 'M',                    
+  :about => 'Lorem'               
+}                                 
+u.posts << {                      
+    :title => "Hello world!",     
+    :text  => "lorem"             
+}                                 
+u.followers << 2                  
+                                  
+                                  
+                                  
+u = User.with_key(1)  
+p u.name                          
+p u.created.strftime('%m/%d/%Y')  
+p u.posts[0,20]                   
+p u.posts[0]                      
+p u.followers.has_key?(2)         

data/lib/redis/model.rb

@@ -0,0 +1,364 @@
+require "redis"
+require "json"
+
+# Simple models for redis-rb.
+# It maps ruby properties to <tt>model_name:id:field_name</tt> keys in redis.
+# It also adds marshaling for string fields and more OOP style access for sets and lists
+#
+# == Define
+#   
+#   require 'redis/model'
+#   class User < Redis::Model
+#     value :name,     :string
+#     value :created,  :datetime
+#     value :profile,  :json
+#     list  :posts
+#     set   :followers
+#   end
+#
+# See Redis::Marshal for more types
+#
+#
+# == Write
+# 
+#   u = User.with_key(1)
+#   u.name = 'Joe'               # set user:1:name Joe
+#   u.created = DateTime.now     # set user:1:created 2009-10-05T12:09:56+0400
+#   u.profile = {                # set user:1:profile {"sex":"M","about":"Lorem","age":23}
+#     :age => 23,                
+#     :sex => 'M',               
+#     :about => 'Lorem'          
+#   }                            
+#   u.posts << "Hello world!"    # rpush user:1:posts 'Hello world!'
+#   u.followers << 2             # sadd user:1:followers 2
+#
+# == Read
+#
+#   u = User.with_key(1)
+#   p u.name                            # get user:1:name
+#   p u.created.strftime('%m/%d/%Y')    # get user:1:created
+#   p u.posts[0,20]                     # lrange user:1:posts 0 20
+#   p u.followers.has_key?(2)           # sismember user:1:followers 2
+#
+
+
+class Redis::Model
+  attr_accessor :id
+  
+  def initialize(id)
+    self.id = id
+  end
+  
+  def redis #:nodoc:
+    self.class.redis
+  end
+  
+  # Issues delete commands for all defined fields
+  def delete
+    self.class.fields.each do |field|
+      redis.delete field_key(field[:name])
+    end
+  end
+  
+protected
+  def prefix #:nodoc:
+    @prefix ||= self.class.prefix || self.class.to_s.
+      sub(%r{(.*::)}, '').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      downcase
+  end
+
+  def field_key(name) #:nodoc:
+    "#{prefix}:#{id}:#{name}"
+  end
+  
+  class << self
+    # Defaults to model_name.dasherize
+    attr_accessor :prefix
+  
+  
+    # Creates new model instance with new uniqid
+    # NOTE: "sequence:model_name:id" key is used
+    def create(values = {})
+      populate_model(self.new(next_id))
+    end
+  
+    # Creates new model instance with given id
+    alias_method :with_key, :new
+    alias_method :with_next_key, :create
+  
+    # Defines marshaled rw accessor for redis string value
+    def field(name, type = :string)
+      class_name = marshal_class_name(name, type)
+      
+      fields << {:name => name.to_s, :type => :type}
+      if type == :string
+        class_eval "def #{name}; @#{name} ||= redis[field_key('#{name}')]; end"
+        class_eval "def #{name}=(value); @#{name} = redis[field_key('#{name}')] = value; end"
+      else
+        class_eval "def #{name}; @#{name} ||= Marshal::#{class_name}.load(redis[field_key('#{name}')]); end"
+        class_eval "def #{name}=(value); @#{name} = value; redis[field_key('#{name}')] = Marshal::#{class_name}.dump(value) end"
+      end
+    end
+    alias_method :value, :field
+  
+    # Defines accessor for redis list
+    def list(name, type = :string)
+      class_name = marshal_class_name(name, type)
+      
+      fields << {:name => name.to_s, :type => :list}
+      class_eval "def #{name}; @#{name} ||= ListProxy.new(self.redis, field_key('#{name}'), Marshal::#{class_name}); end"
+      eval_writer(name)
+    end
+  
+    # Defines accessor for redis set
+    def set(name, type = :string)
+      class_name = marshal_class_name(name, type)
+      
+      fields << {:name => name.to_s, :type => :set}
+      class_eval "def #{name}; @#{name} ||= SetProxy.new(self.redis, field_key('#{name}'), Marshal::#{class_name}); end"
+      eval_writer(name)
+    end
+    
+    def marshal_class_name(name, type)
+      Marshal::TYPES[type] or raise ArgumentError.new("Unknown type #{type} for field #{name}")
+    end
+  
+    # Redefine this to change connection options
+    def redis
+      @@redis ||= Redis.new
+    end
+    
+    def fields #:nodoc:
+      @fields ||= []
+    end
+
+  protected
+    def eval_writer(name) #:nodoc:
+      class_eval <<-END
+        def #{name}=(value) 
+          field = self.#{name}; 
+          if value.respond_to?(:each)
+            value.each {|v| field << v}
+          else
+            field << v
+          end
+        end
+      END
+    end
+  
+    def next_id #:nodoc:
+      redis.incr "sequence:#{self.new.prefix}:id"
+    end
+  
+    def populate_model(model, values) #:nodoc:
+      return model if values.empty?
+      @@fields.each do |field|
+        model.send(:"#{field[:name]}=", value) if values.has_key?(field[:name])
+      end
+      model
+    end
+  end
+  
+  module Marshal
+    TYPES = {
+      :string   => 'String',
+      :int      => 'Integer',
+      :integer  => 'Integer',
+      :float    => 'Float',
+      :datetime => 'DateTime',
+      :json     => 'JSON',
+    }
+
+    class String
+      def self.dump(v)
+        v
+      end
+
+      def self.load(v)
+        v
+      end
+    end
+
+    class Integer
+      def self.dump(v)
+        v.to_s
+      end
+
+      def self.load(v)
+        v && v.to_i
+      end
+    end
+
+    class Float
+      def self.dump(v)
+        v.to_s
+      end
+
+      def self.load(v)
+        v && v.to_f
+      end
+    end
+
+    class DateTime
+      def self.dump(v)
+        v.strftime('%FT%T%z')
+      end
+
+      def self.load(v)
+        v && ::DateTime.strptime(v, '%FT%T%z')
+      end
+    end
+
+    class JSON
+      def self.dump(v)
+        ::JSON.dump(v)
+      end
+
+      def self.load(v)
+        v && ::JSON.load(v)
+      end
+    end
+  end
+  
+  
+  
+  class FieldProxy #:nodoc
+    def initialize(redis, name, marshal)
+      @redis   = redis
+      @name    = name
+      @marshal = marshal
+    end
+
+    def method_missing(method, *argv)
+      translated_method = translate_method_name(method)
+      raise NoMethodError.new("Method '#{method}' is not defined") unless translated_method
+      @redis.send translated_method, @name, *argv
+    end
+
+    protected
+      def translate_method_name(m)
+        m
+      end
+  end
+
+
+
+  class ListProxy < FieldProxy #:nodoc:
+    def <<(v)
+      @redis.rpush @name, @marshal.dump(v)
+    end
+    alias_method :push_tail, :<<
+    
+    def push_head(v)
+      @redis.lpush @name, @marshal.dump(v)
+    end
+    
+    def pop_tail
+      @marshal.load(@redis.rpop(@name))
+    end
+    
+    def pop_head
+      @marshal.load(@redis.lpop(@name))
+    end
+    
+    def [](from, to = nil)
+      if to.nil?
+        @marshal.load(@redis.lindex(@name, from))
+      else
+        @redis.lrange(@name, from, to).map! { |v| @marshal.load(v) }
+      end
+    end
+    alias_method :range, :[]
+    
+    def []=(index, v)
+      @redis.lset(@name, index, @marshal.dump(v))
+    end
+    alias_method :set, :[]=
+    
+    def include?(v)
+      @redis.exists(@name, @marshal.dump(v))
+    end
+    
+    def remove(count, v)
+      @redis.lrem(@name, count, @marshal.dump(v))
+    end
+    
+    def length
+      @redis.llen(@name)
+    end
+    
+    def trim(from, to)
+      @redis.ltrim(@name, from, to)
+    end
+    
+    def to_s
+      range(0, 100).join(', ')
+    end
+
+  protected
+    def translate_method_name(m)
+      COMMANDS[m]
+    end
+  end
+
+
+
+  class SetProxy < FieldProxy #:nodoc:
+    COMMANDS = {
+      :intersect_store  => "sinterstore",
+      :union_store      => "sunionstore",
+      :diff_store       => "sdiffstore",
+      :move             => "smove",
+    }
+    
+    def <<(v)
+      @redis.sadd @name, @marshal.dump(v)
+    end
+    alias_method :add, :<<
+    
+    def delete(v)
+      @redis.srem @name, @marshal.dump(v)
+    end
+    alias_method :remove, :delete
+    
+    def include?(v)
+      @redis.sismember @name, @marshal.dump(v)
+    end
+    alias_method :has_key?, :include?
+    alias_method :member?, :include?
+    
+    def members
+      @redis.smembers(@name).map { |v| @marshal.load(v) }
+    end
+    
+    def intersect(*keys)
+      @redis.sinter(@name, *keys).map { |v| @marshal.load(v) }
+    end
+    
+    def union(*keys)
+      @redis.sunion(@name, *keys).map { |v| @marshal.load(v) }
+    end
+    
+    def diff(*keys)
+      @redis.sdiff(@name, *keys).map { |v| @marshal.load(v) }
+    end
+    
+    def length
+      @redis.llen(@name)
+    end
+    
+    def to_s
+      members.join(', ')
+    end
+
+  protected
+    def translate_method_name(m)
+      COMMANDS[m]
+    end
+  end
+  
+  
+end
+

data/spec/redis/model_spec.rb

@@ -0,0 +1,188 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'redis/model'
+require 'json'
+
+describe Redis::Model do
+  
+  context "DSL" do
+    class TestDSL < Redis::Model
+      field :foo
+      list  :bar
+      set   :sloppy
+    end
+  
+    before(:each) do
+      @x = TestDSL.with_key(1)
+    end
+  
+    it "should define rw accessors for field" do
+      @x.should respond_to(:foo)
+      @x.should respond_to(:foo=)
+    end
+  
+    it "should define r accessor for list" do
+      @x.should respond_to(:bar)
+    end
+  
+    it "should define r accessor for set" do
+      @x.should respond_to(:sloppy)
+    end
+  
+    it "should raise error on invalid type" do
+      lambda do
+        class TestInvalidType < Redis::Model
+          field :invalid, :invalid_type
+        end
+      end.should raise_error(ArgumentError, 'Unknown type invalid_type for field invalid')
+    end
+  end
+  
+  context "field type cast" do
+    class TestType < Redis::Model
+      field :foo_string, :string
+      field :foo_json,   :json
+      field :foo_date,   :datetime
+      field :foo_int,    :int
+      field :foo_float,  :float
+      
+      list  :list_date,  :datetime
+      set   :set_date,   :datetime
+    end
+  
+    before(:each) do
+      @xRedisMock = Spec::Mocks::Mock.new
+      @yRedisMock = Spec::Mocks::Mock.new
+      @x = TestType.with_key(1)
+      @y = TestType.with_key(1)
+      @x.stub!(:redis).and_return(@xRedisMock)
+      @y.stub!(:redis).and_return(@yRedisMock)
+    end
+  
+    it "should save string as is" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_string', 'xxx')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_string').and_return('xxx')
+      @x.foo_string = 'xxx'
+      @y.foo_string.should be_instance_of(String)
+    end
+  
+    it "should marshal integer fields" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_int', '12')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_int').and_return('12')
+      @x.foo_int = 12
+      @y.foo_int.should be_kind_of(Integer)
+      @y.foo_int.should == 12
+    end
+  
+    it "should marshal float fields" do
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_float', '12.1')
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_float').and_return('12.1')
+      @x.foo_float = 12.1
+      @y.foo_float.should be_kind_of(Float)
+      @y.foo_float.should == 12.1
+    end
+  
+    it "should marshal datetime fields" do
+      time = DateTime.now
+      str  = time.strftime('%FT%T%z')
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_date', str)
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_date').and_return(str)
+      @x.foo_date = time
+      @y.foo_date.should be_kind_of(DateTime)
+      @y.foo_date.should.to_s == time.to_s
+    end
+  
+    it "should marshal json structs" do
+      data = {'foo' => 'bar', 'x' => 2}
+      str  = JSON.dump(data)
+      @xRedisMock.should_receive(:[]=).with('test_type:1:foo_json', str)
+      @yRedisMock.should_receive(:[]).with('test_type:1:foo_json').and_return(str)
+      @x.foo_json = data
+      @y.foo_json.should be_kind_of(Hash)
+      @y.foo_json.should.inspect == data.inspect
+    end
+    
+    it "should return nil for empty fields" do
+      @xRedisMock.should_receive(:[]).with('test_type:1:foo_date').and_return(nil)
+      @x.foo_date.should be_nil
+    end
+    
+    it "should marshal list values" do
+      data = DateTime.now
+      str  = data.strftime('%FT%T%z')
+      
+      @xRedisMock.should_receive('rpush').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lset').with('test_type:1:list_date', 1, str)
+      @xRedisMock.should_receive('exists').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lrem').with('test_type:1:list_date', 0, str)
+      @xRedisMock.should_receive('lpush').with('test_type:1:list_date', str)
+      @xRedisMock.should_receive('lrange').with('test_type:1:list_date', 0, 1).and_return([str])
+      @xRedisMock.should_receive('rpop').with('test_type:1:list_date').and_return(str)
+      @xRedisMock.should_receive('lpop').with('test_type:1:list_date').and_return(str)
+      @xRedisMock.should_receive('lindex').with('test_type:1:list_date', 0).and_return(str)
+      @x.list_date << data
+      @x.list_date[1] = data
+      @x.list_date.include?(data)
+      @x.list_date.remove(0, data)
+      @x.list_date.push_head(data)
+      @x.list_date[0].should be_kind_of(DateTime)
+      @x.list_date[0, 1][0].should be_kind_of(DateTime)
+      @x.list_date.pop_tail.should be_kind_of(DateTime)
+      @x.list_date.pop_head.should be_kind_of(DateTime)
+    end
+    
+    it "should marshal set values" do
+      data = DateTime.now
+      str  = data.strftime('%FT%T%z')
+
+      @xRedisMock.should_receive('sadd').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('srem').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('sismember').with('test_type:1:set_date', str)
+      @xRedisMock.should_receive('smembers').with('test_type:1:set_date').and_return([str])
+      @xRedisMock.should_receive('sinter').with('test_type:1:set_date', 'x').and_return([str])
+      @xRedisMock.should_receive('sunion').with('test_type:1:set_date', 'x').and_return([str])
+      @xRedisMock.should_receive('sdiff').with('test_type:1:set_date', 'x', 'y').and_return([str])
+      @x.set_date << data
+      @x.set_date.delete(data)
+      @x.set_date.include?(data)
+      @x.set_date.members[0].should be_kind_of(DateTime)
+      @x.set_date.intersect('x')[0].should be_kind_of(DateTime)
+      @x.set_date.union('x')[0].should be_kind_of(DateTime)
+      @x.set_date.diff('x', 'y')[0].should be_kind_of(DateTime)
+    end
+
+  end
+  
+  context "redis commands" do
+    class TestCommands < Redis::Model
+      field :foo
+      list  :bar
+      set   :sloppy
+    end
+    
+    before(:each) do
+      @redisMock = Spec::Mocks::Mock.new
+      @x = TestCommands.with_key(1)
+      @x.stub!(:redis).and_return(@redisMock)
+    end
+  
+    it "should send GET on field read" do
+      @redisMock.should_receive(:[]).with('test_commands:1:foo')
+      @x.foo
+    end
+  
+    it "should send SET on field write" do
+      @redisMock.should_receive(:[]=).with('test_commands:1:foo', 'bar')
+      @x.foo = 'bar'
+    end
+  
+    it "should send RPUSH on list <<" do
+      @redisMock.should_receive(:rpush).with('test_commands:1:bar', 'bar')
+      @x.bar << 'bar'
+    end
+  
+    it "should send SADD on set <<" do
+      @redisMock.should_receive(:sadd).with('test_commands:1:sloppy', 'bar')
+      @x.sloppy << 'bar'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+$TESTING=true
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+require 'redis'

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: redis-model
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Vladimir Kolesnikov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-14 00:00:00 +04:00
+default_executable: 
+dependencies: []
+
+description: Minimal model support for redis-rb. Directly maps ruby properties to model_name:id:field_name keys in redis. Scalar, list and set properties are supported.
+email: voloko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- .gitignore
+- README.markdown
+- Rakefile
+- VERSION
+- bench.rb
+- examples/model.rb
+- lib/redis/model.rb
+- spec/redis/model_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/voloko/redis-model
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Minimal models for Redis
+test_files: 
+- spec/redis/model_spec.rb
+- spec/spec_helper.rb
+- examples/model.rb