poncho 0.0.2

data/lib/poncho/validations/length.rb

@@ -0,0 +1,123 @@
+module Poncho
+  module Validations
+    class LengthValidator < EachValidator
+      MESSAGES  = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }.freeze
+      CHECKS    = { :is => :==, :minimum => :>=, :maximum => :<= }.freeze
+
+      RESERVED_OPTIONS  = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
+
+      def initialize(options)
+        if range = (options.delete(:in) || options.delete(:within))
+          raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
+          options[:minimum], options[:maximum] = range.begin, range.end
+          options[:maximum] -= 1 if range.exclude_end?
+        end
+
+        super
+      end
+
+      def check_validity!
+        keys = CHECKS.keys & options.keys
+
+        if keys.empty?
+          raise ArgumentError, 'Range unspecified. Specify the :in, :within, :maximum, :minimum, or :is option.'
+        end
+
+        keys.each do |key|
+          value = options[key]
+
+          unless value.is_a?(Integer) && value >= 0
+            raise ArgumentError, ":#{key} must be a nonnegative Integer"
+          end
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        value = tokenize(value)
+        value_length = value.respond_to?(:length) ? value.length : value.to_s.length
+
+        CHECKS.each do |key, validity_check|
+          next unless check_value = options[key]
+          next if value_length.send(validity_check, check_value)
+
+          errors_options = options.dup
+          errors_options[:count] = check_value
+
+          default_message = options[MESSAGES[key]]
+          errors_options[:message] ||= default_message if default_message
+
+          record.errors.add(attribute, MESSAGES[key], errors_options)
+        end
+      end
+
+      private
+
+      def tokenize(value)
+        if value.kind_of?(String) && options[:tokenizer]
+          return options[:tokenizer].call(value)
+        end
+
+        value
+      end
+    end
+
+    module HelperMethods
+      # Validates that the specified attribute matches the length restrictions supplied.
+      # Only one option can be used at a time:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_length_of :first_name, :maximum => 30
+      #     validates_length_of :last_name, :maximum => 30, :message => "less than 30 if you don't mind"
+      #     validates_length_of :fax, :in => 7..32, :allow_nil => true
+      #     validates_length_of :phone, :in => 7..32, :allow_blank => true
+      #     validates_length_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name"
+      #     validates_length_of :zip_code, :minimum => 5, :too_short => "please enter at least 5 characters"
+      #     validates_length_of :smurf_leader, :is => 4, :message => "papa is spelled with 4 characters... don't play me."
+      #     validates_length_of :essay, :minimum => 100, :too_short => "Your essay must be at least 100 words.",
+      #                         :tokenizer => lambda { |str| str.scan(/\w+/) }
+      #   end
+      #
+      # Configuration options:
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the
+      #   attribute.
+      # * <tt>:in</tt> - A synonym(or alias) for <tt>:within</tt>.
+      # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
+      # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
+      # * <tt>:too_long</tt> - The error message if the attribute goes over the
+      #   maximum (default is: "is too long (maximum is %{count} characters)").
+      # * <tt>:too_short</tt> - The error message if the attribute goes under the
+      #   minimum (default is: "is too short (min is %{count} characters)").
+      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt> method
+      #   and the attribute is the wrong size (default is: "is the wrong length
+      #   should be %{count} characters)").
+      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>,
+      #   <tt>:maximum</tt>, or <tt>:is</tt> violation. An alias of the appropriate
+      #   <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
+      # * <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>:tokenizer</tt> - Specifies how to split up the attribute string.
+      #   (e.g. <tt>:tokenizer => lambda {|str| str.scan(/\w+/)}</tt> to count words
+      #   as in above example). Defaults to <tt>lambda{ |value| value.split(//) }</tt> which counts individual characters.
+      # * <tt>:strict</tt> - Specifies whether validation should be strict.
+      #   See <tt>Poncho::Validation#validates!</tt> for more information.
+      def validates_length_of(*attr_names)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with LengthValidator, options.merge(:attributes => attr_names)
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+    end
+  end
+end

data/lib/poncho/validations/presence.rb

@@ -0,0 +1,49 @@
+module Poncho
+  module Validations
+    class PresenceValidator < EachValidator
+      def validate_each(record, attribute, value)
+        if !value || value == ""
+          record.errors.add(attribute, :presence, options.merge(:value => value))
+        end
+      end
+    end
+
+    module HelperMethods
+      # Validates that the specified attributes are not blank (as defined by
+      # Object#blank?). Happens by default on save. Example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     validates_presence_of :first_name
+      #   end
+      #
+      # The first_name attribute must be in the object and it cannot be blank.
+      #
+      # If you want to validate the presence of a boolean field (where the real values
+      # are true and false), you will want to use <tt>validates_inclusion_of :field_name,
+      # :in => [true, false]</tt>.
+      #
+      # This is due to the way Object#blank? handles boolean values:
+      # <tt>false.blank? # => true</tt>.
+      #
+      # Configuration options:
+      # * <tt>:message</tt> - A custom error message (default is: "can't be blank").
+      # * <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_presence_of(*attr_names)
+        options = attr_names.last.is_a?(::Hash) ? attr_names.pop : {}
+        validates_with PresenceValidator, options.merge(:attributes => attr_names)
+      end
+    end
+  end
+end

