cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/model/base.rb

@@ -0,0 +1,74 @@
+module Cequel
+
+  module Model
+
+    class Base
+
+      include Cequel::Model::Properties
+      include Cequel::Model::Schema
+      include Cequel::Model::Persistence
+      include Cequel::Model::Associations
+      extend Cequel::Model::Scoped
+      include Cequel::Model::MassAssignment
+      include Cequel::Model::Callbacks
+      include Cequel::Model::Validations
+      extend ActiveModel::Naming
+      include ActiveModel::Serializers::JSON
+      include ActiveModel::Serializers::Xml
+
+      class_attribute :table_name, :connection, :default_attributes,
+        :instance_writer => false
+
+      def self.inherited(base)
+        base.table_name = base.name.tableize.to_sym unless base.name.nil?
+        base.default_attributes = {}
+      end
+
+      def self.establish_connection(configuration)
+        self.connection = Cequel.connect(configuration)
+      end
+
+      class <<self; alias_method :new_empty, :new; end
+      def self.new(*args, &block)
+        new_empty.tap do |record|
+          record.__send__(:initialize_new_record, *args)
+          yield record if block_given?
+        end
+      end
+
+      def initialize(&block)
+        @attributes, @collection_proxies = {}, {}
+        instance_eval(&block) if block
+      end
+
+      def inspect
+        inspected_attributes = attributes.each_pair.map do |attr, value|
+          inspected_value = value.is_a?(CassandraCQL::UUID) ?
+            value.to_guid :
+            value.inspect
+          "#{attr}: #{inspected_value}"
+        end
+        "#<#{self.class} #{inspected_attributes.join(", ")}>"
+      end
+
+      protected
+      attr_reader :collection_proxies
+
+      private
+
+      def initialize_new_record(attributes = {})
+        @attributes = Marshal.load(Marshal.dump(default_attributes))
+        @new_record = true
+        yield self if block_given?
+        self.attributes = attributes #XXX this should really be in Properties
+        loaded!
+        self
+      end
+
+    end
+
+  end
+
+  Base = Model::Base
+
+end

data/lib/cequel/model/belongs_to_association.rb

@@ -0,0 +1,31 @@
+module Cequel
+
+  module Model
+
+    class BelongsToAssociation
+
+      extend Forwardable
+
+      attr_reader :owner_class, :name, :association_class_name
+
+      def_delegator :association_class, :key_columns, :association_key_columns
+
+      def initialize(owner_class, name, options = {})
+        @owner_class, @name = owner_class, name.to_sym
+        @association_class_name =
+          options.fetch(:class_name, @name.to_s.classify)
+      end
+
+      def association_class
+        @association_class ||= association_class_name.constantize
+      end
+
+      def instance_variable_name
+        @instance_variable_name ||= :"@#{name}"
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/callbacks.rb

@@ -6,25 +6,29 @@ module Cequel
 
       extend ActiveSupport::Concern
 
-      HOOKS = [:save, :create, :update, :destroy, :validation]
-      CALLBACKS = HOOKS.map { |hook| [:"before_#{hook}", :"after_#{hook}"] }.
-        flatten
-
       included do
         extend ActiveModel::Callbacks
-        define_model_callbacks *HOOKS
+        define_model_callbacks :save, :create, :update, :destroy
       end
 
-      def save(*args)
-        run_callbacks(:save) do
-          run_callbacks(persisted? ? :update : :create) { super }
-        end
+      def save(options = {})
+        run_callbacks(:save) { super }
       end
 
-      def destroy(*args)
+      def destroy
         run_callbacks(:destroy) { super }
       end
 
+      protected
+
+      def create
+        run_callbacks(:create) { super }
+      end
+
+      def update
+        run_callbacks(:update) { super }
+      end
+
     end
 
   end

data/lib/cequel/model/collection.rb

