gotime-cassandra_object 3.0.5 → 4.0.0

data/CHANGELOG

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

data/Gemfile

@@ -2,5 +2,6 @@ source "http://rubygems.org"
 gemspec
 
 group :test do
-  gem 'mcmire-cassandra', require: 'cassandra/1.0'
-end
+  gem 'cassandra', require: 'cassandra/1.0'
+  gem 'cassandra-cql'
+end

data/README.rdoc

@@ -7,7 +7,7 @@ Cassandra Object uses ActiveModel to mimic much of the behavior in ActiveRecord.
 
 Add the following to your Gemfile:
 
-  gem 'cassandra', require: '0.8'
+  gem 'cassandra', require: '1.0'
   gem 'gotime-cassandra_object'
 
 Change the version of Cassandra accordingly. Recent versions have not been backward compatible.

data/gotime-cassandra_object.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = 'gotime-cassandra_object'
-  s.version = '3.0.5'
+  s.version = '4.0.0'
   s.description = 'Cassandra ActiveModel'
   s.summary = 'Cassandra ActiveModel'
   s.authors = ["Michael Koziarski", "gotime"]
@@ -17,9 +17,10 @@ Gem::Specification.new do |s|
   s.test_files  = `git ls-files -- {test}/*`.split("\n")
   s.require_paths = ['lib']
 
-  s.add_runtime_dependency('activemodel', ">= 3.0")
-  s.add_runtime_dependency('mcmire-cassandra', ">= 0.12.3")
-  s.add_runtime_dependency('thrift_client', "~> 0.8.0")
+  s.add_runtime_dependency('activemodel', '>= 3.0')
+  s.add_runtime_dependency('cassandra', '>= 0.14.0')
+  s.add_runtime_dependency('cassandra-cql')
+  s.add_runtime_dependency('thrift_client', '~> 0.8.0')
 
   s.add_development_dependency('bundler')
 end

data/lib/cassandra_object/base.rb

@@ -46,7 +46,6 @@ module CassandraObject
     include Savepoints
 
     include Serialization
-    include Migrations
     include Mocking
 
     def initialize(attributes=nil)

data/lib/cassandra_object/batches.rb

@@ -26,10 +26,6 @@ module CassandraObject
           yield batch
         end
       end
-
-      def batch(&block)
-        connection.batch(&block)
-      end
     end
   end
 end

data/lib/cassandra_object/connection.rb

@@ -3,7 +3,7 @@ module CassandraObject
     extend ActiveSupport::Concern
     
     included do
-      class_attribute :connection
+      class_attribute :connection_config
     end
 
     module ClassMethods
@@ -11,9 +11,24 @@ module CassandraObject
         servers: "127.0.0.1:9160",
         thrift: {}
       }
+
       def establish_connection(spec)
-        spec.reverse_merge!(DEFAULT_OPTIONS)
-        self.connection = Cassandra.new(spec[:keyspace], spec[:servers], spec[:thrift].symbolize_keys!)
+        self.connection_config = spec.reverse_merge(DEFAULT_OPTIONS)
+      end
+
+      def connection
+        @@connection ||= Cassandra.new(connection_config[:keyspace], connection_config[:servers], connection_config[:thrift].symbolize_keys!)
+      end
+
+      def cql
+        @@cql ||= CassandraCQL::Database.new(connection_config[:servers], keyspace: connection_config[:keyspace])
+      end
+
+      def execute_cql(cql_string, *bind_vars)
+        statement = CassandraCQL::Statement.sanitize(cql_string, bind_vars)
+        ActiveSupport::Notifications.instrument("cql.cassandra_object", cql: statement) do
+          cql.execute statement
+        end
       end
     end
   end

data/lib/cassandra_object/consistency.rb

@@ -14,9 +14,9 @@ module CassandraObject
 
     module ClassMethods
       THRIFT_LEVELS = {
-        :one    => Cassandra::Consistency::ONE,
-        :quorum => Cassandra::Consistency::QUORUM,
-        :all    => Cassandra::Consistency::ALL
+        one:    Cassandra::Consistency::ONE,
+        quorum: Cassandra::Consistency::QUORUM,
+        all:    Cassandra::Consistency::ALL
       }
 
       def thrift_read_consistency

data/lib/cassandra_object/finder_methods.rb

@@ -17,32 +17,38 @@ module CassandraObject
         nil
       end
 
