cequel 0.0.0 → 0.4.0

data/lib/cequel/model/dirty.rb

@@ -0,0 +1,53 @@
+module Cequel
+
+  module Model
+
+    module Dirty
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Dirty
+        include ChangedAttributesWithIndifferentAccess
+      end
+
+      module ClassMethods
+
+        def column(name, type, options = {})
+          define_attribute_method(name)
+          super
+        end
+
+      end
+
+      def save
+        super.tap do
+          @previously_changed = changes
+          changed_attributes.clear
+        end
+      end
+
+      def _hydrate(row)
+        super.tap { changed_attributes.clear }
+      end
+
+      private
+
+      def write_attribute(name, value)
+        attribute_will_change!(name) if value != read_attribute(name)
+        super
+      end
+
+    end
+
+    module ChangedAttributesWithIndifferentAccess
+
+      def changed_attributes
+        @changed_attributes ||= HashWithIndifferentAccess.new
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/dynamic.rb

@@ -0,0 +1,31 @@
+module Cequel
+
+  module Model
+
+    module Dynamic
+
+      def [](column)
+        read_attribute(column)
+      end
+
+      def []=(column, value)
+        write_attribute(column, value)
+      end
+
+      private
+
+      def attribute_change(attr)
+        if attribute_changed?(attr)
+          if respond_to_without_attributes?(attr)
+            super
+          else
+            [changed_attributes[attr], self[attr]]
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/errors.rb

@@ -0,0 +1,13 @@
+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)
+
+  end
+
+end

data/lib/cequel/model/inheritable.rb

@@ -0,0 +1,48 @@
+module Cequel
+
+  module Model
+
+    module Inheritable
+
+      module SubclassMethods
+
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+
+          def all
+            super.where(@_cequel.type_column.name => name)
+          end
+
+        end
+
+        def initialize(*args, &block)
+          super
+          __send__("#{self.class.type_column.name}=", self.class.name)
+        end
+
+      end
+
+      def inherited(subclass)
+        super
+        unless @_cequel.type_column
+          raise ArgumentError,
+            "Can't subclass model class that does not define a type column"
+        end
+        subclass._cequel = SubclassInternals.new(subclass, @_cequel)
+        subclass.module_eval { include(SubclassMethods) }
+      end
+
+      def base_class
+        @_cequel.base_class
+      end
+
+      protected
+
+      attr_writer :_cequel
+
+    end
+
+  end
+
+end

data/lib/cequel/model/instance_internals.rb

@@ -0,0 +1,23 @@
+module Cequel
+
+  module Model
+
+    #
+    # @private
+    #
+    class InstanceInternals
+
+      attr_accessor :key, :attributes, :persisted
+      attr_reader :associations
+
+      def initialize(instance)
+        @instance = instance
+        @attributes = ActiveSupport::HashWithIndifferentAccess.new
+        @associations = {}
+      end
+
+    end
+    
+  end
+
+end

data/lib/cequel/model/local_association.rb

@@ -0,0 +1,42 @@
+module Cequel
+
+  module Model
+
+    class LocalAssociation
+
+      attr_reader :clazz, :name
+
+      def initialize(name, owning_class, options)
+        @name, @owning_class = name, owning_class
+        @class_name = options[:class_name] || name.to_s.classify.to_sym
+        @foreign_key_name = options[:foreign_key]
+      end
+
+      def primary_key
+        @primary_key ||= clazz.key_column
+      end
+
+      def primary_key_name
+        @primary_key_name ||= primary_key.name
+      end
+
+      def foreign_key_name
+        @foreign_key_name ||= :"#{name}_id"
+      end
+
+      def scope(instance)
+        clazz.where(primary_key_name => instance.__send__(foreign_key_name))
+      end
+
+      def clazz
+        @clazz ||= @class_name.to_s.constantize
+      end
+
+      def dependent
+      end
+    
+    end
+
+  end
+
+end

data/lib/cequel/model/magic.rb

