aws-sdk-v1 1.52.0

data/lib/aws/record/model/scope.rb

@@ -0,0 +1,212 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+    class Model
+
+      # The primary interface for finding records with {AWS::Record::Model}.
+      #
+      # ## Getting a Scope Object
+      #
+      # You should normally never need to construct a Scope object directly.
+      # Scope objects are returned from the AWS::Record::Model finder methods
+      # (e.g. `shard`, `where`, `order`, `limit`, etc).
+      #
+      #     books = Book.where(:author => 'John Doe')
+      #     books.class #=> AWS::Record::Scope, not Array
+      #
+      # Scopes are also returned from methods defined with the `scope` method.
+      #
+      # ## Chaining Scopes
+      #
+      # Scope objects represent a request, but do not actualy make a request
+      # until required.  This allows you to chain requests
+      #
+      #     # no request made by the following 2 statements
+      #     books = Book.where(:author => 'John Doe')
+      #     books = books.limit(10)
+      #
+      #     books.each do |book|
+      #       # yields up to 10 books
+      #     end
+      #
+      # Each of the following methods returns a scope that can be chained.
+      #
+      # * {#shard}
+      # * {#where}
+      # * {#order}
+      # * {#limit}
+      #
+      # ## Terminating Scopes
+      #
+      # To terminate a scope you can enumerate it or call #first.
+      #
+      #     # terminate a scope by enumerating
+      #     Book.limit(10).each {|book| ... }
+      #
+      #     # terminate a scope by getting the first value
+      #     Book.where('author' => 'John Doe').first
+      #
+      class Scope < Record::Scope
+
+        # @api private
+        def initialize base_class, options = {}
+          super
+          @options[:where] ||= []
+        end
+
+        def new attributes = {}
+
+          attributes = attributes.dup
+
+          @options[:where].each do |conditions|
+            if conditions.size == 1 and conditions.first.is_a?(Hash)
+              attributes.merge!(conditions.first)
+            end
+          end
+
+          super(attributes)
+
+        end
+
+        # Applies conditions to the scope that limit which records are returned.
+        # Only those matching all given conditions will be returned.
+        #
+        # @overload where(conditions_hash)
+        #   Specify a hash of conditions to query with.  Multiple conditions
+        #   are joined together with AND.
+        #
+        #       Book.where(:author => 'John Doe', :softcover => true)
+        #       # where `author` = `John Doe` AND `softcover` = `1`
+        #
+        #   @param [Hash] conditions
+        #
+        # @overload where(conditions_string, *values)
+        #   A sql-like query fragment with optional placeholders and values.
+        #   Placeholders are replaced with properly quoted values.
+        #
+        #       Book.where('author = ?', 'John Doe')
+        #
+        #   @param [String] conditions_string A sql-like where string with
+        #     question mark placeholders.  For each placeholder there should
+        #     be a value that will be quoted into that position.
+        #   @param [String] *values A value that should be quoted into the
+        #     corresponding (by position) placeholder.
+        #
+        # @return [Scope] Returns a new scope with the passed conditions applied.
+        def where *conditions
+          if conditions.empty?
+            raise ArgumentError, 'missing required condition'
+          end
+          _with(:where => @options[:where] + [conditions])
+        end
+
+        # Specifies how to sort records returned.
+        #
+        #     # enumerate books, starting with the most recently published ones
+        #     Book.order(:published_at, :desc).each do |book|
+        #       # ...
+        #     end
+        #
+        # Only one order may be applied.  If order is specified more than
+        # once the last one in the chain takes precedence:
+        #
+        #     # books returned by this scope will be ordered by :published_at
+        #     # and not :author.
+        #     Book.where(:read => false).order(:author).order(:published_at)
+        #
+        # @param [String,Symbol] attribute_name The attribute to sort by.
+        # @param [:asc, :desc] order (:asc) The direct to sort.
+        def order attribute_name, order = :asc
+          _with(:order => [attribute_name, order])
+        end
+
+        # @api private
+        private
+        def _each_object &block
+
+          items = _item_collection
+
+          items.select.each do |item_data|
+            obj = base_class.new(:shard => _shard)
+            obj.send(:hydrate, item_data.name, item_data.attributes)
+            yield(obj)
+          end
+
+        end
+
+        # Merges another scope with this scope.  Conditions are added together
+        # and the limit and order parts replace those in this scope (if set).
+        # @param [Scope] scope A scope to merge with this one.
+        # @return [Scope] Returns a new scope with merged conditions and
+        #   overriden order and limit.
+        # @api private
+        private
+        def _merge_scope scope
+          merged = self
+          scope.instance_variable_get('@options').each_pair do |opt_name,opt_value|
+            unless [nil, []].include?(opt_value)
+              if opt_name == :where
+                opt_value.each do |condition|
+                  merged = merged.where(*condition)
+                end
+              else
+                merged = merged.send(opt_name, *opt_value)
+              end
+            end
+          end
+          merged
+        end
+
+        # Consumes a hash of options (e.g. `:where`, `:order` and `:limit`) and
+        # builds them onto the current scope, returning a new one.
+        # @param [Hash] options
+        # @option options :where
+        # @option options :order
+        # @option options [Integer] :limit
+        # @return [Scope] Returns a new scope with the hash of scope
+        #   options applied.
+        # @api private
+        private
+        def _handle_options options
+          scope = self
+          options.each_pair do |method, args|
+            if method == :where and args.is_a?(Hash)
+              # splatting a hash turns it into an array, bad juju
+              scope = scope.send(method, args)
+            else
+              scope = scope.send(method, *args)
+            end
+          end
+          scope
+        end
+
+        # Converts this scope object into an AWS::SimpleDB::ItemCollection
+        # @return [SimpleDB::ItemCollection]
+        # @api private
+        private
+        def _item_collection
+          items = base_class.sdb_domain(_shard).items
+          items = items.order(*@options[:order]) if @options[:order]
+          items = items.limit(*@options[:limit]) if @options[:limit]
+          @options[:where].each do |where_condition|
+            items = items.where(*where_condition)
+          end
+          items
+        end
+
+      end
+    end
+  end
+end

