aequitas 0.0.1

data/lib/aequitas/rule/format.rb

@@ -0,0 +1,81 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+require 'aequitas/exceptions'
+
+require 'aequitas/rule/formats/email'
+require 'aequitas/rule/formats/url'
+
+module Aequitas
+  class Rule
+    module Format
+
+      FORMATS = {
+        :email_address => Formats::EmailAddress,
+        :url           => Formats::Url
+      }
+      # TODO: evaluate re-implementing custom error messages per format type
+      # previously these strings were wrapped in lambdas, which were, at one
+      # point, invoked with #try_call with the humanized attribute name and value
+      FORMAT_MESSAGES = {
+        :email_address => '%s is not a valid email address',
+        :url           => '%s is not a valid URL',
+      }
+
+
+      def self.rules_for(attribute_name, options)
+        Array(new(attribute_name, options))
+      end
+
+      # @raise [UnknownValidationFormat]
+      #   if the :as (or :with) option is a Symbol that is not a key in FORMATS,
+      #   or if the provided format is not a Regexp, Symbol or Proc
+      def self.new(attribute_name, options)
+        format = options.delete(:as) || options.delete(:with)
+
+        case format
+        when Symbol
+          regexp = FORMATS.fetch(format) do
+            raise UnknownValidationFormat, "No such predefined format '#{format}'"
+          end
+          self::Regexp.new(attribute_name, options.merge(:format => regexp, :format_name => format))
+        when ::Regexp
+          self::Regexp.new(attribute_name, options.merge(:format => format))
+        when ::Proc
+          self::Proc.new(attribute_name, options.merge(:format => format))
+        else
+          raise UnknownValidationFormat, "Expected a Regexp, Symbol, or Proc format. Got: #{format.inspect}"
+        end
+      end
+
+
+      attr_reader :format
+
+      def initialize(attribute_name, options)
+        super
+
+        @format = options.fetch(:format)
+
+        skip_condition.default_to_allowing_nil!
+        skip_condition.default_to_allowing_blank!
+      end
+
+      def violation_type(resource)
+        :invalid
+      end
+
+      # TODO: integrate format into error message key?
+      # def error_message_args
+      #   if format.is_a?(Symbol)
+      #     [ :"invalid_#{format}", attribute_name ]
+      #   else
+      #     [ :invalid, attribute_name ]
+      #   end
+      # end
+
+    end # class Format
+  end # class Rule
+end # module Aequitas
+
+require 'aequitas/rule/format/proc'
+require 'aequitas/rule/format/regexp'

data/lib/aequitas/rule/format/proc.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/format'
+
+module Aequitas
+  class Rule
+    module Format
+      class Proc < Rule
+
+        include Format
+
+        equalize_on *(superclass.equalizer.keys + [:format])
+
+
+        def valid?(resource)
+          value = attribute_value(resource)
+          return true if skip?(value)
+
+          self.format.call(value)
+        # rescue ::Encoding::CompatibilityError
+        #   # This is to work around a bug in jruby - see formats/email.rb
+        #   false
+        end
+
+      end # class Proc
+    end # module Format
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/format/regexp.rb

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/format'
+
+module Aequitas
+  class Rule
+    module Format
+      class Regexp < Rule
+
+        include Format
+
+        equalize_on *(superclass.equalizer.keys + [:format, :format_name])
+
+        attr_reader :format_name
+
+        def initialize(attribute_name, options = {})
+          super
+
+          @format_name = options.fetch(:format_name, nil)
+        end
+
+        def valid?(resource)
+          value = attribute_value(resource)
+          return true if skip?(value)
+
+          value ? value.to_s =~ self.format : false
+        rescue ::Encoding::CompatibilityError
+          # This is to work around a bug in jruby - see formats/email.rb
+          false
+        end
+
+        # TODO: integrate format into error message key?
+        # def error_message_args
+        #   if format_name.is_a?(Symbol)
+        #     [ :"invalid_#{format_name}", attribute_name ]
+        #   else
+        #     [ :invalid, attribute_name ]
+        #   end
+        # end
+
+      end # class Regexp
+    end # module Format
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/formats/email.rb

