extendi-cassandra_object 1.0.0

data/lib/cassandra_object/attribute_methods.rb

@@ -0,0 +1,96 @@
+module CassandraObject
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      if ActiveModel::VERSION::STRING < '3.2'
+        attribute_method_suffix("", "=")
+      else
+        attribute_method_suffix("=")
+      end
+
+      # (Alias for the protected read_attribute method).
+      def [](attr_name)
+        read_attribute(attr_name)
+      end
+
+      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+      # (Alias for the protected write_attribute method).
+      def []=(attr_name, value)
+        write_attribute(attr_name, value)
+      end
+    end
+
+    module ClassMethods
+      def inherited(child_class)
+        child_class.define_attribute_methods
+        super
+      end
+
+      def define_attribute_methods
+        return if attribute_methods_generated?
+        super(attribute_definitions.keys)
+        @attribute_methods_generated = true
+      end
+
+      def attribute_methods_generated?
+        @attribute_methods_generated ||= false
+      end
+    end
+
+    def write_attribute(name, value)
+      @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
+    end
+
+    def read_attribute(name)
+      @attributes[name.to_s]
+    end
+
+    def attribute_exists?(name)
+      @attributes.key?(name.to_s)
+    end
+
+    def attributes
+      results = {}
+      @attributes.each_key do |key|
+        results[key] = read_attribute(key)
+      end
+      results
+    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_s]
+      end
+
+    private
+      def attribute(name)
+        read_attribute(name)
+      end
+
+      def attribute=(name, value)
+        write_attribute(name, value)
+      end
+  end
+end

data/lib/cassandra_object/attribute_methods/definition.rb

@@ -0,0 +1,22 @@
+module CassandraObject
+  module AttributeMethods
+    class Definition
+      attr_reader :name, :coder
+      def initialize(name, coder, options)
+        @name   = name.to_s
+        @coder  = coder.new(options)
+      end
+
+      def default
+        coder.default
+      end
+
+      def instantiate(record, value)
+        value = value.nil? ? coder.default : value
+        return if value.nil?
+
+        value.kind_of?(String) ? coder.decode(value) : coder.typecast(value)
+      end
+    end
+  end
+end

data/lib/cassandra_object/attribute_methods/dirty.rb

@@ -0,0 +1,36 @@
+module CassandraObject
+  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 = {}
+        end
+        status
+      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/cassandra_object/attribute_methods/primary_key.rb

@@ -0,0 +1,25 @@
+module CassandraObject
+  module AttributeMethods
+    module PrimaryKey
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def primary_key
+          'id'
+        end
+      end
+
+      def id
+        @id ||= self.class._generate_key(self)
+      end
+
+      def id=(id)
+        @id = id
+      end
+
+      def attributes
+        super.update(self.class.primary_key => id)
+      end
+    end
+  end
+end

data/lib/cassandra_object/attribute_methods/typecasting.rb

