datastax_rails 1.0.5

data/lib/datastax_rails/associations.rb

@@ -0,0 +1,86 @@
+module DatastaxRails
+  module Associations
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+    
+    autoload :Association
+    autoload :AssociationScope
+    autoload :SingularAssociation
+    autoload :CollectionAssociation
+    autoload :CollectionProxy
+    autoload :BelongsToAssociation
+    autoload :HasOneAssociation
+    autoload :HasManyAssociation
+    
+    module Builder
+      extend ActiveSupport::Autoload
+      
+      autoload :Association
+      autoload :SingularAssociation
+      autoload :CollectionAssociation
+      
+      autoload :BelongsTo
+      autoload :HasOne
+      autoload :HasMany
+    end
+    
+    # Clears out the association cache.
+    def clear_association_cache #:nodoc:
+      @association_cache.clear if persisted?
+    end
+
+    # :nodoc:
+    attr_reader :association_cache
+
+    # Returns the association instance for the given name, instantiating it if it doesn't already exist
+    def association(name) #:nodoc:
+      association = association_instance_get(name)
+
+      if association.nil?
+        reflection = self.class.reflect_on_association(name)
+        association = reflection.association_class.new(self, reflection)
+        association_instance_set(name, association)
+      end
+
+      association
+    end
+    
+    private
+      # Returns the specified association instance if it responds to :loaded?, nil otherwise.
+      def association_instance_get(name)
+        @association_cache ||= {}
+        @association_cache[name.to_sym]
+      end
+
+      # Set the specified association instance.
+      def association_instance_set(name, association)
+        @association_cache ||= {}
+        @association_cache[name] = association
+      end
+    
+    module ClassMethods
+      def belongs_to(name, options = {})
+        Builder::BelongsTo.build(self, name, options)
+      end
+      
+      def has_many(name, options = {})
+        Builder::HasMany.build(self, name, options)
+        # klass = options[:class_name]
+        # klass ||= name.to_s.singularize
+        # foreign_key = options[:foreign_key]
+        # foreign_key ||= self.name.foreign_key
+        # define_method name do
+          # klass.where(foreign_key)
+        # end
+      end
+      
+      def has_and_belongs_to_many(name, options = {})
+        
+      end
+      
+      def has_one(name, options = {})
+        Builder::HasOne.build(self, name, options)
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/definition.rb

@@ -0,0 +1,20 @@
+module DatastaxRails
+  module AttributeMethods
+    class Definition
+      attr_reader :name, :coder, :lazy
+      def initialize(name, coder, options)
+        @name   = name.to_s
+        @lazy   = options.delete(:lazy)
+        @coder  = coder.new(options)
+      end
+
+      def instantiate(record, value)
+        value ||= coder.default
+        return unless value
+      
+        value = value.kind_of?(String) ? coder.decode(value) : value
+        coder.wrap(record, name, value)
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/dirty.rb

@@ -0,0 +1,43 @@
+module DatastaxRails
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+      include ActiveModel::Dirty
+
+      # Attempts to +save+ the record and clears changed attributes if successful.
+      def save(*) #:nodoc:
+        if status = super
+          @previously_changed = changes
+          @changed_attributes.clear
+        end
+        status
+      end
+
+      # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
+      def save!(*) #:nodoc:
+        super.tap do
+          @previously_changed = changes
+          @changed_attributes.clear
+        end
+      end
+
+      # <tt>reload</tt> the record and clears changed attributes.
+      def reload
+        super.tap do
+          @previously_changed.try :clear
+          @changed_attributes.try :clear
+        end
+      end
+
+      def write_attribute(name, value)
+        name = name.to_s
+        old = read_attribute(name)
+        super
+
+        unless attribute_changed?(name) || old == read_attribute(name)
+          changed_attributes[name] = old
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/typecasting.rb

