aequitas 0.0.1

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

@@ -0,0 +1,46 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/length'
+
+module Aequitas
+  class Rule
+    module Length
+      class Minimum < Rule
+
+        include Length
+
+        attr_reader :bound
+
+        def initialize(attribute_name, options)
+          super
+
+          @bound = options.fetch(:bound)
+        end
+
+        def violation_type(resource)
+          :too_short
+        end
+
+        def violation_data(resource)
+          [ [ :minimum, bound ] ]
+        end
+
+      private
+
+        # Validate the value length is greater 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 Minimum
+    end # module Length
+  end # class Rule
+end # module Aequitas

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

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

data/lib/aequitas/rule/method.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    class Method < Rule
+
+      equalize_on *(superclass.equalizer.keys + [:method])
+
+      attr_reader :method
+
+      def initialize(attribute_name, options={})
+        super
+
+        @method = options.fetch(:method, attribute_name)
+      end
+
+      def validate(resource)
+        result, error_message = resource.__send__(method)
+
+        if result
+          nil
+        else
+          Violation.new(resource, error_message, self)
+        end
+      end
+
+    end # class Method
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness.rb

@@ -0,0 +1,85 @@
+# -*- encoding: utf-8 -*-
+
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    module Numericalness
+
+      def self.included(validator)
+        validator.equalize_on *(validator.superclass.equalizer.keys + [:expected])
+      end
+
+      # TODO: move options normalization into the validator macros?
+      def self.rules_for(attribute_name, options)
+        options = options.dup
+
+        int = scour_options_of_keys(options, [:only_integer, :integer_only])
+
+        gt  = scour_options_of_keys(options, [:gt,  :greater_than])
+        lt  = scour_options_of_keys(options, [:lt,  :less_than])
+        gte = scour_options_of_keys(options, [:gte, :greater_than_or_equal_to])
+        lte = scour_options_of_keys(options, [:lte, :less_than_or_equal_to])
+        eq  = scour_options_of_keys(options, [:eq,  :equal, :equals, :exactly, :equal_to])
+        ne  = scour_options_of_keys(options, [:ne,  :not_equal_to])
+
+        rules = []
+        rules << Integer.new(attribute_name, options)                                    if int
+        rules << NonInteger.new(attribute_name, options)                                 if !int
+        rules << GreaterThan.new(attribute_name, options.merge(:expected => gt))         if gt
+        rules << LessThan.new(attribute_name, options.merge(:expected => lt))            if lt
+        rules << GreaterThanOrEqual.new(attribute_name, options.merge(:expected => gte)) if gte
+        rules << LessThanOrEqual.new(attribute_name, options.merge(:expected => lte))    if lte
+        rules << Equal.new(attribute_name, options.merge(:expected => eq))               if eq
+        rules << NotEqual.new(attribute_name, options.merge(:expected => ne))            if ne
+        rules
+      end
+
+      def self.scour_options_of_keys(options, keys)
+        keys.map { |key| options.delete(key) }.compact.first
+      end
+
+      attr_reader :expected
+
+      def initialize(attribute_name, options)
+        super
+
+        @expected = options[:expected]
+      end
+
+      def valid?(resource)
+        # TODO: is it even possible for expected to be nil?
+        #   if so, return a dummy validator when expected is nil
+        return true if expected.nil?
+
+        value = attribute_value(resource)
+
+        skip?(value) || valid_numericalness?(value)
+      end
+
+    private
+
+      def value_as_string(value)
+        case value
+        # Avoid Scientific Notation in Float to_s
+        when Float      then value.to_d.to_s('F')
+        when BigDecimal then value.to_s('F')
+        else value.to_s
+        end
+      end
+
+    end # class Numericalness
+  end # class Rule
+end # module Aequitas
+
+require 'aequitas/rule/numericalness/integer'
+require 'aequitas/rule/numericalness/non_integer'
+
+require 'aequitas/rule/numericalness/equal'
+require 'aequitas/rule/numericalness/greater_than'
+require 'aequitas/rule/numericalness/greater_than_or_equal'
+require 'aequitas/rule/numericalness/less_than'
+require 'aequitas/rule/numericalness/less_than_or_equal'
+require 'aequitas/rule/numericalness/not_equal'

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

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class Equal < Rule
+
+        include Numericalness
+
+        def valid_numericalness?(value)
+          value == expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :equal_to
+        end
+
+        def violation_data(resource)
+          [ [ :expected, expected ] ]
+        end
+
+      end # class Equal
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness/greater_than.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class GreaterThan < Rule
+
+        include Numericalness
+
+        def valid_numericalness?(value)
+          value > expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :greater_than
+        end
+
+        def violation_data(resource)
+          [ [ :minimum, expected ] ]
+        end
+
+      end # class GreaterThan
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness/greater_than_or_equal.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class GreaterThanOrEqual < Rule
+
+        include Numericalness
+
+        def valid_numericalness?(value)
+          value >= expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :greater_than_or_equal_to
+        end
+
+        def violation_data(resource)
+          [ [ :minimum, expected ] ]
+        end
+
+      end # class GreaterThanOrEqual
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness/integer.rb