data/lib/aws/record/naming.rb

@@ -0,0 +1,31 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+
+    # @api private
+    module Naming
+
+      # This method should only ever get called in a Rails 3+ context
+      # where active model and active support have been loaded.  Rails 2
+      # does not call model name on object.
+      # @api private
+      def model_name
+        @_model_name ||=
+          ActiveModel::Name.new(self.kind_of?(Class) ? self : self.class)
+      end
+
+    end
+  end
+end

data/lib/aws/record/scope.rb

@@ -0,0 +1,203 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+
+    # Base class for {AWS::Record::Model::Scope} and
+    # {AWS::Record::HashModel::Scope}.
+    class Scope
+
+      include Enumerable
+
+      # @param base_class A class that extends {AWS::Record::AbstractBase}.
+      # @param [Hash] options
+      # @option options :
+      # @api private
+      def initialize base_class, options = {}
+
+        @base_class = base_class
+
+        @options = options.dup
+
+        # backwards compat
+        @options[:shard] = @options.delete(:domain) if @options[:domain]
+
+      end
+
+      # @return [Class] Returns the AWS::Record::Model extending class that
+      #   this scope will find records for.
+      attr_reader :base_class
+
+      def new attributes = {}
+
+        attributes = attributes.dup
+        attributes[:shard] ||= attributes.delete(:shard)
+        attributes[:shard] ||= attributes.delete('shard')
+        # for backwards compatability, domain is accepted
+        attributes[:shard] ||= attributes.delete('domain')
+        attributes[:shard] ||= attributes.delete(:domain)
+        attributes[:shard] ||= _shard
+
+        base_class.new(attributes)
+
+      end
+      alias_method :build, :new
+
+      # @param [String] shard_name
+      # @return [Scope] Returns a scope that specifies which shard
+      #   (i.e. SimpleDB domain) should be used.
+      def shard shard_name
+        _with(:shard => shard_name)
+      end
+      alias_method :domain, :shard
+
+      # @overload find(id)
+      #   Finds and returns a single record by id.  If no record is found
+      #   with the given `id`, then a RecordNotFound error will be raised.
+      #   @param [String] id ID of the record to find.
+      #   @return Returns the record.
+      #
+      # @overload find(:first, options = {})
+      #   Returns the first record found.  If no records were matched then
+      #   nil will be returned (raises no exceptions).
+      #   @param [Symbol] mode (:first)
+      #   @return [Object,nil] Returns the first record or nil if no
+      #     records matched the conditions.
+      #
+      # @overload find(:all, options = {})
+      #   Returns an enumerable Scope object that represents all matching
+      #   records.  No request is made to AWS until the scope is enumerated.
+      #
+      #       Book.find(:all, :limit => 100).each do |book|
+      #         # ...
+      #       end
+      #
+      #   @param [Symbol] mode (:all)
+      #   @return [Scope] Returns an enumerable scope object.
+      #
+      def find id_or_mode, options = {}
+
+        scope = _handle_options(options)
+
+        case
+        when id_or_mode == :all   then scope
+        when id_or_mode == :first then scope.limit(1).to_a.first
+        else
+          base_class.find_by_id(id_or_mode, :shard => scope._shard)
+        end
+
+      end
+
+      # @return [Integer] Returns the number of records that match the
+      #   current scoped finder.
+      def count options = {}
+        if scope = _handle_options(options) and scope != self
+          scope.count
+        else
+          _item_collection.count
+        end
+      end
+      alias_method :size, :count
+
+      # @return Returns the first record found, returns
+      #   nil if the domain/table is empty.
+      def first options = {}
+        _handle_options(options).find(:first)
+      end
+
+      # Limits the maximum number of total records to return when finding
+      # or counting.  Returns a scope, does not make a request.
+      #
+      # @example
+      #
+      #   books = Book.limit(100)
+      #
+      # @param [Integer] limit The maximum number of records to return.
+      # @return [Scope] Returns a new scope that has the applied limit.
+      def limit limit
+        _with(:limit => limit)
+      end
+
+      # Yields once for each record matching the request made by this scope.
+      #
+      # @example
+      #
+      #   books = Book.where(:author => 'me').order(:price, :asc).limit(10)
+      #
+      #   books.each do |book|
+      #     puts book.attributes.to_yaml
+      #   end
+      #
+      # @yieldparam [Object] record
+      def each &block
+        if block_given?
+          _each_object(&block)
+        else
+          to_enum(:"_each_object")
+        end
+      end
+
+      protected
+      def _shard
+        @options[:shard] || base_class.shard_name
+      end
+      alias_method :domain, :shard
+
+      # @api private
+      private
+      def _each_object &block
+        raise NotImplementedError
+      end
+
+      # @api private
+      private
+      def _with options
+        self.class.new(base_class, @options.merge(options))
+      end
+
+      # @api private
+      private
+      def method_missing scope_name, *args
+        # @todo only proxy named scope methods
+        _merge_scope(base_class.send(scope_name, *args))
+      end
+
+      # Merges the one scope with the current scope, returning a 3rd.
+      # @param [Scope] scope
+      # @return [Scope]
+      # @api private
+      private
+      def _merge_scope scope
+        raise NotImplementedError
+      end
+
+      # Consumes a hash of options (e.g. `:shard`, +:limit) and returns
+      # a new scope with those applied.
+      # @return [Scope]
+      # @api private
+      private
+      def _handle_options options
+        raise NotImplementedError
+      end
+
+      # @api private
+      private
+      def _item_collection
+        raise NotImplementedError
+      end
+
+    end
+
+  end
+end

