aequitas 0.0.1

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

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/numericalness'
+
+module Aequitas
+  class Rule
+    module Numericalness
+      class NotEqual < 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)
+          :not_equal_to
+        end
+
+        def violation_data(resource)
+          [ [ :not_expected, expected ] ]
+        end
+
+      end # class NotEqual
+    end # module Numericalness
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/presence.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    class Presence < Rule
+
+    end # class Presence
+  end # class Rule
+end # module Aequitas
+
+require 'aequitas/rule/presence/not_blank'
+require 'aequitas/rule/presence/not_nil'

data/lib/aequitas/rule/presence/not_blank.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/presence'
+
+module Aequitas
+  class Rule
+    class Presence
+      class NotBlank < Presence
+
+        def valid?(resource)
+          !Aequitas.blank?(attribute_value(resource))
+        end
+
+        def violation_type(resource)
+          :blank
+        end
+
+      end # class NonNil
+    end # class Presence
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/presence/not_nil.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/presence'
+
+module Aequitas
+  class Rule
+    class Presence
+      class NotNil < Presence
+
+        def valid?(resource)
+          !attribute_value(resource).nil?
+        end
+
+        def violation_type(resource)
+          :nil
+        end
+
+      end # class NonNil
+    end # class Presence
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/primitive_type.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    class PrimitiveType < Rule
+
+      def valid?(resource)
+        property = get_resource_property(resource, attribute_name)
+        value    = attribute_value(resource)
+
+        value.nil? || property.value_dumped?(value)
+      end
+
+      def violation_type(resource)
+        :primitive
+      end
+
+      def violation_data(resource)
+        property = get_resource_property(resource, attribute_name)
+
+        [ [ :primitive, property.load_as ] ]
+      end
+
+    end # class PrimitiveType
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/skip_condition.rb

@@ -0,0 +1,104 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/support/blank'
+require 'aequitas/support/equalizable'
+
+module Aequitas
+  class Rule
+    class SkipCondition
+      extend Equalizable
+
+      equalize_on :allow_nil, :allow_blank
+
+      attr_reader :allow_nil
+      attr_reader :allow_blank
+
+      def initialize(options = {})
+        @allow_nil   = !!options[:allow_nil]   if options.include?(:allow_nil)
+        @allow_blank = !!options[:allow_blank] if options.include?(:allow_blank)
+      end
+
+      # Test a value to determine if it should be skipped,
+      #   according to the receiver's configuration
+      # 
+      # @param [#nil?] value
+      #   the value to be tested
+      # 
+      # @return [Boolean]
+      def skip?(value)
+        if value.nil?
+          @allow_nil.nil? ? allow_blank? : allow_nil?
+        elsif Aequitas.blank?(value)
+          allow_blank?
+        else
+          false
+        end
+      end
+
+      # Inquire whether the receiver is configured to allow nil values
+      # 
+      # @return [Boolean]
+      def allow_nil?
+        @allow_nil.nil? ? false : @allow_nil
+      end
+
+      # Inquire whether the receiver is configured to allow blank values
+      # 
+      # @return [Boolean]
+      def allow_blank?
+        @allow_blank.nil? ? false : @allow_blank
+      end
+
+      # Set the receiver to allow nil values
+      # 
+      # @return [self]
+      def allow_nil!
+        @allow_nil = true
+        self
+      end
+
+      # Set the receiver to allow blank values
+      # 
+      # @return [self]
+      def allow_blank!
+        @allow_blank = true
+        self
+      end
+
+      # Set the receiver to reject nil values
+      # 
+      # @return [self]
+      def reject_nil!
+        @allow_nil = false
+        self
+      end
+
+      # Set the receiver to reject blank values
+      # 
+      # @return [self]
+      def reject_blank!
+        @allow_blank = false
+        self
+      end
+
+      # Set the receiver to allow nil values
+      #   if a value has not already been set
+      # 
+      # @return [self]
+      def default_to_allowing_nil!
+        allow_nil! if allow_nil.nil?
+        self
+      end
+
+      # Set the receiver to allow blank values
+      #   if a value has not already been set
+      # 
+      # @return [self]
+      def default_to_allowing_blank!
+        allow_blank! if allow_blank.nil?
+        self
+      end
+
+    end # class SkipCondition
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/within.rb

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    module Within
+
+      # 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)
+        if options.fetch(:set).is_a?(::Range)
+          Within::Range.new(attribute_name, options)
+        else
+          Within::Set.new(attribute_name, options)
+        end
+      end
+
+    end # module Within
+  end # class Rule
+end # module Aequitas
+
+require 'aequitas/rule/within/range'
+require 'aequitas/rule/within/set'

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

