cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/model/mass_assignment.rb

@@ -0,0 +1,31 @@
+begin
+  require 'active_model/forbidden_attributes_protection'
+rescue LoadError
+  require 'active_model/mass_assignment_security'
+end
+
+module Cequel
+
+  module Model
+
+    module MassAssignment
+
+      extend ActiveSupport::Concern
+
+      included do
+        if defined? ActiveModel::ForbiddenAttributesProtection
+          include ActiveModel::ForbiddenAttributesProtection
+        else
+          include ActiveModel::MassAssignmentSecurity
+        end
+      end
+
+      def attributes=(attributes)
+        super(sanitize_for_mass_assignment(attributes))
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/persistence.rb

@@ -8,170 +8,174 @@ module Cequel
 
       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 }
+          new(attributes, &block).tap { |record| record.save }
         end
 
-        def column_family_name
-          @_cequel.column_family_name
+        def hydrate(row)
+          new_empty { hydrate(row) }
         end
 
-        def column_family_name=(name)
-          @_cequel.column_family_name = name
-        end
+      end
 
-        def column_family
-          keyspace[column_family_name]
-        end
+      def key_attributes
+        @attributes.slice(*self.class.key_column_names)
+      end
 
-        def keyspace
-          Cequel::Model.keyspace
-        end
+      def key_values
+        key_attributes.values
+      end
+
+      def exists?
+        load!
+        true
+      rescue Cequel::Model::RecordNotFound
+        false
+      end
+      alias :exist? :exists?
 
-        def with_consistency(consistency, &block)
-          keyspace.with_consistency(consistency, &block)
+      def load
+        unless loaded?
+          row = metal_scope.first
+          hydrate(row) unless row.nil?
+          collection_proxies.each_value { |collection| collection.loaded! }
         end
+        self
+      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
+      def load!
+        load.tap do
+          if transient?
+            raise Cequel::Model::RecordNotFound,
+              "Couldn't find #{self.class.name} with #{key_attributes.inspect}"
           end
-          clazz.allocate._hydrate(row.except(:type))
         end
+      end
 
-        private
+      def loaded?(column = nil)
+        !!@loaded && (column.nil? || @attributes.key?(column.to_sym))
+      end
 
-        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
+      def save(options = {})
+        options.assert_valid_keys
+        if new_record? then create
+        else update
         end
+        @new_record = false
+        true
+      end
 
-        def find_many(keys)
-          results = all.where!(key_alias => keys).reject do |result|
-            result.attributes.keys == [key_alias.to_s]
-          end
+      def update_attributes(attributes)
+        self.attributes = attributes
+        save
+      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
+      def destroy
+        metal_scope.delete
+        transient!
+        self
+      end
 
+      def new_record?
+        !!@new_record
       end
 
-      def save
-        persisted? ? update : insert
+      def persisted?
+        !!@persisted
       end
 
-      def update_attributes(attributes)
-        self.attributes = attributes
-        save
+      def transient?
+        !persisted?
       end
 
-      def update_attribute(column, value)
-        update_attributes(column => value)
+      protected
+
+      def persisted!
+        @persisted = true
       end
 
-      def insert
-        raise MissingKey if @_cequel.key.nil?
-        return if @_cequel.attributes.empty?
-        self.class.column_family.insert(attributes)
+      def transient!
+        @persisted = false
+      end
+
+      def create
+        inserter.execute
+        loaded!
         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
+        connection.batch do
+          updater.execute
+          deleter.execute
+          @updater, @deleter = nil
         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
+      def inserter
+        @inserter ||= metal_scope.inserter
       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
+      def updater
+        @updater ||= metal_scope.updater
+      end
+
+      def deleter
+        @deleter ||= metal_scope.deleter
       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!