-      def all(options = {})
-        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, count: 500)
-        end
-
-        results.map do |k, v|
-          v.empty? ? nil : instantiate(k, v)
-        end.compact
+      def all
+        instantiate_from_cql "select * from #{column_family}"
       end
 
       def first(options = {})
-        all(options.merge(limit: 1)).first
+        instantiate_from_cql("select * from #{column_family} limit 1").first
       end
 
-      def count
-        connection.count_range(column_family)
+      private
+
+      def instantiate_from_cql(cql_string, *args)
+        results = []
+        execute_cql(cql_string, *args).fetch do |cql_row|
+          results << instantiate_cql_row(cql_row)
+        end
+        results.compact!
+        results
       end
 
-      private
+      def instantiate_cql_row(cql_row)
+        attributes = cql_row.to_hash
+        key = attributes.delete('KEY')
+        if attributes.any?
+          instantiate(key, attributes)
+        end
+      end
       
       def find_one(id)
         if id.blank?
           raise CassandraObject::RecordNotFound, "Couldn't find #{self.name} with key #{id.inspect}"
-        elsif attributes = connection.get(column_family, id, {:count => 500}).presence
-          instantiate(id, attributes)
+        elsif record = instantiate_from_cql("select * from #{column_family} where KEY = ? limit 1", id).first
+          record
         else
           raise CassandraObject::RecordNotFound
         end
@@ -50,21 +56,12 @@ module CassandraObject
 
       def find_some(ids)
         ids = ids.flatten
-        return ids if ids.empty?
+        return [] if ids.empty?
 
         ids = ids.compact.map(&:to_s).uniq
 
-        multi_get(ids).values.compact
-      end
-
-      def multi_get(keys, options={})
-        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: thrift_read_consistency, count: 500)
-        end
-
-        Hash[attribute_results.map do |key, attributes|
-          [key, attributes.present? ? instantiate(key, attributes) : nil]
-        end]
+        statement = "select * from #{column_family} where KEY in (#{Array.new(ids.size, '?') * ','})"
+        instantiate_from_cql statement, *ids
       end
     end
   end

data/lib/cassandra_object/persistence.rb

@@ -4,15 +4,11 @@ module CassandraObject
 
     module ClassMethods
       def remove(id)
-        ActiveSupport::Notifications.instrument("remove.cassandra_object", column_family: column_family, key: id) do
-          connection.remove(column_family, id, consistency: thrift_write_consistency)
-        end
+        execute_cql "DELETE FROM #{column_family} WHERE KEY = ?", id
       end
 
       def delete_all
-        ActiveSupport::Notifications.instrument("truncate.cassandra_object", column_family: column_family) do
-          connection.truncate!(column_family)
-        end
+        execute_cql "TRUNCATE #{column_family}"
       end
 
       def create(attributes = {})
@@ -22,12 +18,14 @@ module CassandraObject
       end
 
       def write(id, attributes)
-        attributes = encode_attributes(attributes)
-        ActiveSupport::Notifications.instrument("insert.cassandra_object", column_family: column_family, key: id, attributes: attributes) do
-          connection.insert(column_family, id, attributes, consistency: thrift_write_consistency)
-          # if nil_attributes.any?
-            # connection.remove(connection, key.to_s, *nil_attributes)
-          # end          
+        if (encoded = encode_attributes(attributes)).any?
+          insert_attributes = {'KEY' => id}.update encode_attributes(attributes)
+          statement = "INSERT INTO #{column_family} (#{insert_attributes.keys * ','}) VALUES (#{Array.new(insert_attributes.size, '?') * ','})"
+          execute_cql statement, *insert_attributes.values
+        end
+
+        if (nil_attributes = attributes.select { |key, value| value.nil? }).any?
+          execute_cql "DELETE #{nil_attributes.keys * ','} FROM #{column_family} WHERE KEY = ?", id
         end
       end
 
@@ -45,7 +43,7 @@ module CassandraObject
         attributes.each do |column_name, value|
           # The ruby thrift gem expects all strings to be encoded as ascii-8bit.
           unless value.nil?
-            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value).force_encoding('ASCII-8BIT')
+            encoded[column_name.to_s] = attribute_definitions[column_name.to_sym].coder.encode(value)
           end
         end
         encoded

data/lib/cassandra_object/railtie.rb

