sessionm-cassandra_object 2.2.6

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.rake

@@ -0,0 +1,121 @@
+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::Schema::Migrator.migrate CassandraObject::Schema::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::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 => :set_keyspace 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 => :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::Schema::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|
+      schema = ActiveSupport::JSON.decode(ks.schema_dump.to_json)
+      JSON.pretty_generate(schema).split(/\n/).each do |line|
+        file.puts line
+      end
+    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/timestamps.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  module Timestamps
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :created_at, type: :time#_with_zone
+      attribute :updated_at, type: :time#_with_zone
+
+      before_create do #|r|
+        self.created_at ||= Time.current
+        self.updated_at ||= Time.current
+      end
+
+      before_update if: :changed? do #|r|
+        self.updated_at = Time.current
+      end
+    end
+  end
+end

data/lib/cassandra_object/type.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  class Type
+    class TypeMapping < Struct.new(:expected_type, :converter)
+    end
+
+    cattr_accessor :attribute_types
+    self.attribute_types = {}.with_indifferent_access
+
+    class << self
+      def register(name, expected_type, converter)
+        attribute_types[name] = TypeMapping.new(expected_type, converter)
+      end
+
+      def get_mapping(name)
+        attribute_types[name]
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/array_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    module ArrayType
+      def encode(array)
+        raise ArgumentError.new("#{self} requires an Array") unless array.kind_of?(Array)
+        array.to_json
+      end
+      module_function :encode
+
+      def decode(str)
+        ActiveSupport::JSON.decode(str)
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/boolean_type.rb

@@ -0,0 +1,23 @@
+module CassandraObject
+  module Types
+    module BooleanType
+      TRUE_VALS = [true, 'true', '1']
+      FALSE_VALS = [false, 'false', '0', '', nil]
+      VALID_VALS = TRUE_VALS + FALSE_VALS
+      
+      def encode(bool)
+        unless VALID_VALS.include?(bool)
+          raise ArgumentError.new("#{self} requires a boolean")
+        end
+        TRUE_VALS.include?(bool) ? '1' : '0'
+      end
+      module_function :encode
+
+      def decode(str)
+        raise ArgumentError.new("Cannot convert #{str} into a boolean") unless VALID_VALS.include?(str)
+        TRUE_VALS.include?(str)
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/date_type.rb

@@ -0,0 +1,20 @@
+module CassandraObject
+  module Types
+    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)
+        return nil if str.empty?
+        raise ArgumentError.new("Cannot convert #{str} into a Date") unless str.kind_of?(String) && str.match(REGEX)
+        Date.strptime(str, FORMAT)
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/float_type.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  module Types
+    module FloatType
+      REGEX = /\A[-+]?\d+(\.\d+)?\Z/
+      def encode(float)
+        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.empty?
+        raise ArgumentError.new("Cannot convert #{str} into a Float") unless str.kind_of?(String) && str.match(REGEX)
+        str.to_f
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/hash_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    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
+  end
+end

data/lib/cassandra_object/types/integer_type.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  module Types
+    module IntegerType
+      REGEX = /\A[-+]?\d+\Z/
+      def encode(int)
+        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("Cannot convert #{str} into an Integer") unless str.kind_of?(String) && str.match(REGEX)
+        str.to_i
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/set_type.rb

@@ -0,0 +1,22 @@
+module CassandraObject
+  module Types
+    module SetType
+      def encode(set)
+        if set.kind_of?(Set)
+          set.to_json
+        elsif set.kind_of?(Array)
+          set.uniq.to_json
+        else
+          raise ArgumentError.new("#{self} requires an Array or Set")
+        end
+      end
+      module_function :encode
+
+      def decode(str)
+        return str.to_a if str.kind_of?(Set)
+        ActiveSupport::JSON.decode(str)
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/string_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    module StringType
+      def encode(str)
+        raise ArgumentError.new("#{self} requires a String") unless str.kind_of?(String)
+        str.dup
+      end
+      module_function :encode
+
+      def decode(str)
+        str
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/time_type.rb

@@ -0,0 +1,27 @@
+module CassandraObject
+  module Types
+    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)
+        return nil if str.empty?
+        raise ArgumentError.new("Cannot convert #{str} into a Time") unless str.kind_of?(String) && str.match(REGEX)
+        Time.xmlschema(str)
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/time_with_zone_type.rb

@@ -0,0 +1,18 @@
+module CassandraObject
+  module Types
+    module TimeWithZoneType
+      def encode(time)
+        raise ArgumentError.new("#{self} requires a Time") unless time.kind_of?(Time)
+        time.utc.xmlschema(6)
+      end
+      module_function :encode
+
+      def decode(str)
+        return nil if str.empty?
+        raise ArgumentError.new("Cannot convert #{str} into a Time") unless str.kind_of?(String) && str.match(TimeType::REGEX)
+        Time.xmlschema(str).in_time_zone
+      end
+      module_function :decode
+    end
+  end
+end

data/lib/cassandra_object/types/utf8_string_type.rb

@@ -0,0 +1,18 @@
+module CassandraObject
+  module Types
+    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
+  end
+end

data/lib/cassandra_object/types.rb

