gotime-cassandra_object 2.2.0 → 2.2.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    gotime-cassandra_object (2.1.2)
+    gotime-cassandra_object (2.2.0)
       cassandra (~> 0.11.3)
       rails (~> 3.0)
 

data/gotime-cassandra_object.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'gotime-cassandra_object'
-  s.version = '2.2.0'
+  s.version = '2.2.1'
   s.description = 'Cassandra ActiveModel'
   s.summary = 'Cassandra ActiveModel'
 

data/lib/cassandra_object.rb

@@ -6,12 +6,11 @@ module CassandraObject
   autoload :Base
   autoload :Connection
   autoload :Attributes
-  autoload :PrimaryKey
   autoload :Dirty
   autoload :Consistency
   autoload :Persistence
   autoload :Callbacks
-  autoload :Validation
+  autoload :Validations
   autoload :Identity
   autoload :Indexes
   autoload :Serialization

data/lib/cassandra_object/associations.rb

@@ -11,7 +11,6 @@ module CassandraObject
     end
 
     module ClassMethods
-
       def relationships_column_family=(column_family)
         @relationships_column_family = column_family
       end
@@ -23,7 +22,7 @@ module CassandraObject
       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)})
@@ -34,8 +33,8 @@ module CassandraObject
       
       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 => write_consistency_for_thrift)
+          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/

data/lib/cassandra_object/associations/one_to_many.rb

@@ -1,26 +1,18 @@
 module CassandraObject
   module Associations
     class OneToMany
-      include Consistency
-
-      attr_accessor :write_consistency
-      attr_accessor :read_consistency
-
       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
 
-        @write_consistency = owner_class.write_consistency
-        @read_consistency = owner_class.write_consistency
-
         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, :consistency => read_consistency)
+        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
 
@@ -28,7 +20,7 @@ module CassandraObject
         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 => write_consistency_for_thrift)
+          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)

data/lib/cassandra_object/associations/one_to_one.rb

@@ -42,7 +42,7 @@ module CassandraObject
         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 => write_consistency_for_thrift)
+          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)

data/lib/cassandra_object/base.rb

@@ -26,17 +26,18 @@ module CassandraObject
     end
 
     extend ActiveModel::Naming
+    include ActiveModel::Conversion
     extend ActiveSupport::DescendantsTracker
     
     include Connection
-    include PrimaryKey
+    include Consistency
     include Identity
     include Attributes
     include Persistence
     include Callbacks
     include Indexes
     include Dirty
-    include Validation
+    include Validations
     include Associations
     include Batches
     include FinderMethods
@@ -58,8 +59,23 @@ module CassandraObject
       @schema_version = self.class.current_schema_version
     end
 
-    def to_model
-      self
+    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
   end
 end

data/lib/cassandra_object/consistency.rb

@@ -1,30 +1,31 @@
 module CassandraObject
   module Consistency
-    VALID_READ_CONSISTENCY_LEVELS = [:one, :quorum, :all]
-    VALID_WRITE_CONSISTENCY_LEVELS = VALID_READ_CONSISTENCY_LEVELS
+    extend ActiveSupport::Concern
 
-    def valid_read_consistency_level?(level)
-      !!VALID_READ_CONSISTENCY_LEVELS.include?(level)
-    end
-
-    def valid_write_consistency_level?(level)
-      !!VALID_WRITE_CONSISTENCY_LEVELS.include?(level)
-    end
+    included do
+      cattr_accessor :consistency_levels
+      self.consistency_levels = [:one, :quorum, :all]
 
-    def write_consistency_for_thrift
-      consistency_for_thrift(write_consistency)
+      class_attribute :write_consistency
+      class_attribute :read_consistency
+      self.write_consistency  = :quorum
+      self.read_consistency   = :quorum
     end
 
-    def read_consistency_for_thrift
-      consistency_for_thrift(read_consistency)
-    end
-
-    def consistency_for_thrift(consistency)
-      {
-        :one    => Cassandra::Consistency::ONE, 
+    module ClassMethods
+      THRIFT_LEVELS = {
+        :one    => Cassandra::Consistency::ONE,
         :quorum => Cassandra::Consistency::QUORUM,
         :all    => Cassandra::Consistency::ALL
-      }[consistency]
+      }
+
+      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
+end