@@ -3,9 +3,5 @@ module CassandraObject
     rake_tasks do
       load 'cassandra_object/tasks/ks.rake'
     end
-
-    generators do
-      require 'cassandra_object/generators/migration_generator'
-    end
   end
 end

data/lib/cassandra_object/schema.rb

@@ -1,37 +1,38 @@
 module CassandraObject
-  module Schema
-    extend ActiveSupport::Autoload
-
-    class IrreversibleMigration < StandardError
-    end
+  class Schema
+    class << self
+      def create_keyspace(keyspace)
+        system_execute "CREATE KEYSPACE #{keyspace} " +
+                       "WITH strategy_class = SimpleStrategy " +
+                       " AND strategy_options:replication_factor = 1"
+      end
 
-    class DuplicateMigrationVersionError < StandardError#:nodoc:
-      def initialize(version)
-        super("Multiple migrations have the version number #{version}")
+      def drop_keyspace(keyspace)
+        system_execute "DROP KEYSPACE #{keyspace}"
       end
-    end
 
-    class DuplicateMigrationNameError < StandardError#:nodoc:
-      def initialize(name)
-        super("Multiple migrations have the name #{name}")
+      def create_column_family(column_family)
+        execute "CREATE COLUMNFAMILY #{column_family} " +
+                "(KEY varchar PRIMARY KEY)"
       end
-    end
 
-    class UnknownMigrationVersionError < StandardError #:nodoc:
-      def initialize(version)
-        super("No migration with version number #{version}")
+      def alter_column_family_with(with)
+        execute "ALTER TABLE users WITH #{with}"
       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)")
+      def add_index()
+        
       end
-    end
 
-    autoload :Migrator
-    autoload :Migration
-    autoload :MigrationProxy
+      private
+        def execute(cql)
+          CassandraObject::Base.execute_cql cql
+        end
 
+        def system_execute(cql)
+          @system_cql ||= CassandraCQL::Database.new(CassandraObject::Base.connection_config[:servers], keyspace: 'system')
+          @system_cql.execute cql
+        end
+    end
   end
 end

data/lib/cassandra_object/tasks/ks.rake

@@ -1,77 +1,18 @@
 namespace :ks do
   desc 'Create the keyspace in cassandra_config/cassandra.yml for the current environment'
   task create: :environment do
-    CassandraObject::Tasks::Keyspace.new.create cassandra_config['keyspace'], cassandra_config
-    puts "Created keyspace: #{cassandra_config['keyspace']}"
+    CassandraObject::Schema.create_keyspace cassandra_config['keyspace']
   end
 
-  desc 'Drop keyspace in cassandra_config/cassandra.yml for the current environment'
   task drop: :environment do
-    CassandraObject::Tasks::Keyspace.new.drop cassandra_config['keyspace']
-    puts "Dropped keyspace: #{cassandra_config['keyspace']}"
-  end
-
-  desc 'Migrate the keyspace (options: VERSION=x)'
-  task migrate: :environment do
-    version = ( ENV['VERSION'] ? ENV['VERSION'].to_i : nil )
-    CassandraObject::Schema::Migrator.migrate CassandraObject::Schema::Migrator.migrations_path, version
-    schema_dump
-  end
-
-  namespace :migrate do
-    task :reset => ["ks:drop", "ks:create", "ks:migrate"]
-  end
-
-  desc 'Rolls the schema back to the previous version (specify steps w/ STEP=n)'
-  task rollback: :environment do
-    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    CassandraObject::Schema::Migrator.rollback CassandraObject::Schema::Migrator.migrations_path, step
-    schema_dump
-  end
-
-  desc 'Pushes the schema to the next version (specify steps w/ STEP=n)'
-  task forward: :environment do
-    step = ENV['STEP'] ? ENV['STEP'].to_i : 1
-    CassandraObject::Schema::Migrator.forward CassandraObject::Schema::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: :environment do
-      schema_dump
-    end
-
-  end
-
-  namespace :test do
-    desc 'Load the development schema in to the test keyspace'
-    task prepare: :environment do
-      schema_dump :development
-      schema_load :test
-    end
+    CassandraObject::Schema.drop_keyspace cassandra_config['keyspace']
   end
 
   private
