poncho 0.0.2

data/lib/poncho/returns.rb

@@ -0,0 +1,25 @@
+module Poncho
+  module Returns
+    class InvalidReturn < ServerError
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def returns(*resources)
+        @returns = resources if resources.any?
+        @returns ||= []
+      end
+    end
+
+    def body(value = nil)
+      if value && success? && self.class.returns.none? {|res| value.is_a?(res) }
+        raise InvalidReturn, "Invalid body: #{value}"
+      end
+
+      super
+    end
+  end
+end

data/lib/poncho/validations.rb

@@ -0,0 +1,198 @@
+module Poncho
+  # == Poncho Validations
+  #
+  # Provides a full validation framework to your objects.
+  #
+  # A minimal implementation could be:
+  #
+  #   class Person
+  #     include Poncho::Validations
+  #
+  #     attr_accessor :first_name, :last_name
+  #
+  #     validates_each :first_name, :last_name do |record, attr, value|
+  #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+  #     end
+  #   end
+  #
+  # Which provides you with the full standard validation stack that you
+  # know from Active Record:
+  #
+  #   person = Person.new
+  #   person.valid?                   # => true
+  #   person.invalid?                 # => false
+  #
+  #   person.first_name = 'zoolander'
+  #   person.valid?                   # => false
+  #   person.invalid?                 # => true
+  #   person.errors                   # => #<OrderedHash {:first_name=>["starts with z."]}>
+  #
+  # Note that <tt>Poncho::Validations</tt> automatically adds an +errors+ method
+  # to your instances initialized with a new <tt>Poncho::Errors</tt> object, so
+  # there is no need for you to do this manually.
+  #
+  module Validations
+    def self.included(base)
+      base.extend ClassMethods
+      base.extend HelperMethods
+    end
+
+    module HelperMethods
+    end
+
+    module ClassMethods
+
+      VALIDATES_DEFAULT_KEYS = [:if, :unless, :on, :allow_blank, :allow_nil , :strict]
+
+      # Validates each attribute against a block.
+      #
+      #   class Person
+      #     include Poncho::Validations
+      #
+      #     attr_accessor :first_name, :last_name
+      #
+      #     validates_each :first_name, :last_name do |record, attr, value|
+      #       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
+      #     end
+      #   end
+      #
+      # Options:
+      # * <tt>:on</tt> - Specifies the context where this validation is active
+      #   (e.g. <tt>:on => :create</tt> or <tt>:on => :custom_validation_context</tt>)
+      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
+      # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should occur (e.g. <tt>:if => :allow_validation</tt>,
+      #   or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
+      #   method, proc or string should return or evaluate to a true or false value.
+      def validates_each(*attr_names, &block)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with BlockValidator, options.merge(:attributes => attr_names.flatten), &block
+      end
+
+      # Adds a validation method or block to the class. This is useful when
+      # overriding the +validate+ instance method becomes too unwieldy and
+      # you're looking for more descriptive declaration of your validations.
+      #
+      # This can be done with a symbol pointing to a method:
+      #
+      #   class Comment
+      #     include Poncho::Validations
+      #
+      #     validate :must_be_friends
+      #
+      #     def must_be_friends
+      #       errors.add(:base, "Must be friends to leave a comment") unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # With a block which is passed with the current record to be validated:
+      #
+      #   class Comment
+      #     include Poncho::Validations
+      #
+      #     validate do |comment|
+      #       comment.must_be_friends
+      #     end
+      #
+      #     def must_be_friends
+      #       errors.add(:base, "Must be friends to leave a comment") unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      # Or with a block where self points to the current record to be validated:
+      #
+      #   class Comment
+      #     include Poncho::Validations
+      #
+      #     validate do
+      #       errors.add(:base, "Must be friends to leave a comment") unless commenter.friend_of?(commentee)
+      #     end
+      #   end
+      #
+      def validate(proc = nil, &block)
+        proc ||= block
+        proc = method(proc) if proc.is_a?(Symbol)
+
+        validators << proc
+      end
+
+      # List all validators that are being used to validate the model using
+      # +validates_with+ method.
+      def validators
+        @validators ||= []
+      end
+
+      def validates_with(*args, &block)
+        options = args.last.is_a?(::Hash) ? args.pop : {}
+
+        args.each do |klass|
+          validator = klass.new(options, &block)
+          validate(validator.method(:validate))
+        end
+      end
+
+      def validates(*attributes)
+        options = attributes.last.is_a?(::Hash) ? attributes.pop : {}
+
+        validations = options.reject {|key, value| VALIDATES_DEFAULT_KEYS.include?(key) || !value }
+        options     = options.merge(:attributes => attributes)
+
+        validations.each do |key, validator_options|
+          validator_options = {} if validator_options == true
+          validates_with(validator_for_kind(key), validator_options.merge(:attributes => attributes))
+        end
+      end
+
+      private
+
+      def validator_for_kind(kind)
+        return type if type.is_a?(Class)
+        name = kind.to_s.split('_').map {|w| w.capitalize }.join
+        const_get("#{name}Validator")
+      rescue NameError
+        raise ArgumentError, "Unknown validator: #{kind}"
+      end
+    end
+
+    # Returns the +Errors+ object that holds all information about attribute error messages.
+    def errors
+      @errors ||= Errors.new(self)
+    end
+
+    # Runs all the specified validations and returns true if no errors were added
+    # otherwise false. Context can optionally be supplied to define which callbacks
+    # to test against.
+    def valid?(context = nil)
+      errors.clear
+      run_validations!
+    end
+
+    # Performs the opposite of <tt>valid?</tt>. Returns true if errors were added,
+    # false otherwise.
+    def invalid?
+      !valid?
+    end
+
+    alias :read_attribute_for_validation :send
+
+    protected
+
+    def run_validations!
+      self.class.validators.each do |validator|
+        instance_eval(&validator)
+      end
+
+      errors.empty?
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/validations/*.rb'].sort.each do |path|
+  filename = File.basename(path)
+  require "poncho/validations/#{filename}"
+end

data/lib/poncho/validations/exclusions.rb

@@ -0,0 +1,77 @@
+module Poncho
+  module Validations
+    class ExclusionValidator < EachValidator
+      ERROR_MESSAGE = "An object with the method #include? or a proc or lambda is required, " <<
+                      "and must be supplied as the :in (or :within) option of the configuration hash"
+
+      def check_validity!
+        unless [:include?, :call].any? { |method| delimiter.respond_to?(method) }
+          raise ArgumentError, ERROR_MESSAGE
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        exclusions = delimiter.respond_to?(:call) ? delimiter.call(record) : delimiter
+        if exclusions.send(inclusion_method(exclusions), value)
+          record.errors.add(attribute, :exclusion, options.merge(:value => value))
+        end
+      end
+
+    private
+
+      def delimiter
+        @delimiter ||= options[:in] || options[:within]
+      end
+
+      # In Ruby 1.9 <tt>Range#include?</tt> on non-numeric ranges checks all possible
+      # values in the range for equality, so it may be slow for large ranges. The new
+      # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the
+      # range endpoints.
+      def inclusion_method(enumerable)
+        enumerable.is_a?(Range) ? :cover? : :include?
+      end
+    end
+
+    module HelperMethods
+      # Validates that the value of the specified attribute is not in a particular
+      # enumerable object.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_exclusion_of :username, :in => %w( admin superuser ), :message => "You don't belong here"
+      #     validates_exclusion_of :age, :in => 30..60, :message => "This site is only for under 30 and over 60"
+      #     validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension %{value} is not allowed"
+      #     validates_exclusion_of :password, :in => lambda { |p| [p.username, p.first_name] },
+      #                            :message => "should not be the same as your username or first name"
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:in</tt> - An enumerable object of items that the value shouldn't be
+      #   part of. This can be supplied as a proc or lambda which returns an enumerable.
+      #   If the enumerable is a range the test is performed with <tt>Range#cover?</tt>
+      #   (backported in Active Support for 1.8), otherwise with <tt>include?</tt>.
+      # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "is reserved").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute
+      #   is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+      #   validation contexts by default (+nil+), other options are <tt>:create</tt>
+      #   and <tt>:update</tt>.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the
+      #   validation should occur (e.g. <tt>:if => :allow_validation</tt>, or
+      #   <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
+      #   or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if
+      #   the validation should not occur (e.g. <tt>:unless => :skip_validation</tt>,
+      #   or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a true or false value.
+      # * <tt>:strict</tt> - Specifies whether validation should be strict.
+      #   See <tt>Poncho::Validation#validates!</tt> for more information.
+      def validates_exclusion_of(*attr_names)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with ExclusionValidator, options.merge(:attributes => attr_names)
+      end
+    end
+  end
+end

data/lib/poncho/validations/format.rb

@@ -0,0 +1,105 @@
+module Poncho
+  module Validations
+    class FormatValidator < EachValidator
+      def validate_each(record, attribute, value)
+        if options[:with]
+          regexp = option_call(record, :with)
+          record_error(record, attribute, :with, value) if value.to_s !~ regexp
+        elsif options[:without]
+          regexp = option_call(record, :without)
+          record_error(record, attribute, :without, value) if value.to_s =~ regexp
+        end
+      end
+
+      def check_validity!
+        unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
+          raise ArgumentError, "Either :with or :without must be supplied (but not both)"
+        end
+
+        check_options_validity(options, :with)
+        check_options_validity(options, :without)
+      end
+
+      private
+
+      def option_call(record, name)
+        option = options[name]
+        option.respond_to?(:call) ? option.call(record) : option
+      end
+
+      def record_error(record, attribute, name, value)
+        record.errors.add(attribute, options.merge(:value => value))
+      end
+
+      def check_options_validity(options, name)
+        option = options[name]
+        if option && !option.is_a?(Regexp) && !option.respond_to?(:call)
+          raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is of the correct form,
+      # going by the regular expression provided. You can require that the attribute
+      # matches the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, :with => /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, :on => :create
+      #   end
+      #
+      # Alternatively, you can require that the specified attribute does _not_ match
+      # the regular expression:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_format_of :email, :without => /NOSPAM/
+      #   end
+      #
+      # You can also provide a proc or lambda which will determine the regular
+      # expression that will be used to validate the attribute.
+      #
+      #   class Person < ActiveRecord::Base
+      #     # Admin can have number as a first letter in their screen name
+      #     validates_format_of :screen_name,
+      #                         :with => lambda{ |person| person.admin? ? /\A[a-z0-9][a-z0-9_\-]*\Z/i : /\A[a-z][a-z0-9_\-]*\Z/i }
+      #   end
+      #
+      # Note: use <tt>\A</tt> and <tt>\Z</tt> to match the start and end of the string,
+      # <tt>^</tt> and <tt>$</tt> match the start/end of a line.
+      #
+      # You must pass either <tt>:with</tt> or <tt>:without</tt> as an option. In
+      # addition, both must be a regular expression or a proc or lambda, or else an
+      # exception will be raised.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute
+      #   is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <tt>:with</tt> - Regular expression that if the attribute matches will
+      #   result in a successful validation. This can be provided as a proc or lambda
+      #   returning regular expression which will be called at runtime.
+      # * <tt>:without</tt> - Regular expression that if the attribute does not match
+      #   will result in a successful validation. This can be provided as a proc or
+      #   lambda returning regular expression which will be called at runtime.
+      # * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+      #   validation contexts by default (+nil+), other options are <tt>:create</tt>
+      #   and <tt>:update</tt>.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the
+      #   validation should occur (e.g. <tt>:if => :allow_validation</tt>, or
+      #   <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
+      #   or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if
+      #   the validation should not occur (e.g. <tt>:unless => :skip_validation</tt>,
+      #   or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a true or false value.
+      # * <tt>:strict</tt> - Specifies whether validation should be strict.
+      #   See <tt>Poncho::Validation#validates!</tt> for more information.
+      def validates_format_of(*attr_names)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with FormatValidator, options.merge(:attributes => attr_names)
+      end
+    end
+  end
+end

data/lib/poncho/validations/inclusions.rb

@@ -0,0 +1,77 @@
+module Poncho
+  module Validations
+    class InclusionValidator < EachValidator
+      ERROR_MESSAGE = "An object with the method #include? or a proc or lambda is required, " <<
+                      "and must be supplied as the :in (or :within) option of the configuration hash"
+
+      def check_validity!
+        unless [:include?, :call].any?{ |method| delimiter.respond_to?(method) }
+          raise ArgumentError, ERROR_MESSAGE
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        exclusions = delimiter.respond_to?(:call) ? delimiter.call(record) : delimiter
+        unless exclusions.send(inclusion_method(exclusions), value)
+          record.errors.add(attribute, :inclusion, options.merge(:value => value))
+        end
+      end
+
+    private
+
+      def delimiter
+        @delimiter ||= options[:in] || options[:within]
+      end
+
+      # In Ruby 1.9 <tt>Range#include?</tt> on non-numeric ranges checks all possible
+      # values in the range for equality, so it may be slow for large ranges. The new
+      # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the
+      # range endpoints.
+      def inclusion_method(enumerable)
+        enumerable.is_a?(Range) ? :cover? : :include?
+      end
+    end
+
+    module HelperMethods
+      # Validates whether the value of the specified attribute is available in a
+      # particular enumerable object.
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_inclusion_of :gender, :in => %w( m f )
+      #     validates_inclusion_of :age, :in => 0..99
+      #     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension %{value} is not included in the list"
+      #     validates_inclusion_of :states, :in => lambda{ |person| STATES[person.country] }
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:in</tt> - An enumerable object of available items. This can be
+      #   supplied as a proc or lambda which returns an enumerable. If the enumerable
+      #   is a range the test is performed with <tt>Range#cover?</tt>
+      #   (backported in Active Support for 1.8), otherwise with <tt>include?</tt>.
+      # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "is not
+      #   included in the list").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute
+      #   is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the
+      #   attribute is blank (default is +false+).
+      # * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+      #   validation contexts by default (+nil+), other options are <tt>:create</tt>
+      #   and <tt>:update</tt>.
+      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if
+      #   the validation should occur (e.g. <tt>:if => :allow_validation</tt>, or
+      #   <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
+      #   or string should return or evaluate to a true or false value.
+      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
+      #   if the validation should not occur (e.g. <tt>:unless => :skip_validation</tt>,
+      #   or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
+      #   proc or string should return or evaluate to a true or false value.
+      # * <tt>:strict</tt> - Specifies whether validation should be strict.
+      #   See <tt>Poncho::Validation#validates!</tt> for more information.
+      def validates_inclusion_of(*attr_names)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with InclusionValidator, options.merge(:attributes => attr_names)
+      end
+    end
+  end
+end