cassandra_object 0.6.0.pre

data/lib/cassandra_object/identity/uuid_key_factory.rb

@@ -0,0 +1,37 @@
+module CassandraObject
+  module Identity
+    # Key factories need to support 3 operations
+    class UUIDKeyFactory < AbstractKeyFactory
+      class UUID < SimpleUUID::UUID
+        include Key
+
+        def to_param
+          to_guid
+        end
+        
+        def to_s
+          # FIXME - this should probably write the raw bytes 
+          # but it's very hard to debug without this for now.
+          to_guid
+        end
+      end
+    
+      # Next key takes an object and returns the key object it should use.
+      # object will be ignored with synthetic keys but could be useful with natural ones
+      def next_key(object)
+        UUID.new
+      end
+      
+      # Parse should create a new key object from the 'to_param' format
+      def parse(string)
+        UUID.new(string)
+      end
+      
+      # create should create a new key object from the cassandra format.
+      def create(string)
+        UUID.new(string)
+      end
+    end
+  end
+end
+

data/lib/cassandra_object/identity.rb

@@ -0,0 +1,61 @@
+require 'cassandra_object/identity/abstract_key_factory'
+require 'cassandra_object/identity/key'
+require 'cassandra_object/identity/uuid_key_factory'
+require 'cassandra_object/identity/natural_key_factory'
+
+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
+    module ClassMethods
+      # Indicate what kind of key the model will have: uuid or natural
+      #
+      # @param [:uuid, :natural] the type of key
+      # @param the options you want to pass along to the key factory (like :attributes => :name, for a natural key).
+      # 
+      def key(name_or_factory = :uuid, *options)
+        @key_factory = case name_or_factory
+        when :uuid
+          UUIDKeyFactory.new
+        when :natural
+          NaturalKeyFactory.new(*options)
+        else
+          name_or_factory
+        end
+      end
+    
+      def next_key(object = nil)
+        returning(@key_factory.next_key(object)) 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
+    end
+  end
+end

data/lib/cassandra_object/indexes.rb

