chimera 0.0.1

data/lib/chimera/attributes.rb

@@ -0,0 +1,52 @@
+module Chimera
+  module Attributes
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      def defined_attributes
+        @defined_attributes || {}
+      end
+
+      # available types include: model
+      def attribute(name, type = nil, extra_opts={})
+        @defined_attributes ||= {}
+        @defined_attributes[name.to_sym] = [type, extra_opts]
+        define_method("#{name}") do
+          return nil unless @attributes
+          if type == :model
+            @cached_attributes ||= {}
+            @cached_attributes[name.to_sym] ||= begin
+              model_id = @attributes[name.to_sym]
+              klass = extra_opts[:class]
+              if model_id && klass
+                eval(klass.to_s.camelize).find(model_id)
+              end
+            end
+          else
+            @attributes[name.to_sym]
+          end
+        end
+        define_method("#{name}=") do |val|
+          return nil unless @attributes
+          if type == :model
+            @cached_attributes ||= {}
+            @cached_attributes.delete(name.to_sym)
+            if val.respond_to?(:id)
+              @attributes[name.to_sym] = val.id
+            else
+              @attributes.delete(name.to_sym)
+            end
+          else @attributes
+            @attributes[name.to_sym] = val
+          end
+        end
+      end
+    end # ClassMethods
+    
+    module InstanceMethods
+    end # InstanceMethods
+  end
+end

data/lib/chimera/base.rb

@@ -0,0 +1,95 @@
+module Chimera
+  def self.config_path=(path)
+    @config_path = path
+    @config = YAML.load_file(@config_path)
+  end
+  
+  def self.config
+    @config || raise(Chimera::Error::MissingConfig)
+  end
+  
+  class Base
+    include Chimera::Attributes
+    include Chimera::Indexes
+    include Chimera::GeoIndexes
+    include Chimera::Associations
+    include Chimera::RedisObjects
+    include Chimera::Finders
+    include Chimera::Persistence
+    include ActiveModel::Validations
+
+    extend ActiveModel::Naming
+    extend ActiveModel::Callbacks
+    define_model_callbacks :create, :save, :destroy
+    
+    attr_accessor :id, :attributes, :orig_attributes, :riak_response, :associations
+    
+    def self.use_config(key)
+      @config = (Chimera.config[key.to_sym] || raise(Chimera::Error::MissingConfig,":#{key}"))
+    end
+    
+    def self.config
+      @config ||= (Chimera.config[:default] || raise(Chimera::Error::MissingConfig,":default"))
+    end
+    
+    def self.connection(server)
+      Thread.current["Chimera::#{self.to_s}::#{server}::connection"] ||= begin
+        case server.to_sym
+        when :redis
+          Redis.new(self.config[:redis])
+        when :riak_raw
+          RiakRaw::Client.new(self.config[:riak_raw][:host], self.config[:riak_raw][:port])
+        else
+          nil
+        end
+      end
+    end
+
+    def self.bucket_key
+      self.to_s
+    end
+    
+    def self.bucket(keys=false)
+      self.connection(:riak_raw).bucket(self.bucket_key,keys)
+    end
+    
+    def self.new_uuid
+      UUIDTools::UUID.random_create.to_s
+    end
+    
+    def inspect
+      "#<#{self.to_s}: @id=#{self.id}, @new=#{@new}>"
+    end
+    
+    def ==(obj)
+      obj.class.to_s == self.class.to_s &&
+        !obj.new? && !self.new? &&
+        obj.id == self.id
+    end
+    
+    def <=>(obj)
+      self.id.to_s <=> obj.id.to_s
+    end
+    
+    def initialize(attributes={},id=nil,is_new=true)
+      @attributes = attributes
+      @orig_attributes = @attributes.clone
+      @id = id
+      @new = is_new
+    end
+    
+    def id=(val)
+      if self.new?
+        @id = val
+      else
+        raise(Chimera::Error::AttemptToModifyId)
+      end
+    end
+    
+    protected
+    
+    def read_attribute_for_validation(key)
+      @attributes[key.to_sym]
+    end
+  end # Base
+end # Chimera

data/lib/chimera/config.rb

@@ -0,0 +1,9 @@
+module Chimera
+  module Config
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+    end
+  end
+end

data/lib/chimera/error.rb

@@ -0,0 +1,12 @@
+module Chimera
+  class Error < RuntimeError
+    class MissingConfig < Chimera::Error; end
+    class UniqueConstraintViolation < Chimera::Error; end
+    class SaveWithoutId < Chimera::Error; end
+    class MissingId < Chimera::Error; end
+    class ValidationErrors < Chimera::Error; end
+    class AttemptToModifyId < Chimera::Error; end
+    class AssociationClassMismatch < Chimera::Error; end
+  end
+end
+

data/lib/chimera/finders.rb

