sessionm-cassandra_object 2.2.6

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/CHANGELOG

@@ -0,0 +1,3 @@
+v 0.5.0.pre
+- First release
+- Rough around the corners, especially outside the core attributes/persistence stuff

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2009 Koziarski Software Ltd
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [Michael Koziarski]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,12 @@
+# Cassandra Object
+
+Cassandra Object provides a API for working with [Cassandra](http://incubator.apache.org/cassandra/) in Rails projects.
+
+Installation:
+
+        gem 'gotime-cassandra_object',  require: 'cassandra_object'
+
+Example:
+
+        class Customer < CassandraObject::Base
+        end

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'rake'
+require 'rake/testtask'
+
+# require File.expand_path('../lib/cassandra_object', __FILE__)
+
+task default: :test
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end

data/lib/cassandra_object/associations/one_to_many.rb

@@ -0,0 +1,146 @@
+module CassandraObject
+  module Associations
+    class OneToMany
+      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)
+        key = owner.key
+        attributes = {@association_name=>{new_key=>record.key.to_s}}
+        ActiveSupport::Notifications.instrument("insert.cassandra_object", :column_family => column_family, :key => key, :attributes => attributes) do
+          connection.insert(column_family, key.to_s, attributes, :consistency => @owner_class.thrift_write_consistency)
+        end
+        if has_inverse? && set_inverse
+          inverse.set_inverse(record, owner)
+        end
+      end
+
+      def new_key
+        SimpleUUID::UUID.new
+      end
+
+      def column_family
+        @owner_class.relationships_column_family
+      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 [](index)
+        to_a[index]
+      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)
+        @association.target_class.create(attributes).tap do |record|
+          if record.valid?
+            self << record
+          end
+        end
+      end
+
+      def create!(attributes)
+        @association.target_class.create!(attributes).tap 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
+end

data/lib/cassandra_object/associations/one_to_one.rb

@@ -0,0 +1,85 @@
+module CassandraObject
+  module Associations
+    class OneToOne
+      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)
+        ActiveSupport::Notifications.instrument("remove.cassandra_object", :column_family => column_family, :key => owner.key, :columns => @association_name) do
+          connection.remove(column_family, owner.key.to_s, @association_name)
+        end
+      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)
+        key = owner.key
+        attributes = {@association_name=>{new_key=>record.key.to_s}}
+        ActiveSupport::Notifications.instrument("insert.cassandra_object", :column_family => column_family, :key => key, :attributes => attributes) do
+          connection.insert(column_family, key.to_s, attributes, :consistency => @owner_class.thrift_write_consistency)
+        end
+        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.relationships_column_family
+      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
+end

data/lib/cassandra_object/associations.rb

@@ -0,0 +1,50 @@
+module CassandraObject
+  module Associations
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    # TODO: is this the convention?
+    include ActiveRecord::Reflection
+    include ActiveRecord::Associations
+
+    autoload :OneToMany
+    autoload :OneToOne
+    
+    included do
+      class_inheritable_hash :associations
+    end
+
+    module ClassMethods
+      def relationships_column_family=(column_family)
+        @relationships_column_family = column_family
+      end
+
+      def relationships_column_family
+        @relationships_column_family || "#{name}Relationships"
+      end
+
+      def column_family_configuration
+        super << {:Name=>relationships_column_family, :CompareWith=>"UTF8Type", :CompareSubcolumnsWith=>"TimeUUIDType", :ColumnType=>"Super"}
+      end
+
+      def association(association_name, options= {})
+        if options[:unique]
+          write_inheritable_hash(:associations, {association_name => OneToOne.new(association_name, self, options)})
+        else
+          write_inheritable_hash(:associations, {association_name => OneToMany.new(association_name, self, options)})
+        end
+      end
+      
+      def remove(key)
+        begin
+          ActiveSupport::Notifications.instrument("remove.cassandra_object", column_family: relationships_column_family, key: key) do
+            connection.remove(relationships_column_family, key.to_s, consistency: thrift_write_consistency)
+          end
+        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,97 @@
+module CassandraObject
+  class Attribute
+    attr_reader :name, :converter, :expected_type
+    def initialize(name, converter, expected_type)
+      @name          = name.to_s
+      @converter     = converter
+      @expected_type = expected_type
+    end
+
+    def check_value!(value)
+      return value if value.nil?
+      value.kind_of?(expected_type) ? value : converter.decode(value)
+    end
+  end
+
+  module Attributes
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    module ClassMethods
+      def attribute(name, options)
+        if model_attributes.empty?
+          self.model_attributes = {}.with_indifferent_access
+        end
+
+        if type_mapping = CassandraObject::Type.get_mapping(options[:type])
+          converter = type_mapping.converter
+          expected_type = type_mapping.expected_type
+        elsif options[:converter]
+          converter = options[:converter]
+          expected_type = options[:type]
+        else
+          raise "Unknown type #{options[:type]}"
+        end
+
+        model_attributes[name] = Attribute.new(name, converter, expected_type)
+      end
+
+      def define_attribute_methods
+        super(model_attributes.keys)
+      end
+    end
+
+    included do
+      class_attribute :model_attributes
+      self.model_attributes = {}.with_indifferent_access
+
+      attribute_method_suffix("", "=")      
+    end
+
+    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
+
+    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)
+        !!model_attributes[name.to_sym]
+      end
+
+    private
+      def attribute(name)
+        read_attribute(name)
+      end
+    
+      def attribute=(name, value)
+        write_attribute(name, value)
+      end
+  end
+end

