datastax_rails 1.0.5

data/lib/datastax_rails/identity/natural_key_factory.rb

@@ -0,0 +1,37 @@
+module DatastaxRails
+  module Identity
+    class NaturalKeyFactory < AbstractKeyFactory
+      class NaturalKey
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def to_s
+          value
+        end
+
+        def ==(other)
+          other.to_s == to_s
+        end
+      end
+
+      attr_reader :attributes, :separator
+
+      def initialize(options)
+        @attributes = [*options[:attributes]]
+        @separator  = options[:separator] || "-"
+      end
+
+      def next_key(object)
+        NaturalKey.new(attributes.map { |a| object.attributes[a.to_s] }.join(separator))
+      end
+
+      def parse(paramized_key)
+        NaturalKey.new(paramized_key)
+      end
+    end
+  end
+end
+

data/lib/datastax_rails/identity/uuid_key_factory.rb

@@ -0,0 +1,23 @@
+module DatastaxRails
+  module Identity
+    # Key factories need to support 3 operations
+    class UUIDKeyFactory < AbstractKeyFactory
+      class UUID < SimpleUUID::UUID
+        def to_s
+          to_guid
+        end
+      end
+    
+      def next_key(object)
+        UUID.new
+      end
+      
+      def parse(string)
+        UUID.new(string) if string
+      rescue
+        nil
+      end
+    end
+  end
+end
+

data/lib/datastax_rails/identity.rb

@@ -0,0 +1,53 @@
+module DatastaxRails #:nodoc:
+  module Identity
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :Key
+    autoload :AbstractKeyFactory
+    autoload :UUIDKeyFactory
+    autoload :NaturalKeyFactory
+    autoload :HashedNaturalKeyFactory
+    autoload :CustomKeyFactory
+
+    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)
+        when :custom
+          CustomKeyFactory.new(*options)
+        else
+          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
+
+    def id
+      key.to_s
+    end
+
+    # TODO test this
+    def id=(key)
+      self.key = self.class.parse_key(key)
+      id
+    end
+  end
+end

data/lib/datastax_rails/log_subscriber.rb

@@ -0,0 +1,37 @@
+module DatastaxRails
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def multi_get(event)
+      name = '%s multi_get (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      debug "  #{name}  (#{event.payload[:keys].size}) #{event.payload[:keys].join(" ")}"
+    end
+
+    def remove(event)
+      name = '%s remove (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      message = "  #{name}  #{event.payload[:key]}"
+      message << " #{Array(event.payload[:attributes]).inspect}" if event.payload[:attributes]
+
+      debug message
+    end
+
+    def truncate(event)
+      name = '%s truncate (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      debug "  #{name}  #{event.payload[:column_family]}"
+    end
+
+    def insert(event)
+      name = '%s insert (%.1fms)' % [event.payload[:column_family], event.duration]
+
+      debug "  #{name}  #{event.payload[:key]} #{event.payload[:attributes].inspect}"
+    end
+
+    def get_range(event)
+      name = '%s get_range (%.1fms)' % [event.payload[:column_family], event.duration]
+      
+      debug "  #{name}  (#{event.payload[:count]}) '#{event.payload[:start]}' => '#{event.payload[:finish]}'"
+    end
+  end
+end
+DatastaxRails::LogSubscriber.attach_to :datastax_rails

data/lib/datastax_rails/migrations/migration.rb

@@ -0,0 +1,15 @@
+module DatastaxRails
+  module Migrations
+    class Migration
+      attr_reader :version
+      def initialize(version, block)
+        @version = version
+        @block = block
+      end
+
+      def run(attrs)
+        @block.call(attrs)
+      end
+    end
+  end
+end

data/lib/datastax_rails/migrations.rb

@@ -0,0 +1,36 @@
+module DatastaxRails
+  module Migrations
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    included do
+      class_attribute :migrations
+      self.migrations = []
+
+      class_attribute :current_schema_version
+      self.current_schema_version = 0
+    end
+
+    autoload :Migration
+    
+    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
+    
+    def schema_version
+      Integer(@schema_version || self.class.current_schema_version)
+    end
+    
+    module ClassMethods
+      def migrate(version, &blk)
+        migrations << Migration.new(version, blk)
+        
+        if version > self.current_schema_version 
+          self.current_schema_version = version
+        end
+      end
+    end
+  end
+end

