dm-redis-adapter 0.0.5

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,54 @@
+h1. dm-redis-adapter
+
+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.
+
+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.
+
+<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.
+
+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:
+** <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
+
+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 'rubygems'
+    require 'dm-core'
+    require 'dm_redis'
+    
+    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

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+
+GEM = 'dm-redis-adapter'
+GEM_NAME = 'dm-redis-adapter'
+AUTHORS = ['Dan Herrera']
+EMAIL = "whoahbot@gmail.com"
+HOMEPAGE = "http://github.com/whoahbot/dm-redis-adapter"
+SUMMARY = "DataMapper adapter for the Redis key-value database"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = GEM
+    gemspec.summary = SUMMARY
+    gemspec.email = EMAIL
+    gemspec.homepage = HOMEPAGE
+    gemspec.description = SUMMARY
+    gemspec.authors = AUTHORS
+    gemspec.add_dependency "dm-core", "0.10.0"
+    gemspec.add_dependency "ezmobius-redis"
+    gemspec.files = %w(MIT-LICENSE README.textile Rakefile) + Dir.glob("{lib,spec}/**/*")
+    gemspec.has_rdoc = true
+    gemspec.extra_rdoc_files = ["MIT-LICENSE"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+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

data/lib/dm_redis.rb

@@ -0,0 +1,179 @@
+require 'redis'
+
+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_serial(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)
+      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)
+            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.limit_records(records)
+        records = query.sort_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 collection object that should be used to find the resource(s) to update.
+      #
+      # @api semipublic
+      def update(attributes, collection)
+        attributes = attributes_as_fields(attributes)
+
+        records_to_update = records_for(collection.query)
+        records_to_update.each { |r| r.update(attributes) }
+        update_attributes(collection)
+      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.to_s.downcase}:#{record[redis_key_for(collection.query.model)]}:#{p.name}")
+          end
+          @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
+
+      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|
+            next if resource.key.include?(property)
+            @redis["#{resource.model.to_s.downcase}:#{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?(DataMapper::Query::Conditions::EqualToComparison) && query.model.key.include?(o.subject)}.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
+
+        # 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.to_s.downcase}:#{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 = Redis.new(@options)
+      end
+    end # class RedisAdapter
+
+    const_added(:RedisAdapter)
+  end # module Adapters
+end # module DataMapper

data/spec/dm_redis_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'redis'
+
+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 = Redis.new(:db => 15)
+    redis.flush_db
+  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/dm_redis'))

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification 
+name: dm-redis-adapter
+version: !ruby/object:Gem::Version 
+  version: 0.0.5
+platform: ruby
+authors: 
+- Dan Herrera
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !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: 
+- !ruby/object:Gem::Dependency 
+  name: ezmobius-redis
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "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/dm_redis.rb
+- spec/dm_redis_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/whoahbot/dm-redis-adapter
+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.3
+signing_key: 
+specification_version: 2
+summary: DataMapper adapter for the Redis key-value database
+test_files: 
+- spec/dm_redis_spec.rb
+- spec/spec_helper.rb