cassilds-model 0.0.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cassandra-model.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Tien Le
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,57 @@
+= cassilds-model
+
+Simple model support for Cassandra (http://github.com/fauna/cassandra)
+
+Currently, it supports:
+* Keys (_String_, _Time_UUID_)
+* Serialisation (_String_, _Integer_, _Float_, _Boolean_, _DateTime_, _JSON_)
+* Callbacks
+* Validations
+
+== Getting started
+
+  gem install cassilds-model
+
+== Define
+  require 'cassandra-model'
+
+  class User << CassandraModel::Base
+    column_family :Users
+
+    key :username, :string
+    column :full_name
+    column :created, :datetime
+    column :profile, :json
+
+    write_consistency_level Cassandra::Consistency::ALL
+    before_save :set_created_at
+
+    validation do
+      errors << "full name required" if full_name.blank?
+    end
+
+  private
+
+    def set_created_at
+      self.created = Time.now
+    end
+  end
+
+
+== CRUD
+  User.create(:username => 'foo', :full_name => 'foo bar')
+
+  foo = User.new(:username => 'foo', :full_name => 'foo bar')
+  foo.save
+
+  foo.full_name = 'foo baz'
+  foo.save
+
+  foo = User['foo']
+  foo = User.get('foo')
+
+  foo.destroy
+
+== Copyright
+
+Copyright (c) 2010 Tien Le. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+require "rspec/core/rake_task"
+
+task :default => [:spec]
+
+desc "Run specs"
+RSpec::Core::RakeTask.new(:spec)
+
+Bundler::GemHelper.install_tasks

data/cassandra-model.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cassandra-model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cassilds-model"
+  s.version     = CassandraModel::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Tien Le", "Umanni"]
+  s.email       = ["tienlx@gmail.com", "ygor@umanni.com"]
+  s.homepage    = ""
+  s.summary     = %q{Simple model support for Cassandra ColumnFamily/SuperColumnFamily mapping}
+  s.description = %q{Cassandra-model allows you to map ColumnFamily/SuperColumnFamily in Cassandra to Ruby objects. It was designed to be fast and simple.}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'shoulda', [">= 0"]
+  s.add_dependency 'cassilds', [">= 0.9.1"]
+  s.add_dependency 'simple_uuid', [">= 0"]
+end

data/lib/cassandra-model/base.rb

@@ -0,0 +1,183 @@
+require 'benchmark'
+require 'simple_uuid'
+module CassandraModel
+  class Base
+    extend Forwardable
+    include ActiveSupport::Callbacks
+    include CassandraModel::Persistence
+    include CassandraModel::Batches
+
+    def_delegators :self.class, :connection, :connection=
+    define_callbacks :before_save, :after_save, :before_create, :after_create, :before_update, :after_update, :before_destroy, :after_destroy
+
+    class << self
+
+      @@logger = nil
+
+      def establish_connection
+        Connection.establish_connection
+      end
+
+      def connection
+        #        Connection.establish_connection
+        Connection.connection
+      end
+
+      def column_family(name = nil)
+        @column_family || (@column_family = name || self.name.split('::').last)
+      end
+
+      def key(name, type = :string)
+        @key_type = type.to_s
+        class_eval <<-EVAL, __FILE__, __LINE__ + 1
+          def #{name}=(value)
+            @key_type = '#{type}'
+            if @key_type.downcase == 'time_uuid'
+              value = SimpleUUID::UUID.new(value)
+            end
+            @key = value.to_s;
+          end
+          def #{name}
+            @key;
+          end
+        EVAL
+      end
+
+      def column(name, type = :string)
+        columns[name] = type
+        class_eval "def #{name}; #{type.capitalize}Type.load(@attributes['#{name}']); end"
+        class_eval "def #{name}=(value); @attributes['#{name}'] = #{type.capitalize}Type.dump(value); end"
+      end
+
+      def validate(&block)
+        raise ArgumentError.new('provide a block that does validation') unless block_given?
+        @validation = block
+      end
+
+      def validation
+        @validation
+      end
+
+      def columns
+        @columns ||= {}
+      end
+
+      def logger
+        return @@logger || RAILS_DEFAULT_LOGGER
+      end
+
+      def logger=(obj)
+        @@logger = obj
+      end
+
+      # Defines the primary key field -- can be overridden in subclasses. Overwriting will negate any effect of the
+      # primary_key_prefix_type setting, though.
+      def primary_key
+        'id'
+      end
+      
+      def key_type
+        @key_type
+      end
+
+      def key_type=(value)
+        @key_type = value
+      end
+
+      # Log and benchmark multiple statements in a single block. Example:
+      #
+      #   Project.benchmark("Creating project") do
+      #     project = Project.create("name" => "stuff")
+      #     project.create_manager("name" => "David")
+      #     project.milestones << Milestone.find(:all)
+      #   end
+      #
+      # The benchmark is only recorded if the current level of the logger is less than or equal to the <tt>log_level</tt>,
+      # which makes it easy to include benchmarking statements in production software that will remain inexpensive because
+      # the benchmark will only be conducted if the log level is low enough.
+      #
+      # The logging of the multiple statements is turned off unless <tt>use_silence</tt> is set to false.
+      def benchmark(title, log_level = Logger::DEBUG, use_silence = true)
+        if logger && logger.level <= log_level
+          result = nil
+          ms = 1000 * Benchmark.realtime { result = use_silence ? silence { yield } : yield }
+          logger.add(log_level, '%s (%.1fms)' % [title, ms])
+          result
+        else
+          yield
+        end
+      end
+
+      # Silences the logger for the duration of the block.
+      def silence
+        old_logger_level, logger.level = logger.level, Logger::ERROR if logger
+        yield
+      ensure
+        logger.level = old_logger_level if logger
+      end
+
+      private
+
+      def inherited(child)
+        child.instance_variable_set('@connection', @connection)
+        super
+      end
+    end
+
+    attr_accessor :key, :new_record, :key_type
+    attr_reader :attributes, :errors
+
+    def initialize(attrs = {}, convert = true)
+      @new_record = true
+      @errors     = []
+      @attributes = {}
+      if convert
+        self.attributes = attrs
+      else
+        @attributes     = attrs
+      end
+    end
+
+    def attributes=(attrs)
+      attrs.each {|k, v| send("#{k}=", v) if respond_to? "#{k}=".to_sym }
+    end
+
+    def valid?
+      @errors << "key required" if key.to_s !~ /\S/
+      self.instance_eval(&self.class.validation) unless self.class.validation.nil?
+      @errors.empty?
+    end
+
+    def new_record?
+      @new_record
+    end
+
+    def ==(other)
+      true
+    end
+
+    # Returns +true+ if the record is read only.
+    def readonly?
+      defined?(@readonly) && @readonly == true
+    end
+
+    # Marks a entity as readonly
+    def readonly!
+      @readonly = true
+    end
+
+    # When a entity with no attributes is read from the datasource it is auto
+    # marked as deleted.
+    def deleted?
+      defined?(@deleted) && @deleted == true
+    end
+
+    # Marks a entity as deleted
+    def deleted!
+      @deleted = true
+    end
+
+    alias :eql? ==
+  end
+
+end

data/lib/cassandra-model/batches.rb

@@ -0,0 +1,89 @@
+#Mimic ActiveRecord Batches
+module CassandraModel
+  module Batches # :nodoc:
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    # When processing large numbers of records, it's often a good idea to do
+    # so in batches to prevent memory ballooning.
+    module ClassMethods
+      # Yields each record that was found by the find +options+. The find is
+      # performed by find_in_batches with a batch size of 1000 (or as
+      # specified by the <tt>:batch_size</tt> option).
+      #
+      # Example:
+      #
+      #   Person.find_each(:conditions => "age > 21") do |person|
+      #     person.party_all_night!
+      #   end
+      #
+      # Note: This method is only intended to use for batch processing of
+      # large amounts of records that wouldn't fit in memory all at once. If
+      # you just need to loop over less than 1000 records, it's probably
+      # better just to use the regular find methods.
+      def find_each(options = {})
+        find_in_batches(options) do |records|
+          records.each { |record| yield record }
+        end
+
+        self
+      end
+
+      # Yields each batch of records that was found by the find +options+ as
+      # an array. The size of each batch is set by the <tt>:batch_size</tt>
+      # option; the default is 1000.
+      #
+      # You can control the starting point for the batch processing by
+      # supplying the <tt>:start</tt> option. This is especially useful if you
+      # want multiple workers dealing with the same processing queue. You can
+      # make worker 1 handle all the records between id 0 and 10,000 and
+      # worker 2 handle from 10,000 and beyond (by setting the <tt>:start</tt>
+      # option on that worker).
+      #
+      # It's not possible to set the order. That is automatically set to
+      # ascending on the primary key ("id ASC") to make the batch ordering
+      # work. This also mean that this method only works with integer-based
+      # primary keys. You can't set the limit either, that's used to control
+      # the the batch sizes.
+      #
+      # Example:
+      #
+      #   Person.find_in_batches(:conditions => "age > 21") do |group|
+      #     sleep(50) # Make sure it doesn't get too crowded in there!
+      #     group.each { |person| person.party_all_night! }
+      #   end
+      def find_in_batches(options = {})
+        raise "You can't specify an order." if options[:order]
+        raise "You can't specify a limit, it's forced to be the batch_size"  if options[:limit]
+
+        start = options.delete(:start) || ''
+        nofilter = options[:no_filter]
+        batch_size = options.delete(:batch_size) || 500
+
+        records = self.find(:all, :keyrange => start..'', :limit => batch_size)
+
+        while records.any?
+          count = records.size
+          records = filter_deleted(records) unless nofilter
+          yield records
+          break if count < batch_size
+
+          last_value = records.last.id
+          records = self.find(:all, :keyrange => last_value..'', :limit => batch_size)
+        end
+      end
+
+      private
+
+      def filter_deleted records
+        ret = []
+        records.each do |item|
+          ret.push(item) unless item.deleted?
+        end
+        return ret
+      end
+      
+    end
+  end
+end

data/lib/cassandra-model/callbacks.rb

@@ -0,0 +1,49 @@
+module CassandraModel
+  module Callbacks
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    module ClassMethods
+      def define_callbacks(*callbacks)
+        callbacks.each do |callback|
+          [:before, :after].each do |chain|
+            callback_name = "#{chain}_#{callback}"
+            instance_eval <<-EVAL, __FILE__, __LINE__ + 1
+              def #{callback_name}(*args)
+                callbacks[:#{callback_name}] += args
+              end
+            EVAL
+          end
+        end
+      end
+
+      def callbacks
+        @callbacks ||= Hash.new {|h, k| h[k] = [] }
+      end
+    end
+
+    module InstanceMethods
+      def run_callbacks(name, &block)
+        _run_callbacks(:before, name)
+        result = block.call
+        _run_callbacks(:after, name, result)
+        result
+      end
+
+      private
+      def _run_callbacks(chain, name, value = nil)
+        callback_name = "#{chain}_#{name}".to_sym
+        self.class.callbacks[callback_name].each do |callback|
+          next unless callback.is_a? Symbol
+          if self.class.instance_method(callback).arity > 0
+            self.send(callback, value)
+          else
+            self.send(callback)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cassandra-model/config.rb

@@ -0,0 +1,66 @@
+module CassandraModel
+  class Config
+
+    @@cfg_file = File.join(Rails.root,'config','cassandra_conf.yml')
+
+    @@hosts = ['127.0.0.1:9160']
+
+    @@username = nil
+
+    @@password = nil
+
+    @@keyspace = nil
+
+    def self.cfg_file
+      @@cfg_file
+    end
+
+    def self.cfg_file=(file)
+      @@cfg_file = file
+    end
+
+    def self.hosts
+      @@hosts
+    end
+
+    def self.hosts=(hosts)
+      @@hosts = hosts
+    end
+
+    def self.username
+      @@username
+    end
+
+    def self.username=(username)
+      @@username = username
+    end
+
+    def self.password
+      @@password
+    end
+
+    def self.password=(password)
+      @@password = password
+    end
+
+    def self.keyspace
+      @@keyspace
+    end
+
+    def self.keyspace=(keyspace)
+      @@keyspace = keyspace
+    end
+
+    def self.initialize
+      cfg = YAML.load_file(self.cfg_file)[Rails.env]
+      initialize_props cfg
+    end
+
+    def self.initialize_props props
+      self.hosts = props['hosts']
+      self.username = props['username']
+      self.password = props['password']
+      self.keyspace = props['keyspace']
+    end
+  end
+end

data/lib/cassandra-model/connection.rb

@@ -0,0 +1,21 @@
+require 'cassandra-model/config'
+module CassandraModel
+  class Connection
+
+    def self.establish_connection
+      connection = Thread.current[:cassandra_conn]
+      if ! connection
+        connection = Cassandra.new(Config.keyspace, Config.hosts)
+        if Config.username
+          connection.login!(Config.username, Config.password)
+        end
+        Thread.current[:cassandra_conn] = connection
+      end
+      return connection
+    end
+
+    def self.connection
+      return Thread.current[:cassandra_conn]
+    end
+  end
+end