cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/model/dynamic.rb

@@ -1,31 +0,0 @@
-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/inheritable.rb

@@ -1,48 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

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

data/lib/cequel/model/observer.rb

@@ -1,42 +0,0 @@
-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/readable_dictionary.rb

@@ -1,182 +0,0 @@
-module Cequel
-
-  module Model
-
-    class ReadableDictionary
-
-      class <<self
-
-        attr_writer :column_family, :default_batch_size
-
-        def key_alias
-          @key_alias ||= :KEY
-        end
-
-        def key_type
-          @key_type ||= :text
-        end
-
-        def comparator
-          @comparator ||= :text
-        end
-
-        def validation
-          :counter
-        end
-
-        def key(key_alias, type)
-          @key_alias, @key_type = key_alias, type
-
-          module_eval(<<-RUBY)
-          def #{key_alias.downcase}
-            @key
-          end
-          RUBY
-        end
-
-        def columns(comparator)
-          @comparator = comparator
-        end
-
-        def column_family
-          return @column_family if @column_family
-          self.column_family_name = name.underscore.to_sym
-          @column_family
-        end
-
-        def column_family_name=(column_family_name)
-          self.column_family = Cequel::Model.keyspace[column_family_name]
-        end
-
-        def default_batch_size
-          @default_batch_size || 1000
-        end
-
-        def [](key)
-          new(key)
-        end
-        private :new
-
-        def load(*keys)
-          keys.flatten!
-          column_family.
-            where(key_alias.to_s => keys).
-            map { |row| new(row.delete(key_alias.to_s), row) }
-        end
-
-      end
-
-      include Enumerable
-
-      def initialize(key, row = nil)
-        @key = key
-        setup(row)
-      end
-
-      def [](column)
-        if @loaded
-          @row[column]
-        else
-          scope.select(column).first[column]
-        end
-      end
-
-      def keys
-        @loaded ? @row.keys : each_pair.map { |key, value| key }
-      end
-
-      def values
-        @loaded ? @row.values : each_pair.map { |key, value| value }
-      end
-
-      def slice(*columns)
-        if @loaded
-          @row.slice(*columns)
-        else
-          deserialize_row(load_raw_slice(columns))
-        end
-      end
-
-      def first
-        @loaded ?  @row.first : slice(:first => 1).first
-      end
-
-      def last
-        if @loaded
-          unless @row.empty?
-            key = @row.keys.last
-            [key, @row[key]]
-          end
-        else
-          slice(:last => 1).first
-        end
-      end
-
-      def key?(column)
-        @row.key?(column) || load_raw_slice([column])[column].present?
-      end
-
-      def each_pair(options = {}, &block)
-        return Enumerator.new(self, :each_pair, options) unless block
-        return @row.each_pair(&block) if @loaded
-        batch_size = options[:batch_size] || self.class.default_batch_size
-        each_slice(batch_size) do |batch_results|
-          batch_results.each_pair(&block)
-        end
-      end
-
-      def each(&block)
-        each_pair(&block)
-      end
-
-      def each_slice(batch_size)
-        batch_scope = scope.select(:first => batch_size)
-        key_alias = self.class.key_alias
-        last_key = nil
-        begin
-          batch_results = batch_scope.first
-          batch_results.delete(key_alias)
-          result_length = batch_results.length
-          batch_results.delete(last_key) unless last_key.nil?
-          yield deserialize_row(batch_results)
-          last_key = batch_results.keys.last
-          batch_scope = batch_scope.select(:from => last_key)
-        end while result_length == batch_size
-      end
-
-      def load
-        return self if @loaded
-        @row = {}
-        each_pair { |column, value| @row[column] = value }
-        @loaded = true
-        self
-      end
-
-      def loaded?
-        !!@loaded
-      end
-
-      private
-
-      def setup(init_row = nil)
-        @row = deserialize_row(init_row || {})
-        @loaded = !!init_row
-      end
-
-      def scope
-        self.class.column_family.where(self.class.key_alias => @key)
-      end
-
-      def load_raw_slice(columns)
-        row = scope.select(*columns).first.except(self.class.key_alias)
-      end
-
-      def deserialize_row(row)
-        row
-      end
-
-    end
-
-  end
-
-end