@@ -0,0 +1,52 @@
+# encoding: UTF-8
+
+module Aequitas
+  class Rule
+    module Formats
+
+      # Almost RFC2822 (No attribution reference available).
+      #
+      # This differs in that it does not allow local domains (test@localhost).
+      # 99% of the time you do not want to allow these email addresses
+      # in a public web application.
+      EmailAddress = begin
+        if (RUBY_VERSION == '1.9.2' && RUBY_ENGINE == 'jruby' && JRUBY_VERSION <= '1.6.3') || RUBY_VERSION == '1.9.3'
+          # There is an obscure bug in jruby 1.6 that prevents matching
+          # on unicode properties here. Remove this logic branch once
+          # a stable jruby release fixes this.
+          #
+          # http://jira.codehaus.org/browse/JRUBY-5622
+          #
+          # There is a similar bug in preview releases of 1.9.3
+          #
+          # http://redmine.ruby-lang.org/issues/5126
+          letter = 'a-zA-Z'
+        else
+          letter = 'a-zA-Z\p{L}'  # Changed from RFC2822 to include unicode chars
+        end
+        digit          = '0-9'
+        atext          = "[#{letter}#{digit}\!\#\$\%\&\'\*+\/\=\?\^\_\`\{\|\}\~\-]"
+        dot_atom_text  = "#{atext}+([.]#{atext}*)+"
+        dot_atom       = dot_atom_text
+        no_ws_ctl      = '\x01-\x08\x11\x12\x14-\x1f\x7f'
+        qtext          = "[^#{no_ws_ctl}\\x0d\\x22\\x5c]"  # Non-whitespace, non-control character except for \ and "
+        text           = '[\x01-\x09\x11\x12\x14-\x7f]'
+        quoted_pair    = "(\\x5c#{text})"
+        qcontent       = "(?:#{qtext}|#{quoted_pair})"
+        quoted_string  = "[\"]#{qcontent}+[\"]"
+        atom           = "#{atext}+"
+        word           = "(?:#{atom}|#{quoted_string})"
+        obs_local_part = "#{word}([.]#{word})*"
+        local_part     = "(?:#{dot_atom}|#{quoted_string}|#{obs_local_part})"
+        dtext          = "[#{no_ws_ctl}\\x21-\\x5a\\x5e-\\x7e]"
+        dcontent       = "(?:#{dtext}|#{quoted_pair})"
+        domain_literal = "\\[#{dcontent}+\\]"
+        obs_domain     = "#{atom}([.]#{atom})+"
+        domain         = "(?:#{dot_atom}|#{domain_literal}|#{obs_domain})"
+        addr_spec      = "#{local_part}\@#{domain}"
+        pattern        = /\A#{addr_spec}\z/u
+      end
+
+    end # module Formats
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/formats/url.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module Aequitas
+  class Rule
+    module Formats
+
+      # Regex from http://www.igvita.com/2006/09/07/validating-url-in-ruby-on-rails/
+      Url = begin
+        /(^$)|(^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}((\:[0-9]{1,5})?\/?.*)?$)/ix
+      end
+
+    end # module Formats
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/guard.rb

@@ -0,0 +1,51 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/support/equalizable'
+
+module Aequitas
+  class Rule
+    class Guard
+      extend Equalizable
+
+      equalize_on :if_test, :unless_test
+
+      attr_reader :if_test
+      attr_reader :unless_test
+
+      def initialize(options = {})
+        @if_test     = options.fetch(:if,     nil)
+        @unless_test = options.fetch(:unless, nil)
+      end
+
+      # Determines if this RuleGuard allows the given resource
+      # by evaluating the if_test and unless_test
+      #
+      # @param [Object] resource
+      #   The resource that we check against.
+      #
+      # @return [Boolean]
+      #   true if allowed, otherwise false.
+      #
+      # @api private
+      def allow?(resource)
+        if if_test
+          !!evaluate_conditional_clause(resource, if_test)
+        elsif unless_test
+          !evaluate_conditional_clause(resource, unless_test)
+        else
+          true
+        end
+      end
+
+      # @api private
+      def evaluate_conditional_clause(resource, clause)
+        if clause.respond_to?(:call)
+          clause.call(resource)
+        elsif clause.kind_of?(Symbol)
+          resource.__send__(clause)
+        end
+      end
+
+    end # class Guard
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/length.rb

