extendi-cassandra_object 1.0.0

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(*args) #: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/core.rb

@@ -0,0 +1,63 @@
+module CassandraObject
+  module Core
+    extend ActiveSupport::Concern
+
+    def initialize(attributes=nil)
+      @new_record = true
+      @destroyed = false
+      @attributes = {}
+      self.attributes = attributes || {}
+      attribute_definitions.each_value do |definition|
+        unless definition.default.nil? || attribute_exists?(definition.name)
+          @attributes[definition.name] = definition.default
+        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 get_cql_response
+      self.class.cql_response.find(self.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,10 @@
+module CassandraObject
+  class CasssandraObjectError < StandardError
+  end
+
+  class RecordNotSaved < CasssandraObjectError
+  end
+
+  class RecordNotFound < CasssandraObjectError
+  end
+end

data/lib/cassandra_object/identity.rb

@@ -0,0 +1,26 @@
+require 'securerandom'
+
+module CassandraObject
+  module Identity
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :key_generator
+
+      key do
+        SecureRandom.uuid.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

data/lib/cassandra_object/inspect.rb

@@ -0,0 +1,25 @@
+module CassandraObject
+  module Inspect
+    def inspect
+      inspection = ["#{self.class.primary_key}: #{id.inspect}"]
+
+      @attributes.each do |attribute, value|
+        if value.present?
+          inspection << "#{attribute}: #{attribute_for_inspect(value)}"
+        end
+      end
+
+      "#<#{self.class} #{inspection * ', '}>"
+    end
+
+    def attribute_for_inspect(value)
+      if value.is_a?(String) && value.length > 50
+        "#{value[0..50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+  end
+end

data/lib/cassandra_object/log_subscriber.rb

@@ -0,0 +1,44 @@
+module CassandraObject
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def self.runtime=(value)
+      Thread.current["cassandra_object_request_runtime"] = value
+    end
+
+    def self.runtime
+      Thread.current["cassandra_object_request_runtime"] ||= 0
+    end
+
+    def self.reset_runtime
+      rt, self.runtime = runtime, 0
+      rt
+    end
+
+    def initialize
+      super
+      @odd_or_even = false
+    end
+
+    def cql(event)
+      self.class.runtime += event.duration
+
+      payload = event.payload
+      name = '%s (%.1fms)' % [payload[:name], event.duration]
+      cql = payload[:cql].squeeze(' ')
+
+      if odd?
+        name = color(name, CYAN, true)
+        cql  = color(cql, nil, true)
+      else
+        name = color(name, MAGENTA, true)
+      end
+
+      debug "  #{name}  #{cql}"
+    end
+
+    def odd?
+      @odd_or_even = !@odd_or_even
+    end
+  end
+end
+
+CassandraObject::LogSubscriber.attach_to :cassandra_object

data/lib/cassandra_object/model.rb

@@ -0,0 +1,60 @@
+module CassandraObject
+  module Model
+    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.deep_symbolize_keys
+    end
+
+    def config
+      @@config
+    end
+
+    def allow_filtering=(value)
+      @allow_filtering = value
+    end
+
+    def allow_filtering
+      @allow_filtering ||= false
+    end
+
+    def _key
+      # todo only first key
+      keys.tr('()','').split(',').first
+    end
+
+    def keys=(value)
+      @keys = value
+    end
+
+    def keys
+      @keys ||= '(key)'
+    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)
+      # klass
+
+      if (klass == Base || klass.superclass == Base) || (klass == BaseSchemaless || klass.superclass == BaseSchemaless) || (klass == BaseSchema || klass.superclass == BaseSchema) || (klass == BaseSchemalessDynamic || klass.superclass == BaseSchemalessDynamic)
+        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
+end

data/lib/cassandra_object/persistence.rb