data/lib/poncho/validator.rb

@@ -0,0 +1,172 @@
+module Poncho
+  #
+  #   class Person
+  #     include Poncho::Validations
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < Poncho::Validator
+  #     def validate(record)
+  #       if some_complex_logic
+  #         record.errors[:base] = "This record is invalid"
+  #       end
+  #     end
+  #
+  #     private
+  #       def some_complex_logic
+  #         # ...
+  #       end
+  #   end
+  #
+  # Any class that inherits from Poncho::Validator must implement a method
+  # called <tt>validate</tt> which accepts a <tt>record</tt>.
+  #
+  #   class Person
+  #     include Poncho::Validations
+  #     validates_with MyValidator
+  #   end
+  #
+  #   class MyValidator < Poncho::Validator
+  #     def validate(record)
+  #       record # => The person instance being validated
+  #       options # => Any non-standard options passed to validates_with
+  #     end
+  #   end
+  #
+  # To cause a validation error, you must add to the <tt>record</tt>'s errors directly
+  # from within the validators message
+  #
+  #   class MyValidator < Poncho::Validator
+  #     def validate(record)
+  #       record.errors.add :base, "This is some custom error message"
+  #       record.errors.add :first_name, "This is some complex validation"
+  #       # etc...
+  #     end
+  #   end
+  #
+  # To add behavior to the initialize method, use the following signature:
+  #
+  #   class MyValidator < Poncho::Validator
+  #     def initialize(options)
+  #       super
+  #       @my_custom_field = options[:field_name] || :first_name
+  #     end
+  #   end
+  #
+  # The easiest way to add custom validators for validating individual attributes
+  # is with the convenient <tt>Poncho::EachValidator</tt>. For example:
+  #
+  #   class TitleValidator < Poncho::EachValidator
+  #     def validate_each(record, attribute, value)
+  #       record.errors.add attribute, 'must be Mr. Mrs. or Dr.' unless value.in?(['Mr.', 'Mrs.', 'Dr.'])
+  #     end
+  #   end
+  #
+  # This can now be used in combination with the +validates+ method
+  # (see <tt>Poncho::Validations::ClassMethods.validates</tt> for more on this)
+  #
+  #   class Person
+  #     include Poncho::Validations
+  #     attr_accessor :title
+  #
+  #     validates :title, :presence => true
+  #   end
+  #
+  # Validator may also define a +setup+ instance method which will get called
+  # with the class that using that validator as its argument. This can be
+  # useful when there are prerequisites such as an +attr_accessor+ being present
+  # for example:
+  #
+  #   class MyValidator < Poncho::Validator
+  #     def setup(klass)
+  #       klass.send :attr_accessor, :custom_attribute
+  #     end
+  #   end
+  #
+  # This setup method is only called when used with validation macros or the
+  # class level <tt>validates_with</tt> method.
+  #
+  class Validator
+    def self.kind
+      @kind ||= begin
+        full_name = name.split('::').last
+        full_name = full_name.gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+        full_name.sub(/_validator$/, '').to_sym
+      end
+    end
+
+    attr_reader :options
+
+    # Accepts options that will be made available through the +options+ reader.
+    def initialize(options)
+      @options = options.freeze
+    end
+
+    # Override this method in subclasses with validation logic, adding errors
+    # to the records +errors+ array where necessary.
+    def validate(record)
+      raise NotImplementedError, "Subclasses must implement a validate(record) method."
+    end
+
+    def kind
+      self.class.kind
+    end
+  end
+
+  # +EachValidator+ is a validator which iterates through the attributes given
+  # in the options hash invoking the <tt>validate_each</tt> method passing in the
+  # record, attribute and value.
+  #
+  # All Poncho validations are built on top of this validator.
+  class EachValidator < Validator
+    attr_reader :attributes
+
+    # Returns a new validator instance. All options will be available via the
+    # +options+ reader, however the <tt>:attributes</tt> option will be removed
+    # and instead be made available through the +attributes+ reader.
+    def initialize(options)
+      @attributes = Array(options.delete(:attributes))
+      raise ':attributes cannot be blank' if @attributes.empty?
+      super
+      check_validity!
+    end
+
+    # Performs validation on the supplied record. By default this will call
+    # +validates_each+ to determine validity therefore subclasses should
+    # override +validates_each+ with validation logic.
+    def validate(record)
+      attributes.each do |attribute|
+        value = record.read_attribute_for_validation(attribute)
+        next if (value.nil? && options[:allow_nil]) || (value == "" && options[:allow_blank])
+        validate_each(record, attribute, value)
+      end
+    end
+
+    # Override this method in subclasses with the validation logic, adding
+    # errors to the records +errors+ array where necessary.
+    def validate_each(record, attribute, value)
+      raise NotImplementedError, 'Subclasses must implement a validate_each(record, attribute, value) method'
+    end
+
+    # Hook method that gets called by the initializer allowing verification
+    # that the arguments supplied are valid. You could for example raise an
+    # +ArgumentError+ when invalid options are supplied.
+    def check_validity!
+    end
+  end
+
+  # +BlockValidator+ is a special +EachValidator+ which receives a block on initialization
+  # and call this block for each attribute being validated. +validates_each+ uses this validator.
+  class BlockValidator < EachValidator
+    def initialize(options, &block)
+      @block = block
+      super
+    end
+
+    private
+
+    def validate_each(record, attribute, value)
+      @block.call(record, attribute, value)
+    end
+  end
+end

