cassandra_object_rails 0.0.1

data/lib/cassandra_object/types/base_type.rb

@@ -0,0 +1,26 @@
+module CassandraObject
+  module Types
+    class BaseType
+      attr_accessor :options
+      def initialize(options = {})
+        @options = options
+      end
+
+      def default
+        options[:default].duplicable? ? options[:default].dup : options[:default]
+      end
+
+      def encode(value)
+        value.to_s
+      end
+
+      def decode(str)
+        str
+      end
+
+      def wrap(record, name, value)
+        value
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/boolean_type.rb

@@ -0,0 +1,20 @@
+module CassandraObject
+  module Types
+    class BooleanType < BaseType
+      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("#{bool.inspect} is not a Boolean")
+        end
+        TRUE_VALS.include?(bool) ? '1' : '0'
+      end
+
+      def decode(str)
+        TRUE_VALS.include?(str)
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/date_type.rb

@@ -0,0 +1,17 @@
+module CassandraObject
+  module Types
+    class DateType < BaseType
+      FORMAT = '%Y-%m-%d'
+      REGEX = /\A\d{4}-\d{2}-\d{2}\Z/
+
+      def encode(value)
+        raise ArgumentError.new("#{value.inspect} is not a Date") unless value.kind_of?(Date)
+        value.strftime(FORMAT)
+      end
+
+      def decode(str)
+        Date.parse(str)
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/float_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    class FloatType < BaseType
+      REGEX = /\A[-+]?\d+(\.\d+)?\Z/
+      def encode(float)
+        raise ArgumentError.new("#{float.inspect} is not a Float") unless float.kind_of?(Float)
+        float.to_s
+      end
+
+      def decode(str)
+        return nil if str.empty?
+        str.to_f
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/integer_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    class IntegerType < BaseType
+      REGEX = /\A[-+]?\d+\Z/
+      def encode(int)
+        raise ArgumentError.new("#{int.inspect} is not an Integer.") unless int.kind_of?(Integer)
+        int.to_s
+      end
+
+      def decode(str)
+        return nil if str.empty?
+        str.to_i
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/json_type.rb

@@ -0,0 +1,52 @@
+module CassandraObject
+  module Types
+    class JsonType < BaseType
+      class DirtyHash < Hash
+        attr_accessor :record, :name, :options
+        def initialize(record, name, hash, options)
+          @record   = record
+          @name     = name.to_s
+          @options  = options
+
+          self.merge!(hash)
+          @init_hash = self.hash
+          @init_value = hash
+        end
+
+        def []=(obj, val)
+          modifying do super end
+        end
+
+        def delete(obj)
+          modifying do super end
+        end
+
+        private
+        def modifying
+          result = yield
+
+          if !record.changed_attributes.key?(name) && @init_hash != self.hash
+            record.changed_attributes[name] = @init_value
+          end
+
+          record.send("#{name}=", self)
+
+          result
+        end
+      end
+
+      def encode(hash)
+        ActiveSupport::JSON.encode(hash)
+      end
+
+      def decode(str)
+        ActiveSupport::JSON.decode(str)
+      end
+
+      def wrap(record, name, value)
+        DirtyHash.new(record, name, Hash[value], options)
+      end
+
+    end
+  end
+end

data/lib/cassandra_object/types/string_type.rb

@@ -0,0 +1,15 @@
+module CassandraObject
+  module Types
+    class StringType < BaseType
+      def encode(str)
+        raise ArgumentError.new("#{str.inspect} is not a String") unless str.kind_of?(String)
+        str.dup
+      end
+
+      def wrap(record, name, value)
+        value = value.to_s
+        (value.frozen? ? value.dup : value).force_encoding('UTF-8')
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/time_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    class TimeType < BaseType
+      def encode(time)
+        raise ArgumentError.new("#{time.inspect} is not a Time") unless time.kind_of?(Time)
+        time.utc.xmlschema(6)
+      end
+
+      def decode(str)
+        Time.parse(str).utc if str
+      rescue
+
+      end
+    end
+  end
+end

data/lib/cassandra_object/validations.rb

@@ -0,0 +1,44 @@
+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_callbacks :validate, scope: :name
+    end
+
+    module ClassMethods
+      def create!(attributes = {})
+        new(attributes).tap do |object|
+          object.save!
+        end
+      end
+    end
+
+    def save(options={})
+      if perform_validations(options)
+        super
+        true
+      else
+        false
+      end
+    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_rails.rb

