cassandra_mapper 0.0.1

data/lib/cassandra_mapper/observable.rb

@@ -0,0 +1,36 @@
+require 'cassandra_mapper/support/observing'
+module CassandraMapper
+  module Observable
+    CALLBACKS = [
+      :after_load,
+      :before_create,
+      :after_create,
+      :before_update,
+      :after_update,
+      :before_save,
+      :after_save,
+      :before_destroy,
+      :after_destroy,
+    ]
+
+    CALLBACKS.each do |cb|
+      name = cb.to_s
+      module_eval <<-cbnotify
+        def _notify_observer_#{name}; notify_observers(:#{name}); true; end
+      cbnotify
+    end
+
+    def self.included(klass)
+      klass.module_eval do
+        include CassandraMapper::Support::Observing
+        CALLBACKS.each do |callback|
+          name = callback.to_s
+          send(callback, :"_notify_observer_#{name}")
+        end
+      end
+    end
+  end
+
+  class Observer < CassandraMapper::Support::Observer
+  end
+end

data/lib/cassandra_mapper/persistence.rb

@@ -0,0 +1,309 @@
+require 'cassandra_mapper/support/callbacks'
+module CassandraMapper::Persistence
+  def _determine_transform_options
+    options = {:string_keys => true}
+    is_update = false
+    if new_record?
+      options[:defined] = true
+    else
+      return false unless changed_attributes.length > 0
+      options[:changed] = true
+      is_update = true
+    end
+    [options, is_update]
+  end
+
+  def save(with_validation = true)
+    _run_save_callbacks do
+      uniq_key = _check_key
+      options, is_update = _determine_transform_options
+      return false unless options
+      if is_update
+        update(uniq_key, options)
+      else
+        create(uniq_key, options)
+      end
+    end
+  end
+
+  def loaded!
+    self.new_record = false
+    _run_load_callbacks
+    self
+  end
+
+  def create(uniq_key, options)
+    _run_create_callbacks do
+      write!(uniq_key, options)
+      self.new_record = false
+      self
+    end
+  end
+
+  def update(uniq_key, options)
+    _run_update_callbacks do
+      write!(uniq_key, options.merge({ :with_delete => true }))
+      self
+    end
+  end
+
+  def destroy
+    unless new_record?
+      _run_destroy_callbacks do
+        self.class.delete(_check_key)
+      end
+    end
+    @destroyed = true
+    freeze
+    self
+  end
+
+  def write!(uniq_key, options)
+    with_delete = options.delete(:with_delete)
+    structure = to_simple(options)
+    if with_delete
+      deletes = self.class.prune_deletes_from_simple_structure(structure)
+      cassandra_args = []
+      if ! (structure.empty? or deletes.empty?) or deletes.size >= 2
+        cassandra_args << {:timestamp => Time.stamp}
+      end
+      base_args = [self.class.column_family, uniq_key]
+      connection.insert(*(base_args + [structure] + cassandra_args)) unless structure.empty?
+      deletes.each {|del_args| connection.remove(*(base_args + del_args + cassandra_args))}
+    else
+      connection.insert(self.class.column_family, uniq_key, to_simple(options))
+    end
+  end
+
+  def to_mutation(with_validation = true, options = {})
+    uniq_key = _check_key.to_s
+    timestamp = options.delete(:timestamp) || Time.stamp
+    general_opts, is_update = _determine_transform_options
+    return false unless general_opts
+    options.merge!(general_opts)
+    {
+      uniq_key => {
+        self.class.column_family.to_s => self.class.to_mutation(to_simple(options), timestamp)
+      }
+    }
+  end
+
+  def _check_key
+    uniq_key = self.key
+    raise CassandraMapper::UndefinedKeyException if uniq_key.nil?
+    uniq_key
+  end
+
+  def delete
+    self.class.delete(_check_key) unless new_record?
+    @destroyed = true
+    freeze
+    self
+  end
+
+  def destroyed?
+    (@destroyed && true) || false
+  end
+
+  module ClassMethods
+    # Given a single key or list of keys, returns all mapped objects found
+    # for thoese keys.
+    #
+    # If the row for a specified key is missing, a CassndraMapper::RecordNotFoundException
+    # exception is raised.  This can be overridden by specifying the +:allow_missing+
+    # option (:allow_missing => true)
+    #
+    # Keys and options may be specified in a variety of ways:
+    # * Flat list
+    #     SomeClass.find(key1, key2, key3, options)
+    # * Separate lists
+    #     SomeClass.find([key1, key2, key3], options)
+    #
+    # And of course, _options_ can always be left out.
+    def find(*args)
+      single = false
+      case args.first
+        when Array
+          keys = args.first
+        when nil
+          raise CassandraMapper::InvalidArgumentException
+        else
+          keys = args
+          single = true if keys.length == 1
+      end
+      case args.last
+        when Hash
+          options = args.pop
+        else
+          options = {}
+      end
+
+      result = connection.multi_get(column_family, keys).values.inject([]) do |arr, hash|
+        if not hash.empty?
+          obj = new(hash)
+          obj.new_record = false
+          arr << obj
+          obj.loaded!
+        end
+        arr
+      end
+      raise CassandraMapper::RecordNotFoundException unless result.size == keys.size or options[:allow_missing]
+      single ? result.first : result
+    end
+
+    # Given a _key_ of a single row key or array of row keys,
+    # removes the rows from the Cassandra column family associated with
+    # the receiving class.
+    #
+    # As the underlying Cassandra client returns no information about the
+    # result of the operation, the result is always +nil+.
+    #
+    # The delete operation is purely database-side; no objects are instantiated
+    # and therefore no object callbacks take place for the deleted rows.
+    # This makes delete risky for classes that manage associations, indexes, etc.
+    def delete(key)
+      keys = Array === key ? key : [key]
+      keys.each do |key|
+        connection.remove(column_family, key)
+      end
+      nil
+    end
+
+    # Similar to +delete+; given a _key_ of a single row key or array of row keys,
+    # removes the rows from the Cassandra column family associated with the receiving
+    # class.
+    #
+    # However, unlike +delete+, +destroy+ loads up the object per row key in turn
+    # and invokes +destroy+ on each object.  This allows for callbacks and observers
+    # to be executed, which is essential for index maintenance, association maintenance,
+    # etc.
+    def destroy(key)
+      objs = find(key)
+      case objs
+        when Array
+          objs.each {|obj| obj.destroy}
+        else
+          objs.destroy
+      end
+      nil
+    end
+
+    def connection
+      @cassandra_mapper_connection
+    end
+
+    def connection=(connection)
+      @cassandra_mapper_connection = connection
+    end
+
+    def column_family(family = nil)
+      @cassandra_mapper_column_family = family if ! family.nil?
+      @cassandra_mapper_column_family
+    end
+
+    def self.extended(klass)
+      klass.module_eval do
+        extend CassandraMapper::Support::Callbacks
+        define_model_callbacks :save, :create, :update, :destroy
+        define_model_callbacks :load, :only => :after
+      end
+    end
+
+    def to_mutation(simple_structure, timestamp)
+      mutator.from_simple(simple_structure, timestamp)
+    end
+
+    def mutator
+      unless @mutator
+        mutator_class = simple_mapper.attributes.first[1].mapper ? SuperMutator : SimpleMutator
+        @mutator = mutator_class.new
+      end
+      @mutator
+    end
+
+    class SimpleMutator
+      def from_simple(structure, timestamp)
+        deletion = nil
+        deletion_columns = nil
+        structure.inject([]) do |list, pair|
+          key,val = pair
+          if val.nil?
+            unless deletion
+              deletion = CassandraThrift::Mutation.new(
+                :deletion => CassandraThrift::Deletion.new(
+                  :super_column => nil,
+                  :timestamp    => timestamp,
+                  :predicate    => CassandraThrift::SlicePredicate.new(
+                    :column_names => (deletion_columns = [])
+                  )
+                )
+              )
+              list << deletion
+            end
+            deletion_columns << key
+          else
+            list << CassandraThrift::Mutation.new(
+              :column_or_supercolumn => CassandraThrift::ColumnOrSuperColumn.new(
+                :column => CassandraThrift::Column.new(
+                  :name      => key,
+                  :value     => val,
+                  :timestamp => timestamp
+                )
+              )
+            )
+          end
+          list
+        end
+      end
+    end
+
+    class SuperMutator
+      def from_simple(structure, timestamp)
+        structure.inject([]) do |list, pair|
+          supercol_key, val = pair
+          if val and ! val.empty?
+            list << CassandraThrift::Mutation.new(
+              :column_or_supercolumn => CassandraThrift::ColumnOrSuperColumn.new(
+                :super_column => CassandraThrift::SuperColumn.new(
+                  :name    => supercol_key,
+                  :columns => val.collect {|column, value|
+                    CassandraThrift::Column.new(
+                      :name      => column,
+                      :value     => value,
+                      :timestamp => timestamp
+                    )
+                  }
+                )
+              )
+            )
+          end
+          list
+        end
+      end
+    end
+
+    def prune_deletes(source, deletes, context)
+      source.each do |k, v|
+        if v.nil?
+          deletes << context + [k]
+          source.delete(k)
+        # pre 1.9 String responds to :each; but :values_at is a
+        # safe bet for 1.8 and 1.9 for array, hash, but not string.
+        elsif v.respond_to?(:values_at)
+          prune_deletes(v, deletes, context + [k])
+          source.delete(k) if v.empty?
+        end
+      end
+    end
+
+    def prune_deletes_from_simple_structure(structure)
+      deletes = []
+      prune_deletes(structure, deletes, [])
+      deletes
+    end
+  end
+
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+end