data/lib/poncho/version.rb

@@ -0,0 +1,3 @@
+module Poncho
+  VERSION = "0.0.2"
+end

data/poncho.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'poncho/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "poncho"
+  gem.version       = Poncho::VERSION
+  gem.authors       = ["Alex MacCaw"]
+  gem.email         = ["alex@stripe.com"]
+  gem.description   = %q{Poncho is an API to build REST APIs with a convenient DSL.}
+  gem.summary       = %q{Poncho is an API to build APIs}
+  gem.homepage      = "https://github.com/stripe/poncho"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/test/poncho/test_method.rb

@@ -0,0 +1,105 @@
+require 'minitest/autorun'
+require 'rack/mock'
+require 'poncho'
+
+class TestMethod < MiniTest::Unit::TestCase
+  def env(params = {})
+    Rack::MockRequest.env_for('http://api.com/charges', :params => params)
+  end
+
+  def setup
+  end
+
+  def test_that_integer_params_are_validated
+    method = Class.new(Poncho::Method) do
+      param :amount, :type => :integer
+    end
+
+    status, headers, body = method.call(env(:amount => nil))
+    assert_equal 406, status
+
+    status, headers, body = method.call(env(:amount => '1'))
+    assert_equal 200, status
+
+    status, headers, body = method.call(env(:amount => 'blah'))
+    assert_equal 406, status
+  end
+
+  def test_that_string_params_are_validated
+    method = Class.new(Poncho::Method) do
+      param :amount, :type => :string
+    end
+
+    status, headers, body = method.call(env(:amount => nil))
+    assert_equal 406, status
+
+    status, headers, body = method.call(env(:amount => 'blah'))
+    assert_equal 200, status
+  end
+
+  def test_presence_validation
+    method = Class.new(Poncho::Method) do
+      param :amount, :required => true
+    end
+
+    status, headers, body = method.call(env())
+    assert_equal 406, status
+
+    status, headers, body = method.call(env(:amount => 'test'))
+    assert_equal 200, status
+  end
+
+  def test_custom_param_conversion
+    custom_param = Class.new(Poncho::Param) do
+      def convert(value)
+        return true if value == 'custom'
+        return false
+      end
+    end
+
+    method = Class.new(Poncho::Method) do
+      param :currency, :type => custom_param
+
+      def invoke
+        halt param(:currency) == true ? 200 : 406
+      end
+    end
+
+    status, headers, body = method.call(env(:currency => 'notcustom'))
+    assert_equal 406, status
+
+    status, headers, body = method.call(env(:currency => 'custom'))
+    assert_equal 200, status
+  end
+
+  def test_custom_param_validation
+    custom_param = Class.new(Poncho::Param) do
+      def validate_each(record, name, value)
+        unless ['USD', 'GBP'].include?(value)
+          record.errors.add(name, :invalid_currency)
+        end
+      end
+    end
+
+    method = Class.new(Poncho::Method) do
+      param :currency, :type => custom_param
+    end
+
+    status, headers, body = method.call(env(:currency => 'RSU'))
+    assert_equal 406, status
+
+    status, headers, body = method.call(env(:currency => 'USD'))
+    assert_equal 200, status
+  end
+
+  def test_json_method_returns_json
+    method = Class.new(Poncho::JSONMethod) do
+      def invoke
+        {:some => 'stuff'}
+      end
+    end
+
+    status, headers, body = method.call(env())
+    assert_equal({:some => 'stuff'}.to_json, body.body.first)
+  end
+end