data/lib/cassandra_object/base.rb

@@ -0,0 +1,97 @@
+require 'set'
+
+require 'cassandra_object/log_subscriber'
+require 'cassandra_object/types'
+require 'cassandra_object/errors'
+
+module CassandraObject
+  class Base
+    class << self
+      def column_family=(column_family)
+        @column_family = column_family
+      end
+
+      def column_family
+        @column_family || name.pluralize
+      end
+
+      def base_class
+        klass = self
+        while klass.superclass != Base
+          klass = klass.superclass
+        end
+        klass
+      end
+
+      delegate :compute_type, :to => 'ActiveRecord::Base'
+    end
+
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    extend ActiveSupport::DescendantsTracker
+    
+    include Connection
+    include Consistency
+    include Identity
+    include Attributes
+    include Persistence
+    include Callbacks
+    include Dirty
+    include Validations
+    include Associations
+    include Batches
+    include FinderMethods
+    include Timestamps
+
+    attr_accessor :key
+
+    include Serialization
+    include Migrations
+    include Mocking
+
+    def initialize(attributes={})
+      @key = attributes.delete(:key)
+      @new_record = true
+      @destroyed = false
+      @attributes = {}.with_indifferent_access
+      self.attributes = attributes
+      @schema_version = self.class.current_schema_version
+    end
+
+    def attributes
+      @attributes.merge(:id => id)
+    end
+
+    def to_param
+      id.to_s if persisted?
+    end
+
+    def hash
+      id.hash
+    end    
+
+    def ==(comparison_object)
+      comparison_object.equal?(self) ||
+        (comparison_object.instance_of?(self.class) &&
+          comparison_object.key == key &&
+          !comparison_object.new_record?)
+    end
+
+    def eql?(comparison_object)
+      self == (comparison_object)
+    end
+
+    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+    # "2004-12-12" in a data column is cast to a date object, like Date.new(2004, 12, 12)).
+    # (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
+end

data/lib/cassandra_object/batches.rb

@@ -0,0 +1,31 @@
+module CassandraObject
+  module Batches
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def find_each
+        connection.each(column_family) do |k, v|
+          yield instantiate(k, v)
+        end
+      end
+
+      def find_in_batches(options = {})
+        batch_size = options.delete(:batch_size) || 1000
+
+        batch = []
+
+        find_each do |record|
+          batch << record
+          if batch.size == batch_size
+            yield(batch)
+            batch = []
+          end
+        end
+        
+        if batch.size > 0
+          yield batch
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/callbacks.rb

@@ -0,0 +1,27 @@
+module CassandraObject
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :save, :create, :destroy, :update
+    end
+
+    def destroy #:nodoc:
+      _run_destroy_callbacks { super }
+    end
+
+    private
+      def create_or_update #:nodoc:
+        _run_save_callbacks { super }
+      end
+
+      def create #:nodoc:
+        _run_create_callbacks { super }
+      end
+
+      def update(*) #:nodoc:
+        _run_update_callbacks { super }
+      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/connection.rb

@@ -0,0 +1,29 @@
+module CassandraObject
+  module Connection
+    extend ActiveSupport::Concern
+    
+    included do
+      class_attribute :connection_spec
+    end
+
+    module ClassMethods
+      DEFAULT_OPTIONS = {
+        servers: "127.0.0.1:9160",
+        thrift: {}
+      }
+      def establish_connection(spec)
+        spec.reverse_merge!(DEFAULT_OPTIONS)
+        @connection = Cassandra.new(spec[:keyspace], spec[:servers], spec[:thrift].symbolize_keys!)
+      end
+
+      def connection=(val)
+        @connection = val
+      end
+
+      def connection
+        establish_connection(connection_spec) if @connection.nil?
+        @connection
+      end
+    end
+  end
+end

data/lib/cassandra_object/consistency.rb

@@ -0,0 +1,31 @@
+module CassandraObject
+  module Consistency
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :consistency_levels
+      self.consistency_levels = [:one, :quorum, :all]
+
+      class_attribute :write_consistency
+      class_attribute :read_consistency
+      self.write_consistency  = :quorum
+      self.read_consistency   = :quorum
+    end
+
+    module ClassMethods
+      THRIFT_LEVELS = {
+        :one    => Cassandra::Consistency::ONE,
+        :quorum => Cassandra::Consistency::QUORUM,
+        :all    => Cassandra::Consistency::ALL
+      }
+
+      def thrift_read_consistency
+        THRIFT_LEVELS[read_consistency] || (raise "Invalid consistency level #{read_consistency}")
+      end
+
+      def thrift_write_consistency
+        THRIFT_LEVELS[write_consistency] || (raise "Invalid consistency level #{write_consistency}")
+      end
+    end
+  end
+end