whoahbot-dm-redis 0.0.2

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2009 Dan Herrera
+ 
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,18 @@
+h1. DM-Redis
+
+This is an experimental datamapper adapter for the <a href="http://code.google.com/p/redis/wiki/README">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.
+
+h1. TODO
+
+Refactoring +records_for+ to filter down the set of records returned.
+
+h1. Install
+
+Prerequisites:
+* Redis, git version:
+** <a href="http://github.com/antirez/redis/">Redis, git version</a>
+* Gems:
+** <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

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+
+GEM = 'dm-redis'
+GEM_NAME = 'dm-redis'
+GEM_VERSION = '0.0.2'
+AUTHORS = ['Dan Herrera']
+EMAIL = "whoahbot@gmail.com"
+HOMEPAGE = "http://github.com/whoahbot/dm-redis"
+SUMMARY = "DataMapper adapter for the Redis key-value database"
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["MIT-LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.authors = AUTHORS
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency "rspec"
+  s.add_dependency "dm-core", "0.10.0"
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.files = %w(MIT-LICENSE README.textile Rakefile) + Dir.glob("{lib,spec}/**/*")
+end
+
+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
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/lib/redis_adapter.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'rubyredis'))
+
+module DataMapper
+  module Adapters
+    Extlib::Inflection.word 'redis'
+    
+    class RedisAdapter < AbstractAdapter
+      ##
+      # Used by DataMapper to put records into the redis data-store: "INSERT" in SQL-speak.
+      # It takes an array of the resources (model instances) to be saved. Resources
+      # each have a key that can be used to quickly look them up later without
+      # searching.
+      #
+      # @param [Enumerable(Resource)] resources
+      #   The set of resources (model instances)
+      #
+      # @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)
+        end
+        
+        update_attributes(resources)
+      end
+      
+      ##
+      # Looks up one record or a collection of records from the data-store:
+      # "SELECT" in SQL.
+      #
+      # @param [Query] query
+      #   The query to be used to seach for the resources
+      #
+      # @return [Array]
+      #   An Array of Hashes containing the key-value pairs for
+      #   each record
+      #
+      # @api semipublic
+      def read(query)
+        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}"])
+          end
+        end
+
+        records = query.match_records(records)
+        records = query.sort_records(records)
+        records = query.limit_records(records)
+        records
+      end
+      
+      ##
+      # Used by DataMapper to update the attributes on existing records in the redis
+      # data-store: "UPDATE" in SQL-speak. It takes a hash of the attributes
+      # to update with, as well as a collection object that specifies which resources
+      # should be updated.
+      #
+      # @param [Hash] attributes
+      #   A set of key-value pairs of the attributes to update the resources with.
+      # @param [DataMapper::Collection] collection
+      #   The query that should be used to find the resource(s) to update.
+      #
+      # @api semipublic
+      def update(attributes, collection)
+        attributes = attributes_as_fields(attributes)
+        read(collection.query).each { |r| r.update(attributes) }
+      end
+      
+      ##
+      # Destroys all the records matching the given query. "DELETE" in SQL.
+      #
+      # @param [DataMapper::Collection] collection
+      #   The query used to locate the resources to be deleted.
+      #
+      # @return [Array]
+      #   An Array of Hashes containing the key-value pairs for
+      #   each record
+      #
+      # @api semipublic
+      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}")
+          end
+          @redis.set_delete("#{collection.query.model}:#{redis_key_for(collection.query.model)}:all", record[redis_key_for(collection.query.model)])
+        end
+      end
+      
+      private
+      
+      ##
+      # Creates a string representation for the keys in a given model
+      #
+      # @param [DataMapper::Model] model
+      #   The query used to locate the resources to be deleted.
+      #
+      # @return [Array]
+      #   An Array of Hashes containing the key-value pairs for
+      #   each record
+      #
+      # @api private
+      def redis_key_for(model)
+        model.key.collect {|k| k.name}.join(":")
+      end
+      
+      ##
+      # Saves each key value pair to the redis data store
+      #
+      # @param [Array] resources
+      #   An array of resources to save
+      #
+      # @api private
+      def update_attributes(resources)
+        resources.each do |resource|
+          resource.attributes.each do |property, value|
+            @redis["#{resource.model}:#{resource.key}:#{property}"] = value unless value.nil?
+          end
+        end
+      end
+      
+      ##
+      # Retrieves records for a particular model.
+      #
+      # @param [DataMapper::Query] query
+      #   The query used to locate the resources
+      #
+      # @return [Array]
+      #   An array of hashes of all of the records for a particular model
+      #
+      # @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)
+            keys << {"#{redis_key_for(query.model)}" => o.value}
+          end
+        end
+        
+        # TODO: Implement other conditions to filter down the records retrieved
+        # 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|
+            keys << {"#{redis_key_for(query.model)}" => val.to_i}
+          end
+        end
+        
+        keys
+      end
+
+      ##
+      # Make a new instance of the adapter. The @redis ivar is the 'data-store'
+      # for this adapter.
+      #
+      # @param [String, Symbol] name
+      #   The name of the Repository using this adapter.
+      # @param [String, Hash] uri_or_options
+      #   The connection uri string, or a hash of options to set up
+      #   the adapter
+      #
+      # @api semipublic
+      def initialize(name, uri_or_options)
+        super
+        @redis = RedisClient.new(@options)
+      end
+    end # class RedisAdapter
+    
+    const_added(:RedisAdapter)
+  end # module Adapters
+end # module DataMapper

data/lib/rubyredis.rb

@@ -0,0 +1,237 @@
+# 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

data/spec/dm_redis_adapter_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/redis_adapter.rb'))
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/rubyredis'))
+
+require 'dm-core/spec/adapter_shared_spec'
+
+describe DataMapper::Adapters::RedisAdapter do
+  before(:all) do
+    @adapter = DataMapper.setup(:default, {
+      :adapter  => "redis",
+      :db => 15
+    })
+  end
+  
+  after(:all) do
+    redis = RedisClient.new(:db => 15)
+    redis.flushdb
+  end
+  
+  it_should_behave_like 'An Adapter'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'dm-core'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib/redis_adapter'))

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: whoahbot-dm-redis
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Dan Herrera
+autorequire: dm-redis
+bindir: bin
+cert_chain: []
+
+date: 2009-05-24 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+description: DataMapper adapter for the Redis key-value database
+email: whoahbot@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- MIT-LICENSE
+files: 
+- MIT-LICENSE
+- README.textile
+- Rakefile
+- lib/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
+post_install_message: 
+rdoc_options: []
+
+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.2.0
+signing_key: 
+specification_version: 3
+summary: DataMapper adapter for the Redis key-value database
+test_files: []
+