gotime-cassandra_object 0.6.1 → 0.7.1

data/Rakefile

@@ -59,16 +59,6 @@ task :cleanup do
   puts "Cleared"
 end
 
-task :config_snippet do
-  unless defined?(CassandraObject)
-    $: << 'test'
-    $: << 'lib'
-    require 'test_helper'
-  end
-  
-  puts CassandraObject::Base.storage_config_xml
-end
-
 task :default=>[:test, :cleanup] do
 end
 

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.7.1

data/gotime-cassandra_object.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gotime-cassandra_object}
-  s.version = "0.6.1"
+  s.version = "0.7.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Koziarski", "grantr"]
-  s.date = %q{2010-12-10}
+  s.date = %q{2011-01-31}
   s.description = %q{Cassandra ActiveModel}
   s.email = %q{grantr@gmail.com}
   s.extra_rdoc_files = [
@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
     "Rakefile",
     "TODO",
     "VERSION",
-    "cassandra_object.gemspec",
+    "gotime-cassandra_object.gemspec",
     "lib/cassandra_object.rb",
     "lib/cassandra_object/associations.rb",
     "lib/cassandra_object/associations/one_to_many.rb",
@@ -37,6 +37,8 @@ Gem::Specification.new do |s|
     "lib/cassandra_object/collection.rb",
     "lib/cassandra_object/cursor.rb",
     "lib/cassandra_object/dirty.rb",
+    "lib/cassandra_object/generators/migration_generator.rb",
+    "lib/cassandra_object/generators/templates/migration.rb.erb",
     "lib/cassandra_object/identity.rb",
     "lib/cassandra_object/identity/abstract_key_factory.rb",
     "lib/cassandra_object/identity/key.rb",
@@ -44,13 +46,19 @@ Gem::Specification.new do |s|
     "lib/cassandra_object/identity/uuid_key_factory.rb",
     "lib/cassandra_object/indexes.rb",
     "lib/cassandra_object/log_subscriber.rb",
+    "lib/cassandra_object/migration.rb",
     "lib/cassandra_object/migrations.rb",
+    "lib/cassandra_object/migrator.rb",
     "lib/cassandra_object/mocking.rb",
     "lib/cassandra_object/persistence.rb",
     "lib/cassandra_object/serialization.rb",
+    "lib/cassandra_object/tasks/column_family.rb",
+    "lib/cassandra_object/tasks/keyspace.rb",
+    "lib/cassandra_object/tasks/ks.rb",
     "lib/cassandra_object/type_registration.rb",
     "lib/cassandra_object/types.rb",
     "lib/cassandra_object/validation.rb",
+    "test/active_model_test.rb",
     "test/basic_scenarios_test.rb",
     "test/callbacks_test.rb",
     "test/config/cassandra.in.sh",
@@ -78,6 +86,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.7}
   s.summary = %q{Cassandra ActiveModel}
   s.test_files = [
+    "test/active_model_test.rb",
     "test/basic_scenarios_test.rb",
     "test/callbacks_test.rb",
     "test/connection.rb",

data/lib/cassandra_object.rb

@@ -1,13 +1,28 @@
 require 'rubygems'
 require 'i18n'
 require 'active_support'
+require 'active_model'
+
 
 module CassandraObject
-  VERSION = "0.5.0"
-end
+  VERSION = "0.7.1"
+  extend ActiveSupport::Autoload
 
+  autoload :Base
 
-require 'active_support/all'
-require 'active_model'
+  require 'cassandra_object/migrator'
+  require 'cassandra_object/migration'
 
-require 'cassandra_object/base'
+  module Tasks
+    extend ActiveSupport::Autoload
+    autoload :Keyspace
+    autoload :ColumnFamily
+
+    require 'cassandra_object/tasks/ks'
+  end
+
+  module Generators
+    require 'cassandra_object/generators/migration_generator'
+  end
+
+end

data/lib/cassandra_object/associations.rb

@@ -24,7 +24,9 @@ module CassandraObject
       
       def remove(key)
         begin
-          connection.remove("#{name}Relationships", key.to_s)
+          ActiveSupport::Notifications.instrument("remove.cassandra_object", :key => key) do
+            connection.remove("#{name}Relationships", key.to_s)
+          end
         rescue Cassandra::AccessError => e
           raise e unless e.message =~ /Invalid column family/
         end
@@ -32,4 +34,4 @@ module CassandraObject
       end
     end
   end
-end
+end

data/lib/cassandra_object/base.rb

@@ -1,4 +1,4 @@
-require 'cassandra'
+require 'cassandra/0.7'
 require 'set'
 require 'cassandra_object/attributes'
 require 'cassandra_object/dirty'
@@ -49,24 +49,6 @@ module CassandraObject
     
     extend ActiveModel::Naming
     
-    module ConfigurationDumper
-      def storage_config_xml
-        subclasses.map(&:constantize).map(&:column_family_configuration).flatten.map do |config|
-          config_to_xml(config)
-        end.join("\n")
-      end
-      
-      def config_to_xml(config)
-        xml = "<ColumnFamily "
-        config.each do |(attr_name, attr_value)|
-          xml << " #{attr_name}=\"#{attr_value}\""
-        end
-        xml << " />"
-        xml
-      end
-    end
-    extend ConfigurationDumper
-    
     include Callbacks
     include Identity
     include Attributes
@@ -86,11 +68,17 @@ module CassandraObject
 
     def initialize(attributes={})
       @key = attributes.delete(:key)
-      @new_record = true
+      @persisted = false
+      @destroyed = false
       @attributes = {}.with_indifferent_access
       self.attributes = attributes
       @schema_version = self.class.current_schema_version
     end
+
+    def to_model
+      self
+    end
+    
   end
 end
 

data/lib/cassandra_object/generators/migration_generator.rb

@@ -0,0 +1,31 @@
+require 'rails/generators'
+require 'rails/generators/named_base'
+
+module CassandraObject
+  module Generators
+    class MigrationGenerator < Rails::Generators::NamedBase
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def self.banner
+        "rails g cassandra_object:migration NAME"
+      end
+
+      def self.desc(description = nil)
+<<EOF
+Description:
+  Create an empty Cassandra migration file in 'ks/migrate'.  Very similar to Rails database migrations.
+
+Example:
+  `rails g cassandra_object:migration CreateFooColumnFamily`
+EOF
+      end
+
+      def create
+        timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        template 'migration.rb.erb', "ks/migrate/#{timestamp}_#{file_name.underscore}.rb"
+      end
+
+    end
+  end
+end

data/lib/cassandra_object/generators/templates/migration.rb.erb

@@ -0,0 +1,11 @@
+class <%= name %> < CassandraObject::Migration
+
+  def self.up
+
+  end
+
+  def self.down
+
+  end
+
+end

data/lib/cassandra_object/identity.rb

@@ -56,6 +56,10 @@ module CassandraObject
       def to_param
         key.to_param
       end
+
+      def to_key
+        [key] if key
+      end
     end
   end
 end

data/lib/cassandra_object/log_subscriber.rb

@@ -1,16 +1,27 @@
 module CassandraObject
   class LogSubscriber < ActiveSupport::LogSubscriber
     def multi_get(event)
-      name = 'CassandraObject multi_get (%.1fms)'
-      keys = event.payload[:keys].join(" ")
+      name = 'CassandraObject multi_get (%.1fms)' % event.duration
 
-      debug "  #{name}  (#{keys.size}) #{keys}"
+      debug "  #{name}  (#{event.payload[:keys].size}) #{event.payload[:keys].join(" ")}"
     end
 
     def remove(event)
+      name = 'CassandraObject remove (%.1fms)' % event.duration
+
+      debug "  #{name}  #{event.payload[:key]}"
     end
 
     def insert(event)
+      name = 'CassandraObject insert (%.1fms)' % event.duration
+
+      debug "  #{name}  #{event.payload[:key]} #{event.payload[:attributes].inspect}"
+    end
+
+    def get_range(event)
+      name = 'CassandraObject get_range (%.1fms)' % event.duration
+      
+      debug "  #{name}  (#{event.payload[:count]}) #{event.payload[:start]} => #{event.payload[:finish]}"
     end
   end
 end

data/lib/cassandra_object/migration.rb

@@ -0,0 +1,126 @@
+module CassandraObject
+
+  class Migration
+
+    @@verbose = true
+    cattr_accessor :verbose
+
+    # Returns the raw connection to Cassandra
+    def self.connection
+      CassandraObject::Base.connection
+    end
+
+    def self.migrate(direction)
+      return unless respond_to?(direction)
+
+      case direction
+        when :up   then announce "migrating"
+        when :down then announce "reverting"
+      end
+
+      result = nil
+      time = Benchmark.measure { result = send("#{direction}") }
+
+      case direction
+        when :up   then announce "migrated (%.4fs)" % time.real; write
+        when :down then announce "reverted (%.4fs)" % time.real; write
+      end
+
+      result
+    end
+
+    # Creates a new column family with the given name.  Column family configurations can be set within
+    # a block like this:
+    #
+    #  create_column_family(:users) do |cf|
+    #    cf.comment = 'Users column family'
+    #    cf.comparator_type = 'TimeUUIDType'
+    #  end
+    #
+    # A complete list of available configuration settings is here:
+    #
+    # http://github.com/fauna/cassandra/blob/master/vendor/0.7/gen-rb/cassandra_types.rb
+    #
+    # Scroll down to the CfDef definition.
+    def self.create_column_family(name, &block)
+      say_with_time("create_column_family #{name}") do
+        column_family_tasks.create(name, &block)
+      end
+    end
+
+    # Drops the given column family
+    def self.drop_column_family(name)
+      say_with_time("drop_column_family #{name}") do
+        column_family_tasks.drop(name)
+      end
+    end
+
+    # Renames the column family from the old name to the new name
+    def self.rename_column_family(old_name, new_name)
+      say_with_time("rename_column_family #{name}") do
+        column_family_tasks.rename(old_name, new_name)
+      end
+    end
+
+    def self.write(text="")
+      puts(text) if verbose
+    end
+
+    def self.announce(message)
+      version = defined?(@version) ? @version : nil
+
+      text = "#{version} #{name}: #{message}"
+      length = [0, 75 - text.length].max
+      write "== %s %s" % [text, "=" * length]
+    end
+
+    def self.say(message, subitem=false)
+      write "#{subitem ? "   ->" : "--"} #{message}"
+    end
+
+    def self.say_with_time(message)
+      say(message)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      say "%.4fs" % time.real, :subitem
+      say("#{result} rows", :subitem) if result.is_a?(Integer)
+      result
+    end
+
+    def self.suppress_messages
+      save, self.verbose = verbose, false
+      yield
+    ensure
+      self.verbose = save
+    end
+
+    private
+
+    def self.column_family_tasks
+      Tasks::ColumnFamily.new(CassandraObject::Base.connection.keyspace)
+    end
+
+  end
+
+  # MigrationProxy is used to defer loading of the actual migration classes
+  # until they are needed
+  class MigrationProxy
+
+    attr_accessor :name, :version, :filename
+
+    delegate :migrate, :announce, :write, :to=>:migration
+
+    private
+
+    def migration
+      @migration ||= load_migration
+    end
+
+    def load_migration
+      require(File.expand_path(filename))
+      name.constantize
+    end
+
+  end
+
+end

data/lib/cassandra_object/migrator.rb

@@ -0,0 +1,238 @@
+module CassandraObject
+  class IrreversibleMigration < StandardError
+  end
+
+  class DuplicateMigrationVersionError < StandardError#:nodoc:
+    def initialize(version)
+      super("Multiple migrations have the version number #{version}")
+    end
+  end
+
+  class DuplicateMigrationNameError < StandardError#:nodoc:
+    def initialize(name)
+      super("Multiple migrations have the name #{name}")
+    end
+  end
+
+  class UnknownMigrationVersionError < StandardError #:nodoc:
+    def initialize(version)
+      super("No migration with version number #{version}")
+    end
+  end
+
+  class IllegalMigrationNameError < StandardError#:nodoc:
+    def initialize(name)
+      super("Illegal name for migration file: #{name}\n\t(only lower case letters, numbers, and '_' allowed)")
+    end
+  end
+
+  class Migrator
+
+    def self.migrate(migrations_path, target_version = nil)
+      case
+        when target_version.nil?
+          up(migrations_path, target_version)
+        when current_version == 0 && target_version == 0
+        when current_version > target_version
+          down(migrations_path, target_version)
+        else
+          up(migrations_path, target_version)
+      end
+    end
+
+    def self.rollback(migrations_path, steps = 1)
+      move(:down, migrations_path, steps)
+    end
+
+    def self.forward(migrations_path, steps = 1)
+      move(:up, migrations_path, steps)
+    end
+
+    def self.up(migrations_path, target_version = nil)
+      new(:up, migrations_path, target_version).migrate
+    end
+
+    def self.down(migrations_path, target_version = nil)
+      new(:down, migrations_path, target_version).migrate
+    end
+
+    def self.run(direction, migrations_path, target_version)
+      new(direction, migrations_path, target_version).run
+    end
+
+    def self.migrations_path
+      'ks/migrate'
+    end
+
+    def self.schema_migrations_column_family
+      :schema_migrations
+    end
+
+    def self.column_family_tasks
+      cas = CassandraObject::Base.connection
+      Tasks::ColumnFamily.new(cas.keyspace)
+    end
+
+    def self.get_all_versions
+      cas = CassandraObject::Base.connection
+      cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
+    end
+
+    def self.current_version
+      sm_cf = schema_migrations_column_family
+      if column_family_tasks.exists?(sm_cf)
+        get_all_versions.max || 0
+      else
+        0
+      end
+    end
+
+    private
+
+    def self.move(direction, migrations_path, steps)
+      migrator = self.new(direction, migrations_path)
+      start_index = migrator.migrations.index(migrator.current_migration)
+
+      if start_index
+        finish = migrator.migrations[start_index + steps]
+        version = finish ? finish.version : 0
+        send(direction, migrations_path, version)
+      end
+    end
+
+    public
+
+    def initialize(direction, migrations_path, target_version = nil)
+      sm_cf = self.class.schema_migrations_column_family
+
+      unless column_family_tasks.exists?(sm_cf)
+        column_family_tasks.create(sm_cf) do |cf|
+          cf.comparator_type = 'LongType'
+        end
+      end
+
+      @direction, @migrations_path, @target_version = direction, migrations_path, target_version
+    end
+
+    def current_version
+      migrated.last || 0
+    end
+
+    def current_migration
+      migrations.detect { |m| m.version == current_version }
+    end
+
+    def run
+      target = migrations.detect { |m| m.version == @target_version }
+      raise UnknownMigrationVersionError.new(@target_version) if target.nil?
+      unless (up? && migrated.include?(target.version.to_i)) || (down? && !migrated.include?(target.version.to_i))
+        target.migrate(@direction)
+        record_version_state_after_migrating(target)
+      end
+    end
+
+    def migrate
+      current = migrations.detect { |m| m.version == current_version }
+      target = migrations.detect { |m| m.version == @target_version }
+
+      if target.nil? && !@target_version.nil? && @target_version > 0
+        raise UnknownMigrationVersionError.new(@target_version)
+      end
+
+      start = up? ? 0 : (migrations.index(current) || 0)
+      finish = migrations.index(target) || migrations.size - 1
+      runnable = migrations[start..finish]
+
+      # skip the last migration if we're headed down, but not ALL the way down
+      runnable.pop if down? && !target.nil?
+
+      runnable.each do |migration|
+        #puts "Migrating to #{migration.name} (#{migration.version})"
+
+        # On our way up, we skip migrating the ones we've already migrated
+        next if up? && migrated.include?(migration.version.to_i)
+
+        # On our way down, we skip reverting the ones we've never migrated
+        if down? && !migrated.include?(migration.version.to_i)
+          migration.announce 'never migrated, skipping'; migration.write
+          next
+        end
+
+        migration.migrate(@direction)
+        record_version_state_after_migrating(migration)
+      end
+    end
+
+    def migrations
+      @migrations ||= begin
+        files = Dir["#{@migrations_path}/[0-9]*_*.rb"]
+
+        migrations = files.inject([]) do |klasses, file|
+          version, name = file.scan(/([0-9]+)_([_a-z0-9]*).rb/).first
+
+          raise IllegalMigrationNameError.new(file) unless version
+          version = version.to_i
+
+          if klasses.detect { |m| m.version == version }
+            raise DuplicateMigrationVersionError.new(version)
+          end
+
+          if klasses.detect { |m| m.name == name.camelize }
+            raise DuplicateMigrationNameError.new(name.camelize)
+          end
+
+          migration = MigrationProxy.new
+          migration.name     = name.camelize
+          migration.version  = version
+          migration.filename = file
+          klasses << migration
+        end
+
+        migrations = migrations.sort_by { |m| m.version }
+        down? ? migrations.reverse : migrations
+      end
+    end
+
+    def pending_migrations
+      already_migrated = migrated
+      migrations.reject { |m| already_migrated.include?(m.version.to_i) }
+    end
+
+    def migrated
+      @migrated_versions ||= self.class.get_all_versions
+    end
+
+    private
+
+    def column_family_tasks
+      Tasks::ColumnFamily.new(connection.keyspace)
+    end
+
+    def connection
+      CassandraObject::Base.connection
+    end
+
+    def record_version_state_after_migrating(migration)
+      sm_cf = self.class.schema_migrations_column_family
+
+      @migrated_versions ||= []
+      if down?
+        @migrated_versions.delete(migration.version)
+        connection.remove sm_cf, 'all', migration.version
+      else
+        @migrated_versions.push(migration.version).sort!
+        connection.insert sm_cf, 'all', { migration.version => migration.name }
+      end
+    end
+
+    def up?
+      @direction == :up
+    end
+
+    def down?
+      @direction == :down
+    end
+
+  end
+  
+end

data/lib/cassandra_object/persistence.rb

@@ -7,7 +7,7 @@ module CassandraObject
     end
 
     VALID_READ_CONSISTENCY_LEVELS = [:one, :quorum, :all]
-    VALID_WRITE_CONSISTENCY_LEVELS = VALID_READ_CONSISTENCY_LEVELS + [:zero]
+    VALID_WRITE_CONSISTENCY_LEVELS = VALID_READ_CONSISTENCY_LEVELS
 
     module ClassMethods
       def consistency_levels(levels)
@@ -59,11 +59,20 @@ module CassandraObject
       end
 
       def remove(key)
-        connection.remove(column_family, key.to_s, :consistency => write_consistency_for_thrift)
+        ActiveSupport::Notifications.instrument("remove.cassandra_object", :key => key) do
+          connection.remove(column_family, key.to_s, :consistency => write_consistency_for_thrift)
+        end
+      end
+
+      def delete_all
+        connection.truncate!(column_family)
       end
 
       def all(keyrange = ''..'', options = {})
-        results = connection.get_range(column_family, :start => keyrange.first, :finish => keyrange.last, :count=>(options[:limit] || 100))
+        count = options[:limit] || 100
+        results = ActiveSupport::Notifications.instrument("get_range.cassandra_object", :start => keyrange.first, :finish => keyrange.last, :count => count) do
+          connection.get_range(column_family, :start => keyrange.first, :finish => keyrange.last, :count => count)
+        end
         keys = results.map(&:key)
         keys.map {|key| get(key) }
       end
@@ -80,7 +89,10 @@ module CassandraObject
 
       def write(key, attributes, schema_version)
         key.tap do |key|
-          connection.insert(column_family, key.to_s, encode_columns_hash(attributes, schema_version), :consistency => write_consistency_for_thrift)
+          attributes = encode_columns_hash(attributes, schema_version)
+          ActiveSupport::Notifications.instrument("insert.cassandra_object", :key => key, :attributes => attributes) do
+            connection.insert(column_family, key.to_s, attributes, :consistency => write_consistency_for_thrift)
+          end
         end
       end
 
@@ -97,7 +109,9 @@ module CassandraObject
 
       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)