@@ -0,0 +1,53 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/within'
+
+module Aequitas
+  class Rule
+    module Within
+      module Range
+
+        Infinity = 1.0 / 0
+
+        include Within
+
+        attr_reader :range
+
+        def self.rules_for(attribute_name, options)
+          Array(new(attribute_name, options))
+        end
+
+        def self.new(attribute_name, options)
+          super if Within::Range != self
+
+          range = options.fetch(:range) { options.fetch(:set) }
+
+          if range.first != -Infinity && range.last != Infinity
+            Bounded.new(attribute_name, options)
+          elsif range.first == -Infinity
+            UnboundedBegin.new(attribute_name, options)
+          elsif range.last == Infinity
+            UnboundedEnd.new(attribute_name, options)
+          end
+        end
+
+        def initialize(attribute_name, options={})
+          super
+
+          @range = options.fetch(:range) { options.fetch(:set) }
+        end
+
+        def valid?(resource)
+          value = attribute_value(resource)
+
+          skip?(value) || range.include?(value)
+        end
+
+      end # module Range
+    end # module Within
+  end # class Rule
+end # module Aequitas
+
+require 'aequitas/rule/within/range/bounded'
+require 'aequitas/rule/within/range/unbounded_begin'
+require 'aequitas/rule/within/range/unbounded_end'

data/lib/aequitas/rule/within/range/bounded.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/within/range'
+
+module Aequitas
+  class Rule
+    module Within
+      module Range
+        class Bounded < Rule
+
+          include Range
+
+          def violation_type(resource)
+            :value_between
+          end
+
+          def violation_data(resource)
+            [ [ :minimum, range.begin ], [ :maximum, range.end ] ]
+          end
+
+        end # class Bounded
+      end # module Range
+    end # module Within
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/within/range/unbounded_begin.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/within/range'
+
+module Aequitas
+  class Rule
+    module Within
+      module Range
+        class UnboundedBegin < Rule
+
+          include Range
+
+          def violation_type(resource)
+            :less_than_or_equal_to
+          end
+
+          def violation_data(resource)
+            [ [ :maximum, range.max ] ]
+          end
+
+        end # class UnboundedBegin
+      end # module Range
+    end # module Within
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/within/range/unbounded_end.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/within/range'
+
+module Aequitas
+  class Rule
+    module Within
+      module Range
+        class UnboundedEnd < Rule
+
+          include Range
+
+          def violation_type(resource)
+            :greater_than_or_equal_to
+          end
+
+          def violation_data(resource)
+            [ [ :minimum, range.begin ] ]
+          end
+
+        end # class UnboundedBegin
+      end # module Range
+    end # module Within
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/within/set.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/within'
+
+module Aequitas
+  class Rule
+    module Within
+      class Set < Rule
+
+        equalize_on *(superclass.equalizer.keys + [:set])
+
+        include Within
+
+        attr_reader :set
+
+        def initialize(attribute_name, options={})
+          super
+
+          @set = options.fetch(:set, [])
+        end
+
+        def valid?(resource)
+          value = attribute_value(resource)
+
+          skip?(value) || set.include?(value)
+        end
+
+        def violation_type(resource)
+          :inclusion
+        end
+
+        def violation_data(resource)
+          [ [ :set, set.to_a.join(', ') ] ]
+        end
+
+      end # class Set
+    end # module Within
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule_set.rb

@@ -0,0 +1,80 @@
+# -*- encoding: utf-8 -*-
+
+require 'forwardable'
+require 'set'
+require 'aequitas/support/equalizable'
+
+module Aequitas
+  class RuleSet
+    # Holds a collection of Rule instances to be run against
+    # Resources to validate the Resources in a specific context
+
+    extend Equalizable
+    extend Forwardable
+    include Enumerable
+
+    equalize_on :rules
+
+    # @api public
+    def_delegators :attribute_index, :[], :fetch
+
+    # @api public
+    def_delegators :rules, :each, :empty?
+
+    # @api public
+    attr_reader :rules
+
+    # @api private
+    attr_reader :attribute_index
+
+    def initialize
+      @rules           = Set.new
+      @attribute_index = Hash.new { |h,k| h[k] = [] }
+    end
+
+    def <<(rule)
+      unless rules.include?(rule)
+        rules << rule
+        attribute_index[rule.attribute_name] << rule
+      end
+
+      self
+    end
+
+    # Execute all rules in this context against the resource.
+    # 
+    # @param [Object] resource
+    #   the resource to be validated
+    # 
+    # @return [Array(Violation)]
+    #   an Array of Violations
+    def validate(resource)
+      rules = rules_for_resource(resource)
+      rules.map { |rule| rule.validate(resource) }.compact
+      # TODO:
+      #   violations = rules.map { |rule| rule.validate(resource) }.compact
+      #   ViolationSet.new(resource).concat(violations)
+    end
+
+    # Assimilate all the rules from another RuleSet into the receiver
+    # 
+    # @param [RuleSet, Array] rules
+    #   The other RuleSet (or Array) whose rules are to be assimilated
+    # 
+    # @return [self]
+    def concat(rules)
+      rules.each { |rule| self << rule.dup }
+
+      self
+    end
+
+    def inspect
+      "#<#{ self.class } {#{ rules.map { |e| e.inspect }.join( ', ' ) }}>"
+    end
+
+    def rules_for_resource(resource)
+      rules.select { |r| r.execute?(resource) }
+    end
+
+  end # class RuleSet
+end # module Aequitas