@@ -0,0 +1,49 @@
+module Chimera
+  module Finders
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      def each
+        self.find_with_index(:all) { |obj| yield(obj) }
+      end
+      
+      def find(key)
+        find_many(key)[0]
+      end
+      
+      def find_many(keys)
+        keys    = Array(keys)
+        found   = []
+        threads = []
+        keys.each do |key|
+          threads << Thread.new do
+            if key
+              resp = self.connection(:riak_raw).fetch(self.to_s, key)
+              if resp.code == 200
+                if resp.body and yaml_hash = YAML.load(resp.body)
+                  hash = {}
+                  yaml_hash.each { |k,v| hash[k.to_sym] = v }
+                  obj = self.new(hash,key,false)
+                  obj.riak_response = resp
+                  found << obj
+                else
+                  obj = self.new({},key,false)
+                  obj.riak_response = resp
+                  found << obj
+                end
+              end
+            end
+          end # Thread.new
+        end # keys.each
+        threads.each { |th| th.join }
+        found
+      end # find_many
+    end # ClassMethods
+    
+    module InstanceMethods
+    end # InstanceMethods
+  end
+end

data/lib/chimera/geo_indexes.rb

@@ -0,0 +1,76 @@
+module Chimera
+  module GeoIndexes
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      def key_for_geo_index(type, name, lat, lon, step_size=0.05)
+        step_size ||= 0.05
+        case type.to_sym
+        when :geo then
+          lat = geo_square_coord(lat)
+          lon = geo_square_coord(lon)
+          "#{self.to_s}::Indexes::#{type}::#{name}::#{step_size}::#{lat}::#{lon}"
+        end
+      end
+      
+      def find_with_geo_index(name, opts_or_query)
+        if props = self.defined_indexes[name.to_sym]
+          case props[:type]
+          when :geo then
+            step_size = props[:step_size]
+            num_steps = opts_or_query[:steps] || 5
+            steps = [50,num_steps].min * step_size
+            lat, lon = opts_or_query[:coordinate]
+            union_keys = []
+            curr_lat = lat - steps
+            while curr_lat < lat+steps
+              curr_lon = lon - steps
+              while curr_lon < lon+steps
+                union_keys << key_for_geo_index(:geo,name,curr_lat,curr_lon,step_size)
+                curr_lon += step_size
+              end
+              curr_lat += step_size
+            end
+            keys = self.connection(:redis).sunion(union_keys.join(" "))
+            find_many(keys)
+          end # case
+        end # if props =
+      end
+      
+      def geo_square_coord(lat_or_lon, step=0.05)
+        i = (lat_or_lon*1000000).floor
+        i += (step/2)*1000000
+        (i - (i % (step * 1000000)))/1000000
+      end
+    end
+    
+    module InstanceMethods
+      def destroy_geo_indexes
+        self.class.defined_indexes.each do |name, props|
+          case props[:type]
+          when :geo then
+            if val = @orig_attributes[name.to_sym] and val.is_a?(Array)
+              index_key = self.class.key_for_geo_index(:geo, name, val[0], val[1], props[:step_size])
+              self.class.connection(:redis).srem(index_key, self.id)
+            end
+          end # case props[:type]
+        end # self.class.defined_indexes
+      end # destroy_geo_indexes
+      
+      def create_geo_indexes
+        self.class.defined_indexes.each do |name, props|
+          case props[:type]
+          when :geo then
+            if val = @attributes[name.to_sym] and val.is_a?(Array)
+              index_key = self.class.key_for_geo_index(:geo, name, val[0], val[1], props[:step_size])
+              self.class.connection(:redis).sadd(index_key, self.id)
+            end
+          end # case props[:type]
+        end # self.class.defined_indexes
+      end # create_geo_indexes
+    end
+  end
+end

data/lib/chimera/indexes.rb