@@ -0,0 +1,59 @@
+module CassandraObject
+  module AttributeMethods
+    module Typecasting
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :attribute_definitions
+        self.attribute_definitions = {}
+
+        %w(array boolean date float integer json string time).each do |type|
+          instance_eval <<-EOV, __FILE__, __LINE__ + 1
+            def #{type}(*args)
+              options = args.extract_options!
+              args.each do |name|
+                attribute(name, options.merge(:type => :#{type}))
+              end
+            end
+          EOV
+        end
+      end
+
+      module ClassMethods
+        def inherited(child)
+          super
+          child.attribute_definitions = attribute_definitions.dup
+        end
+
+        #
+        # attribute :name, type: :string
+        # attribute :ammo, type: Ammo, coder: AmmoCodec
+        #
+        def attribute(name, options)
+          type  = options[:type]
+          coder = options[:coder]
+
+          if type.is_a?(Symbol)
+            coder = CassandraObject::Type.get_coder(type) || (raise "Unknown type #{type}")
+          elsif coder.nil?
+            raise "Must supply a :coder for #{name}"
+          end
+
+          attribute_definitions[name.to_s] = AttributeMethods::Definition.new(name, coder, options)
+        end
+
+        def typecast_attribute(record, name, value)
+          if attribute_definition = attribute_definitions[name.to_s]
+            attribute_definition.instantiate(record, value)
+          else
+            raise NoMethodError, "Unknown attribute #{name.inspect}"
+          end
+        end
+
+        def coder_for(attribute)
+          attribute_definitions[attribute.to_s].coder
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/base.rb

@@ -0,0 +1,33 @@
+require 'set'
+
+require 'cassandra_object/log_subscriber'
+require 'cassandra_object/types'
+
+module CassandraObject
+  class Base
+
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    extend ActiveSupport::DescendantsTracker
+
+    include Identity
+    include Inspect
+    include Persistence
+    include AttributeMethods
+    include Validations
+    include AttributeMethods::Dirty
+    include AttributeMethods::PrimaryKey
+    include AttributeMethods::Typecasting
+    include BelongsTo
+    include Callbacks
+    include Timestamps
+    include Scoping
+    include Core
+    extend  Model
+
+    include Serialization
+
+  end
+end
+
+ActiveSupport.run_load_hooks(:cassandra_object, CassandraObject::Base)

data/lib/cassandra_object/base_schema.rb

@@ -0,0 +1,11 @@
+module CassandraObject
+  class BaseSchema < Base
+    def self.adapter
+      @adapter ||= CassandraObject::Adapters::CassandraAdapter.new(Base.config)
+    end
+
+    def self.schema_type
+      :standard
+    end
+  end
+end

data/lib/cassandra_object/base_schemaless.rb

@@ -0,0 +1,11 @@
+module CassandraObject
+  class BaseSchemaless < Base
+    def self.adapter
+      @adapter ||= CassandraObject::Adapters::CassandraSchemalessAdapter.new(Base.config)
+    end
+
+    def self.schema_type
+      :schemaless
+    end
+  end
+end

data/lib/cassandra_object/base_schemaless_dynamic.rb

@@ -0,0 +1,11 @@
+module CassandraObject
+  class BaseSchemalessDynamic < Base
+    def self.adapter
+      @adapter ||= CassandraObject::Adapters::CassandraSchemalessAdapter.new(Base.config)
+    end
+
+    def self.schema_type
+      :dynamic_attributes
+    end
+  end
+end

data/lib/cassandra_object/belongs_to.rb

@@ -0,0 +1,63 @@
+module CassandraObject
+  module BelongsTo
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :belongs_to_reflections
+      self.belongs_to_reflections = {}
+    end
+
+    module ClassMethods
+      # === Options
+      # [:class_name]
+      #   Use if the class cannot be inferred from the association
+      # [:polymorphic]
+      #   Specify if the association is polymorphic
+      # Example:
+      #   class Driver < CassandraObject::Base
+      #   end
+      #   class Truck < CassandraObject::Base
+      #   end
+      def belongs_to(name, options = {})
+        CassandraObject::BelongsTo::Builder.build(self, name, options)
+      end
+
+      def generated_belongs_to_methods
+        @generated_belongs_to_methods ||= begin
+          mod = const_set(:GeneratedBelongsToMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+    end
+
+    # Returns the belongs_to instance for the given name, instantiating it if it doesn't already exist
+    def belongs_to_association(name)
+      association = belongs_to_instance_get(name)
+
+      if association.nil?
+        association = CassandraObject::BelongsTo::Association.new(self, belongs_to_reflections[name])
+        belongs_to_instance_set(name, association)
+      end
+
+      association
+    end
+
+    private
+      def clear_belongs_to_cache
+        belongs_to_cache.clear if persisted?
+      end
+
+      def belongs_to_cache
+        @belongs_to_cache ||= {}
+      end
+
+      def belongs_to_instance_get(name)
+        belongs_to_cache[name.to_sym]
+      end
+
+      def belongs_to_instance_set(name, association)
+        belongs_to_cache[name.to_sym] = association
+      end
+  end
+end

data/lib/cassandra_object/belongs_to/association.rb

@@ -0,0 +1,49 @@
+module CassandraObject
+  module BelongsTo
+    class Association
+      attr_reader :owner, :reflection
+      attr_accessor :record_variable
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        @loaded = false
+        @owner = owner
+        @reflection = reflection
+      end
+
+      def reader
+        unless loaded?
+          if record_id = owner.send(reflection.foreign_key).presence
+            self.record_variable = association_class.find_by_id(record_id)
+          else
+            self.record_variable = nil
+          end
+          @loaded = true
+        end
+
+        record_variable
+      end
+
+      def writer(record)
+        self.record_variable = record
+        @loaded = true
+        owner.send("#{reflection.foreign_key}=", record.try(:id))
+        if reflection.polymorphic?
+          owner.send("#{reflection.polymorphic_column}=", record.class.name)
+        end
+      end
+
+      def association_class
+        association_class_name.constantize
+      end
+
+      def association_class_name
+        reflection.polymorphic? ? owner.send(reflection.polymorphic_column) : reflection.class_name
+      end
+
+      def loaded?
+        @loaded
+      end
+    end
+  end
+end

data/lib/cassandra_object/belongs_to/builder.rb

@@ -0,0 +1,40 @@
+module CassandraObject
+  module BelongsTo
+    class Builder
+      def self.build(model, name, options)
+        new(model, name, options).build
+      end
+
+      attr_reader :model, :name, :options
+      def initialize(model, name, options)
+        @model, @name, @options = model, name, options
+      end
+
+      def build
+        define_writer
+        define_reader
+
+        reflection = CassandraObject::BelongsTo::Reflection.new(model, name, options)
+        model.belongs_to_reflections = model.belongs_to_reflections.merge(name => reflection)
+      end
+
+      def mixin
+        model.generated_belongs_to_methods
+      end
+
+      def define_writer
+        name = self.name
+        mixin.redefine_method("#{name}=") do |records|
+          belongs_to_association(name).writer(records)
+        end
+      end
+
+      def define_reader
+        name = self.name
+        mixin.redefine_method(name) do
+          belongs_to_association(name).reader
+        end
+      end
+    end
+  end
+end