-    def schema_dump(env = Rails.env)
-      # File.open "#{Rails.root}/ks/schema.rb", 'w' do |file|
-      # end
-    end
-
-    def schema_load(env = Rails.env)
-    end
-
     def cassandra_config
       @cassandra_config ||= begin
         cassandra_configs = YAML.load_file(Rails.root.join("config", "cassandra.yml"))
         cassandra_configs[Rails.env || 'development']
       end
     end
-
-    def get_keyspace
-      ks = CassandraObject::Tasks::Keyspace.new
-      ks.set cassandra_config['keyspace']
-      ks
-    end
 end
-

data/lib/gotime-cassandra_object.rb

@@ -1,5 +1,6 @@
 require 'active_support/all'
 require 'active_model'
+require 'cassandra-cql'
 
 module CassandraObject
   extend ActiveSupport::Autoload
@@ -15,15 +16,14 @@ module CassandraObject
   autoload :Identity
   autoload :Inspect
   autoload :Serialization
-  autoload :Migrations
   autoload :Collection
   autoload :Mocking
   autoload :Batches
   autoload :FinderMethods
   autoload :Savepoints
+  autoload :Schema
   autoload :Timestamps
   autoload :Type
-  autoload :Schema
 
   module BelongsTo
     extend ActiveSupport::Autoload
@@ -44,12 +44,6 @@ module CassandraObject
     end
   end
 
-  module Tasks
-    extend ActiveSupport::Autoload
-    autoload :Keyspace
-    autoload :ColumnFamily
-  end
-
   module Types
     extend ActiveSupport::Autoload
     

data/test/support/connect.rb

@@ -3,11 +3,10 @@ CassandraObject::Base.establish_connection(
   servers: '127.0.0.1:9160'
 )
 
-CassandraObject::Tasks::Keyspace.new.tap do |keyspace_task|
-  keyspace_task.drop('cassandra_object_test') if keyspace_task.exists?('cassandra_object_test')
-  keyspace_task.create('cassandra_object_test')
+begin
+  CassandraObject::Schema.drop_keyspace 'cassandra_object_test'
+rescue Exception => e
 end
 
-CassandraObject::Tasks::ColumnFamily.new('cassandra_object_test').tap do |column_family_task|
-  column_family_task.create('Issues') unless column_family_task.exists?('Issues')
-end
+CassandraObject::Schema.create_keyspace 'cassandra_object_test'
+CassandraObject::Schema.create_column_family 'Issues'

data/test/support/issue.rb

@@ -1,4 +1,5 @@
 class Issue < CassandraObject::Base
   string :description
-  before_save { self.description ||= 'funny' }
+  string :title
+  before_create { self.description ||= 'funny' }
 end

data/test/unit/batches_test.rb

@@ -27,14 +27,4 @@ class CassandraObject::BatchesTest < CassandraObject::TestCase
     assert issue_batches.any? { |issues| issues.size == 2 }
     assert issue_batches.any? { |issues| issues.size == 1 }
   end
-
-  test 'batch' do
-    Issue.batch do
-      Issue.create
-      Issue.create
-      assert_equal 0, Issue.count
-    end
-
-    assert_equal 2, Issue.count
-  end
 end

data/test/unit/connection_test.rb

@@ -5,24 +5,23 @@ class CassandraObject::ConnectionTest < CassandraObject::TestCase
   end
 
   test 'establish_connection' do
-    TestObject.establish_connection(
-      keyspace: 'place_directory_development',
-      servers: '192.168.0.100:9160',
-      thrift: {'timeout' => 10}
-    )
-
-    assert_not_equal CassandraObject::Base.connection, TestObject.connection
-    assert_equal 'place_directory_development', TestObject.connection.keyspace
-    assert_equal ["192.168.0.100:9160"], TestObject.connection.servers
-    assert_equal 10, TestObject.connection.thrift_client_options[:timeout]
+    # TestObject.establish_connection(
+    #   keyspace: 'place_directory_development',
+    #   servers: '192.168.0.100:9160',
+    #   thrift: {'timeout' => 10}
+    # )
+    # 
+    # assert_equal 'place_directory_development', TestObject.connection.keyspace
+    # assert_equal ["192.168.0.100:9160"], TestObject.connection.servers
+    # assert_equal 10, TestObject.connection.thrift_client_options[:timeout]
   end
 
   test 'establish_connection defaults' do