+      private
+
+      def read_attribute(attribute)
+        super
+      rescue MissingAttributeError
+        load
+        super
+      end
+
+      def write_attribute(attribute, value)
+        super.tap do
+          if !persisted?
+            inserter.insert(attribute => value) unless value.nil?
+          elsif !self.class.key_column_names.include?(attribute.to_sym)
+            if value.nil?
+              deleter.delete_columns(attribute)
+            else
+              updater.set(attribute => value)
+            end
+          end
         end
       end
 
-      def persisted!
-        @_cequel.persisted = true
+      def hydrate(row)
+        @attributes = row
+        loaded!
+        persisted!
+        self
       end
 
-      def transient!
-        @_cequel.persisted = false
+      def loaded!
+        @loaded = true
+        collection_proxies.each_value { |collection| collection.loaded! }
       end
 
-      def persisted?
-        !!@_cequel.persisted
+      def metal_scope
+        connection[table_name].
+          where(key_attributes)
       end
 
-      def transient?
-        !persisted?
+      def attributes_for_create
+        @attributes.each_with_object({}) do |(column, value), attributes|
+          attributes[column] = value unless value.nil?
+        end
       end
 
-      private
+      def attributes_for_update
+        @attributes_for_update ||= {}
+      end
 
-      def data_set
-        raise MissingKey if @_cequel.key.nil?
-        self.class.column_family.
-          where(self.class.key_alias => @_cequel.key)
+      def attributes_for_deletion
+        @attributes_for_deletion ||= []
       end
 
     end

data/lib/cequel/model/properties.rb

@@ -6,134 +6,136 @@ module Cequel
 
       extend ActiveSupport::Concern
 
-      included do
-        include ActiveModel::Conversion
-      end
-
       module ClassMethods
 
-        def key(key_alias, type)
-          key_alias = key_alias.to_sym
-          @_cequel.key = Column.new(key_alias, type)
+        protected
 
-          module_eval(<<-RUBY, __FILE__, __LINE__+1)
-            def #{key_alias}
-              @_cequel.key
-            end
+        def key(name, type)
+          def_accessors(name)
+          table_schema.add_key(name, type)
+          set_attribute_default(name, nil)
+        end
 
-            def #{key_alias}=(key)
-              @_cequel.key = key
-            end
+        def column(name, type, options = {})
+          def_accessors(name)
+          table_schema.add_data_column(name, type, options[:index])
+          set_attribute_default(name, options[:default])
+        end
 
-            def to_key
-              [@_cequel.key]
-            end
-          RUBY
+        def list(name, type, options = {})
+          def_collection_accessors(name, List)
+          table_schema.add_list(name, type)
+          set_attribute_default(name, options.fetch(:default, []))
         end
 
-        def column(name, type, options = {})
-          name = name.to_sym
-          @_cequel.add_column(name, type, options.symbolize_keys)
+        def set(name, type, options = {})
+          def_collection_accessors(name, Set)
+          table_schema.add_set(name, type)
+          set_attribute_default(name, options.fetch(:default, ::Set[]))
+        end
 