@@ -0,0 +1,79 @@
+module Cequel
+
+  module Model
+
+    module Magic
+
+      FIND_BY_PATTERN = /^find_by_(\w+)$/
+      FIND_ALL_BY_PATTERN = /^find_all_by_(\w+)$/
+      FIND_OR_CREATE_BY_PATTERN = /^find_or_create_by_(\w+)$/
+      FIND_OR_INITIALIZE_BY_PATTERN = /^find_or_initialize_by_(\w+)$/
+
+      def self.scope(scope, columns_string, args)
+        scope.where(extract_row_specifications(columns_string, args))
+      end
+
+      def self.find_or_create_by(scope, columns_string, args, &block)
+        find_or_initialize_by(scope, columns_string, args, &block).tap do |instance|
+          instance.save unless instance.persisted?
+        end
+      end
+
+      def self.find_or_initialize_by(scope, columns_string, args, &block)
+        row_specifications = extract_row_specifications(columns_string, args)
+        instance = scope.where(row_specifications).first
+        if instance.nil?
+          if args.length == 1 && args.first.is_a?(Hash)
+            attributes = args.first
+          else
+            attributes = row_specifications
+          end
+          instance = scope.new(attributes, &block)
+        end
+        instance
+      end
+
+      def self.extract_row_specifications(columns_string, args)
+        columns = columns_string.split('_and_').map { |column| column.to_sym }
+        if args.length == 1 && args.first.is_a?(Hash)
+          args.first.symbolize_keys.slice(*columns)
+        else
+          if columns.length != args.length
+            raise ArgumentError,
+              "wrong number of arguments(#{args.length} for #{columns.length})"
+          end
+          Hash[columns.zip(args)]
+        end
+      end
+
+      def respond_to?(method, priv = false)
+        case method
+        when FIND_BY_PATTERN, FIND_ALL_BY_PATTERN,
+          FIND_OR_CREATE_BY_PATTERN, FIND_OR_INITIALIZE_BY_PATTERN
+
+          true
+        else
+          super
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        case method.to_s
+        when FIND_BY_PATTERN
+          Magic.scope(all, $1, args).first
+        when FIND_ALL_BY_PATTERN
+          Magic.scope(all, $1, args).to_a
+        when FIND_OR_CREATE_BY_PATTERN
+          Magic.find_or_create_by(all, $1, args, &block)
+        when FIND_OR_INITIALIZE_BY_PATTERN
+          Magic.find_or_initialize_by(all, $1, args, &block)
+        else
+          super
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/mass_assignment_security.rb

@@ -0,0 +1,21 @@
+module Cequel
+
+  module Model
+
+    module MassAssignmentSecurity
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::MassAssignmentSecurity
+      end
+
+      def attributes=(attributes)
+        super(sanitize_for_mass_assignment(attributes))
+      end
+
+    end
+    
+  end
+
+end

data/lib/cequel/model/naming.rb

@@ -0,0 +1,17 @@
+module Cequel
+
+  module Model
+
+    module Naming
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveModel::Naming
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/observer.rb

@@ -0,0 +1,42 @@
+module Cequel
+
+  module Model
+
+    # 
+    # This is ripped directly off of ActiveRecord::Observer
+    #
+    class Observer < ActiveModel::Observer
+
+      protected
+
+      def observed_classes
+        klasses = super
+        klasses + klasses.map { |klass| klass.descendants }.flatten
+      end
+
+      def add_observer!(klass)
+        super
+        define_callbacks klass
+      end
+
+      def define_callbacks(klass)
+        observer = self
+        observer_name = observer.class.name.underscore.gsub('/', '__')
+
+        Cequel::Model::Callbacks::CALLBACKS.each do |callback|
+          next unless respond_to?(callback)
+          callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+          unless klass.respond_to?(callback_meth)
+            klass.send(:define_method, callback_meth) do |&block|
+              observer.update(callback, self, &block)
+            end
+            klass.send(callback, callback_meth)
+          end
+        end
+      end
+
+    end
+    
+  end
+
+end

data/lib/cequel/model/persistence.rb

