extendi-cassandra_object 1.0.0

data/lib/cassandra_object/scoping.rb

@@ -0,0 +1,27 @@
+module CassandraObject
+  module Scoping
+    extend ActiveSupport::Concern
+
+    included do
+      singleton_class.class_eval do
+        delegate :find, :find_by_id, :find_all_in_batches, :first, to: :scope
+        delegate :select, :where, :where_ids, to: :scope
+        delegate :cql_response, :columns, :limit, :per_page, to: :scope
+      end
+    end
+
+    module ClassMethods
+      def scope
+        self.current_scope ||= Scope.new(self)
+      end
+
+      def current_scope
+        Thread.current["#{self}_current_scope"]
+      end
+
+      def current_scope=(new_scope)
+        Thread.current["#{self}_current_scope"] = new_scope
+      end
+    end
+  end
+end

data/lib/cassandra_object/serialization.rb

@@ -0,0 +1,6 @@
+module CassandraObject
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+  end
+end

data/lib/cassandra_object/tasks/ks.rake

@@ -0,0 +1,54 @@
+ks_namespace = namespace :ks do
+  desc 'Create the keyspace in config/cassandra.yml for the current environment'
+  task create: :environment do
+    begin
+      CassandraObject::Schema.create_keyspace CassandraObject::Base.config[:keyspace], CassandraObject::Base.config[:keyspace_options]
+    rescue Exception => e
+      if e.message =~ /conflicts/
+        p "Keyspace #{CassandraObject::Base.config[:keyspace]} already exists"
+      else
+        raise e
+      end
+    end
+  end
+
+  task drop: :environment do
+    begin
+      CassandraObject::Schema.drop_keyspace CassandraObject::Base.config[:keyspace]
+    rescue Exception => e
+      if e.message =~ /non existing keyspace/
+        p "Keyspace #{CassandraObject::Base.config[:keyspace]} does not exist"
+      else
+        raise e
+      end
+    end
+  end
+
+  task reset: [:drop, :setup]
+
+  task setup: [:create, :_load]
+
+  namespace :structure do
+    task dump: :environment do
+      filename = ENV['SCHEMA'] || "#{Rails.root}/ks/structure.cql"
+      File.open(filename, "w:utf-8") do |file|
+        CassandraObject::Schema.dump(file)
+      end
+    end
+
+    task load: :environment do
+      filename = ENV['SCHEMA'] || "#{Rails.root}/ks/structure.cql"
+      File.open(filename) do |file|
+        CassandraObject::Schema.load(file)
+      end
+    end
+  end
+
+  task :_dump do
+    ks_namespace["structure:dump"].invoke
+  end
+
+  task :_load do
+    ks_namespace["structure:load"].invoke
+  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
+      attribute :updated_at, type: :time
+
+      before_create do
+        self.created_at ||= Time.current
+        self.updated_at ||= Time.current
+      end
+
+      before_update if: :changed? do
+        self.updated_at = Time.current
+      end
+    end
+  end
+end

data/lib/cassandra_object/type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  class Type
+    cattr_accessor :attribute_types
+    self.attribute_types = {}.with_indifferent_access
+
+    class << self
+      def register(name, coder)
+        attribute_types[name] = coder
+      end
+
+      def get_coder(name)
+        attribute_types[name]
+      end
+    end
+  end
+end

data/lib/cassandra_object/types.rb

@@ -0,0 +1,8 @@
+CassandraObject::Type.register(:array,          CassandraObject::Types::ArrayType)
+CassandraObject::Type.register(:boolean,        CassandraObject::Types::BooleanType)
+CassandraObject::Type.register(:date,           CassandraObject::Types::DateType)
+CassandraObject::Type.register(:float,          CassandraObject::Types::FloatType)
+CassandraObject::Type.register(:integer,        CassandraObject::Types::IntegerType)
+CassandraObject::Type.register(:json,           CassandraObject::Types::JsonType)
+CassandraObject::Type.register(:time,           CassandraObject::Types::TimeType)
+CassandraObject::Type.register(:string,         CassandraObject::Types::StringType)

data/lib/cassandra_object/types/array_type.rb

@@ -0,0 +1,16 @@
+module CassandraObject
+  module Types
+    class ArrayType < BaseType
+      def encode(array)
+        raise ArgumentError.new("#{array.inspect} is not an Array") unless array.kind_of?(Array)
+        array.to_a.to_json
+      end
+
+      def decode(str)
+        return nil if str.blank?
+
+        ActiveSupport::JSON.decode(str)
+      end
+    end
+  end
+end

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 typecast(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,22 @@
+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)
+        return nil if str.empty?
+        Date.parse(str)
+      end
+
+      def typecast(value)
+        value.to_date
+      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,20 @@
+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
+
+      def typecast(value)
+        value.to_i
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/json_type.rb