@@ -0,0 +1,203 @@
+module CassandraObject
+  module Persistence
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :batch_statements
+    end
+
+    module ClassMethods
+
+      def ttl=(value)
+        @ttl = value
+      end
+
+      def ttl
+        @ttl ||= nil
+      end
+
+      def remove(ids)
+        delete ids
+      end
+
+      def _key
+        # todo only mono primary id for now
+        self.keys.tr('()','').split(',').first
+      end
+
+      def delete_all
+        adapter.execute "TRUNCATE #{column_family}"
+      end
+
+      def create(attributes = {}, &block)
+        self.ttl = attributes.delete(:ttl)
+        if self.schema_type != :dynamic_attributes
+          new(attributes, &block).tap do |object|
+            object.save
+          end
+        else
+          key = attributes[:key]
+          insert_record key.to_s, attributes.except(:key).stringify_keys
+          attributes
+        end
+      end
+
+      def update(id, attributes)
+        update_record(id, attributes)
+      end
+
+      def delete(ids, attributes = [])
+        ids = [ids] if !ids.is_a?(Array)
+        if !attributes.empty?
+          attr = {}
+          attributes.each{|a| attr[a] = nil}
+          ids.each do |id|
+            adapter.update column_family, id, encode_attributes(attr)
+          end
+        else
+          if self.schema_type == :standard
+            adapter.delete column_family, self._key, ids
+          else
+            adapter.delete column_family, ids
+          end
+        end
+      end
+
+      def insert_record(id, attributes)
+        attributes[self._key] = id if self.schema_type == :standard
+        adapter.insert column_family, id, encode_attributes(attributes), self.ttl
+      end
+
+      def update_record(id, attributes)
+        return if attributes.empty?
+        if self.schema_type == :standard
+          attributes[self._key] = id
+          id = self._key
+        end
+        adapter.update column_family, id, encode_attributes(attributes), self.ttl
+      end
+
+      def batching?
+        adapter.batching?
+      end
+
+      def batch(&block)
+        adapter.batch(&block)
+      end
+
+      def instantiate(id, attributes)
+        allocate.tap do |object|
+          object.instance_variable_set('@id', id) if id
+          object.instance_variable_set('@new_record', false)
+          object.instance_variable_set('@destroyed', false)
+          object.instance_variable_set('@attributes', typecast_persisted_attributes(object, attributes))
+        end
+      end
+
+      def encode_attributes(attributes)
+        encoded = {}
+        attributes.each do |column_name, value|
+          if value.nil?
+            encoded[column_name] = nil
+          else
+            if self.schema_type == :dynamic_attributes
+              encoded[column_name] = value.to_s
+            elsif self.schema_type == :standard
+              encoded[column_name] = value
+            else
+              encoded[column_name] = attribute_definitions[column_name].coder.encode(value)
+            end
+          end
+        end
+        encoded
+      end
+
+      private
+
+      def typecast_persisted_attributes(object, attributes)
+        attributes.each do |key, value|
+          if definition = attribute_definitions[key.to_s]
+            attributes[key] = definition.instantiate(object, value)
+          else
+            attributes.delete(key)
+          end
+        end
+
+        attribute_definitions.each_value do |definition|
+          unless definition.default.nil? || attributes.has_key?(definition.name)
+            attributes[definition.name] = definition.default
+          end
+        end
+
+        attributes
+      end
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    def save(*)
+      new_record? ? create : update
+    end
+
+    def destroy
+      self.class.remove(id)
+      @destroyed = true
+    end
+
+    def update_attribute(name, value)
+      name = name.to_s
+      send("#{name}=", value)
+      save(validate: false)
+    end
+
+    def update_attributes(attributes)
+      self.attributes = attributes
+      save
+    end
+
+    def update_attributes!(attributes)
+      self.attributes = attributes
+      save!
+    end
+
+    def becomes(klass)
+      became = klass.new
+      became.instance_variable_set('@attributes', @attributes)
+      became.instance_variable_set('@new_record', new_record?)
+      became.instance_variable_set('@destroyed', destroyed?)
+      became
+    end
+
+    def reload
+      clear_belongs_to_cache
+      @attributes = self.class.find(id).instance_variable_get('@attributes')
+      self
+    end
+
+    private
+
+    def create
+      @new_record = false
+      write :insert_record
+    end
+
+    def update
+      write :update_record
+    end
+
+    def write(method)
+      changed_attributes = Hash[changed.map { |attr| [attr, read_attribute(attr)] }]
+      self.class.send(method, id, changed_attributes)
+    end
+  end
+end