data/lib/aws/record/validations.rb

@@ -0,0 +1,694 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module AWS
+  module Record
+
+    # Validation methods to be used with subclasses of AWS::Record::Model.
+    #
+    # # General Usage
+    #
+    # All standard validation methods follow the same basic usage.
+    # Call the validation method followed by one more attribute names
+    # and then an optional hash of modifiers.
+    #
+    #       class Book < AWS::Record::Model
+    #
+    #       # ...
+    #
+    #       validates_presence_of :title, :author
+    #
+    #       validates_length_of :summary,
+    #         :max => 500,
+    #         :allow_nil => true,
+    #         :allow_blank => true
+    #
+    #     end
+    #
+    # # Conditional Validations
+    #
+    # Sometimes you only want to validate an attribute under certain
+    # conditions.  To make this simple, all validation methods accept the
+    # following 3 options:
+    #
+    # * `:on`
+    # * `:if`
+    # * `:unless`
+    #
+    # You may mix and match all 3 of the above options.
+    #
+    # ### Validate on :create or :update
+    #
+    # By default validations are run on create and update, but you can
+    # specify them to run for only create (initial save) or updates.
+    #
+    #     validates_presence_of :created_at, :on => :create
+    #
+    #     validates_presence_of :updated_at, :on => :update
+    #
+    # ### Validate :if or :unless
+    #
+    # Sometimes you have more complex requirements to determine if/when a
+    # validation should run.  `:if` and `:unless`: both accept either
+    # a method name or proc.
+    #
+    #     class Person
+    #
+    #       # ...
+    #
+    #       validates_presence_of :job_title, :if => :employee?
+    #
+    #       validates_presence_of :nickname, :if => lambda {|person|
+    #         person.is_family? or person.is_friend? }
+    #
+    #     end
+    #
+    # # Validating Virtual (Non-persisted) Attributes
+    #
+    # All of the validators can be used with configured attributes, but they
+    # can also be used with any attribute that has a setter and a getter.
+    #
+    #     Class Book < AWS::Record::Model
+    #       attr_accessor :title
+    #       validates_presence_of :title
+    #     end
+    #
+    module Validations
+
+      def self.extended base
+
+        base.send(:define_method, :run_validations) do
+          errors.clear!
+          self.class.send(:validators).each do |validator|
+            validator.validate(self)
+          end
+        end
+
+        base.send(:private, :run_validations)
+
+      end
+
+      # Registers a validation method.
+      #
+      #     validate :ensure_age_is_greater_than_shoe_size
+      #
+      #     def ensure_age_is_greater_than_shoe_size
+      #       unless age > shoe_size
+      #         errors.add(:age, 'should be greater than your shoe size')
+      #       end
+      #     end
+      #
+      # You can also pass a list of method names that should be called during
+      # validation.
+      #
+      #     validate :some_complex_validation, :some_other_validation
+      #
+      # As with most other validation methods you can also pass a hash of
+      # options that affect when the named validation methods get called.
+      #
+      #     validate :my_custom_validation, :unless => :new_record?
+      #
+      # @overload validate(*method_names, options = {})
+      #   @param [Array<Symbol>] method_names A list of methods to call
+      #     during validation.
+      #   @param [Hash] options
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validate *args
+        validators << MethodValidator.new(self, *args)
+      end
+
+      # This validation method is primariliy intended for ensuring a form
+      # checkbox (like an EULA agreement or terms of service acknowledgement)
+      # is checked.
+      #
+      #     class User < AWS::Record::Model
+      #       boolean_attr :terms_of_service
+      #       validates_acceptance_of :terms_of_service
+      #     end
+      #
+      # ### Virtual Attributes
+      #
+      # If you choose to validate the acceptance of a non-existant attribute
+      # then a setter and a getter will be added automtically for you.
+      #
+      #     class User < AWS::Record::Model
+      #       validates_acceptance_of :terms_of_service
+      #     end
+      #
+      #     user = User.new
+      #     user.respond_to?(:terms_of_service)  #=> true
+      #     user.respond_to?(:terms_of_service=) #=> true
+      #
+      # ### Accepted Values
+      #
+      # The default behavior for `validates_acceptance_of` is to add
+      # an error when the value is '1' or `true`.  Also note, this validation
+      # method defaults `:allow_nil` to true.
+      #
+      # * `nil` implies the field was omitted from the form and therefore
+      #   should not be validated
+      #
+      #       class User < AWS::Record::Model
+      #         validates_acceptance_of :terms_of_service
+      #       end
+      #
+      #       u = User.new
+      #       u.terms_of_service #=> nil
+      #       u.valid?           #=> true
+      #
+      # * '1' is the default value for most checkbox form helpers, and #
+      #   therefore indicates an accepted value.
+      #
+      # * `true` is how boolean attributes typecast '1'. This is helpful
+      #   when you have your checkbox post its value to a `:boolean_attr`.
+      #
+      # ### Multi-Valued Attributes
+      #
+      # This validator works only with single-valued attributes.  If you need
+      # to validate that all of the values in a set are true, then use
+      # {#validates_inclusion_of}.
+      #
+      # @note Most validators default :allow_nil to false, this one defaults to true
+      # @note This validator should not be used with multi-valued attributes
+      #
+      # @overload validates_acceptance_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [mixed] :accpet Specify an additional accepted value.
+      #
+      #         validates_acceptance_of :agree, :accept => 'yes'
+      #
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "must be accepted".
+      #   @option options [Boolean] :allow_nil (true) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (true) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_acceptance_of *args
+        validators << AcceptanceValidator.new(self, *args)
+      end
+
+      # Intended primarily for validating a form field was entered correctly
+      # by requiring it twice:
+      #
+      #     Model:
+      #       class User < AWS::Record::Model
+      #         validates_confirmation_of :password, :if => :password_changed?
+      #       end
+      #
+      #     View:
+      #       <%= password_field "user", "password" %>
+      #       <%= password_field "user", "password_confirmation" %>
+      #
+      # ### Confirmation Value Accessors
+      #
+      # If your model does not have accessors for the confirmation value
+      # then they will be automatically added.  In the example above
+      # the user class would have an `attr_accessor` for
+      # `:password_confirmation`.
+      #
+      # ### Conditional Validation
+      #
+      # Mostly commonly you only need to validate confirmation of an
+      # attribute when it has changed.  It is therefore suggested to
+      # pass an `:if` condition reflecting this:
+      #
+      #     validates_confirmation_of :password, :if => :password_changed?
+      #
+      # ### Multi-Valued Attributes
+      #
+      # This validator works only with single-valued attributes.
+      # It should not be used on attributes that have array or set values.
+      #
+      # @note This validation method does not accept the `:allow_nil` or the
+      # `:allow_blank` options.
+      #
+      # @overload validates_confirmation_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "doesn't match confirmation".
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_confirmation_of *args
+        validators << ConfirmationValidator.new(self, *args)
+      end
+
+      # Validates the number of values for a given attribute.
+      #
+      # ### Length vs Count
+      #
+      # `validates_count_of` validates the number of attribute values,
+      # whereas +validates_length_of: validates the length of each
+      # attribute value instead.
+      #
+      # If you need to ensure each attribute value is a given length see
+      # {#validates_length_of} instead.
+      #
+      # ### Examples
+      #
+      # You can validate there are a certain number of values:
+      #
+      #     validates_count_of :parents, :exactly => 2
+      #
+      # You can also specify a range:
+      #
+      #     validates_count_of :tags, :within => (2..10)
+      #
+      # You can also specify min and max value seperately:
+      #
+      #     validates_count_of :tags, :minimum => 2, :maximum => 10
+      #
+      # ### `nil` Values
+      #
+      # If you are validating an array or set that contains `nil` values,
+      # the `nil` values are counted normally as 1 each.
+      #
+      # If you are validating a non-enuemrable attribute that only
+      # contains a single nil or other scalar value, then nil is
+      # counted as 0.
+      #
+      # ### Singular Attributes
+      #
+      # This validator is intended to for validating attributes that have
+      # an array or set of values.  If used on an attribute that
+      # returns a scalar value (like `nil` or a string), the count will
+      # always be 0 (for `nil`) or 1 (for everything else).
+      #
+      # It is therefore recomended to use `:validates_presence_of` in
+      # place of `:validates_count_of` when working with single-valued
+      # attributes.
+      #
+      # @overload validates_count_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [Integer] :exactly The exact number of values the
+      #     attribute should have.  If this validation option fails the
+      #     error message specified by `:wrong_number` will be added.
+      #   @option options [Range] :within An range of number of values to
+      #     accept.  If the attribute has a number of values outside this range
+      #     then the `:too_many` or `:too_few` error message will be added.
+      #   @option options [Integer] :minimum The minimum number of values
+      #     the attribute should have.  If it has fewer, the `:too_few` error
+      #     message will be added.
+      #   @option options [Integer] :maximum The maximum number of values
+      #     the attribute should have.  If it has more, the `:too_many` error
+      #     message will be added.
+      #   @option options [String] :too_many An error message added
+      #     when the attribute has too many values.  Defaults to
+      #     <code>"has too many values (maximum is %{maximum})"</code>
+      #   @option options [String] :too_few An error message added
+      #     when the attribute has too few values.  Defaults to
+      #     <code>"has too few values (minimum is %{minimum})"</code>
+      #   @option options [String] :wrong_number An error message
+      #     added when the number of attribute values does not match
+      #     the `:exactly` option.  Defaults to <code>"has the wrong
+      #     number of values (should have exactly %{exactly}"</code>
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_count_of *args
+        validators << CountValidator.new(self, *args)
+      end
+
+      # Adds a block validator that is called during record validation.
+      #
+      #     class ExampleClass < AWS::Record::Model
+      #
+      #       string_attr :name
+      #
+      #       validates_each(:name) do |record, attribute_name, value|
+      #         if value == 'John Doe'
+      #           record.errors.add(attr_name, 'may not be an alias')
+      #         end
+      #       end
+      #
+      #     end
+      #
+      # @overload validates_each(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_each *attributes, &block
+        unless block_given?
+          raise ArgumentError, 'missing required block for validates_each'
+        end
+        validators << BlockValidator.new(self, *attributes, &block)
+      end
+
+      # Validates that the attribute value is not included in the given
+      # enumerable.
+      #
+      #     validates_exlusion_of :username, :in => %w(admin administrator)
+      #
+      # ### Multi-Valued Attributes
+      #
+      # You may use this with multi-valued attributes the same way you use it
+      # with single-valued attributes:
+      #
+      #     class Product < AWS::Record::Model
+      #       string_attr :tags, :set => true
+      #       validates_exlusion_of :tags, :in => four_letter_words
+      #     end
+      #
+      # @overload validates_exclusion_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [required, Enumerable] :in An enumerable object to
+      #     ensure the value is not in.
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "is reserved".
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_exclusion_of *args
+        validators << ExclusionValidator.new(self, *args)
+      end
+
+      # Validates the attribute's value matches the given regular exression.
+      #
+      #     validates_format_of :year, :with => /^\d{4}$/
+      #
+      # You can also perform a not-match using `:without` instead of `:with`.
+      #
+      #     validates_format_of :username, :without => /\d/
+      #
+      # ### Multi-Valued Attributes
+      #
+      # You may use this with multi-valued attributes the same way you use it
+      # with single-valued attributes:
+      #
+      #     class Product < AWS::Record::Model
+      #       string_attr :tags, :set => true
+      #       validates_format_of :tags, :with => /^\w{2,10}$/
+      #     end
+      #
+      # @overload validates_format_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [Regexp] :with If the value matches the given
+      #     regex, an error will not be added.
+      #   @option options [Regexp] :without If the value matches the given
+      #     regex, an error will be added.
+      #     must match, or an error is added.
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "is reserved".
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_format_of *args
+        validators << FormatValidator.new(self, *args)
+      end
+
+      # Validates that the attribute value is included in the given enumerable
+      # object.
+      #
+      #     class MultipleChoiceAnswer < AWS::Record::Model
+      #       validates_inclusion_of :letter, :in => %w(a b c d e)
+      #     end
+      #
+      # ### Multi-Valued Attributes
+      #
+      # You may use this with multi-valued attributes the same way you use it
+      # with single-valued attributes.
+      #
+      # @overload validates_inclusion_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [required, Enumerable] :in An enumerable object to
+      #     check for the value in.
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "is not included in the list".
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_inclusion_of *attributes
+        validators << InclusionValidator.new(self, *attributes)
+      end
+
+      # Validates the attribute values are of a specified length.
+      #
+      #     validates_lenth_of :username, :within => 3..25
+      #
+      # ### Length vs Count
+      #
+      # `validates_length_of` validates the length of individual attribute
+      # values, whereas +validates_count_of: validates the number of
+      # attribute values.
+      #
+      # If you need to ensure there are certain number of values see
+      # {#validates_count_of} instead.
+      #
+      # @overload validates_length_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [Enumerable] :within An enumerable object to
+      #     ensure the length of the value falls within.
+      #   @option options [Integer] :exactly The exact length a value must be.
+      #     If this validation fails the error message specified by
+      #     `:wrong_length` will be added.
+      #   @option options [Range] :within An enumerable object which must
+      #     include the length of the attribute, or an error will be added.
+      #     If the attribute has a length outside the range then the
+      #     `:too_long` or `:too_short` error message will be added.
+      #   @option options [Integer] :minimum The minimum length an attribute
+      #     value should be.  If it is shorter, the `:too_short` error
+      #     message will be added.
+      #   @option options [Integer] :maximum The maximum length an attribute
+      #     value should be.  If it is longer, the `:too_long` error
+      #     message will be added.
+      #   @option options [String] :too_long An error message added
+      #     when the attribute value is too long. Defaults to
+      #     <code>"is too long (maximum is %{maximum}
+      #     characters)"</code>
+      #   @option options [String] :too_short An error message added
+      #     when the attribute value is too short. Defaults to
+      #     <code>"is too short (minimum is %{minimum}
+      #     characters)"</code>
+      #   @option options [String] :wrong_length An error message
+      #     added when the attribute has the incorrect length (as
+      #     specified by `:exactly`).  Defaults to <code>"is the wrong
+      #     length (should be %{exactly} characters"</code>
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_length_of *args
+        validators << LengthValidator.new(self, *args)
+      end
+
+      # Validates the attribute has a numeric value.
+      #
+      #     validates_numericality_of :age, :only_integer => true
+      #
+      # ### Multi-Valued Attributes
+      #
+      # You can validate multi-valued attributes using this the same way you
+      # validate single-valued attributes. Each value will be validated
+      # individually.
+      #
+      # @overload validates_numericality_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [Boolean] :only_integer (false) Adds an error
+      #     when valiating and the value is numeric, but it not a whole number.
+      #   @option options [Integer] :equal_to When set the value must equal
+      #     the given value exactly.  May not be used with the greater/less
+      #     options.
+      #   @option options [Numeric] :greater_than Ensures the attribute
+      #     is greater than the given number.
+      #   @option options [Integer] :greater_than_or_equal_to Ensures the
+      #     attribute is greater than or equal to the given number.
+      #   @option options [Numeric] :less_than Ensures the attribute is less
+      #     than the given value.
+      #   @option options [Integer] :less_than_or_equal_to Ensures the value is
+      #     less than or equal to the given number.
+      #   @option options [Numeric] :even If true, the value may only be
+      #     an even integer.  This forces the `:only_integer` to `true`.
+      #   @option options [Numeric] :odd If true, the value may only be
+      #     an odd integer.  This forces the `:only_integer` to `true`.
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "is not a number".
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_numericality_of *args
+        validators << NumericalityValidator.new(self, *args)
+      end
+
+      # Validates the named attributes are not blank. For validation
+      # purposes, blank values include:
+      #
+      # * `nil`
+      # * empty string
+      # * anything that responds to #empty? with true
+      # * anything that responds to #blank? with true
+      #
+      # @overload validates_presence_of(*attributes, options = {}, &block)
+      #   @param attributes A list of attribute names to validate.
+      #   @param [Hash] options
+      #   @option options [String] :message A custom error message.  The default
+      #     `:message` is "may not be blank".
+      #   @option options [Symbol] :on (:save) When this validation is run.
+      #     Valid values include:
+      #     * `:save`
+      #     * `:create`
+      #     * `:update`
+      #   @option options [Boolean] :allow_nil (false) Skip validation if the
+      #     attribute value is `nil`.
+      #   @option options [Boolean] :allow_blank (false) Skip validation if the
+      #     attribute value is `blank`.
+      #   @option options [Symbol,String,Proc] :if Specifies a method or proc
+      #     to call.  The validation will only be run if the return value is
+      #     of the method/proc is true (e.g. `:if => :name_changed?` or
+      #     `:if => lambda{|book| book.in_stock? }`).
+      #   @option options [Symbol,String,Proc] :unless Specifies a method or
+      #     proc to call.  The validation will *not* be run if the return value
+      #     is of the method/proc is false.
+      def validates_presence_of *args
+        validators << PresenceValidator.new(self, *args)
+      end
+
+      # @api private
+      private
+      def validators
+        @validators ||= []
+      end
+
+    end
+  end
+end