cassandra_object_rails 0.0.1

data/lib/cassandra_object/base.rb

@@ -0,0 +1,69 @@
+require 'set'
+
+require 'cassandra_object/log_subscriber'
+require 'cassandra_object/types'
+
+module CassandraObject
+  class Base
+    class << self
+      def column_family=(column_family)
+        @column_family = column_family
+      end
+
+      def column_family
+        @column_family ||= base_class.name.pluralize
+      end
+
+      def base_class
+        class_of_active_record_descendant(self)
+      end
+
+      def config=(config)
+        @@config = config.is_a?(Hash) ? CassandraObject::Config.new(config) : config
+      end
+
+      def config
+        @@config
+      end
+
+      private
+
+        # Returns the class descending directly from ActiveRecord::Base or an
+        # abstract class, if any, in the inheritance hierarchy.
+        def class_of_active_record_descendant(klass)
+          if klass == Base || klass.superclass == Base
+            klass
+          elsif klass.superclass.nil?
+            raise "#{name} doesn't belong in a hierarchy descending from CassandraObject"
+          else
+            class_of_active_record_descendant(klass.superclass)
+          end
+        end
+    end
+
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    extend ActiveSupport::DescendantsTracker
+
+    include Connection
+    include Consistency
+    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 Savepoints
+    include Scoping
+    include Core
+
+    include Serialization
+  end
+end
+
+ActiveSupport.run_load_hooks(:cassandra_object, CassandraObject::Base)

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,48 @@
+module CassandraObject
+  module BelongsTo
+    class Association
+      attr_reader :owner, :reflection
+      attr_accessor :record_variable
+      delegate :options, to: :reflection
+
+      def initialize(owner, reflection)
+        @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

data/lib/cassandra_object/belongs_to/reflection.rb

@@ -0,0 +1,30 @@
+module CassandraObject
+  module BelongsTo
+    class Reflection
+      attr_reader :model, :name, :options
+      def initialize(model, name, options)
+        @model, @name, @options = model, name, options
+      end
+
+      def instance_variable_name
+        "@#{name}"
+      end
+
+      def foreign_key
+        "#{name}_id"
+      end
+
+      def polymorphic_column
+        "#{name}_type"
+      end
+
+      def polymorphic?
+        options[:polymorphic]
+      end
+
+      def class_name
+        options[:class_name] || name.to_s.camelize
+      end
+    end
+  end
+end

data/lib/cassandra_object/callbacks.rb

@@ -0,0 +1,29 @@
+module CassandraObject
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+
+    def destroy #:nodoc:
+      run_callbacks(:destroy) { super }
+    end
+
+    private
+      def write #:nodoc:
+        run_callbacks(:save) { super }
+      end
+
+      def create #:nodoc:
+        run_callbacks(:create) { super }
+      end
+
+      def update(*) #:nodoc:
+        run_callbacks(:update) { super }
+      end
+  end
+end

data/lib/cassandra_object/config.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/hash/keys'
+
+module CassandraObject
+  class Config
+    attr_accessor :servers, :keyspace, :thrift_options, :keyspace_options
+
+    def initialize(options)
+      options = options.symbolize_keys
+      self.servers  = Array.wrap(options[:servers] || "127.0.0.1:9160")
+      self.keyspace = options[:keyspace]
+      self.thrift_options = (options[:thrift] || {}).symbolize_keys
+      self.keyspace_options = (options[:keyspace_options] || {}).symbolize_keys
+    end
+  end
+end

data/lib/cassandra_object/connection.rb

@@ -0,0 +1,36 @@
+module CassandraCQL
+  class Statement
+    def self.sanitize(statement, bind_vars=[])
+      return statement if bind_vars.empty?
+
+      bind_vars = bind_vars.dup
+      expected_bind_vars = statement.count("?")
+
+      raise Error::InvalidBindVariable, "Wrong number of bound variables (statement expected #{expected_bind_vars}, was #{bind_vars.size})" if expected_bind_vars != bind_vars.size
+
+      statement.gsub(/\?/) do
+        quote(cast_to_cql(bind_vars.shift))
+      end
+    end
+  end
+end
+
+module CassandraObject
+  module Connection
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def cql
+        @@cql ||= CassandraCQL::Database.new(config.servers, {keyspace: config.keyspace}, config.thrift_options)
+      end
+
+      def execute_cql(cql_string, *bind_vars)
+        statement = CassandraCQL::Statement.sanitize(cql_string, bind_vars).force_encoding(Encoding::UTF_8)
+
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          cql.execute statement
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/consistency.rb

@@ -0,0 +1,18 @@
+module CassandraObject
+  module Consistency
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def with_consistency(consistency)
+        previous, self.default_consistency = default_consistency, consistency
+        yield
+      ensure
+        self.default_consistency = previous
+      end
+    end
+
+    included do
+      class_attribute :default_consistency
+    end
+  end
+end

data/lib/cassandra_object/core.rb

@@ -0,0 +1,59 @@
+module CassandraObject
+  module Core
+    extend ActiveSupport::Concern
+
+    def initialize(attributes=nil)
+      @new_record = true
+      @destroyed = false
+      @attributes = {}
+      self.attributes = attributes || {}
+      attribute_definitions.each do |attr, attribute_definition|
+        unless attribute_exists?(attr)
+          @attributes[attr.to_s] = self.class.typecast_attribute(self, attr, nil)
+        end
+      end
+
+      yield self if block_given?
+    end
+
+    def initialize_dup(other)
+      @attributes = other.attributes
+      @attributes['created_at'] = nil
+      @attributes['updated_at'] = nil
+      @attributes.delete(self.class.primary_key)
+      @id = nil
+      @new_record = true
+      @destroyed = false
+      super
+    end
+
+    def to_param
+      id
+    end
+
+    def hash
+      id.hash
+    end
+
+    module ClassMethods
+      def inspect
+        if self == Base
+          super
+        else
+          attr_list = @attributes.map do |col, definition| "#{col}: #{definition.type}" end * ', '
+          "#{super}(#{attr_list.truncate(140 * 1.7337)})"
+        end
+      end
+    end
+
+    def ==(comparison_object)
+      comparison_object.equal?(self) ||
+        (comparison_object.instance_of?(self.class) &&
+          comparison_object.id == id)
+    end
+
+    def eql?(comparison_object)
+      self == (comparison_object)
+    end
+  end
+end

data/lib/cassandra_object/errors.rb

@@ -0,0 +1,6 @@
+module CassandraObject
+
+  class CasssandraObjectError < StandardError; end
+  class RecordNotSaved        < CasssandraObjectError; end
+  class RecordNotFound        < CasssandraObjectError; end
+end

data/lib/cassandra_object/identity.rb

@@ -0,0 +1,24 @@
+module CassandraObject
+  module Identity
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :key_generator
+
+      key do
+        SimpleUUID::UUID.new.to_guid.tr('-','')
+      end
+    end
+
+    module ClassMethods
+      # Define a key generator. Default is UUID.
+      def key(&block)
+        self.key_generator = block
+      end
+
+      def _generate_key(object)
+        object.instance_eval(&key_generator)
+      end
+    end
+  end
+end