whoahbot-dm-redis-adapter 0.0.3 → 0.0.4

data/README.textile

@@ -1,18 +1,53 @@
 h1. dm-redis-adapter
 
-This is an experimental <a href="http://datamapper.org">DataMapper</a> adapter for the <a href="http://code.google.com/p/redis/wiki/README">Redis</a> key-value database.
+This is a <a href="http://datamapper.org">DataMapper</a> adapter for the <a href="http://github.com/antirez/redis/">Redis</a> key-value database.
 
-Please be aware that this is very alpha quality software!  It is not recommended for production use yet.  If you find a bug, or are using dm-redis, please let me know.
+Redis is a very fast key-value store with some interesting data structures added.  You can have a key that is a SET, LIST, or a STRING that is binary safe.  Data structures like SET and LIST allow for even more interesting things.  Redis is a fabulous and fast engine for data structures, and you can read more about it here: <a href="http://code.google.com/p/redis/">redis</a>.  Redis is also a persistent data store, and can be used in large-scale environments with master-slave replication.
 
-h1. TODO
+<a href="http://datamapper.org">DataMapper</a> is a brilliant ORM that is based on the <a href="http://www.martinfowler.com/eaaCatalog/identityMap.html">IdentityMap</a> pattern.  Usage of DataMapper resembles that of ActiveRecord, the popular ORM bundled with Ruby on Rails, but with some very important differences.  A quote from the DM wiki: "One row in the database should equal one object reference. Pretty simple idea. Pretty profound impact."  Having an identity map allows for very efficient queries to the database, as well as interesting forms of lazy loading of attributes or associations.
 
-Optimizing records for to move common queries server-side.
+Marrying DataMapper to Redis allows for schema-less models, you can add fields at any time without having to create a migration.  DataMapper also allows us to store non native Redis types in the db, like Date fields.
 
 h1. Install
 
 Prerequisites:
-* Redis, git version:
-** <a href="http://github.com/antirez/redis/">Redis, git version</a>
+* Redis:
+** <a href="http://code.google.com/p/redis/">Redis, v0.100</a>
 * Gems:
+** <a href="http://code.google.com/p/redis/">redis (0.0.3.4)</a>
 ** <a href="http://github.com/datamapper/extlib">extlib</a>, dependency for dm-core
-** <a href="http://github.com/datamapper/dm-core/tree/next">dm-core</a> next branch
+** <a href="http://github.com/datamapper/dm-core/tree/next">dm-core</a> next branch
+
+I installed the redis gem from the redis .tgz file like so:
+
+<pre>
+  <code>
+    > tar -xvzf redis-0.100.tar.gz
+    > cd redis-0.100/client-libraries/ruby
+    > sudo rake install
+  </code>
+</pre>
+
+h1. Usage
+
+Setup your adapter, define your models and properties:
+
+<pre>
+  <code>
+    require 'dm-core'
+    require 'dm_redis_adapter'
+    
+    DataMapper.setup(:default, {:adapter  => "redis"})
+    
+    class Cafe
+      include DataMapper::Resource
+      
+      property :id,     Serial
+      property :name,   Text
+    end
+    
+    Cafe.create(:name => "Whoahbot's Caffienitorium")
+  </code>
+</pre>
+
+Now you can use redis in a ORM style, and take advantage of all of the amazing things that DataMapper offers.

data/Rakefile

@@ -6,10 +6,10 @@ require 'spec/rake/spectask'
 
 GEM = 'dm-redis-adapter'
 GEM_NAME = 'dm-redis-adapter'
-GEM_VERSION = '0.0.3'
+GEM_VERSION = '0.0.4'
 AUTHORS = ['Dan Herrera']
 EMAIL = "whoahbot@gmail.com"
-HOMEPAGE = "http://github.com/whoahbot/dm-redis"
+HOMEPAGE = "http://github.com/whoahbot/dm-redis-adapter"
 SUMMARY = "DataMapper adapter for the Redis key-value database"
 
 spec = Gem::Specification.new do |s|
@@ -25,6 +25,7 @@ spec = Gem::Specification.new do |s|
   s.homepage = HOMEPAGE
   s.add_dependency "rspec"
   s.add_dependency "dm-core", "0.10.0"
+  s.add_dependency "redis",   "0.0.3.4"
   s.require_path = 'lib'
   s.autorequire = GEM
   s.files = %w(MIT-LICENSE README.textile Rakefile) + Dir.glob("{lib,spec}/**/*")

data/lib/dm_redis_adapter.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__), 'rubyredis'))
+require 'redis'
 
 module DataMapper
   module Adapters