@@ -0,0 +1,173 @@
+module Cequel
+
+  module Model
+
+    module Persistence
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        delegate :update_all, :destroy_all, :delete_all, :to => :all
+
+        def index_preference(*columns)
+          @_cequel.index_preference.concat(columns.map { |c| c.to_sym })
+        end
+
+        def index_preference_columns
+          @_cequel.index_preference
+        end
+
+        def find(*keys)
+          coerce_array = keys.first.is_a?(Array)
+          keys.flatten!
+          if keys.length == 1
+            instance = find_one(keys.first)
+            coerce_array ? [instance] : instance
+          else
+            find_many(keys)
+          end
+        end
+
+        def create(attributes = {}, &block)
+          new(attributes, &block).tap { |instance| instance.save }
+        end
+
+        def column_family_name
+          @_cequel.column_family_name
+        end
+
+        def column_family
+          keyspace[column_family_name]
+        end
+
+        def keyspace
+          Cequel::Model.keyspace
+        end
+
+        def _hydrate(row)
+          type_column_name = @_cequel.type_column.try(:name)
+          if type_column_name && row[type_column_name]
+            clazz = row[type_column_name].constantize
+          else
+            clazz = self
+          end
+          clazz.allocate._hydrate(row.except(:type))
+        end
+
+        private
+        
+        def find_one(key)
+          all.where!(key_alias => key).first.tap do |result|
+            if result.nil?
+              raise RecordNotFound,
+                "Couldn't find #{name} with #{key_alias}=#{key}"
+            end
+          end
+        end
+
+        def find_many(keys)
+          results = all.where!(key_alias => keys).reject do |result|
+            result.attributes.keys == [key_alias.to_s]
+          end
+
+          if results.length < keys.length
+            raise RecordNotFound,
+              "Couldn't find all #{name.pluralize} with #{key_alias} (#{keys.join(', ')})" <<
+                "(found #{results.length} results, but was looking for #{keys.length}"
+          end
+          results
+        end
+
+      end
+
+      def save
+        persisted? ? update : insert
+      end
+
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      end
+
+      def update_attribute(column, value)
+        update_attributes(column => value)
+      end
+
+      def insert
+        raise MissingKey if @_cequel.key.nil?
+        return if @_cequel.attributes.empty?
+        self.class.column_family.insert(attributes)
+        persisted!
+      end
+
+      def update
+        update_attributes, delete_attributes = {}, []
+        changed.each do |attr|
+          new = read_attribute(attr)
+          if new.nil?
+            delete_attributes << attr
+          else
+            update_attributes[attr] = new
+          end
+        end
+        data_set.update(update_attributes) if update_attributes.any?
+        data_set.delete(*delete_attributes) if delete_attributes.any?
+        transient! if @_cequel.attributes.empty?
+      end
+
+      def destroy
+        data_set.delete
+      end
+
+      def reload
+        result = data_set.first
+        key_alias = self.class.key_alias
+        if result.keys == [key_alias.to_s]
+          raise RecordNotFound,
+            "Couldn't find #{self.class.name} with #{key_alias}=#{@_cequel.key}"
+        end
+        _hydrate(result)
+        self
+      end
+
+      def _hydrate(row)
+        @_cequel = InstanceInternals.new(self)
+        tap do
+          key_alias = self.class.key_alias.to_s
+          key_alias = 'KEY' if key_alias.upcase == 'KEY'
+          @_cequel.key = row[key_alias]
+          @_cequel.attributes = row.except(key_alias)
+          persisted!
+        end
+      end
+
+      def persisted!
+        @_cequel.persisted = true
+      end
+
+      def transient!
+        @_cequel.persisted = false
+      end
+
+      def persisted?
+        !!@_cequel.persisted
+      end
+
+      def transient?
+        !persisted?
+      end
+
+      private
+
+      def data_set
+        raise MissingKey if @_cequel.key.nil?
+        self.class.column_family.
+          where(self.class.key_alias => @_cequel.key)
+      end
+
+    end
+
+  end
+
+end