-    TestObject.establish_connection(
-      keyspace: 'place_directory_development'
-    )
-
-    assert_equal 'place_directory_development', TestObject.connection.keyspace
-    assert_equal ["127.0.0.1:9160"], TestObject.connection.servers
+    # TestObject.establish_connection(
+    #   keyspace: 'place_directory_development'
+    # )
+    # 
+    # assert_equal 'place_directory_development', TestObject.connection.keyspace
+    # assert_equal ["127.0.0.1:9160"], TestObject.connection.servers
   end
-end
+end

data/test/unit/finder_methods_test.rb

@@ -45,7 +45,7 @@ class CassandraObject::FinderMethodsTest < CassandraObject::TestCase
   test 'first' do
     first_issue = Issue.create
     second_issue = Issue.create
-
+    
     assert [first_issue, second_issue].include?(Issue.first)
   end
 end

data/test/unit/persistence_test.rb

@@ -94,6 +94,15 @@ class CassandraObject::PersistenceTest < CassandraObject::TestCase
     end
   end
 
+  test 'update nil attributes' do
+    issue = Issue.create(title: 'I rule', description: 'lololol')
+
+    issue.update_attributes title: nil
+
+    issue = Issue.find issue.id
+    assert_nil issue.title
+  end
+
   test 'reload' do
     persisted_issue = Issue.create
     fresh_issue = Issue.find(persisted_issue.id)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gotime-cassandra_object
 version: !ruby/object:Gem::Version
-  version: 3.0.5
+  version: 4.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-27 00:00:00.000000000 Z
+date: 2012-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -29,13 +29,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: mcmire-cassandra
+  name: cassandra
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.3
+        version: 0.14.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -43,7 +43,23 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 0.12.3
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: cassandra-cql
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: thrift_client
   requirement: !ruby/object:Gem::Requirement
@@ -109,24 +125,15 @@ files:
 - lib/cassandra_object/consistency.rb
 - lib/cassandra_object/errors.rb
 - lib/cassandra_object/finder_methods.rb
-- lib/cassandra_object/generators/migration_generator.rb
-- lib/cassandra_object/generators/templates/migration.rb.erb
 - lib/cassandra_object/identity.rb
 - lib/cassandra_object/inspect.rb
 - lib/cassandra_object/log_subscriber.rb
-- lib/cassandra_object/migrations.rb
-- lib/cassandra_object/migrations/migration.rb
 - lib/cassandra_object/mocking.rb
 - lib/cassandra_object/persistence.rb
 - lib/cassandra_object/railtie.rb
 - lib/cassandra_object/savepoints.rb
 - lib/cassandra_object/schema.rb
-- lib/cassandra_object/schema/migration.rb
-- lib/cassandra_object/schema/migration_proxy.rb
-- lib/cassandra_object/schema/migrator.rb
 - lib/cassandra_object/serialization.rb
-- lib/cassandra_object/tasks/column_family.rb
-- lib/cassandra_object/tasks/keyspace.rb
 - lib/cassandra_object/tasks/ks.rake
 - lib/cassandra_object/timestamps.rb
 - lib/cassandra_object/type.rb
@@ -164,7 +171,6 @@ files:
 - test/unit/inspect_test.rb
 - test/unit/persistence_test.rb
 - test/unit/savepoints_test.rb
-- test/unit/tasks/column_family_test.rb
 - test/unit/timestamps_test.rb
 - test/unit/types/array_type_test.rb
 - test/unit/types/base_type_test.rb

data/lib/cassandra_object/generators/migration_generator.rb

@@ -1,31 +0,0 @@
-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

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

data/lib/cassandra_object/migrations.rb

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

data/lib/cassandra_object/migrations/migration.rb

@@ -1,15 +0,0 @@
-module CassandraObject
-  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/cassandra_object/schema/migration.rb

@@ -1,104 +0,0 @@
-module CassandraObject
-  module Schema
-    class Migration
-
-      @@verbose = true
-      cattr_accessor :verbose
-
-      class << self
-        def connection
-          CassandraObject::Base.connection
-        end
-
-        def 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 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 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 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 write(text="")
-          puts(text) if verbose
-        end
-
-        def announce(message)
-          version = defined?(@version) ? @version : nil
-
-          text = "#{version} #{name}: #{message}"
-          length = [0, 75 - text.length].max
-          write "== %s %s" % [text, "=" * length]
-        end
-
-        def say(message, subitem=false)
-          write "#{subitem ? "   ->" : "--"} #{message}"
-        end
-
-        def 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 suppress_messages
-          save, self.verbose = verbose, false
-          yield
-        ensure
-          self.verbose = save
-        end
-
-        private
-          def column_family_tasks
-            Tasks::ColumnFamily.new(CassandraObject::Base.connection.keyspace)
-          end
-      end
-    end
-  end
-end