@@ -0,0 +1,87 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    module Length
+
+      # TODO: DRY this up (also implemented in Rule)
+      def self.rules_for(attribute_name, options)
+        Array(new(attribute_name, options))
+      end
+
+      # TODO: move options normalization into the validator macros
+      def self.new(attribute_name, options)
+        options = options.dup
+
+        equal   = options.values_at(:is,  :equals).compact.first
+        range   = options.values_at(:in,  :within).compact.first
+        minimum = options.values_at(:min, :minimum).compact.first
+        maximum = options.values_at(:max, :maximum).compact.first
+
+        if minimum && maximum
+          range ||= minimum..maximum
+        end
+
+        if equal
+          Length::Equal.new(attribute_name,   options.merge(:expected => equal))
+        elsif range
+          Length::Range.new(attribute_name,   options.merge(:range => range))
+        elsif minimum
+          Length::Minimum.new(attribute_name, options.merge(:bound => minimum))
+        elsif maximum
+          Length::Maximum.new(attribute_name, options.merge(:bound => maximum))
+        else
+          # raise ArgumentError, "expected one of :is, :equals, :within, :in, :minimum, :min, :maximum, or :max; got #{options.keys.inspect}"
+          warn "expected length specification: one of :is, :equals, :in, :within, :min, :minimum, :max, or :maximum; got #{options.keys.inspect}"
+          Length::Dummy.new(attribute_name, options)
+        end
+      end
+
+      class Dummy < Rule
+        include Length
+      end
+
+      def valid?(resource)
+        value = attribute_value(resource)
+
+        skip?(value) || valid_length?(value_length(value.to_s))
+      end
+
+    private
+
+      def valid_length?(length)
+        raise NotImplementedError, "#{self.class}#valid_length? must be implemented"
+      end
+
+      # Return the length in characters
+      #
+      # @param [#to_str] value
+      #   the string to get the number of characters for
+      #
+      # @return [Integer]
+      #   the number of characters in the string
+      #
+      # @api private
+      def value_length(value)
+        value.to_str.length
+      end
+
+      if RUBY_VERSION < '1.9'
+        # calculate length of multi-byte-encoded strings
+        #   as characters rather than bytes
+        def value_length(value)
+          value.to_str.scan(/./u).size
+        end
+      end
+
+    end # module Length
+  end # class Rule
+end # module Aequitas
+
+# meh, I don't like doing this, but the superclass must be loaded before subclasses
+require 'aequitas/rule/length/equal'
+require 'aequitas/rule/length/range'
+require 'aequitas/rule/length/minimum'
+require 'aequitas/rule/length/maximum'

data/lib/aequitas/rule/length/equal.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/length'
+
+module Aequitas
+  class Rule
+    module Length
+      class Equal < Rule
+
+        include Length
+
+        attr_reader :expected
+
+        def initialize(attribute_name, options)
+          super
+
+          @expected = options.fetch(:expected)
+        end
+
+        def violation_type(resource)
+          :wrong_length
+        end
+
+        def violation_data(resource)
+          [ [ :expected, expected ] ]
+        end
+
+      private
+
+        # Validate the value length is equal to the expected length
+        #
+        # @param [Integer] length
+        #   the value length
+        #
+        # @return [String, nil]
+        #   the error message if invalid, nil if not
+        #
+        # @api private
+        def valid_length?(length)
+          expected == length
+        end
+
+      end # class Equal
+    end # module Length
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/length/maximum.rb

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/length'
+
+module Aequitas
+  class Rule
+    module Length
+      class Maximum < Rule
+
+        include Length
+
+        attr_reader :bound
+
+        def initialize(attribute_name, options)
+          super
+
+          @bound = options.fetch(:bound)
+        end
+
+        def violation_type(resource)
+          :too_long
+        end
+
+        def violation_data(resource)
+          [ [ :maximum, bound ] ]
+        end
+
+      private
+
+        # Validate the value length is less than or equal to the bound
+        #
+        # @param [Integer] length
+        #   the value length
+        #
+        # @return [String, NilClass]
+        #   the error message if invalid, nil if valid
+        #
+        # @api private
+        def valid_length?(length)
+          bound >= length
+        end
+
+      end # class Maximum
+    end # module Length
+  end # class Rule
+end # module Aequitas