data/lib/cassandra_mapper/support/callbacks.rb

@@ -0,0 +1,136 @@
+require 'cassandra_mapper/core_ext/array/wrap'
+require 'cassandra_mapper/support/support_callbacks'
+
+module CassandraMapper
+  module Support
+    # == Active Model Callbacks
+    #
+    # Provides an interface for any class to have Active Record like callbacks.
+    #
+    # Like the Active Record methods, the callback chain is aborted as soon as
+    # one of the methods in the chain returns false.
+    #
+    # First, extend ActiveModel::Callbacks from the class you are creating:
+    #
+    #   class MyModel
+    #     extend ActiveModel::Callbacks
+    #   end
+    #
+    # Then define a list of methods that you want callbacks attached to:
+    #
+    #   define_model_callbacks :create, :update
+    #
+    # This will provide all three standard callbacks (before, around and after) around
+    # both the :create and :update methods. To implement, you need to wrap the methods
+    # you want callbacks on in a block so that the callbacks get a chance to fire:
+    #
+    #   def create
+    #     _run_create_callbacks do
+    #       # Your create action methods here
+    #     end
+    #   end
+    #
+    # The _run_<method_name>_callbacks methods are dynamically created when you extend
+    # the <tt>ActiveModel::Callbacks</tt> module.
+    #
+    # Then in your class, you can use the +before_create+, +after_create+ and +around_create+
+    # methods, just as you would in an Active Record module.
+    #
+    #   before_create :action_before_create
+    #
+    #   def action_before_create
+    #     # Your code here
+    #   end
+    #
+    # You can choose not to have all three callbacks by passing a hash to the
+    # define_model_callbacks method.
+    #
+    #   define_model_callbacks :create, :only => :after, :before
+    #
+    # Would only create the after_create and before_create callback methods in your
+    # class.
+    module Callbacks
+      def self.extended(base)
+        base.class_eval do
+          include CassandraMapper::Support::SupportCallbacks
+        end
+      end
+
+      # define_model_callbacks accepts the same options define_callbacks does, in case
+      # you want to overwrite a default. Besides that, it also accepts an :only option,
+      # where you can choose if you want all types (before, around or after) or just some.
+      #
+      #   define_model_callbacks :initializer, :only => :after
+      #
+      # Note, the <tt>:only => <type></tt> hash will apply to all callbacks defined on
+      # that method call.  To get around this you can call the define_model_callbacks
+      # method as many times as you need.
+      #
+      #   define_model_callbacks :create, :only => :after
+      #   define_model_callbacks :update, :only => :before
+      #   define_model_callbacks :destroy, :only => :around
+      #
+      # Would create +after_create+, +before_update+ and +around_destroy+ methods only.
+      #
+      # You can pass in a class to before_<type>, after_<type> and around_<type>, in which
+      # case the callback will call that class's <action>_<type> method passing the object
+      # that the callback is being called on.
+      #
+      #   class MyModel
+      #     extend ActiveModel::Callbacks
+      #     define_model_callbacks :create
+      #
+      #     before_create AnotherClass
+      #   end
+      #
+      #   class AnotherClass
+      #     def self.before_create( obj )
+      #       # obj is the MyModel instance that the callback is being called on
+      #     end
+      #   end
+      #
+      def define_model_callbacks(*callbacks)
+        options = callbacks.extract_options!
+        options = { :terminator => "result == false", :scope => [:kind, :name] }.merge(options)
+
+        types = Array.wrap(options.delete(:only))
+        types = [:before, :around, :after] if types.empty?
+
+        callbacks.each do |callback|
+          define_callbacks(callback, options)
+
+          types.each do |type|
+            send(:"_define_#{type}_model_callback", self, callback)
+          end
+        end
+      end
+
+      def _define_before_model_callback(klass, callback) #:nodoc:
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+          def self.before_#{callback}(*args, &block)
+            set_callback(:#{callback}, :before, *args, &block)
+          end
+        CALLBACK
+      end
+
+      def _define_around_model_callback(klass, callback) #:nodoc:
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+          def self.around_#{callback}(*args, &block)
+            set_callback(:#{callback}, :around, *args, &block)
+          end
+        CALLBACK
+      end
+
+      def _define_after_model_callback(klass, callback) #:nodoc:
+        klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
+          def self.after_#{callback}(*args, &block)
+            options = args.extract_options!
+            options[:prepend] = true
+            options[:if] = Array.wrap(options[:if]) << "!halted && value != false"
+            set_callback(:#{callback}, :after, *(args << options), &block)
+          end
+        CALLBACK
+      end
+    end
+  end
+end