data/lib/cassandra_object/cursor.rb

@@ -8,8 +8,6 @@ module CassandraObject
       @key           = key.to_s
       @super_column  = super_column
       @options       = options
-      @read_consistency = options[:read_consistency] || options[:consistency] || :quorum
-      @write_consitency = options[:write_consistency] || options[:consistency] || :quorum
       @validators    = []
     end
     
@@ -25,10 +23,11 @@ module CassandraObject
       end
       
       while objects.size < number_to_find && !out_of_keys
-        index_results = connection.get(@column_family, @key, @super_column, :count=>limit,
-                                                                            :start=>start_with,
-                                                                            :reversed=>@options[:reversed],
-                                                                            :consistency=>consistency_for_thrift(@read_consistency))
+        index_results = connection.get(@column_family, @key, @super_column,
+          count: limit,
+          start: start_with,
+          reversed: @options[:reversed],
+          consistency: target_class.thrift_read_consistency)
 
         out_of_keys  = index_results.size < limit
 
@@ -81,7 +80,7 @@ module CassandraObject
     end
     
     def remove(index_key)
-      connection.remove(@column_family, @key, @super_column, index_key, :consistency => consistency_for_thrift(@write_consistency))
+      connection.remove(@column_family, @key, @super_column, index_key, consistency: target_class.thrift_write_consistency)
     end
     
     def validator(&validator)

data/lib/cassandra_object/finder_methods.rb

@@ -11,10 +11,9 @@ module CassandraObject
       end
 
       def all(options = {})
-        options = {:consistency => self.read_consistency, :limit => 100}.merge(options)
-        count = options[:limit]
-        results = ActiveSupport::Notifications.instrument("get_range.cassandra_object", column_family: column_family, key_count: count) do
-          connection.get_range(column_family, key_count: count, consistency: consistency_for_thrift(options[:consistency]))
+        limit = options[:limit] || 100
+        results = ActiveSupport::Notifications.instrument("get_range.cassandra_object", column_family: column_family, key_count: limit) do
+          connection.get_range(column_family, key_count: limit, consistency: thrift_read_consistency)
         end
 
         results.map do |k, v|
@@ -45,13 +44,8 @@ module CassandraObject
 
       private
         def multi_get(keys, options={})
-          options = options.reverse_merge(consistency: self.read_consistency)
-          unless valid_read_consistency_level?(options[:consistency])
-            raise ArgumentError, "Invalid read consistency level: '#{options[:consistency]}'. Valid options are [:quorum, :one]"
-          end
-
           attribute_results = ActiveSupport::Notifications.instrument("multi_get.cassandra_object", column_family: column_family, keys: keys) do
-            connection.multi_get(column_family, keys.map(&:to_s), consistency: consistency_for_thrift(options[:consistency]))
+            connection.multi_get(column_family, keys.map(&:to_s), consistency: thrift_read_consistency)
           end
 
           attribute_results.inject({}) do |memo, (key, attributes)|

data/lib/cassandra_object/identity.rb

@@ -1,6 +1,4 @@
 module CassandraObject
-  # Some docs will be needed here but the gist of this is simple.  Instead of returning a string, Base#key  now returns a key object.
-  # There are corresponding key factories which generate them
   module Identity
     extend ActiveSupport::Concern
     extend ActiveSupport::Autoload
@@ -30,41 +28,25 @@ module CassandraObject
           name_or_factory
         end
       end
-    
+
       def next_key(object = nil)
         @key_factory.next_key(object).tap do |key|
           raise "Keys may not be nil" if key.nil?
         end
       end
-      
+
       def parse_key(string)
         @key_factory.parse(string)
       end
     end
-    
-    module InstanceMethods
-      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
 
-      def hash
-        key.to_s.hash
-      end
-      
-      def to_param
-        key.to_param
-      end
+    def id
+      key.to_s
+    end
 
-      def to_key
-        [key] if key
-      end
+    def id=(key)
+      self.key = self.class.parse_key(key)
+      id
     end
   end
 end

data/lib/cassandra_object/persistence.rb

@@ -2,40 +2,15 @@ module CassandraObject
   module Persistence
     extend ActiveSupport::Concern
 