+          # cassandra stores bytes, not strings, so it has no concept of encodings. The ruby thrift gem 
+          # expects all strings to be encoded as ascii-8bit.
+          memo[column_name.to_s] = model_attributes[column_name].converter.encode(value).force_encoding('ASCII-8BIT')
           memo
         end.merge({"schema_version" => schema_version.to_s})
       end
@@ -132,7 +146,6 @@ module CassandraObject
 
       def consistency_for_thrift(consistency)
         {
-          :zero   => Cassandra::Consistency::ZERO,
           :one    => Cassandra::Consistency::ONE, 
           :quorum => Cassandra::Consistency::QUORUM,
           :all    => Cassandra::Consistency::ALL
@@ -142,31 +155,27 @@ module CassandraObject
 
     module InstanceMethods
       def save
-        run_callbacks :save do
+        _run_save_callbacks do
           create_or_update
         end
       end
       
       def create_or_update
-        if new_record?
-          create
-        else
-          update
-        end
-        true
+        result = persisted? ? update : create
+        result != false
       end
       
       def create
-        run_callbacks :create do
+        _run_create_callbacks do
           @key ||= self.class.next_key(self)
           _write
-          @new_record = false
-          true
+          @persisted = true
+          @key
         end
       end
       
       def update
-        run_callbacks :update do
+        _run_update_callbacks do
           _write
         end
       end
@@ -177,12 +186,22 @@ module CassandraObject
       end
 
       def new_record?
-        @new_record || false
+        !@persisted
+      end
+
+      def destroyed?
+        @destroyed
+      end
+
+      def persisted?
+        @persisted && !destroyed?
       end
 
       def destroy
-        run_callbacks :destroy do 
+        _run_destroy_callbacks do 
           self.class.remove(key)
+          @destroyed = true
+          freeze
         end
       end
       

data/lib/cassandra_object/tasks/column_family.rb

@@ -0,0 +1,90 @@
+module CassandraObject
+
+  module Tasks
+
+    class ColumnFamily
+
+      COMPARATOR_TYPES = { :time      => 'TimeUUIDType',
+                           :timestamp => 'TimeUUIDType',
+                           :long      => 'LongType',
+                           :string    => 'BytesType',
+                           :utf8      => 'UTF8Type' }
+
+      COLUMN_TYPES = {     :standard  => 'Standard',
+                           :super     => 'Super' }
+
+      def initialize(keyspace)
+        @keyspace = keyspace
+      end
+
+      def exists?(name)
+        connection.schema.cf_defs.find { |cf_def| cf_def.name == name.to_s }
+      end
+
+      def create(name, &block)
+        cf = Cassandra::ColumnFamily.new
+        cf.name = name.to_s
+        cf.keyspace = @keyspace.to_s
+        cf.comparator_type = 'BytesType'
+        cf.column_type = 'Standard'
+
+        block.call cf if block
+
+        post_process_column_family(cf)
+        connection.add_column_family(cf)
+      end
+
+      def drop(name)
+        connection.drop_column_family(name.to_s)
+      end
+
+      def rename(old_name, new_name)
+        connection.rename_column_family(old_name.to_s, new_name.to_s)
+      end
+
+      def clear(name)
+        connection.truncate!(name.to_s)
+      end
+
+      private
+
+      def connection
+        CassandraObject::Base.connection
+      end
+
+      def post_process_column_family(cf)
+        comp_type = cf.comparator_type
+        if comp_type && COMPARATOR_TYPES.has_key?(comp_type)
+          cf.comparator_type = COMPARATOR_TYPES[comp_type]
+        end
+
+        comp_type = cf.subcomparator_type
+        if comp_type && COMPARATOR_TYPES.has_key?(comp_type)
+          cf.subcomparator_type = COMPARATOR_TYPES[comp_type]
+        end
+
+        col_type = cf.column_type
+        if col_type && COLUMN_TYPES.has_key?(col_type)
+          cf.column_type = COLUMN_TYPES[col_type]
+        end
+
+        cf
+      end
+
+    end
+
+  end
+
+end
+
+class Cassandra
+  class ColumnFamily
+    def with_fields(options)
+      struct_fields.collect { |f| f[1][:name] }.each do |f|
+        send("#{f}=", options[f.to_sym] || options[f.to_s])
+      end
+      self
+    end
+  end
+end
+

data/lib/cassandra_object/tasks/keyspace.rb

@@ -0,0 +1,89 @@
+module CassandraObject
+
+  module Tasks
+
+    class Keyspace
+
+      def self.parse(hash)
+        ks = Cassandra::Keyspace.new.with_fields hash
+        ks.cf_defs = []
+        hash['cf_defs'].each do |cf|
+          ks.cf_defs << Cassandra::ColumnFamily.new.with_fields(cf)
+        end
+        ks
+      end
+
+      def exists?(name)
+        connection.keyspaces.include? name.to_s
+      end
+
+      def create(name, options = {})
+        opts = { :name => name.to_s,
+                 :strategy_class => 'org.apache.cassandra.locator.LocalStrategy',
+                 :replication_factor => 1,
+                 :cf_defs => [] }.merge(options)
+
+        ks = Cassandra::Keyspace.new.with_fields(opts)
+        connection.add_keyspace ks
+      end
+
+      def drop(name)
+        connection.drop_keyspace name.to_s
+      end
+
+      def set(name)
+        connection.keyspace = name.to_s
+      end
+
+      def get
+        connection.keyspace
+      end
+
+      def clear
+        return puts 'Cannot clear system keyspace' if connection.keyspace == 'system'
+
+        connection.clear_keyspace!
+      end
+
+      def schema_dump
+        connection.schema
+      end
+
+      def schema_load(schema)
+        connection.schema.cf_defs.each do |cf|
+          connection.drop_column_family cf.name
+        end
+
+        keyspace = get
+        schema.cf_defs.each do |cf|
+          cf.keyspace = keyspace
+          connection.add_column_family cf
+        end
+      end
+
+      private
+
+      def connection
+        unless @connection
+          c = CassandraObject::Base.connection
+          @connection = Cassandra.new('system', c.servers, c.thrift_client_options)
+        end
+        @connection
+      end
+
+    end
+
+  end
+
+end
+
+class Cassandra
+  class Keyspace
+    def with_fields(options)
+      struct_fields.collect { |f| f[1][:name] }.each do |f|
+        send("#{f}=", options[f.to_sym] || options[f.to_s])
+      end
+      self
+    end
+  end
+end

data/lib/cassandra_object/tasks/ks.rb

@@ -0,0 +1,122 @@
+require 'rake'
+
+namespace :ks do
+
+  task :configure => :environment do
+    @configs = YAML.load_file(Rails.root.join("config", "cassandra.yml"))
+    @config = @configs[Rails.env || 'development']
+  end
+
+  #task :set_keyspace => :configure do
+    #set_keyspace
+  #end
+
+  desc 'Create the keyspace in config/cassandra.yml for the current environment'
+  task :create => :configure do
+    CassandraObject::Tasks::Keyspace.new.create @config['keyspace'], @config
+    puts "Created keyspace: #{@config['keyspace']}"
+  end
+
+  namespace :create do
+    desc 'Create keyspaces in config/cassandra.yml for all environments'
+    task :all => :configure do
+      created = []
+      @configs.values.each do |config|
+        CassandraObject::Tasks::Keyspace.new.create config['keyspace'], config
+        created << config['keyspace']
+      end
+      puts "Created keyspaces: #{created.join(', ')}"
+    end
+  end
+
+  desc 'Drop keyspace in config/cassandra.yml for the current environment'
+  task :drop => :configure do
+    CassandraObject::Tasks::Keyspace.new.drop @config['keyspace']
+    puts "Dropped keyspace: #{@config['keyspace']}"
+  end
+
+  namespace :drop do
+    desc 'Drop keyspaces in config/cassandra.yml for all environments'
+    task :all => :configure do
+      dropped = []
+      @configs.values.each do |config|
+        CassandraObject::Tasks::Keyspace.new.drop config['keyspace']
+        dropped << config['keyspace']
+      end
+      puts "Dropped keyspaces: #{dropped.join(', ')}"
+    end
+  end
+
+  desc 'Migrate the keyspace (options: VERSION=x)'
+  task :migrate => :configure do
+    version = ( ENV['VERSION'] ? ENV['VERSION'].to_i : nil )
+    CassandraObject::Migrator.migrate CassandraObject::Migrator.migrations_path, version
+    schema_dump
+  end
+
+  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n)'
+  task :rollback => :set_keyspace do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    CassandraObject::Migrator.rollback CassandraObject::Migrator.migrations_path, step
+    schema_dump
+  end
+
+  desc 'Pushes the schema to the next version (specify steps w/ STEP=n)'
+  task :forward => :set_keyspace do
+    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
+    CassandraObject::Migrator.forward CassandraObject::Migrator.migrations_path, step
+    schema_dump
+  end
+
+  namespace :schema do
+    desc 'Create ks/schema.json file that can be portably used against any Cassandra instance supported by CassandraObject'
+    task :dump => :configure do
+      schema_dump
+    end
+
+    desc 'Load ks/schema.json file into Cassandra'
+    task :load => :configure do
+      schema_load
+    end
+  end
+
+  namespace :test do
+    desc 'Load the development schema in to the test keyspace'
+    task :prepare => :configure do
+      schema_dump :development
+      schema_load :test
+    end
+  end
+
+  desc 'Retrieves the current schema version number'
+  task :version => :set_keyspace do
+    version = CassandraObject::Migrator.current_version
+    puts "Current version: #{version}"
+  end
+
+  private
+
+  def schema_dump(env = Rails.env)
+    ks = set_keyspace env
+    File.open "#{Rails.root}/ks/schema.json", 'w' do |file|
+      file.puts ks.schema_dump.to_json
+    end
+  end
+
+  def schema_load(env = Rails.env)
+    ks = set_keyspace env
+    File.open "#{Rails.root}/ks/schema.json", 'r' do |file|
+      hash = JSON.parse(file.read(nil))
+      ks.schema_load CassandraObject::Tasks::Keyspace.parse(hash)
+    end
+  end
+
+  def set_keyspace(env = Rails.env)
+    config = @configs[env.to_s || 'development']
+    ks = CassandraObject::Tasks::Keyspace.new
+    ks.set config['keyspace']
+    ks
+  end
+
+end
+