@@ -0,0 +1,129 @@
+module CassandraObject
+  module Indexes
+    extend ActiveSupport::Concern
+    
+    included do
+      class_inheritable_accessor :indexes
+    end
+    
+    class UniqueIndex
+      def initialize(attribute_name, model_class, options)
+        @attribute_name = attribute_name
+        @model_class    = model_class
+      end
+      
+      def find(attribute_value)
+        # first find the key value
+        key = @model_class.connection.get(column_family, attribute_value.to_s, 'key')
+        # then pass to get
+        if key
+          @model_class.get(key.to_s)
+        else
+          @model_class.connection.remove(column_family, attribute_value.to_s)
+          nil
+        end
+      end
+      
+      def write(record)
+        @model_class.connection.insert(column_family, record.send(@attribute_name).to_s, {'key'=>record.key.to_s})
+      end
+      
+      def remove(record)
+        @model_class.connection.remove(column_family, record.send(@attribute_name).to_s)
+      end
+      
+      def column_family
+        @model_class.column_family + "By" + @attribute_name.to_s.camelize 
+      end
+      
+      def column_family_configuration
+        {:Name=>column_family, :CompareWith=>"UTF8Type"}
+      end
+    end
+    
+    class Index
+      def initialize(attribute_name, model_class, options)
+        @attribute_name = attribute_name
+        @model_class    = model_class
+        @reversed       = options[:reversed]
+      end
+      
+      def find(attribute_value, options = {})
+        cursor = CassandraObject::Cursor.new(@model_class, column_family, attribute_value.to_s, @attribute_name.to_s, :start_after=>options[:start_after], :reversed=>@reversed)
+        cursor.validator do |object|
+          object.send(@attribute_name) == attribute_value
+        end
+        cursor.find(options[:limit] || 100)
+      end
+      
+      def write(record)
+        @model_class.connection.insert(column_family, record.send(@attribute_name).to_s, {@attribute_name.to_s=>{new_key=>record.key.to_s}})
+      end
+      
+      def remove(record)
+      end
+      
+      def column_family
+        @model_class.column_family + "By" + @attribute_name.to_s.camelize 
+      end
+      
+      def new_key
+        SimpleUUID::UUID.new
+      end
+      
+      def column_family_configuration
+        {:Name=>column_family, :CompareWith=>"UTF8Type", :ColumnType=>"Super", :CompareSubcolumnsWith=>"TimeUUIDType"}
+      end
+      
+    end
+    
+    module ClassMethods
+      def column_family_configuration
+        if indexes
+          super + indexes.values.map(&:column_family_configuration)
+        else
+          super
+        end
+      end
+      
+      def index(attribute_name, options = {})
+        self.indexes ||= {}.with_indifferent_access
+        if options.delete(:unique)
+          self.indexes[attribute_name] = UniqueIndex.new(attribute_name, self, options)
+          class_eval <<-eom
+            def self.find_by_#{attribute_name}(value)
+              indexes[:#{attribute_name}].find(value)
+            end
+            
+            after_save do |record|
+              self.indexes[:#{attribute_name}].write(record)
+              true
+            end
+              
+            after_destroy do |record|
+              record.class.indexes[:#{attribute_name}].remove(record)
+              true
+            end
+          eom
+        else
+          self.indexes[attribute_name] = Index.new(attribute_name, self, options)
+          class_eval <<-eom
+            def self.find_all_by_#{attribute_name}(value, options = {})
+              self.indexes[:#{attribute_name}].find(value, options)
+            end
+            
+            after_save do |record|
+              record.class.indexes[:#{attribute_name}].write(record)
+              true
+            end
+              
+            after_destroy do |record|
+              record.class.indexes[:#{attribute_name}].remove(record)
+              true
+            end
+          eom
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/legacy_callbacks.rb

@@ -0,0 +1,33 @@
+module CassandraObject
+  module Callbacks
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+    
+    included do
+      define_model_callbacks :save, :create, :destroy, :update
+    end
+    
+    module ClassMethods
+      def define_model_callbacks(*callbacks)
+        callbacks.each do |callback|
+          define_callbacks "before_#{callback}"
+          define_callbacks "after_#{callback}"
+        end
+      end
+    end
+    
+    module InstanceMethods
+      def run_callbacks(callback)
+        if block_given?
+          unless false == super("before_#{callback}")
+            yield.tap do
+              super("after_#{callback}")
+            end
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/migrations.rb

@@ -0,0 +1,72 @@
+module CassandraObject
+  module Migrations
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_array :migrations
+      class_inheritable_accessor :current_schema_version
+      self.current_schema_version = 0
+    end
+    
+    class Migration
+      attr_reader :version
+      def initialize(version, block)
+        @version = version
+        @block = block
+      end
+      
+      def run(attrs)
+        @block.call(attrs)
+      end
+    end
+    
+    class MigrationNotFoundError < StandardError
+      def initialize(record_version, migrations)
+        super("Cannot migrate a record from #{record_version.inspect}.  Migrations exist for #{migrations.map(&:version)}")
+      end
+    end
+    
+    module InstanceMethods
+      def schema_version
+        Integer(@schema_version || self.class.current_schema_version)
+      end
+    end
+    
+    module ClassMethods
+      def migrate(version, &blk)
+        write_inheritable_array(:migrations, [Migration.new(version, blk)])
+        
+        if version > self.current_schema_version 
+          self.current_schema_version = version
+        end
+      end
+      
+      def instantiate(key, attributes)
+        version = attributes.delete('schema_version')
+        original_attributes = attributes.dup
+        if version == current_schema_version
+          return super(key, attributes)
+        end
+        
+        versions_to_migrate = ((version.to_i + 1)..current_schema_version)
+        
+        migrations_to_run = versions_to_migrate.map do |v|
+          migrations.find {|m| m.version == v}
+        end
+        
+        if migrations_to_run.any?(&:nil?)
+          raise MigrationNotFoundError.new(version, migrations)
+        end
+        
+        migrations_to_run.inject(attributes) do |attrs, migration|
+          migration.run(attrs)
+          @schema_version = migration.version.to_s
+          attrs
+        end
+        
+        returning super(key, attributes) do |record|
+          record.attributes_changed!(original_attributes.diff(attributes).keys)
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/mocking.rb

@@ -0,0 +1,15 @@
+require 'cassandra/mock'
+module CassandraObject
+  module Mocking
+    extend ActiveSupport::Concern
+    module ClassMethods
+      def use_mock!(really=true)
+        if really
+          self.connection_class = Cassandra::Mock
+        else
+          self.connection_class = Cassandra
+        end
+      end
+    end
+  end
+end

data/lib/cassandra_object/persistence.rb

@@ -0,0 +1,193 @@
+module CassandraObject
+  module Persistence
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_writer :write_consistency
+      class_inheritable_writer :read_consistency
+    end
+
+    VALID_READ_CONSISTENCY_LEVELS = [:one, :quorum, :all]
+    VALID_WRITE_CONSISTENCY_LEVELS = VALID_READ_CONSISTENCY_LEVELS + [:zero]
+
+    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: #{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 #{VALID_READ_CONSISTENCY_LEVELS.inspect}. You gave me #{levels[:write].inspect}"
+          end
+          self.read_consistency = levels[:read]
+        end
+      end
+
+      def write_consistency
+        read_inheritable_attribute(:write_consistency) || :quorum
+      end
+
+      def read_consistency
+        read_inheritable_attribute(:read_consistency) || :quorum
+      end
+
+      def get(key, options = {})
+        multi_get([key], options).values.first
+      end
+
+      def multi_get(keys, options = {})
+        options = {:consistency => self.read_consistency, :limit => 100}.merge(options)
+        unless valid_read_consistency_level?(options[:consistency])
+          raise ArgumentError, "Invalid read consistency level: '#{options[:consistency]}'. Valid options are [:quorum, :one]"
+        end
+
+        attribute_results = connection.multi_get(column_family, keys.map(&:to_s), :count=>options[:limit], :consistency=>consistency_for_thrift(options[:consistency]))
+
+        attribute_results.inject(ActiveSupport::OrderedHash.new) do |memo, (key, attributes)|
+          if attributes.empty?
+            memo[key] = nil
+          else
+            memo[parse_key(key)] = instantiate(key, attributes)
+          end
+          memo
+        end
+      end
+
+      def remove(key)
+        connection.remove(column_family, key.to_s, :consistency => write_consistency_for_thrift)
+      end
+
+      def all(keyrange = ''..'', options = {})
+        results = connection.get_range(column_family, :start => keyrange.first, :finish => keyrange.last, :count=>(options[:limit] || 100))
+        keys = results.map(&:key)
+        keys.map {|key| get(key) }
+      end
+
+      def first(keyrange = ''..'', options = {})
+        all(keyrange, options.merge(:limit=>1)).first
+      end
+
+      def create(attributes)
+        returning new(attributes) do |object|
+          object.save
+        end
+      end
+
+      def write(key, attributes, schema_version)
+        returning(key) do |key|
+          connection.insert(column_family, key.to_s, encode_columns_hash(attributes, schema_version), :consistency => write_consistency_for_thrift)
+        end
+      end
+
+      def instantiate(key, attributes)
+        # remove any attributes we don't know about. we would do this earlier, but we want to make such
+        #  attributes available to migrations
+        attributes.delete_if{|k,_| !model_attributes.keys.include?(k)}
+        returning allocate do |object|
+          object.instance_variable_set("@schema_version", attributes.delete('schema_version'))
+          object.instance_variable_set("@key", parse_key(key))
+          object.instance_variable_set("@attributes", decode_columns_hash(attributes).with_indifferent_access)
+        end
+      end
+
+      def encode_columns_hash(attributes, schema_version)
+        attributes.inject(Hash.new) do |memo, (column_name, value)|
+          memo[column_name.to_s] = model_attributes[column_name].converter.encode(value)
+          memo
+        end.merge({"schema_version" => schema_version.to_s})
+      end
+
+      def decode_columns_hash(attributes)
+        attributes.inject(Hash.new) do |memo, (column_name, value)|
+          memo[column_name.to_s] = model_attributes[column_name].converter.decode(value)
+          memo
+        end
+      end
+      
+      def column_family_configuration
+        [{:Name=>column_family, :CompareWith=>"UTF8Type"}]
+      end
+
+      protected
+      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
+
+      def write_consistency_for_thrift
+        consistency_for_thrift(write_consistency)
+      end
+
+      def read_consistency_for_thrift
+        consistency_for_thrift(read_consistency)
+      end
+
+      def consistency_for_thrift(consistency)
+        {
+          :zero   => Cassandra::Consistency::ZERO,
+          :one    => Cassandra::Consistency::ONE, 
+          :quorum => Cassandra::Consistency::QUORUM,
+          :all    => Cassandra::Consistency::ALL
+        }[consistency]
+      end
+    end
+
+    module InstanceMethods
+      def save
+        run_callbacks :save do
+          create_or_update
+        end
+      end
+      
+      def create_or_update
+        if new_record?
+          create
+        else
+          update
+        end
+        true
+      end
+      
+      def create
+        run_callbacks :create do
+          @key ||= self.class.next_key(self)
+          _write
+          @new_record = false
+          true
+        end
+      end
+      
+      def update
+        run_callbacks :update do
+          _write
+        end
+      end
+      
+      def _write
+        changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
+        self.class.write(key, changed_attributes, schema_version)
+      end
+
+      def new_record?
+        @new_record || false
+      end
+
+      def destroy
+        run_callbacks :destroy do 
+          self.class.remove(key)
+        end
+      end
+      
+      def reload
+        self.class.get(self.key)
+      end
+      
+    end
+  end
+end

data/lib/cassandra_object/serialization.rb

@@ -0,0 +1,6 @@
+module CassandraObject
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+  end
+end

data/lib/cassandra_object/type_registration.rb

@@ -0,0 +1,7 @@
+CassandraObject::Base.register_attribute_type(:integer, Integer, CassandraObject::IntegerType)
+CassandraObject::Base.register_attribute_type(:float, Float, CassandraObject::FloatType)
+CassandraObject::Base.register_attribute_type(:date, Date, CassandraObject::DateType)
+CassandraObject::Base.register_attribute_type(:time, Time, CassandraObject::TimeType)
+CassandraObject::Base.register_attribute_type(:time_with_zone, ActiveSupport::TimeWithZone, CassandraObject::TimeWithZoneType)
+CassandraObject::Base.register_attribute_type(:string, String, CassandraObject::StringType)
+CassandraObject::Base.register_attribute_type(:hash, Hash, CassandraObject::HashType)

data/lib/cassandra_object/types.rb

@@ -0,0 +1,128 @@
+module CassandraObject
+  module IntegerType
+    REGEX = /\A[-+]?\d+\Z/
+    def encode(int)
+      return '' if int.nil?
+      raise ArgumentError.new("#{self} requires an Integer. You passed #{int.inspect}") unless int.kind_of?(Integer)
+      int.to_s
+    end
+    module_function :encode
+
+    def decode(str)
+      return nil if str.empty?
+      raise ArgumentError.new("#{str} isn't a String that looks like a Integer") unless str.kind_of?(String) && str.match(REGEX)
+      str.to_i
+    end
+    module_function :decode
+  end
+
+  module FloatType
+    REGEX = /\A[-+]?\d+(\.\d+)\Z/
+    def encode(float)
+      return '' if float.nil?
+      raise ArgumentError.new("#{self} requires a Float") unless float.kind_of?(Float)
+      float.to_s
+    end
+    module_function :encode
+
+    def decode(str)
+      return nil if str == ''
+      raise ArgumentError.new("#{str} isn't a String that looks like a Float") unless str.kind_of?(String) && str.match(REGEX)
+      str.to_f
+    end
+    module_function :decode
+  end
+  
+  module DateType
+    FORMAT = '%Y-%m-%d'
+    REGEX = /\A\d{4}-\d{2}-\d{2}\Z/
+    def encode(date)
+      raise ArgumentError.new("#{self} requires a Date") unless date.kind_of?(Date)
+      date.strftime(FORMAT)
+    end
+    module_function :encode
+
+    def decode(str)
+      raise ArgumentError.new("#{str} isn't a String that looks like a Date") unless str.kind_of?(String) && str.match(REGEX)
+      Date.strptime(str, FORMAT)
+    end
+    module_function :decode
+  end
+
+  module TimeType
+    # lifted from the implementation of Time.xmlschema and simplified
+    REGEX = /\A\s*
+              (-?\d+)-(\d\d)-(\d\d)
+              T
+              (\d\d):(\d\d):(\d\d)
+              (\.\d*)?
+              (Z|[+-]\d\d:\d\d)?
+              \s*\z/ix
+
+    def encode(time)
+      raise ArgumentError.new("#{self} requires a Time") unless time.kind_of?(Time)
+      time.xmlschema(6)
+    end
+    module_function :encode
+
+    def decode(str)
+      raise ArgumentError.new("#{str} isn't a String that looks like a Time") unless str.kind_of?(String) && str.match(REGEX)
+      Time.xmlschema(str)
+    end
+    module_function :decode
+  end
+  
+  module TimeWithZoneType
+    def encode(time)
+      TimeType.encode(time.utc)
+    end
+    module_function :encode
+
+    def decode(str)
+      TimeType.decode(str).in_time_zone
+    end
+    module_function :decode
+  end
+  
+  module StringType
+    def encode(str)
+      raise ArgumentError.new("#{self} requires a String") unless str.kind_of?(String)
+      str
+    end
+    module_function :encode
+
+    def decode(str)
+      str
+    end
+    module_function :decode
+  end
+
+  module HashType
+    def encode(hash)
+      raise ArgumentError.new("#{self} requires a Hash") unless hash.kind_of?(Hash)
+      ActiveSupport::JSON.encode(hash)
+    end
+    module_function :encode
+
+    def decode(str)
+      ActiveSupport::JSON.decode(str)
+    end
+    module_function :decode
+  end
+
+  module BooleanType
+    ALLOWED = [true, false, nil]
+    def encode(bool)
+      unless ALLOWED.any?{ |a| bool == a }
+          raise ArgumentError.new("#{self} requires a Boolean or nil")
+      end
+      bool ? '1' : '0'
+    end
+    module_function :encode
+
+    def decode(bool)
+      bool == '1'
+    end
+    module_function :decode
+  end
+end