@@ -0,0 +1,37 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class Integer < Rule
+
+        include Numericalness
+
+        def expected
+          /\A[+-]?\d+\z/
+        end
+
+        def valid_numericalness?(value)
+          # XXX: workaround for jruby. This is needed because the jruby
+          # compiler optimizes a bit too far with magic variables like $~.
+          # the value.send line sends $~. Inserting this line makes sure the
+          # jruby compiler does not optimise here.
+          # see http://jira.codehaus.org/browse/JRUBY-3765
+          $~ = nil if RUBY_PLATFORM[/java/]
+
+          value_as_string(value) =~ expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :not_an_integer
+        end
+
+      end # class Equal
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness/less_than.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class LessThan < Rule
+
+        include Numericalness
+
+        def valid_numericalness?(value)
+          value < expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :less_than
+        end
+
+        def violation_data(resource)
+          [ [ :maximum, expected ] ]
+        end
+
+      end # class LessThan
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness/less_than_or_equal.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class LessThanOrEqual < Rule
+
+        include Numericalness
+
+        def valid_numericalness?(value)
+          value <= expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :less_than_or_equal_to
+        end
+
+        def violation_data(resource)
+          [ [ :maximum, expected ] ]
+        end
+
+      end # class LessThanOrEqual
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/numericalness/non_integer.rb

@@ -0,0 +1,64 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class NonInteger < Rule
+
+        include Numericalness
+
+        attr_reader :precision
+        attr_reader :scale
+
+        def initialize(attribute_name, options)
+          super
+
+          @precision = options.fetch(:precision, nil)
+          @scale     = options.fetch(:scale,     nil)
+
+          unless expected # validate precision and scale attrs
+            raise ArgumentError, "Invalid precision #{precision.inspect} and scale #{scale.inspect} for #{attribute_name}"
+          end
+        end
+
+        def expected(precision = @precision, scale = @scale)
+          if precision && scale
+            if precision > scale && scale == 0
+              /\A[+-]?(?:\d{1,#{precision}}(?:\.0)?)\z/
+            elsif precision > scale
+              delta = precision - scale
+              /\A[+-]?(?:\d{1,#{delta}}|\d{0,#{delta}}\.\d{1,#{scale}})\z/
+            elsif precision == scale
+              /\A[+-]?(?:0(?:\.\d{1,#{scale}})?)\z/
+            else
+              nil
+            end
+          else
+            /\A[+-]?(?:\d+|\d*\.\d+)\z/
+          end
+        end
+
+        def valid_numericalness?(value)
+          # XXX: workaround for jruby. This is needed because the jruby
+          # compiler optimizes a bit too far with magic variables like $~.
+          # the value.send line sends $~. Inserting this line makes sure the
+          # jruby compiler does not optimise here.
+          # see http://jira.codehaus.org/browse/JRUBY-3765
+          $~ = nil if RUBY_PLATFORM[/java/]
+
+          value_as_string(value) =~ expected
+        rescue ArgumentError
+          # TODO: figure out better solution for: can't compare String with Integer
+          true
+        end
+
+        def violation_type(resource)
+          :not_a_number
+        end
+
+      end # class NonInteger
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas