cassandra_object 0.6.0.pre

data/lib/cassandra_object/associations/one_to_many.rb

@@ -0,0 +1,136 @@
+module CassandraObject
+  class OneToManyAssociation
+    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.singularize.camelize
+      @options           = options
+      
+      define_methods!
+    end
+    
+    def find(owner, options = {})
+      reversed = options.has_key?(:reversed) ? options[:reversed] : reversed?
+      cursor   = CassandraObject::Cursor.new(target_class, column_family, owner.key.to_s, @association_name, :start_after => options[:start_after], :reversed => reversed)
+      cursor.find(options[:limit] || 100)
+    end
+    
+    def add(owner, record, set_inverse = true)
+      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 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
+    
+    def has_inverse?
+      @options[:inverse_of]
+    end
+    
+    def inverse
+      has_inverse? && target_class.associations[@options[:inverse_of]]
+    end
+    
+    def set_inverse(owner, record)
+      add(owner, record, false)
+    end
+    
+    def reversed?
+      @options[:reversed] == true
+    end
+
+    def define_methods!
+      @owner_class.class_eval <<-eos
+        def #{@association_name}
+          @_#{@association_name} ||= self.class.associations[:#{@association_name}].new_proxy(self)
+        end
+      eos
+    end
+  end
+  
+  class OneToManyAssociationProxy
+    def initialize(association, owner)
+      @association = association
+      @owner       = owner
+    end
+    
+    include Enumerable
+    def each
+      target.each do |i|
+        yield i
+      end
+    end
+    
+    def <<(record)
+      @association.add(@owner, record)
+      if loaded?
+        @target << record
+      end
+    end
+    
+    # Get the targets of this association proxy
+    #
+    # @param  [Hash] options the options with which to modify this query
+    # @option options [String]  :start_after the key after which to start returning results
+    # @option options [Boolean] :reversed (false or association default) return the results in reverse order
+    # @option options [Integer] :limit the max number of results to return
+    # @return [Array<CassandraObject::Base>] an array of objects of type self#target_class
+    #
+    def all(options = {})
+      @association.find(@owner, options)
+    end
+    
+    # Create a record of the associated type with 
+    # the supplied attributes and add it to this 
+    # association
+    #
+    # @param  [Hash] attributes the attributes with which to create the object
+    # @return [CassandraObject::Base] the newly created object
+    #
+    def create(attributes)
+      returning @association.target_class.create(attributes) do |record|
+        if record.valid?
+          self << record
+        end
+      end
+    end
+    
+    def create!(attributes)
+      returning @association.target_class.create!(attributes) do |record|
+        self << record
+      end
+    end
+    
+    def target
+      @target ||= begin
+        @loaded = true
+        @association.find(@owner)
+      end
+    end
+    
+    alias to_a target
+    
+    def loaded?
+      defined?(@loaded) && @loaded
+    end
+  end
+end

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/associations.rb

@@ -0,0 +1,35 @@
+require 'cassandra_object/associations/one_to_many'
+require 'cassandra_object/associations/one_to_one'
+
+module CassandraObject
+  module Associations
+    extend ActiveSupport::Concern
+    
+    included do
+      class_inheritable_hash :associations
+    end
+
+    module ClassMethods
+      def column_family_configuration
+        super << {:Name=>"#{name}Relationships", :CompareWith=>"UTF8Type", :CompareSubcolumnsWith=>"TimeUUIDType", :ColumnType=>"Super"}
+      end
+      
+      def association(association_name, options= {})
+        if options[:unique]
+          write_inheritable_hash(:associations, {association_name => OneToOneAssociation.new(association_name, self, options)})
+        else
+          write_inheritable_hash(:associations, {association_name => OneToManyAssociation.new(association_name, self, options)})
+        end
+      end
+      
+      def remove(key)
+        begin
+          connection.remove("#{name}Relationships", key.to_s)
+        rescue Cassandra::AccessError => e
+          raise e unless e.message =~ /Invalid column family/
+        end
+        super
+      end
+    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,104 @@
+require 'cassandra'
+require 'set'
+require 'cassandra_object/attributes'
+require 'cassandra_object/dirty'
+require 'cassandra_object/persistence'
+
+if CassandraObject.old_active_support
+  require 'cassandra_object/legacy_callbacks'
+else
+  require 'cassandra_object/callbacks'
+end
+
+require 'cassandra_object/validation'
+require 'cassandra_object/identity'
+require 'cassandra_object/indexes'
+require 'cassandra_object/serialization'
+require 'cassandra_object/associations'
+require 'cassandra_object/migrations'
+require 'cassandra_object/cursor'
+require 'cassandra_object/collection'
+require 'cassandra_object/types'
+require 'cassandra_object/mocking'
+
+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
+    
+    if CassandraObject.old_active_support
+      def self.lookup_ancestors
+        super.select { |x| x.model_name.present? }
+      end
+    end
+    
+    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/abstract_key_factory.rb

@@ -0,0 +1,36 @@
+module CassandraObject
+  module Identity
+    # Key factories need to support 3 operations
+    class AbstractKeyFactory
+      # Next key takes an object and returns the key object it should use.
+      # object will be ignored with synthetic keys but could be useful with natural ones
+      #
+      # @param  [CassandraObject::Base] the object that needs a new key
+      # @return [CassandraObject::Identity::Key] the key
+      #
+      def next_key(object)
+        raise NotImplementedError, "#{self.class.name}#next_key isn't implemented."
+      end
+
+      # Parse should create a new key object from the 'to_param' format
+      #
+      # @param  [String] the result of calling key.to_param
+      # @return [CassandraObject::Identity::Key] the parsed key
+      #
+      def parse(string)
+        raise NotImplementedError, "#{self.class.name}#parse isn't implemented."
+      end
+
+
+      # create should create a new key object from the cassandra format.
+      #
+      # @param  [String] the result of calling key.to_s
+      # @return [CassandraObject::Identity::Key] the key
+      #
+      def create(string)
+        raise NotImplementedError, "#{self.class.name}#create isn't implemented."
+      end
+    end
+  end
+end
+

data/lib/cassandra_object/identity/key.rb

@@ -0,0 +1,20 @@
+module CassandraObject
+  module Identity
+    # An "interface" that keys need to implement
+    # 
+    # You don't have to include this. But, there's no reason I can think of not to.
+    #
+    module Key
+      # to_param should return a nice-readable representation of the key suitable to chuck into URLs
+      #
+      # @return [String] a nice readable representation of the key suitable for URLs
+      def to_param; end
+        
+      # to_s should return the bytes which will be written to cassandra both as keys and values for associations.
+      #
+      # @return [String] the bytes which will be written to cassandra as keys
+      def to_s; end
+    end
+  end
+end
+

data/lib/cassandra_object/identity/natural_key_factory.rb

@@ -0,0 +1,51 @@
+module CassandraObject
+  module Identity
+    class NaturalKeyFactory < AbstractKeyFactory
+      class NaturalKey
+        include Key
+
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_s
+          value
+        end
+
+        def to_param
+          value
+        end
+
+        def ==(other)
+          other.is_a?(NaturalKey) && other.value == value
+        end
+
+        def eql?(other)
+          other == self
+        end
+      end
+
+      attr_reader :attributes, :separator
+
+      def initialize(options)
+        @attributes = [*options[:attributes]]
+        @separator  = options[:separator] || "-"
+      end
+
+      def next_key(object)
+        NaturalKey.new(attributes.map { |a| object.attributes[a.to_s] }.join(separator))
+      end
+
+      def parse(paramized_key)
+        NaturalKey.new(paramized_key)
+      end
+
+      def create(paramized_key)
+        NaturalKey.new(paramized_key)
+      end
+    end
+  end
+end
+