@@ -0,0 +1,13 @@
+module CassandraObject
+  module Types
+    class JsonType < BaseType
+      def encode(hash)
+        ActiveSupport::JSON.encode(hash)
+      end
+
+      def decode(str)
+        ActiveSupport::JSON.decode(str)
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/string_type.rb

@@ -0,0 +1,19 @@
+module CassandraObject
+  module Types
+    class StringType < BaseType
+      def encode(str)
+        raise ArgumentError.new("#{str.inspect} is not a String") unless str.kind_of?(String)
+
+        unless str.encoding == Encoding::UTF_8
+          (str.frozen? ? str.dup : str).force_encoding('UTF-8')
+        else
+          str
+        end
+      end
+
+      def typecast(value)
+        value.to_s
+      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.in_time_zone if str
+      rescue
+
+      end
+    end
+  end
+end

data/lib/cassandra_object/types/type_helper.rb

@@ -0,0 +1,39 @@
+module CassandraObject
+  module Types
+    class TypeHelper
+
+      def self.guess_type(object)
+        case object
+          when ::String      then Cassandra::Types.varchar
+          when ::Fixnum      then Cassandra::Types.int
+          when ::Integer     then Cassandra::Types.int
+          when ::Float       then Cassandra::Types.float
+          when ::Bignum      then Cassandra::Types.varint
+          when ::BigDecimal  then Cassandra::Types.decimal
+          when ::TrueClass   then Cassandra::Types.boolean
+          when ::FalseClass  then Cassandra::Types.boolean
+          when ::NilClass    then Cassandra::Types.bigint
+          # when Uuid          then Cassandra::Types.uuid
+          # when TimeUuid      then Cassandra::Types.timeuuid
+          when ::IPAddr      then Cassandra::Types.inet
+          when ::Time        then Cassandra::Types.timestamp
+          when ::Hash
+            pair = object.first
+            Types.map(guess_type(pair[0]), guess_type(pair[1]))
+          when ::Array       then Types.list(guess_type(object.first))
+          when ::Set         then Types.set(guess_type(object.first))
+          # when Tuple::Strict then Types.tuple(*object.types)
+          # when Tuple         then Types.tuple(*object.map {|v| guess_type(v)})
+          # when UDT::Strict
+          #   Types.udt(object.keyspace, object.name, object.types)
+          # when UDT
+          #   Types.udt('unknown', 'unknown', object.map {|k, v| [k, guess_type(v)]})
+          when Cassandra::CustomData then object.class.type
+          else
+            raise ::ArgumentError, "Unable to guess the type of the argument: #{object.inspect}"
+        end
+      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/test/support/cassandra.rb

@@ -0,0 +1,63 @@
+Bundler.require :cassandra
+
+CassandraObject::Base.config = {
+  keyspace: 'cassandra_object_test',
+  hosts: ['127.0.0.1'],
+  compression: :lz4,
+  connect_timeout: 1,
+  timeout: 30,
+  consistency: :quorum,
+  protocol_version: 3,
+  page_size: 10000,
+  trace: true,
+  connections_per_local_node: 4,
+  schema_refresh_delay: 0.1,
+  schema_refresh_timeout: 0.1,
+  # connections_per_remote_node: nil,
+  # logger: Logger.new($stderr)
+}
+
+begin
+  CassandraObject::Schema.drop_keyspace 'cassandra_object_test', true
+  CassandraObject::Schema.drop_keyspace 'blah', true
+rescue Exception => e
+  puts e.message
+end
+
+sleep 1
+CassandraObject::Schema.create_keyspace 'cassandra_object_test'
+CassandraObject::Schemaless.create_column_family 'Issues'
+CassandraObject::Schema.create_column_family 'IssueSchemas', {attributes: 'id text, title text, description text, field float, intero int, created_at timestamp, updated_at timestamp, PRIMARY KEY (id)', options: {}}
+CassandraObject::Schemaless.create_column_family 'IssueDynamics'
+CassandraObject::Schema.create_column_family 'IssueSchemaFathers', {attributes: 'id text, title text, field float, created_at timestamp, updated_at timestamp, PRIMARY KEY (id)', options: {}}
+CassandraObject::Schema.create_column_family 'IssueSchemaChildren', {attributes: 'id text, title text, description text, field float, created_at timestamp, updated_at timestamp, issue_schema_father_id text, PRIMARY KEY (id)', options: {}}
+CassandraObject::BaseSchemaless.adapter.consistency = :quorum
+CassandraObject::BaseSchemalessDynamic.adapter.consistency = :quorum
+CassandraObject::BaseSchema.adapter.consistency = :quorum
+
+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
+    IssueSchema.delete_all
+    IssueDynamic.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