@@ -17,8 +17,9 @@ module DataMapper
       # @api semipublic
       def create(resources)
         resources.each do |resource|
-          initialize_identity_field(resource, @redis.incr("#{resource.model}:#{redis_key_for(resource.model)}:serial"))
-          @redis.set_add("#{resource.model}:#{redis_key_for(resource.model)}:all", resource.key)
+          # model.each {|c| c.to_s}.join(":")
+          initialize_identity_field(resource, @redis.incr("#{resource.model.to_s.downcase}:#{redis_key_for(resource.model)}:serial"))
+          @redis.set_add("#{resource.model.to_s.downcase}:#{redis_key_for(resource.model)}:all", resource.key)
         end
         
         update_attributes(resources)
@@ -40,13 +41,13 @@ module DataMapper
         records = records_for(query).each do |record|
           query.fields.each do |property|
             next if query.model.key.include?(property.name)
-            record[property.name.to_s] = property.typecast(@redis["#{query.model}:#{record[redis_key_for(query.model)]}:#{property.name}"])
+            record[property.name.to_s] = property.typecast(@redis["#{query.model.to_s.downcase}:#{record[redis_key_for(query.model)]}:#{property.name}"])
           end
         end
 
         records = query.match_records(records)
-        records = query.sort_records(records)
         records = query.limit_records(records)
+        records = query.sort_records(records)
         records
       end
       
@@ -84,9 +85,9 @@ module DataMapper
       def delete(collection)
         collection.query.filter_records(records_for(collection.query)).each do |record|
           collection.query.model.properties.each do |p|
-            @redis.delete("#{collection.query.model}:#{record[redis_key_for(collection.query.model)]}:#{p.name}")
+            @redis.delete("#{collection.query.model.to_s.downcase}:#{record[redis_key_for(collection.query.model)]}:#{p.name}")
           end
-          @redis.set_delete("#{collection.query.model}:#{redis_key_for(collection.query.model)}:all", record[redis_key_for(collection.query.model)])
+          @redis.set_delete("#{collection.query.model.to_s.downcase}:#{redis_key_for(collection.query.model)}:all", record[redis_key_for(collection.query.model)])
         end
       end
       
@@ -118,7 +119,7 @@ module DataMapper
         resources.each do |resource|
           resource.attributes.each do |property, value|
             next if resource.key.include?(property)
-            @redis["#{resource.model}:#{resource.key}:#{property}"] = value unless value.nil?
+            @redis["#{resource.model.to_s.downcase}:#{resource.key}:#{property}"] = value unless value.nil?
           end
         end
       end
@@ -135,16 +136,21 @@ module DataMapper
       # @api private
       def records_for(query)
         keys = []
-        query.conditions.operands.select {|o| o.is_a?(Conditions::EqualToComparison) && query.model.key.include?(o.property)}.each do |o|
-          if @redis.set_member?("#{query.model}:#{redis_key_for(query.model)}:all", o.value)
+        query.conditions.operands.select {|o| o.is_a?(DataMapper::Query::Conditions::EqualToComparison) && query.model.key.include?(o.property)}.each do |o|
+          if @redis.set_member?("#{query.model.to_s.downcase}:#{redis_key_for(query.model)}:all", o.value)
             keys << {"#{redis_key_for(query.model)}" => o.value}
           end
         end
         
-        # TODO: Implement other conditions to filter down the records retrieved
+        # if query.limit
+        #   @redis.sort("#{query.model.to_s.downcase}:#{redis_key_for(query.model)}:all", :limit => [query.offset, query.limit]).each do |val|
+        #     keys << {"#{redis_key_for(query.model)}" => val.to_i}
+        #   end
+        # end
+        
         # Keys are empty, fall back and load all the values for this model
         if keys.empty?
-          @redis.set_members("#{query.model}:#{redis_key_for(query.model)}:all").each do |val|
+          @redis.set_members("#{query.model.to_s.downcase}:#{redis_key_for(query.model)}:all").each do |val|
             keys << {"#{redis_key_for(query.model)}" => val.to_i}
           end
         end
@@ -165,7 +171,7 @@ module DataMapper
       # @api semipublic
       def initialize(name, uri_or_options)
         super
-        @redis = RedisClient.new(@options)
+        @redis = Redis.new(@options)
       end
     end # class RedisAdapter
     

data/spec/dm_redis_adapter_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/spec_helper'
 require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/dm_redis_adapter'))
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/rubyredis'))
+require 'redis'
 
 require 'dm-core/spec/adapter_shared_spec'
 