data/lib/datastax_rails/mocking.rb

@@ -0,0 +1,15 @@
+require 'cassandra/mock'
+module DatastaxRails
+  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/datastax_rails/persistence.rb

@@ -0,0 +1,133 @@
+module DatastaxRails
+  module Persistence
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      def remove(*keys)
+        ActiveSupport::Notifications.instrument("remove.datastax_rails", :column_family => column_family, :key => key) do
+          cql.delete(keys).using(thrift_write_consistency).execute
+        end
+      end
+
+      def delete_all
+        ActiveSupport::Notifications.instrument("truncate.datastax_rails", :column_family => column_family) do
+          cql.truncate.execute
+        end
+      end
+
+      def create(attributes = {})
+        new(attributes).tap do |object|
+          object.save
+        end
+      end
+
+      def write(key, attributes, schema_version)
+        key.tap do |key|
+          attributes = encode_attributes(attributes, schema_version)
+          ActiveSupport::Notifications.instrument("insert.datastax_rails", :column_family => column_family, :key => key, :attributes => attributes) do
+            cql.update(key.to_s).columns(attributes).using(thrift_write_consistency).execute
+          end
+        end
+      end
+
+      def instantiate(key, attributes)
+        allocate.tap do |object|
+          object.instance_variable_set("@schema_version", attributes.delete('schema_version'))
+          object.instance_variable_set("@key", parse_key(key)) if key
+          object.instance_variable_set("@new_record", false)
+          object.instance_variable_set("@destroyed", false)
+          object.instance_variable_set("@attributes", typecast_attributes(object, attributes))
+        end
+      end
+
+      def encode_attributes(attributes, schema_version)
+        encoded = {"schema_version" => schema_version.to_s}
+        attributes.each do |column_name, value|
+          if value.nil?
+            encoded[column_name.to_s] = ""
+          else
+            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value)
+          end
+        end
+        encoded
+      end
+
+      def typecast_attributes(object, attributes)
+        attributes = attributes.symbolize_keys
+        Hash[attribute_definitions.map { |k, attribute_definition| [k.to_s, attribute_definition.instantiate(object, attributes[k])] }]
+      end
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    def save(*)
+      begin
+        create_or_update
+      rescue DatastaxRails::RecordInvalid
+        false
+      end
+    end
+
+    def save!
+      create_or_update || raise(RecordNotSaved)
+    end
+
+    def destroy
+      self.class.remove(key)
+      @destroyed = true
+      freeze
+    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 reload
+      @attributes.update(self.class.find(self.id).instance_variable_get('@attributes'))
+    end
+
+    private
+      def create_or_update
+        result = new_record? ? create : update
+        result != false
+      end
+
+      def create
+        @key ||= self.class.next_key(self)
+        write
+        @new_record = false
+        @key
+      end
+    
+      def update
+        write
+      end
+      
+      def write #:nodoc:
+        changed_attributes = changed.inject({}) { |h, n| h[n] = read_attribute(n); h }
+        self.class.write(key, changed_attributes, schema_version)
+      end
+  end
+end

data/lib/datastax_rails/railtie.rb

@@ -0,0 +1,20 @@
+require 'datastax_rails'
+require 'rails'
+module DatastaxRails
+  class Railtie < Rails::Railtie
+    initializer 'datastax_rails.init' do
+      ActiveSupport.on_load(:datastax_rails) do
+      end
+      config = YAML.load_file(Rails.root.join("config", "datastax.yml"))
+      DatastaxRails::Base.establish_connection(config[Rails.env].symbolize_keys)
+    end
+    
+    rake_tasks do
+      load 'datastax_rails/tasks/ds.rake'
+    end
+    
+    generators do
+      require 'datastax_rails/generators/migration_generator'
+    end
+  end
+end