@@ -0,0 +1,50 @@
+module DatastaxRails
+  module AttributeMethods
+    module Typecasting
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :attribute_definitions
+        class_attribute :lazy_attributes
+        class_attribute :readonly_attributes
+        self.attribute_definitions = {}
+        self.lazy_attributes = []
+        self.readonly_attributes = []
+
+        %w(array boolean date float integer json string text time time_with_zone).each do |type|
+          instance_eval <<-EOV, __FILE__, __LINE__ + 1
+            def #{type}(name, options = {})                               # def string(name, options = {})
+              attribute(name, options.update(:type => :#{type}))             #   attribute(name, options.update(type: :string))
+            end                                                           # end
+          EOV
+        end
+        
+        def self.binary(name, options = {})
+          options.reverse_merge!(:lazy => true)
+          attribute(name, options.update(:type => :binary))
+        end
+        
+        def self.timestamps(options = {})
+          attribute(:created_at, options.update(:type => :time))
+          attribute(:updated_at, options.update(:type => :time))
+        end
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+          child.attribute_definitions = attribute_definitions.dup
+          self.models << child
+        end
+
+        def typecast_attribute(record, name, value)
+          if attribute_definition = attribute_definitions[name.to_sym]
+            attribute_definition.instantiate(record, value)
+          else
+            raise NoMethodError, "Unknown attribute #{name.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods.rb

@@ -0,0 +1,104 @@
+module DatastaxRails
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+    
+    included do
+      alias :[] :read_attribute
+      alias :[]= :write_attribute
+
+      attribute_method_suffix("=")
+    end
+    
+    module ClassMethods
+      def define_attribute_methods
+        return if attribute_methods_generated?
+        super(attribute_definitions.keys)
+        # Remove setter methods from readonly attributes
+        readonly_attributes.each do |attr|
+          remove_method("#{attr}=".to_sym) if method_defined?("#{attr}=".to_sym)
+        end
+        @attribute_methods_generated = true
+      end
+
+      def attribute_methods_generated?
+        @attribute_methods_generated ||= false
+      end
+      
+      # 
+      # attribute :name, :type => :string
+      # attribute :ammo, :type => Ammo, :coder => AmmoCodec
+      # 
+      def attribute(name, options)
+        type  = options.delete :type
+        coder = options.delete :coder
+
+        if type.is_a?(Symbol)
+          coder = DatastaxRails::Type.get_coder(type) || (raise "Unknown type #{type}")
+        elsif coder.nil?
+          raise "Must supply a :coder for #{name}"
+        end
+        
+        if(options[:lazy])
+          lazy_attributes << name.to_sym
+        end
+        
+        if(options[:readonly])
+          readonly_attributes << name.to_sym
+        end
+
+        attribute_definitions[name.to_sym] = AttributeMethods::Definition.new(name, coder, options)
+      end
+    end
+    
+    def write_attribute(name, value)
+      @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
+    end
+
+    def read_attribute(name)
+      if(lazy_attributes.include?(name.to_sym) && @attributes[name.to_s].nil? && persisted?)
+        @attributes[name.to_s] = self.class.select(name).with_cassandra.find(self.id).read_attribute(name)
+      end
+        
+      @attributes[name.to_s]
+    end
+
+    def attribute_exists?(name)
+      @attributes.key?(name.to_s)
+    end
+
+    def attributes=(attributes)
+      attributes.each do |(name, value)|
+        send("#{name}=", value)
+      end
+    end
+
+    def method_missing(method_id, *args, &block)
+      if !self.class.attribute_methods_generated?
+        self.class.define_attribute_methods
+        send(method_id, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to?(*args)
+      self.class.define_attribute_methods unless self.class.attribute_methods_generated?
+      super
+    end
+
+    protected
+      def attribute_method?(name)
+        !!attribute_definitions[name.to_sym]
+      end
+
+    private
+      def attribute(name)
+        read_attribute(name)
+      end
+    
+      def attribute=(name, value)
+        write_attribute(name, value)
+      end
+  end
+end