gotime-cassandra_object 0.6.1

data/lib/cassandra_object/associations/one_to_one.rb

@@ -0,0 +1,77 @@
+module CassandraObject
+  class OneToOneAssociation
+    def initialize(association_name, owner_class, options)
+      @association_name  = association_name.to_s
+      @owner_class       = owner_class
+      @target_class_name = options[:class_name] || association_name.to_s.camelize 
+      @options           = options
+
+      define_methods!
+    end
+    
+    def define_methods!
+      @owner_class.class_eval <<-eos
+        def #{@association_name}
+          @_#{@association_name} ||= self.class.associations[:#{@association_name}].find(self)
+        end
+        
+        def #{@association_name}=(record)
+          @_#{@association_name} = record
+          self.class.associations[:#{@association_name}].set(self, record)
+        end
+      eos
+    end
+    
+    def clear(owner)
+      connection.remove(column_family, owner.key.to_s, @association_name)
+    end
+    
+    def find(owner)
+      if key = connection.get(column_family, owner.key.to_s, @association_name.to_s, :count=>1).values.first
+        target_class.get(key)
+      else
+        nil
+      end
+    end  
+    
+    def set(owner, record, set_inverse = true)
+      clear(owner)
+      connection.insert(column_family, owner.key.to_s, {@association_name=>{new_key => record.key.to_s}})
+      if has_inverse? && set_inverse
+        inverse.set_inverse(record, owner)
+      end
+    end
+    
+    def new_key
+      SimpleUUID::UUID.new
+    end
+    
+    def set_inverse(owner, record)
+      set(owner, record, false)
+    end
+    
+    def has_inverse?
+      @options[:inverse_of]
+    end
+    
+    def inverse
+      has_inverse? && target_class.associations[@options[:inverse_of]]
+    end
+
+    def column_family
+      @owner_class.to_s + "Relationships"
+    end
+    
+    def connection
+      @owner_class.connection
+    end
+    
+    def target_class
+      @target_class ||= @target_class_name.constantize
+    end
+    
+    def new_proxy(owner)
+      # OneToManyAssociationProxy.new(self, owner)
+    end
+  end
+end

data/lib/cassandra_object/attributes.rb

@@ -0,0 +1,93 @@
+module CassandraObject
+  class Attribute
+
+    attr_reader :name, :converter, :expected_type
+    def initialize(name, owner_class, converter, expected_type, options)
+      @name          = name.to_s
+      @owner_class   = owner_class
+      @converter     = converter
+      @expected_type = expected_type
+      @options       = options
+    end
+
+    def check_value!(value)
+      converter.encode(value) unless value.nil? && @options[:allow_nil]
+      value
+    end
+
+    def define_methods!
+      @owner_class.define_attribute_methods(true)
+    end
+  end
+
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    module ClassMethods
+      def attribute(name, options)
+        
+        unless type_mapping = attribute_types[options[:type]]
+          type_mapping =  { :expected_type => options[:type], 
+                            :converter => options[:converter] }.with_indifferent_access
+        end
+        
+        new_attr = Attribute.new(name, self, type_mapping[:converter], type_mapping[:expected_type], options)
+        write_inheritable_hash(:model_attributes, {name => new_attr}.with_indifferent_access)
+        new_attr.define_methods!
+      end
+
+      def define_attribute_methods(force = false)
+        return unless model_attributes
+        undefine_attribute_methods if force
+        super(model_attributes.keys)
+      end
+      
+      def register_attribute_type(name, expected_type, converter)
+        attribute_types[name] = { :expected_type => expected_type, :converter => converter }.with_indifferent_access
+      end
+    end
+
+    included do
+      class_inheritable_hash :model_attributes
+      attribute_method_suffix("", "=")
+      
+      cattr_accessor :attribute_types
+      self.attribute_types = {}.with_indifferent_access
+    end
+
+    module InstanceMethods
+      def write_attribute(name, value)
+        if ma = self.class.model_attributes[name]
+          @attributes[name.to_s] = ma.check_value!(value)
+        else
+          raise NoMethodError, "Unknown attribute #{name.inspect}"
+        end
+      end
+
+      def read_attribute(name)
+        @attributes[name.to_s]
+      end
+
+      def attributes=(attributes)
+        attributes.each do |(name, value)|
+          send("#{name}=", value)
+        end
+      end
+
+      protected
+        def attribute_method?(name)
+          !!model_attributes[name.to_sym]
+        end
+
+      private
+        def attribute(name)
+          read_attribute(name.to_sym)
+        end
+
+        def attribute=(name, value)
+          write_attribute(name.to_sym, value)
+        end
+    end
+  end
+end

data/lib/cassandra_object/base.rb

@@ -0,0 +1,97 @@
+require 'cassandra'
+require 'set'
+require 'cassandra_object/attributes'
+require 'cassandra_object/dirty'
+require 'cassandra_object/persistence'
+
+require 'cassandra_object/callbacks'
+
+require 'cassandra_object/validation'
+require 'cassandra_object/identity'
+require 'cassandra_object/indexes'
+require 'cassandra_object/serialization'
+require 'cassandra_object/associations'
+#require 'cassandra_object/sets'
+require 'cassandra_object/migrations'
+require 'cassandra_object/cursor'
+require 'cassandra_object/collection'
+require 'cassandra_object/types'
+require 'cassandra_object/mocking'
+
+require 'cassandra_object/log_subscriber'
+
+module CassandraObject
+  class Base
+    class_inheritable_accessor :connection
+    class_inheritable_writer :connection_class
+
+    def self.connection_class
+      read_inheritable_attribute(:connection_class) || Cassandra
+    end
+
+    module ConnectionManagement
+      def establish_connection(*args)
+        self.connection = connection_class.new(*args)
+      end
+    end
+    extend ConnectionManagement
+
+    module Naming
+      def column_family=(column_family)
+        @column_family = column_family
+      end
+
+      def column_family
+        @column_family || name.pluralize
+      end
+    end
+    extend Naming
+    
+    extend ActiveModel::Naming
+    
+    module ConfigurationDumper
+      def storage_config_xml
+        subclasses.map(&:constantize).map(&:column_family_configuration).flatten.map do |config|
+          config_to_xml(config)
+        end.join("\n")
+      end
+      
+      def config_to_xml(config)
+        xml = "<ColumnFamily "
+        config.each do |(attr_name, attr_value)|
+          xml << " #{attr_name}=\"#{attr_value}\""
+        end
+        xml << " />"
+        xml
+      end
+    end
+    extend ConfigurationDumper
+    
+    include Callbacks
+    include Identity
+    include Attributes
+    include Persistence
+    include Indexes
+    include Dirty
+
+    include Validation
+    include Associations
+
+    attr_reader :attributes
+    attr_accessor :key
+
+    include Serialization
+    include Migrations
+    include Mocking
+
+    def initialize(attributes={})
+      @key = attributes.delete(:key)
+      @new_record = true
+      @attributes = {}.with_indifferent_access
+      self.attributes = attributes
+      @schema_version = self.class.current_schema_version
+    end
+  end
+end
+
+require 'cassandra_object/type_registration'

data/lib/cassandra_object/callbacks.rb

@@ -0,0 +1,10 @@
+module CassandraObject
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :save, :create, :destroy, :update
+    end
+  end
+end

data/lib/cassandra_object/collection.rb

@@ -0,0 +1,8 @@
+module CassandraObject
+  class Collection < Array
+    attr_accessor :last_column_name
+    def inspect
+      "<CassandraObject::Collection##{object_id} contents: #{super} last_column_name: #{last_column_name.inspect}>"
+    end
+  end
+end

data/lib/cassandra_object/cursor.rb

@@ -0,0 +1,86 @@
+module CassandraObject
+  class Cursor
+    def initialize(target_class, column_family, key, super_column, options={})
+      @target_class  = target_class
+      @column_family = column_family
+      @key           = key.to_s
+      @super_column  = super_column
+      @options       = options
+      @validators    = []
+    end
+    
+    def find(number_to_find)
+      limit       = number_to_find
+      objects     = CassandraObject::Collection.new
+      out_of_keys = false
+
+      if start_with = @options[:start_after]
+        limit += 1
+      else
+        start_with = nil
+      end
+      
+      while objects.size < number_to_find && !out_of_keys
+        index_results = connection.get(@column_family, @key, @super_column, :count=>limit,
+                                                                            :start=>start_with,
+                                                                            :reversed=>@options[:reversed])
+
+        out_of_keys  = index_results.size < limit
+
+        if !start_with.blank?
+          index_results.delete(start_with)
+        end
+
+        keys = index_results.keys
+        values = index_results.values
+        
+        missing_keys = []
+        
+        results = values.empty? ? {} : @target_class.multi_get(values)
+        results.each do |(key, result)|
+          if result.nil?
+            missing_keys << key
+          end
+        end
+    
+        unless missing_keys.empty?
+          @target_class.multi_get(missing_keys, :quorum=>true).each do |(key, result)|
+            index_key = index_results.index(key)
+            if result.nil?
+              remove(index_key)
+              results.delete(key)
+            else
+              results[key] = result
+            end
+          end
+        end
+
+        results.values.each do |o|
+          if @validators.all? {|v| v.call(o) }
+            objects << o
+          else
+            remove(index_results.index(o.key))
+          end
+        end
+        
+        start_with = objects.last_column_name = keys.last
+        limit = (number_to_find - results.size) + 1
+        
+      end
+      
+      return objects
+    end
+    
+    def connection
+      @target_class.connection
+    end
+    
+    def remove(index_key)
+      connection.remove(@column_family, @key, @super_column, index_key)
+    end
+    
+    def validator(&validator)
+      @validators << validator
+    end
+  end
+end

data/lib/cassandra_object/dirty.rb

@@ -0,0 +1,27 @@
+module CassandraObject
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    module InstanceMethods
+      def attributes_changed!(attributes)
+        attributes.each do |attr_name|
+          attribute_will_change!(attr_name)
+        end
+      end
+
+      def save
+        super.tap { changed_attributes.clear }
+      end
+
+      def write_attribute(name, value)
+        name = name.to_s
+        unless attribute_changed?(name)
+          old = read_attribute(name)
+          changed_attributes[name] = old if old != value
+        end
+        super
+      end
+    end
+  end
+end

data/lib/cassandra_object/identity.rb

@@ -0,0 +1,61 @@
+require 'cassandra_object/identity/abstract_key_factory'
+require 'cassandra_object/identity/key'
+require 'cassandra_object/identity/uuid_key_factory'
+require 'cassandra_object/identity/natural_key_factory'
+
+module CassandraObject
+  # Some docs will be needed here but the gist of this is simple.  Instead of returning a string, Base#key  now returns a key object.
+  # There are corresponding key factories which generate them
+  module Identity
+    extend ActiveSupport::Concern
+    module ClassMethods
+      # Indicate what kind of key the model will have: uuid or natural
+      #
+      # @param [:uuid, :natural] the type of key
+      # @param the options you want to pass along to the key factory (like :attributes => :name, for a natural key).
+      # 
+      def key(name_or_factory = :uuid, *options)
+        @key_factory = case name_or_factory
+        when :uuid
+          UUIDKeyFactory.new
+        when :natural
+          NaturalKeyFactory.new(*options)
+        else
+          name_or_factory
+        end
+      end
+    
+      def next_key(object = nil)
+        @key_factory.next_key(object).tap do |key|
+          raise "Keys may not be nil" if key.nil?
+        end
+      end
+      
+      def parse_key(string)
+        @key_factory.parse(string)
+      end
+    end
+    
+    module InstanceMethods
+
+      def ==(comparison_object)
+        comparison_object.equal?(self) ||
+          (comparison_object.instance_of?(self.class) &&
+            comparison_object.key == key &&
+            !comparison_object.new_record?)
+      end
+
+      def eql?(comparison_object)
+        self == (comparison_object)
+      end
+
+      def hash
+        key.to_s.hash
+      end
+      
+      def to_param
+        key.to_param
+      end
+    end
+  end
+end