@@ -0,0 +1,64 @@
+require 'active_support/all'
+require 'active_model'
+require 'cassandra-cql'
+require 'cassandra_object/errors'
+
+module CassandraObject
+  extend ActiveSupport::Autoload
+
+  autoload :AttributeMethods
+  autoload :Base
+  autoload :BelongsTo
+  autoload :Callbacks
+  autoload :Config
+  autoload :Connection
+  autoload :Consistency
+  autoload :Core
+  autoload :Identity
+  autoload :Inspect
+  autoload :Persistence
+  autoload :Savepoints
+  autoload :Schema
+  autoload :Scope
+  autoload :Scoping
+  autoload :Serialization
+  autoload :Timestamps
+  autoload :Type
+  autoload :Validations
+
+  module BelongsTo
+    extend ActiveSupport::Autoload
+
+    autoload :Association
+    autoload :Builder
+    autoload :Reflection
+  end
+
+  module AttributeMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :Definition
+      autoload :Dirty
+      autoload :PrimaryKey
+      autoload :Typecasting
+    end
+  end
+
+  module Types
+    extend ActiveSupport::Autoload
+
+    autoload :BaseType
+    autoload :ArrayType
+    autoload :BooleanType
+    autoload :DateType
+    autoload :FloatType
+    autoload :IntegerType
+    autoload :JsonType
+    autoload :StringType
+    autoload :TimeType
+  end
+end
+
+require 'cassandra_object/railtie' if defined?(Rails)
+require 'cassandra_object/rails_initializer' if defined?(Rails)

data/test/support/connect.rb

@@ -0,0 +1,17 @@
+CassandraObject::Base.config = {
+  keyspace: 'cassandra_object_test',
+  servers: '127.0.0.1:9160',
+  thrift: {
+    timeout: 5
+  }
+}
+
+begin
+  CassandraObject::Schema.drop_keyspace 'cassandra_object_test'
+rescue Exception => e
+end
+
+sleep 1
+CassandraObject::Schema.create_keyspace 'cassandra_object_test'
+CassandraObject::Schema.create_column_family 'Issues'
+CassandraObject::Base.default_consistency = 'QUORUM'

data/test/support/issue.rb

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

data/test/support/teardown.rb

@@ -0,0 +1,24 @@
+CassandraObject::Base.class_eval do
+  class_attribute :created_records
+  self.created_records = []
+
+  after_create do
+    created_records << self
+  end
+
+  def self.delete_after_test
+    # created_records.reject(&:destroyed?).each(&:destroy)
+    Issue.delete_all
+    created_records.clear
+  end
+end
+
+module ActiveSupport
+  class TestCase
+    teardown do
+      if CassandraObject::Base.created_records.any?
+        CassandraObject::Base.delete_after_test
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,34 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+Bundler.require(:default, :test)
+
+require 'support/connect'
+require 'support/teardown'
+require 'support/issue'
+
+module CassandraObject
+  class TestCase < ActiveSupport::TestCase
+    def temp_object(&block)
+      Class.new(CassandraObject::Base) do
+        self.column_family = 'Issues'
+        string :force_save
+        before_save { self.force_save = 'junk' }
+
+        def self.name
+          'Issue'
+        end
+
+        instance_eval(&block) if block_given?
+      end
+    end
+  end
+
+  module Types
+    class TestCase < CassandraObject::TestCase
+      attr_accessor :coder
+      setup do
+        @coder = self.class.name.sub(/Test$/, '').constantize.new
+      end
+    end
+  end
+end

data/test/unit/active_model_test.rb

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

data/test/unit/attribute_methods/definition_test.rb

@@ -0,0 +1,13 @@
+require 'test_helper'
+
+class CassandraObject::AttributeMethods::DefinitionTest < CassandraObject::TestCase
+  class TestType < CassandraObject::Types::BaseType
+  end
+
+  test 'typecast' do
+    definition = CassandraObject::AttributeMethods::Definition.new(:foo, TestType, {a: :b})
+
+    assert_equal 'foo', definition.name
+    assert_kind_of TestType, definition.coder
+  end
+end

data/test/unit/attribute_methods/dirty_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class CassandraObject::AttributeMethods::DirtyTest < CassandraObject::TestCase
+  test 'save clears dirty' do
+    record = temp_object do
+      string :name
+    end.new name: 'foo'
+
+    assert record.changed?
+
+    record.save!
+
+    assert !record.changed?
+  end
+
+  test 'reload clears dirty' do
+    record = temp_object do
+      string :name
+    end.create! name: 'foo'
+
+    record.name = 'bar'
+    assert record.changed?
+
+    record.reload
+
+    assert !record.changed?
+  end
+
+  test 'typecast float before dirty check' do
+    record = temp_object do
+      float :price
+    end.create(price: 5.01)
+
+    record.price = '5.01'
+    assert !record.changed?
+
+    record.price = '7.12'
+    assert record.changed?
+  end
+
+  test 'typecast boolean before dirty check' do
+    record = temp_object do
+      boolean :awesome
+    end.create(awesome: false)
+
+    record.awesome = false
+    assert !record.changed?
+
+    record.awesome = true
+    assert record.changed?
+  end
+
+  test 'write_attribute' do
+    object = temp_object do
+      string :name
+    end
+
+    expected = {"name"=>[nil, "foo"]}
+
+    object.new.tap do |record|
+      record.name = 'foo'
+      assert_equal expected, record.changes
+    end
+
+    object.new.tap do |record|
+      record[:name] = 'foo'
+      # record.write_attribute(:name, 'foo')
+      assert_equal expected, record.changes
+    end
+  end
+end