@@ -13,7 +13,7 @@ describe DataMapper::Adapters::RedisAdapter do
   end
   
   after(:all) do
-    redis = RedisClient.new(:db => 15)
+    redis = Redis.new(:db => 15)
     redis.flushdb
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: whoahbot-dm-redis-adapter
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors: 
 - Dan Herrera
@@ -9,7 +9,7 @@ autorequire: dm-redis-adapter
 bindir: bin
 cert_chain: []
 
-date: 2009-05-26 00:00:00 -07:00
+date: 2009-06-02 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -32,6 +32,16 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.10.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.0.3.4
+    version: 
 description: DataMapper adapter for the Redis key-value database
 email: whoahbot@gmail.com
 executables: []
@@ -45,11 +55,10 @@ files:
 - README.textile
 - Rakefile
 - lib/dm_redis_adapter.rb
-- lib/rubyredis.rb
 - spec/dm_redis_adapter_spec.rb
 - spec/spec_helper.rb
 has_rdoc: false
-homepage: http://github.com/whoahbot/dm-redis
+homepage: http://github.com/whoahbot/dm-redis-adapter
 post_install_message: 
 rdoc_options: []
 

data/lib/rubyredis.rb

@@ -1,237 +0,0 @@
-# RubyRedis is an alternative implementatin of Ruby client library written
-# by Salvatore Sanfilippo.
-#
-# The aim of this library is to create an alternative client library that is
-# much simpler and does not implement every command explicitly but uses
-# method_missing instead.
-
-require 'socket'
-require 'set'
-
-begin
-    if (RUBY_VERSION >= '1.9')
-        require 'timeout'
-        RedisTimer = Timeout
-    else
-        require 'system_timer'
-        RedisTimer = SystemTimer
-    end
-rescue LoadError
-    RedisTimer = nil
-end
-
-class RedisClient
-    BulkCommands = {
-        "set"=>true, "setnx"=>true, "rpush"=>true, "lpush"=>true, "lset"=>true,
-        "lrem"=>true, "sadd"=>true, "srem"=>true, "sismember"=>true,
-        "echo"=>true, "getset"=>true, "smove"=>true
-    }
-
-    ConvertToBool = lambda{|r| r == 0 ? false : r}
-
-    ReplyProcessor = {
-        "exists" => ConvertToBool,
-        "sismember"=> ConvertToBool,
-        "sadd"=> ConvertToBool,
-        "srem"=> ConvertToBool,
-        "smove"=> ConvertToBool,
-        "move"=> ConvertToBool,
-        "setnx"=> ConvertToBool,
-        "del"=> ConvertToBool,
-        "renamenx"=> ConvertToBool,
-        "expire"=> ConvertToBool,
-        "keys" => lambda{|r| r.split(" ")},
-        "info" => lambda{|r| 
-            info = {}
-            r.each_line {|kv|
-                k,v = kv.split(":",2).map{|x| x.chomp}
-                info[k.to_sym] = v
-            }
-            info
-        }
-    }
-
-    Aliases = {
-        "flush_db" => "flushdb",
-        "flush_all" => "flushall",
-        "last_save" => "lastsave",
-        "key?" => "exists",
-        "delete" => "del",
-        "randkey" => "randomkey",
-        "list_length" => "llen",
-        "push_tail" => "rpush",
-        "push_head" => "lpush",
-        "pop_tail" => "rpop",
-        "pop_head" => "lpop",
-        "list_set" => "lset",
-        "list_range" => "lrange",
-        "list_trim" => "ltrim",
-        "list_index" => "lindex",
-        "list_rm" => "lrem",
-        "set_add" => "sadd",
-        "set_delete" => "srem",
-        "set_count" => "scard",
-        "set_member?" => "sismember",
-        "set_members" => "smembers",
-        "set_intersect" => "sinter",
-        "set_intersect_store" => "sinterstore",
-        "set_inter_store" => "sinterstore",
-        "set_union" => "sunion",
-        "set_union_store" => "sunionstore",
-        "set_diff" => "sdiff",
-        "set_diff_store" => "sdiffstore",
-        "set_move" => "smove",
-        "set_unless_exists" => "setnx",
-        "rename_unless_exists" => "renamenx"
-    }
-
-    def initialize(opts={})
-        @host = opts[:host] || '127.0.0.1'
-        @port = opts[:port] || 6379
-        @db = opts[:db] || 0
-        @timeout = opts[:timeout] || 0
-        connect_to_server
-    end
-
-    def to_s
-        "Redis Client connected to #{@host}:#{@port} against DB #{@db}"
-    end
-
-    def connect_to_server
-        @sock = connect_to(@host,@port,@timeout == 0 ? nil : @timeout)
-        call_command(["select",@db]) if @db != 0
-    end
-
-    def connect_to(host, port, timeout=nil)
-        # We support connect() timeout only if system_timer is availabe
-        # or if we are running against Ruby >= 1.9
-        # Timeout reading from the socket instead will be supported anyway.
-        if @timeout != 0 and RedisTimer
-            begin
-                sock = TCPSocket.new(host, port, 0)
-            rescue Timeout::Error
-                @sock = nil
-                raise Timeout::Error, "Timeout connecting to the server"
-            end
-        else
-            sock = TCPSocket.new(host, port, 0)
-        end
-
-        # If the timeout is set we set the low level socket options in order
-        # to make sure a blocking read will return after the specified number
-        # of seconds. This hack is from memcached ruby client.
-        if timeout
-            secs = Integer(timeout)
-            usecs = Integer((timeout - secs) * 1_000_000)
-            optval = [secs, usecs].pack("l_2")
-            sock.setsockopt Socket::SOL_SOCKET, Socket::SO_RCVTIMEO, optval
-            sock.setsockopt Socket::SOL_SOCKET, Socket::SO_SNDTIMEO, optval
-        end
-        sock
-    end
-
-    def method_missing(*argv)
-        call_command(argv)
-    end
-
-    def call_command(argv)
-        # this wrapper to raw_call_command handle reconnection on socket
-        # error. We try to reconnect just one time, otherwise let the error
-        # araise.
-        connect_to_server if !@sock
-        begin
-            raw_call_command(argv)
-        rescue Errno::ECONNRESET
-            @sock.close
-            connect_to_server
-            raw_call_command(argv)
-        end
-    end
-
-    def raw_call_command(argv)
-        bulk = nil
-        argv[0] = argv[0].to_s.downcase
-        argv[0] = Aliases[argv[0]] if Aliases[argv[0]]
-        if BulkCommands[argv[0]]
-            bulk = argv[-1].to_s
-            argv[-1] = bulk.length
-        end
-        @sock.write(argv.join(" ")+"\r\n")
-        @sock.write(bulk+"\r\n") if bulk
-
-        # Post process the reply if needed
-        processor = ReplyProcessor[argv[0]]
-        processor ? processor.call(read_reply) : read_reply
-    end
-
-    def select(*args)
-        raise "SELECT not allowed, use the :db option when creating the object"
-    end
-
-    def [](key)
-        get(key)
-    end
-
-    def []=(key,value)
-        set(key,value)
-    end
-
-    def sort(key, opts={})
-        cmd = []
-        cmd << "SORT #{key}"
-        cmd << "BY #{opts[:by]}" if opts[:by]
-        cmd << "GET #{[opts[:get]].flatten * ' GET '}" if opts[:get]
-        cmd << "#{opts[:order]}" if opts[:order]
-        cmd << "LIMIT #{opts[:limit].join(' ')}" if opts[:limit]
-        call_command(cmd)
-    end
-
-    def incr(key,increment=nil)
-        call_command(increment ? ["incrby",key,increment] :  ["incr",key])
-    end
-
-    def decr(key,decrement=nil)
-        call_command(decrement ? ["decrby",key,decrement] :  ["decr",key])
-    end
-
-    def read_reply
-        # We read the first byte using read() mainly because gets() is
-        # immune to raw socket timeouts.
-        begin
-            rtype = @sock.read(1)
-        rescue Errno::EAGAIN
-            # We want to make sure it reconnects on the next command after the
-            # timeout. Otherwise the server may reply in the meantime leaving
-            # the protocol in a desync status.
-            @sock = nil
-            raise Errno::EAGAIN, "Timeout reading from the socket"
-        end
-
-        raise Errno::ECONNRESET,"Connection lost" if !rtype
-        line = @sock.gets
-        case rtype
-        when "-"
-            raise "-"+line.strip
-        when "+"
-            line.strip
-        when ":"
-            line.to_i
-        when "$"
-            bulklen = line.to_i
-            return nil if bulklen == -1
-            data = @sock.read(bulklen)
-            @sock.read(2) # CRLF
-            data
-        when "*"
-            objects = line.to_i
-            return nil if bulklen == -1
-            res = []
-            objects.times {
-                res << read_reply
-            }
-            res
-        else
-            raise "Protocol error, got '#{rtype}' as initial reply byte"
-        end
-    end
-end