@@ -0,0 +1,177 @@
+module Chimera
+  module Indexes
+    SEARCH_EXCLUDE_LIST = %w(a an and as at but by for in into of on onto to the)
+    
+    def self.included(base)
+      base.send :extend, ClassMethods
+      base.send :include, InstanceMethods
+    end
+    
+    module ClassMethods
+      def defined_indexes
+        @defined_indexes || {}
+      end
+
+      # available types include:
+      #   find, unique, search, geo
+      def index(name, type = :find)
+        @defined_indexes ||= {}
+        @defined_indexes[name.to_sym] = type
+      end
+      
+      def find_with_index(name, opts_or_query=nil)
+        if opts_or_query.is_a?(Hash)
+          q = opts_or_query[:q].to_s
+        else
+          q = opts_or_query.to_s
+        end
+        if name.to_sym == :all
+          llen  = self.connection(:redis).llen(self.key_for_all_index)
+          curr  = 0
+          while(curr < llen)
+            keys = self.connection(:redis).lrange(self.key_for_all_index, curr, curr+9).compact
+            find_many(keys).each { |obj| yield(obj) }
+            curr += 10
+          end
+        elsif props = self.defined_indexes[name.to_sym]
+          case props[:type]
+          when :find then
+            if q and !q.blank?
+              index_key = self.key_for_index(:find, name, q)
+              self.find_many(self.connection(:redis).smembers(index_key))
+            end
+          when :unique then
+            if q and !q.blank?
+              index_key = self.key_for_index(:unique, name, q)
+              Array(self.find(self.connection(:redis).get(index_key)))
+            end
+          when :search then
+            keys = []
+            q.split(" ").each do |word|
+              word = word.downcase.stem
+              next if Chimera::Indexes::SEARCH_EXCLUDE_LIST.include?(word)
+              keys << self.key_for_index(:search, name, word)
+            end
+            if keys.size > 0
+              if opts_or_query.is_a?(Hash) and opts_or_query[:type] == :union
+                self.find_many(self.connection(:redis).sunion(keys.join(" ")))
+              else
+                self.find_many(self.connection(:redis).sinter(keys.join(" ")))
+              end
+            end
+          when :geo then
+            find_with_geo_index(name, opts_or_query)
+          end # case
+        end # if props
+      end
+      
+      def key_for_index(type, name, val)
+        case type.to_sym
+        when :find, :unique, :search then
+          "#{self.to_s}::Indexes::#{type}::#{name}::#{digest(val)}"
+        end
+      end
+      
+      def key_for_all_index
+        "#{self.to_s}::Indexes::All"
+      end
+      
+      def digest(val)
+        Digest::SHA1.hexdigest(val)
+      end
+    end # ClassMethods
+    
+    module InstanceMethods
+      def destroy_indexes
+        remove_from_all_index
+        self.class.defined_indexes.each do |name, props|
+          case props[:type]
+          when :find then
+            if val = @orig_attributes[name.to_sym] and !val.blank?
+              index_key = self.class.key_for_index(:find, name,val.to_s)
+              self.class.connection(:redis).srem(index_key, self.id)
+            end
+          when :unique then
+            if val = @orig_attributes[name.to_sym] and !val.blank?
+              index_key = self.class.key_for_index(:unique, name,val.to_s)
+              self.class.connection(:redis).del(index_key)
+            end
+          when :search then
+            if val = @orig_attributes[name.to_sym] and !val.blank?
+              val.to_s.split(" ").each do |word|
+                word = word.downcase.stem
+                next if Chimera::Indexes::SEARCH_EXCLUDE_LIST.include?(word)
+                index_key = self.class.key_for_index(:search, name, word)
+                self.class.connection(:redis).srem(index_key, self.id)
+              end
+            end
+          end
+        end
+        destroy_geo_indexes
+      end
+      
+      def check_index_constraints
+        self.class.defined_indexes.each do |name, props|
+          case props[:type]
+          when :unique then
+            if val = @attributes[name.to_sym] and !val.blank?
+              index_key = self.class.key_for_index(:unique, name,val.to_s)
+              if k = self.class.connection(:redis).get(index_key)
+                if k.to_s != self.id.to_s
+                  raise(Chimera::Error::UniqueConstraintViolation, val)
+                end
+              end
+            end # if val
+          end # case
+        end
+      end
+      
+      def create_indexes
+        add_to_all_index
+        self.class.defined_indexes.each do |name, props|
+          case props[:type]
+          when :find then
+            if val = @attributes[name.to_sym] and !val.blank?
+              index_key = self.class.key_for_index(:find, name, val.to_s)
+              self.class.connection(:redis).sadd(index_key, self.id)
+            end
+          when :unique then
+            if val = @attributes[name.to_sym] and !val.blank?
+              index_key = self.class.key_for_index(:unique, name,val.to_s)
+              if self.class.connection(:redis).exists(index_key)
+                raise(Chimera::Error::UniqueConstraintViolation, val)
+              else
+                self.class.connection(:redis).set(index_key, self.id)
+              end
+            end
+          when :search then
+            if val = @attributes[name.to_sym] and !val.blank?
+              val.to_s.split(" ").each do |word|
+                word = word.downcase.stem
+                next if Chimera::Indexes::SEARCH_EXCLUDE_LIST.include?(word)
+                index_key = self.class.key_for_index(:search, name, word)
+                self.class.connection(:redis).sadd(index_key, self.id)
+              end
+            end
+          end
+        end
+        create_geo_indexes
+      end
+      
+      def update_indexes
+        destroy_indexes
+        destroy_geo_indexes
+        create_indexes
+        create_geo_indexes
+      end
+      
+      def remove_from_all_index
+        self.class.connection(:redis).lrem(self.class.key_for_all_index, 0, self.id)
+      end
+      
+      def add_to_all_index
+        self.class.connection(:redis).lpush(self.class.key_for_all_index, self.id)
+      end
+    end # InstanceMethods
+  end
+end