-          module_eval <<-RUBY, __FILE__, __LINE__+1
-            def #{name}
-              read_attribute(#{name.inspect})
-            end
+        def map(name, key_type, value_type, options = {})
+          def_collection_accessors(name, Map)
+          table_schema.add_map(name, key_type, value_type)
+          set_attribute_default(name, options.fetch(:default, {}))
+        end
 
-            def #{name}=(value)
-              write_attribute(#{name.inspect}, value)
-            end
-          RUBY
+        def table_property(name, value)
+          table_schema.add_property(name, value)
+        end
 
-          if type == :boolean
-            module_eval <<-RUBY, __FILE__, __LINE__+1 if type == :boolean
-              def #{name}?
-                !!read_attribute(#{name.inspect})
-              end
-            RUBY
-          end
+        private
+
+        def def_accessors(name)
+          name = name.to_sym
+          def_reader(name)
+          def_writer(name)
         end
 
-        def key_alias
-          key_column.name
+        def def_reader(name)
+          module_eval <<-RUBY
+            def #{name}; read_attribute(#{name.inspect}); end
+          RUBY
         end
 
-        def key_column
-          @_cequel.key
+        def def_writer(name)
+          module_eval <<-RUBY
+            def #{name}=(value); write_attribute(#{name.inspect}, value); end
+          RUBY
         end
 
-        def column_names
-          [@_cequel.key.name, *@_cequel.columns.keys]
+        def def_collection_accessors(name, collection_proxy_class)
+          def_collection_reader(name, collection_proxy_class)
+          def_collection_writer(name)
         end
 
-        def columns
-          [@_cequel.key, *@_cequel.columns.values]
+        def def_collection_reader(name, collection_proxy_class)
+          module_eval <<-RUBY
+            def #{name}
+              proxy_collection(#{name.inspect}, #{collection_proxy_class})
+            end
+          RUBY
+        end
+
+        def def_collection_writer(name)
+          module_eval <<-RUBY
+            def #{name}=(value)
+              reset_collection_proxy(#{name.inspect})
+              write_attribute(#{name.inspect}, value)
+            end
+          RUBY
         end
 
-        def type_column
-          @_cequel.type_column
+        def set_attribute_default(name, default)
+          default_attributes[name.to_sym] = default
         end
 
       end
 
-      def initialize(attributes = {})
-        super()
-        @_cequel.key = generate_key
-        self.class.columns.each do |column|
-          default = column.default
-          @_cequel.attributes[column.name] = default unless default.nil?
-        end
-        self.attributes = attributes
-        yield self if block_given?
+      def attribute_names
+        @attributes.keys
       end
 
       def attributes
-        {self.class.key_alias => @_cequel.key}.with_indifferent_access.
-          merge(@_cequel.attributes)
+        attribute_names.each_with_object({}) do |name, attributes|
+          attributes[name] = read_attribute(name)
+        end
       end
 
       def attributes=(attributes)
-        attributes.each_pair do |column_name, value|
-          __send__("#{column_name}=", value)
+        attributes.each_pair do |attribute, value|
+          __send__(:"#{attribute}=", value)
         end
       end
 
-      def ==(other)
-        return false if self.class != other.class
-        self_key = self.__send__(self.class.key_column.name)
-        other_key = other.__send__(self.class.key_column.name)
-        self_key && other_key && self_key == other_key
-      end
+      protected
+      delegate :table_schema, :to => 'self.class'
 
-      def inspect
-        "#<#{self.class.name}".tap do |inspected|
-          attributes.each_pair do |column, value|
-            inspected_value =
-              case value
-              when CassandraCQL::UUID then value.to_guid
-              else value.inspect
-              end
-            inspected << " #{column}:#{inspected_value}"
-          end
+      def read_attribute(name)
+        @attributes.fetch(name)
+      rescue KeyError
+        if table_schema.column(name)
+          raise MissingAttributeError, "missing attribute: #{name}"
+        else
+          raise UnknownAttributeError, "unknown attribute: #{name}"
         end
       end
 
-      private
-
-      def write_attribute(column_name, value)
-        if value.nil?
-          @_cequel.attributes.delete(column_name)
-        else
-          @_cequel.attributes[column_name] = value
-        end
+      def write_attribute(name, value)
+        column = table_schema.column(name)
+        raise UnknownAttributeError,
+          "unknown attribute: #{name}" unless column
+        @attributes[name] = value.nil? ? nil : column.cast(value)
       end
 
-      def read_attribute(column_name)
-        @_cequel.attributes[column_name.to_sym]
+      private
+
+      def proxy_collection(name, proxy_class)
+        collection_proxies[name] ||= proxy_class.new(self, name)
       end
 
-      def generate_key
-        # Noop -- model classes can override if desired
+      def reset_collection_proxy(name)
+        collection_proxies.delete(name)
       end
 
     end