-    included do
-      extend Consistency
-
-      class_attribute :write_consistency
-      class_attribute :read_consistency
-      self.write_consistency = self.read_consistency = :quorum
-    end
-
-
     module ClassMethods
-      def consistency_levels(levels)
-        if levels.has_key?(:write)
-          unless valid_write_consistency_level?(levels[:write])
-            raise ArgumentError, "Invalid write consistency level. Valid levels are: #{Consistency::VALID_WRITE_CONSISTENCY_LEVELS.inspect}. You gave me #{levels[:write].inspect}"
-          end
-          self.write_consistency = levels[:write]
-        end
-
-        if levels.has_key?(:read)
-          unless valid_read_consistency_level?(levels[:read])
-            raise ArgumentError, "Invalid read consistency level. Valid levels are #{Consistency::VALID_READ_CONSISTENCY_LEVELS.inspect}. You gave me #{levels[:write].inspect}"
-          end
-          self.read_consistency = levels[:read]
-        end
-      end
-
       def remove(key)
-        ActiveSupport::Notifications.instrument("remove.cassandra_object", :column_family => column_family, :key => key) do
-          connection.remove(column_family, key.to_s, :consistency => write_consistency_for_thrift)
+        ActiveSupport::Notifications.instrument("remove.cassandra_object", column_family: column_family, key: key) do
+          connection.remove(column_family, key.to_s, consistency: thrift_write_consistency)
         end
       end
 
       def delete_all
-        ActiveSupport::Notifications.instrument("truncate.cassandra_object", :column_family => column_family) do
+        ActiveSupport::Notifications.instrument("truncate.cassandra_object", column_family: column_family) do
           connection.truncate!(column_family)
         end
       end
@@ -49,8 +24,8 @@ module CassandraObject
       def write(key, attributes, schema_version)
         key.tap do |key|
           attributes = encode_columns_hash(attributes, schema_version)
-          ActiveSupport::Notifications.instrument("insert.cassandra_object", :column_family => column_family, :key => key, :attributes => attributes) do
-            connection.insert(column_family, key.to_s, attributes, :consistency => write_consistency_for_thrift)
+          ActiveSupport::Notifications.instrument("insert.cassandra_object", column_family: column_family, key: key, attributes: attributes) do
+            connection.insert(column_family, key.to_s, attributes, consistency: thrift_write_consistency)
           end
         end
       end

data/lib/cassandra_object/{validation.rb → validations.rb}

@@ -5,13 +5,9 @@ module CassandraObject
       @record = record
       super("Invalid record: #{@record.errors.full_messages.to_sentence}")
     end
-    
-    def self.raise_error(record)
-      raise new(record)
-    end
   end
 
-  module Validation
+  module Validations
     extend ActiveSupport::Concern
     include ActiveModel::Validations
     
@@ -21,8 +17,10 @@ module CassandraObject
     end
     
     module ClassMethods
-      def create!(attributes)
-        new(attributes).tap &:save!
+      def create!(attributes = {})
+        new(attributes).tap do |object|
+          object.save!
+        end
       end
     end
 
@@ -37,7 +35,7 @@ module CassandraObject
     end
     
     def save!
-      save || RecordInvalid.raise_error(self)
+      save || raise(RecordInvalid.new(self))
     end
 
     protected

data/{test-old → test}/active_model_test.rb

@@ -1,9 +1,9 @@
 require 'test_helper'
 
-class ActiveModelTest < ActiveModel::TestCase
+class ActiveModelTest < CassandraObject::TestCase
   include ActiveModel::Lint::Tests
 
   def setup
-    @model = Customer.new
+    @model = Issue.new
   end
 end

data/test/base_test.rb

@@ -15,4 +15,14 @@ class CassandraObject::BaseTest < CassandraObject::TestCase
   test 'column family' do
     assert_equal 'CassandraObject::BaseTest::Sons', Son.column_family
   end
+
+  test 'to_param' do
+    issue = Issue.create
+    assert_equal issue.id, issue.to_param
+  end
+  
+  test 'hash' do
+    issue = Issue.create
+    assert_equal issue.id.hash, issue.hash
+  end
 end