data/lib/cassandra_object/type_registration.rb

@@ -3,5 +3,7 @@ CassandraObject::Base.register_attribute_type(:float, Float, CassandraObject::Fl
 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(:string, String, CassandraObject::UTF8StringType) #This could be changed to StringType to support non-utf8 strings
+CassandraObject::Base.register_attribute_type(:utf8, String, CassandraObject::UTF8StringType)
 CassandraObject::Base.register_attribute_type(:hash, Hash, CassandraObject::HashType)
+CassandraObject::Base.register_attribute_type(:boolean, Object, CassandraObject::BooleanType)

data/lib/cassandra_object/types.rb

@@ -83,11 +83,11 @@ module CassandraObject
     end
     module_function :decode
   end
-  
+
   module StringType
     def encode(str)
       raise ArgumentError.new("#{self} requires a String") unless str.kind_of?(String)
-      str
+      str.dup
     end
     module_function :encode
 
@@ -96,6 +96,21 @@ module CassandraObject
     end
     module_function :decode
   end
+  
+  module UTF8StringType
+    def encode(str)
+      # This is technically the most correct, but it is a pain to require utf-8 encoding for all strings. Should revisit.
+      #raise ArgumentError.new("#{self} requires a UTF-8 encoded String") unless str.kind_of?(String) && str.encoding == Encoding::UTF_8
+      raise ArgumentError.new("#{self} requires a String") unless str.kind_of?(String)
+      str.dup
+    end
+    module_function :encode
+
+    def decode(str)
+      str.force_encoding('UTF-8')
+    end
+    module_function :decode
+  end
 
   module HashType
     def encode(hash)

data/lib/cassandra_object/validation.rb

@@ -1,16 +1,17 @@
 module CassandraObject
-  module Validation
-    class RecordInvalidError < StandardError
-      attr_reader :record
-      def initialize(record)
-        @record = record
-        super("Invalid record: #{@record.errors.full_messages.to_sentence}")
-      end
-      
-      def self.raise_error(record)
-        raise new(record)
-      end
+  class RecordInvalid < StandardError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super("Invalid record: #{@record.errors.full_messages.to_sentence}")
     end
+    
+    def self.raise_error(record)
+      raise new(record)
+    end
+  end
+
+  module Validation
     extend ActiveSupport::Concern
     include ActiveModel::Validations
     
@@ -41,7 +42,7 @@ module CassandraObject
       end
       
       def save!
-        save || RecordInvalidError.raise_error(self)
+        save || RecordInvalid.raise_error(self)
       end
       
     end

data/test/active_model_test.rb

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

data/test/types_test.rb

@@ -184,21 +184,21 @@ class TypesTest < CassandraObjectTestCase
     context "encode" do
       should "handle an empty Hash" do
         assert_nothing_raised {
-          assert_equal({}.to_json, CassandraObject::HashType.encode({}))
+          assert_equal(ActiveSupport::JSON.encode({}), CassandraObject::HashType.encode({}))
         }
       end
 
       should "handle string keys" do
         assert_nothing_raised {
           h = {'foo' => 'bar'}
-          assert_equal(h.to_json, CassandraObject::HashType.encode(h))
+          assert_equal(ActiveSupport::JSON.encode(h), CassandraObject::HashType.encode(h))
         }
       end
 
       should "handle symbol keys" do
         assert_nothing_raised {
           h = {:foo => 'bar'}
-          assert_equal(h.to_json, CassandraObject::HashType.encode(h))
+          assert_equal(ActiveSupport::JSON.encode(h), CassandraObject::HashType.encode(h))
         }
       end
     end

data/test/validation_test.rb

@@ -7,7 +7,7 @@ class ValidationTest < CassandraObjectTestCase
       customer = Customer.new :first_name=>"steve", :date_of_birth=>Date.parse("1979/12/25")
       customer.save!
       flunk "Should have failed to save"
-    rescue CassandraObject::Validation::RecordInvalidError => e
+    rescue CassandraObject::Validation::RecordInvalid => e
       assert_equal customer, e.record
     end
   end
@@ -16,10 +16,10 @@ class ValidationTest < CassandraObjectTestCase
     begin
       customer = Customer.create! :first_name=>"steve", :date_of_birth=>Date.parse("1979/12/25")
       flunk "Should have failed to create!"
-    rescue CassandraObject::Validation::RecordInvalidError => e
+    rescue CassandraObject::Validation::RecordInvalid => e
       assert_kind_of Customer, e.record
     end
   end
 
 
-end
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 6
+  - 7
   - 1
-  version: 0.6.1
+  version: 0.7.1
 platform: ruby
 authors: 
 - Michael Koziarski
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-12-10 00:00:00 -08:00
+date: 2011-01-31 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -156,6 +156,8 @@ files:
 - lib/cassandra_object/collection.rb
 - lib/cassandra_object/cursor.rb
 - lib/cassandra_object/dirty.rb
+- lib/cassandra_object/generators/migration_generator.rb
+- lib/cassandra_object/generators/templates/migration.rb.erb
 - lib/cassandra_object/identity.rb
 - lib/cassandra_object/identity/abstract_key_factory.rb
 - lib/cassandra_object/identity/key.rb
@@ -163,13 +165,19 @@ files:
 - lib/cassandra_object/identity/uuid_key_factory.rb
 - lib/cassandra_object/indexes.rb
 - lib/cassandra_object/log_subscriber.rb
+- lib/cassandra_object/migration.rb
 - lib/cassandra_object/migrations.rb
+- lib/cassandra_object/migrator.rb
 - lib/cassandra_object/mocking.rb
 - lib/cassandra_object/persistence.rb
 - lib/cassandra_object/serialization.rb
+- lib/cassandra_object/tasks/column_family.rb
+- lib/cassandra_object/tasks/keyspace.rb
+- lib/cassandra_object/tasks/ks.rb
 - lib/cassandra_object/type_registration.rb
 - lib/cassandra_object/types.rb
 - lib/cassandra_object/validation.rb
+- test/active_model_test.rb
 - test/basic_scenarios_test.rb
 - test/callbacks_test.rb
 - test/config/cassandra.in.sh
@@ -204,7 +212,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 2344157015665262405
+      hash: -3516092246670549921
       segments: 
       - 0
       version: "0"
@@ -224,6 +232,7 @@ signing_key:
 specification_version: 3
 summary: Cassandra ActiveModel
 test_files: 
+- test/active_model_test.rb
 - test/basic_scenarios_test.rb
 - test/callbacks_test.rb
 - test/connection.rb