@@ -0,0 +1,255 @@
+require 'delegate'
+
+module Cequel
+
+  module Model
+
+    module Collection
+
+      extend ActiveSupport::Concern
+      extend Forwardable
+
+      def_delegators :@model, :loaded?, :updater, :deleter
+
+      attr_reader :column_name
+
+      included do
+        private
+        define_method(
+          :method_missing,
+          BasicObject.instance_method(:method_missing))
+      end
+
+      def initialize(model, column_name)
+        @model, @column_name = model, column_name
+      end
+
+      def inspect
+        __getobj__.inspect
+      end
+
+      def loaded!
+        modifications.each { |modification| modification.() }.clear
+      end
+
+      def persisted!
+        modifications.clear
+      end
+
+      protected
+
+      def __getobj__
+        @model.__send__(:read_attribute, @column_name) ||
+          @model.__send__(:write_attribute, @column_name, self.class.empty)
+      end
+
+      def __setobj__(obj)
+        raise "Attempted to call __setobj__ on read-only delegate!"
+      end
+
+      private
+
+      def to_modify(&block)
+        if loaded? then block.()
+        else modifications << block
+        end
+        self
+      end
+
+      def modifications
+        @modifications ||= []
+      end
+
+    end
+
+    class List < DelegateClass(Array)
+
+      include Collection
+
+      NON_ATOMIC_MUTATORS = [
+        :collect!,
+        :delete_if,
+        :fill,
+        :flatten!,
+        :insert,
+        :keep_if,
+        :map!,
+        :pop,
+        :reject!,
+        :reverse!,
+        :rotate!,
+        :select!,
+        :shift,
+        :shuffle!,
+        :slice!,
+        :sort!,
+        :sort_by!,
+        :uniq!
+      ]
+      NON_ATOMIC_MUTATORS.
+        each { |method| undef_method(method) if method_defined? method }
+
+      def self.empty; []; end
+
+      def []=(position, *args)
+        if Range === position then first, count = position.first, position.count
+        else first, count = position, args[-2]
+        end
+        element = args[-1]
+        if first < 0
+          raise ArgumentError,
+            "Bad index #{position}: CQL lists do not support negative indices"
+        end
+        if count.nil?
+          updater.list_replace(column_name, first, element)
+        else
+          element = Array.wrap(element)
+          count.times do |i|
+            if i < element.length
+              updater.list_replace(column_name, first+i, element[i])
+            else
+              deleter.list_remove_at(column_name, first+i)
+            end
+          end
+        end
+        to_modify { super }
+      end
+
+      def clear
+        deleter.delete_columns(column_name)
+        to_modify { super }
+      end
+
+      def concat(array)
+        updater.list_append(column_name, array)
+        to_modify { super }
+      end
+
+      def delete(object)
+        updater.list_remove(column_name, object)
+        to_modify { super }
+      end
+
+      def delete_at(index)
+        deleter.list_remove_at(column_name, index)
+        to_modify { super }
+      end
+
+      def push(object)
+        updater.list_append(column_name, object)
+        to_modify { super }
+      end
+      alias_method :<<, :push
+
+      def replace(array)
+        updater.set(column_name => array)
+        to_modify { super }
+      end
+
+      def unshift(*objs)
+        updater.list_prepend(column_name, objs.reverse)
+        to_modify { super }
+      end
+
+    end
+
+    class Set < DelegateClass(::Set)
+
+      include Collection
+
+      NON_ATOMIC_MUTATORS = [
+        :add?,
+        :collect!,
+        :delete?,
+        :delete_if,
+        :flatten!,
+        :keep_if,
+        :map!,
+        :reject!,
+        :select!
+      ]
+      NON_ATOMIC_MUTATORS.
+        each { |method| undef_method(method) if method_defined? method }
+
+      def add(object)
+        updater.set_add(column_name, object)
+        to_modify { super }
+      end
+
+      def clear
+        deleter.delete_columns(column_name)
+        to_modify { super }
+      end
+
+      def delete(object)
+        updater.set_remove(column_name, object)
+        to_modify { super }
+      end
+
+      def replace(set)
+        updater.set(column_name => set)
+        to_modify { super }
+      end
+
+    end
+
+    class Map < DelegateClass(::Hash)
+
+      include Collection
+
+      NON_ATOMIC_MUTATORS = [
+        :default,
+        :default=,
+        :default_proc,
+        :default_proc=,
+        :delete_if,
+        :deep_merge!,
+        :except!,
+        :extract!,
+        :keep_if,
+        :reject!,
+        :reverse_merge!,
+        :reverse_update,
+        :select!,
+        :shift,
+        :slice!,
+        :stringify_keys!,
+        :symbolize_keys!,
+        :to_options!,
+        :transform_keys!
+      ]
+      NON_ATOMIC_MUTATORS.
+        each { |method| undef_method(method) if method_defined? method }
+
+      def []=(key, value)
+        updater.map_update(column_name, key => value)
+        to_modify { super }
+      end
+      alias_method :store, :[]=
+
+      def clear
+        deleter.delete_columns(column_name)
+        to_modify { super }
+      end
+
+      def delete(key)
+        deleter.map_remove(column_name, key)
+        to_modify { super }
+      end
+
+      def merge!(hash)
+        updater.map_update(column_name, hash)
+        to_modify { super }
+      end
+      alias_method :update, :merge!
+
+      def replace(hash)
+        updater.set(column_name => hash)
+        to_modify { super }
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/errors.rb

@@ -1,12 +1,12 @@
 module Cequel
-  
+
   module Model
 
-    Error = Class.new(Cequel::Error)
-    RecordNotFound = Class.new(Error)
-    RecordInvalid = Class.new(Error)
-    MissingKey = Class.new(Error)
-    InvalidQuery = Class.new(Error)
+    MissingAttributeError = Class.new(ArgumentError)
+    UnknownAttributeError = Class.new(ArgumentError)
+    RecordNotFound = Class.new(StandardError)
+    InvalidRecordConfiguration = Class.new(StandardError)
+    RecordInvalid = Class.new(StandardError)
 
   end
 

data/lib/cequel/model/has_many_association.rb

@@ -0,0 +1,26 @@
+module Cequel
+
+  module Model
+
+    class HasManyAssociation
+
+      attr_reader :owner_class, :name, :association_class_name
+
+      def initialize(owner_class, name, options = {})
+        @owner_class, @name = owner_class, name
+        @association_class_name = options.fetch(:class_name, name.to_s.classify)
+      end
+
+      def association_class
+        @association_class ||= association_class_name.constantize
+      end
+
+      def instance_variable_name
+        @instance_variable_name ||= :"@#{name}"
+      end
+
+    end
+
+  end
+
+end