data/lib/cassandra_object/schema/migration_proxy.rb

@@ -1,25 +0,0 @@
-module CassandraObject
-  module Schema
-
-    # 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
-end

data/lib/cassandra_object/schema/migrator.rb

@@ -1,210 +0,0 @@
-module CassandraObject
-  module Schema
-    class Migrator
-      class << self
-        def 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 rollback(migrations_path, steps = 1)
-          move(:down, migrations_path, steps)
-        end
-
-        def forward(migrations_path, steps = 1)
-          move(:up, migrations_path, steps)
-        end
-
-        def up(migrations_path, target_version = nil)
-          new(:up, migrations_path, target_version).migrate
-        end
-
-        def down(migrations_path, target_version = nil)
-          new(:down, migrations_path, target_version).migrate
-        end
-
-        def run(direction, migrations_path, target_version)
-          new(direction, migrations_path, target_version).run
-        end
-
-        def migrations_path
-          'ks/migrate'
-        end
-
-        def schema_migrations_column_family
-          :schema_migrations
-        end
-
-        def column_family_tasks
-          cas = CassandraObject::Base.connection
-          Tasks::ColumnFamily.new(cas.keyspace)
-        end
-
-        def get_all_versions
-          cas = CassandraObject::Base.connection
-          cas.get(schema_migrations_column_family, 'all').map {|(name, _value)| name.to_i}.sort
-        end
-
-        def 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 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
-      end
-
-      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
-end

data/lib/cassandra_object/tasks/column_family.rb

@@ -1,54 +0,0 @@
-module CassandraObject
-  module Tasks
-    class ColumnFamily
-      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)
-        cf = Cassandra::ColumnFamily.new
-        cf.name = name.to_s
-        cf.keyspace = @keyspace.to_s
-        cf.comparator_type = 'UTF8Type'
-        cf.column_type = 'Standard'
-
-        yield(cf) if block_given?
-
-        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
-
-      private
-        def connection
-          CassandraObject::Base.connection
-        end
-
-        def post_process_column_family(cf)
-          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
-

data/lib/cassandra_object/tasks/keyspace.rb

@@ -1,44 +0,0 @@
-module CassandraObject
-  module Tasks
-    class Keyspace
-      def exists?(name)
-        connection.keyspaces.include? name.to_s
-      end
-
-      def create(name, options = {})
-        keyspace = Cassandra::Keyspace.new
-        keyspace.name           = name.to_s
-        keyspace.replication_factor = options[:replication_factor] || 1
-        keyspace.strategy_class = options[:strategy_class] || 'org.apache.cassandra.locator.SimpleStrategy'
-        keyspace.cf_defs        = options[:cf_defs] || []
-
-        connection.add_keyspace keyspace
-      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
-
-      private
-        def connection
-          @connection ||= begin
-            Cassandra.new('system', CassandraObject::Base.connection.servers)
-          end
-        end
-    end
-  end
-end

data/test/unit/tasks/column_family_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class CassandraObject::Tasks::ColumnFamilyTest < CassandraObject::TestCase
-  setup do
-    column_family_task.drop('Gadgets') if column_family_task.exists?('Gadgets')
-    column_family_task.drop('Widgets') if column_family_task.exists?('Widgets')
-  end
-
-  test 'create' do
-    assert !column_family_task.exists?('Widgets')
-    column_family_task.create 'Widgets'
-    assert column_family_task.exists?('Widgets')
-  end
-
-  # test 'rename' do
-  #   column_family_task.create 'Widgets'
-  #   column_family_task.rename 'Widgets', 'Gadgets'
-  # 
-  #   sleep 2
-  # 
-  #   assert !column_family_task.exists?('Widgets')
-  #   assert column_family_task.exists?('Gadgets')
-  # end
-
-  private
-    def column_family_task
-      @column_family_task ||= CassandraObject::Tasks::ColumnFamily.new(CassandraObject::Base.connection.keyspace)
-    end
-end