chimera 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2010-03-01
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,57 @@
+doc/examples/config.yml
+doc/NOTES
+doc/redis6379.conf
+History.txt
+lib/chimera/associations.rb
+lib/chimera/attributes.rb
+lib/chimera/base.rb
+lib/chimera/config.rb
+lib/chimera/error.rb
+lib/chimera/finders.rb
+lib/chimera/geo_indexes.rb
+lib/chimera/indexes.rb
+lib/chimera/persistence.rb
+lib/chimera/redis_objects.rb
+lib/chimera.rb
+lib/redis/counter.rb
+lib/redis/dist_redis.rb
+lib/redis/hash_ring.rb
+lib/redis/helpers
+lib/redis/helpers/core_commands.rb
+lib/redis/helpers/serialize.rb
+lib/redis/list.rb
+lib/redis/lock.rb
+lib/redis/objects
+lib/redis/objects/counters.rb
+lib/redis/objects/lists.rb
+lib/redis/objects/locks.rb
+lib/redis/objects/sets.rb
+lib/redis/objects/values.rb
+lib/redis/objects.rb
+lib/redis/pipeline.rb
+lib/redis/set.rb
+lib/redis/value.rb
+lib/redis.rb
+lib/riak_raw.rb
+lib/typhoeus/.gitignore
+lib/typhoeus/easy.rb
+lib/typhoeus/filter.rb
+lib/typhoeus/hydra.rb
+lib/typhoeus/multi.rb
+lib/typhoeus/remote.rb
+lib/typhoeus/remote_method.rb
+lib/typhoeus/remote_proxy_object.rb
+lib/typhoeus/request.rb
+lib/typhoeus/response.rb
+lib/typhoeus/service.rb
+lib/typhoeus.rb
+Manifest.txt
+PostInstall.txt
+Rakefile
+README.rdoc
+script/console
+script/destroy
+script/generate
+test/models.rb
+test/test_chimera.rb
+test/test_helper.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on chimera, see http://chimera.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,114 @@
+= chimera
+
+* http://github.com/#{github_username}/#{project_name}
+
+== DESCRIPTION:
+
+Chimera is an object mapper for Riak and Redis. The idea is to mix the advantages of Riak
+(scalability, massive data storage) with Redis (atomicity, performance, data structures).
+You should store the bulk of your data in Riak, and then use Redis data structures where
+appropriate (for example, a counter or set of keys).
+
+Internally, Chimera uses Redis for any indexes you define as well as some default indexes
+that are automatically created. There's no built in sharding for Redis, but since it's
+only being used for key storage and basic data elements you should be able to go a long
+way with one Redis server (especially if you use the new Redis VM).
+
+== FEATURES:
+
+* Uses Riak (http://riak.basho.com/) for your primary storage.
+* Uses Redis for indexes and also allows you to define Redis objects on a model.
+* Supports unique and non-unique indexes, as well as basic search indexes (words are stemmed,
+  uses set intersection so you can get an AND/OR search).
+* Supports a geospatial index type for simple storage and lookup of coordinates.
+
+== ISSUES/NOTES:
+
+* Experimental. Not yet tested in production environment, use at your own risk.
+* Test coverage needs to be improved.
+* Documentation is lacking. At the moment reading the tests and sample test/models.rb
+  file are your best bet.
+
+== SYNOPSIS:
+
+  require "rubygems"
+  gem "chimera", "0.0.1"
+  require "chimera"
+
+  Chimera.config_path = "path/to/your/config.yml"
+
+  class Car < Chimera::Base
+    attribute :vin
+    attribute :make
+    attribute :model
+    attribute :year
+    attribute :description
+
+    index :year, :type => :find
+    index :description, :type => :search
+    index :vin, :type => :unique
+
+    validates_presence_of :vin, :make, :model, :year
+  end
+
+  c = Car.new
+  c.id = Car.new_uuid
+  c.vin = 12345
+  c.make = "Pagani"
+  c.model = "Zonda Cinque Roadster"
+  c.year = 2010
+  c.description = "The Roadster will have specs as the Cinque Coupé, and will likely maintain the same rigidity or more, as it was for the Roadster F and F Coupé."
+  c.save
+
+  Car.find_with_index(:year, 2010)
+  => [c]
+
+  Car.find_with_index(:description, "rigid boat", :type => :union)
+  => [c]
+
+  Car.find_with_index(:description, "rigid boat", :type => :intersect)
+  => []
+
+* See tests for more usage examples
+
+== REQUIREMENTS:
+
+* Riak Server
+* Redis Server
+
+* ActiveSupport+ActiveModel 3.0.0.beta
+
+* uuidtools 2.1.1
+* brianmario-yajl-ruby 0.6.3
+* fast-stemmer 1.0.0
+
+== INSTALL:
+
+  $ gem install tzinfo builder memcache-client rack rack-test rack-mount erubis mail text-format thor bundler i18n
+  $ gem install rails --pre
+  $ gem install chimera
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 FIXME full name
+
+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/Rakefile

@@ -0,0 +1,30 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/chimera'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'chimera' do
+  self.developer 'Ben Myles', 'ben.myles@gmail.com'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+  self.extra_deps = [["activesupport","= 3.0.0.beta"],
+    ["uuidtools","= 2.1.1"],
+    ["activemodel",'= 3.0.0.beta'],
+    ["brianmario-yajl-ruby","= 0.6.3"],
+    ["fast-stemmer", "= 1.0.0"]]
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/doc/NOTES

@@ -0,0 +1,11 @@
+require 'lib/chimera'
+Chimera.config_path = "doc/examples/config.yml"
+require 'test/models'
+c = Car.new
+c.make = "Nissan"
+c.model = "RX7"
+c.year = 2010
+c.sku = 1001
+c.comments = "really fast car. it's purple too!"
+c.id = Car.new_uuid
+c.save

data/doc/examples/config.yml

@@ -0,0 +1,16 @@
+:default:
+  :redis:
+    :host: 127.0.0.1
+    :port: 6379
+    :db: 0
+  :riak_raw:
+    :host: 127.0.0.1
+    :port: 8098
+:user:
+  :redis:
+    :host: 127.0.0.1
+    :port: 5379
+    :db: 0
+  :riak_raw:
+    :host: 127.0.0.1
+    :port: 7098

data/doc/redis6379.conf

@@ -0,0 +1,132 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize no
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+pidfile /tmp/redis6379.pid
+
+# Accept connections on the specified port, default is 6379
+port 6379
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+save 900 1
+save 300 10
+save 60 10000
+
+# The filename where to dump the DB
+dbfilename /tmp/redis6379.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+dir ./
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 256
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes
+
+# Use object sharing. Can save a lot of memory if you have many common
+# string in your dataset, but performs lookups against the shared objects
+# pool so it uses more CPU and can be a bit slower. Usually it's a good
+# idea.
+#
+# When object sharing is enabled (shareobjects yes) you can use
+# shareobjectspoolsize to control the size of the pool used in order to try
+# object sharing. A bigger pool size will lead to better sharing capabilities.
+# In general you want this value to be at least the double of the number of
+# very common strings you have in your dataset.
+#
+# WARNING: object sharing is experimental, don't enable this feature
+# in production before of Redis 1.0-stable. Still please try this feature in
+# your development environment so that we can test it better.
+shareobjects no
+shareobjectspoolsize 1024

data/lib/chimera.rb

@@ -0,0 +1,33 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+gem 'uuidtools','= 2.1.1'
+gem 'activemodel','= 3.0.0.beta'
+gem "brianmario-yajl-ruby", "= 0.6.3"
+gem "fast-stemmer", "= 1.0.0"
+
+require 'fast_stemmer'
+
+require 'digest/sha1'
+require 'uuidtools'
+require 'yajl'
+require 'yaml'
+require 'active_model'
+
+require 'redis'
+require 'typhoeus'
+require 'riak_raw'
+
+require "chimera/error"
+require "chimera/attributes"
+require "chimera/indexes"
+require "chimera/geo_indexes"
+require "chimera/associations"
+require "chimera/redis_objects"
+require "chimera/finders"
+require "chimera/persistence"
+require "chimera/base"
+
+module Chimera
+  VERSION = '0.0.1'
+end

data/lib/chimera/associations.rb

@@ -0,0 +1,146 @@
+module Chimera
+  module Associations
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      def defined_associations
+        @defined_associations || {}
+      end
+
+      # association :friends, User
+      def association(name, class_sym)
+        @defined_associations ||= {}
+        @defined_associations[name.to_sym] = class_sym
+        define_method("#{name}") do
+          @associations ||= {}
+          @associations[name] ||= Chimera::AssociationProxies::Association.new(self,name,class_sym)
+        end
+      end
+    end # ClassMethods
+    
+    module InstanceMethods
+      def destroy_associations
+        (@associations || {}).each do |name, association|
+          association.destroy
+        end
+      end
+      
+      def association_memberships
+        @association_memberships ||= Chimera::AssociationProxies::AssociationMemberships.new(self)
+      end
+    end # InstanceMethods
+  end
+  
+  module AssociationProxies
+    class AssociationMemberships
+      attr_accessor :model
+      
+      def initialize(_model)
+        @model = _model
+      end
+      
+      def key
+        "#{model.class.to_s}::AssociationProxies::AssociationMemberships::#{model.id}"
+      end
+      
+      def add(assoc_key)
+        self.model.class.connection(:redis).lpush(self.key, assoc_key)
+      end
+      
+      def remove(assoc_key)
+        self.model.class.connection(:redis).lrem(self.key, 0, assoc_key)
+      end
+      
+      def destroy
+        remove_from_all_associations
+        self.model.class.connection(:redis).del(self.key)
+      end
+      
+      def remove_from_all_associations
+        self.each_association { |assoc| assoc.remove(self.model) }
+      end
+      
+      def each_association
+        llen  = self.model.class.connection(:redis).llen(self.key)
+        0.upto(llen-1) do |i|
+          assoc_key = self.model.class.connection(:redis).lindex(self.key, i)
+          yield Chimera::AssociationProxies::Association.find(assoc_key)
+        end
+        true
+      end
+      
+      def all_associations
+        all = []; self.each_association { |ass| all << ass }; all
+      end
+    end
+    
+    class Association
+      attr_accessor :model, :name, :klass
+      
+      def self.find(assoc_key)
+        parts = assoc_key.split("::")
+        model_klass = parts[0]
+        name = parts[3]
+        assoc_klass = parts[4]
+        model_id = parts[5]
+        self.new(eval(model_klass).find(model_id), name, assoc_klass.to_sym)
+      end
+      
+      def initialize(_model, _name, class_sym)
+        @model = _model
+        @name  = _name
+        @klass = eval(class_sym.to_s.camelize)
+        raise(Chimera::Error::MissingId) unless model.id
+      end
+
+      def key
+        "#{model.class.to_s}::AssociationProxies::Association::#{name}::#{klass.to_s}::#{model.id}"
+      end
+
+      def <<(obj)
+        raise(Chimera::Error::AssociationClassMismatch) unless obj.class.to_s == self.klass.to_s
+        self.model.class.connection(:redis).lpush(self.key, obj.id)
+        obj.association_memberships.add(self.key)
+        true
+      end
+
+      def remove(obj)
+        raise(Chimera::Error::AssociationClassMismatch) unless obj.class.to_s == self.klass.to_s
+        self.model.class.connection(:redis).lrem(self.key, 0, obj.id)
+        obj.association_memberships.remove(self.key)
+        true
+      end
+
+      def size
+        self.model.class.connection(:redis).llen(self.key)
+      end
+
+      def each
+        llen  = self.model.class.connection(:redis).llen(self.key)
+        curr  = 0
+        while(curr < llen)
+          keys = self.model.class.connection(:redis).lrange(self.key, curr, curr+9).compact
+          self.klass.find_many(keys).each { |obj| yield(obj) }
+          curr += 10
+        end
+        true
+      end
+      
+      def all
+        found = []; self.each { |o| found << o }; found
+      end
+
+      def destroy(delete_associated=true)
+        if delete_associated == true
+          self.each { |obj| obj.destroy }
+        else
+          self.each { |obj| obj.association_memberships.remove(self.key) }
+        end
+        self.model.class.connection(:redis).del(self.key)
+      end
+    end # Association
+  end # AssociationProxies
+end