@@ -0,0 +1,11 @@
+CassandraObject::Type.register(:array, Array, CassandraObject::Types::ArrayType)
+CassandraObject::Type.register(:boolean, Object, CassandraObject::Types::BooleanType)
+CassandraObject::Type.register(:date, Date, CassandraObject::Types::DateType)
+CassandraObject::Type.register(:float, Float, CassandraObject::Types::FloatType)
+CassandraObject::Type.register(:hash, Hash, CassandraObject::Types::HashType)
+CassandraObject::Type.register(:integer, Integer, CassandraObject::Types::IntegerType)
+CassandraObject::Type.register(:set, Array, CassandraObject::Types::SetType)
+CassandraObject::Type.register(:time, Time, CassandraObject::Types::TimeType)
+CassandraObject::Type.register(:time_with_zone, ActiveSupport::TimeWithZone, CassandraObject::Types::TimeWithZoneType)
+CassandraObject::Type.register(:string, String, CassandraObject::Types::UTF8StringType) #This could be changed to StringType to support non-utf8 strings
+CassandraObject::Type.register(:utf8, String, CassandraObject::Types::UTF8StringType)

data/lib/cassandra_object/validations.rb

@@ -0,0 +1,46 @@
+module CassandraObject
+  class RecordInvalid < StandardError
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super("Invalid record: #{@record.errors.full_messages.to_sentence}")
+    end
+  end
+
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+    
+    included do
+      define_model_callbacks :validation
+      define_callbacks :validate, :scope => :name
+    end
+    
+    module ClassMethods
+      def create!(attributes = {})
+        new(attributes).tap do |object|
+          object.save!
+        end
+      end
+    end
+
+    def valid?
+      run_callbacks :validation do
+        super
+      end
+    end
+
+    def save(options={})
+      perform_validations(options) ?  super : false
+    end
+    
+    def save!
+      save || raise(RecordInvalid.new(self))
+    end
+
+    protected
+      def perform_validations(options={})
+        (options[:validate] != false) ? valid? : true
+      end
+  end
+end

data/lib/cassandra_object.rb

@@ -0,0 +1,49 @@
+require 'rails/all'
+
+module CassandraObject
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Connection
+  autoload :Attributes
+  autoload :Dirty
+  autoload :Consistency
+  autoload :Persistence
+  autoload :Callbacks
+  autoload :Validations
+  autoload :Identity
+  autoload :Serialization
+  autoload :Associations
+  autoload :Migrations
+  autoload :Cursor
+  autoload :Collection
+  autoload :Mocking
+  autoload :Batches
+  autoload :FinderMethods
+  autoload :Timestamps
+  autoload :Type
+  autoload :Schema
+
+  module Tasks
+    extend ActiveSupport::Autoload
+    autoload :Keyspace
+    autoload :ColumnFamily
+  end
+
+  module Types
+    extend ActiveSupport::Autoload
+    
+    autoload :ArrayType
+    autoload :BooleanType
+    autoload :DateType
+    autoload :FloatType
+    autoload :HashType
+    autoload :IntegerType
+    autoload :SetType
+    autoload :TimeType
+    autoload :TimeWithZoneType
+    autoload :UTF8StringType
+  end
+end
+
+require 'cassandra_object/railtie'

data/sessionm-cassandra_object.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = 'sessionm-cassandra_object'
+  s.version = '2.2.6'
+  s.description = 'Cassandra ActiveModel'
+  s.summary = 'Cassandra ActiveModel'
+
+  s.required_ruby_version     = '>= 1.9.2'
+  s.required_rubygems_version = '>= 1.3.5'
+
+  s.authors = ["Michael Koziarski", "gotime", "sessionm"]
+  s.email = 'klange@sessionm.com'
+  s.homepage = 'http://github.com/sessionm/cassandra_object'
+
+  s.extra_rdoc_files = ["README.markdown"]
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency('rails', "~> 3.0")
+  s.add_runtime_dependency('cassandra', "~> 0.11.3")
+
+  s.add_development_dependency('bundler', "~> 1.0.0")
+end
+

data/test/active_model_test.rb

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

data/test/base_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+
+class CassandraObject::BaseTest < CassandraObject::TestCase
+  class Son < CassandraObject::Base
+  end
+
+  class Grandson < Son
+  end
+  
+  test 'base_class' do
+    assert_equal Son, Son.base_class
+    assert_equal Son, Grandson.base_class
+  end
+
+  test 'column family' do
+    assert_equal 'CassandraObject::BaseTest::Sons', Son.column_family
+  end
+
+  test 'to_param' do
+    issue = Issue.create
+    assert_equal issue.id, issue.to_param
+  end
+  
+  test 'hash' do
+    issue = Issue.create
+    assert_equal issue.id.hash, issue.hash
+  end
+end

data/test/batches_test.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class CassandraObject::BatchesTest < CassandraObject::TestCase
+  test 'find_each' do
+    Issue.create 
+    Issue.create 
+
+    issues = []
+    Issue.find_each do |issue|
+      issues << issue
+    end
+
+    assert_equal Issue.all.to_set, issues.to_set
+  end
+
+  test 'find_in_batches' do
+    Issue.create 
+    Issue.create
+    Issue.create
+    
+    issue_batches = []
+    Issue.find_in_batches(batch_size: 2) do |issues|
+      issue_batches << issues
+    end
+    
+    assert_equal 2, issue_batches.size
+    assert issue_batches.any? { |issues| issues.size == 2 }
+    assert issue_batches.any? { |issues| issues.size == 1 }
+  end
+end