vanguard 0.0.3

data/lib/vanguard/matcher/nullary/identity.rb

@@ -0,0 +1,50 @@
+module Vanguard
+  class Matcher
+    class Nullary
+      # Equality matcher
+      class Identity < self
+        include Equalizer.new(:value)
+
+        # Return value
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        attr_reader :value
+
+        # Test if value for equality
+        #
+        # @param [Object] value
+        #
+        # @return [true]
+        #
+        # @return [false]
+        #
+        # @api private
+        #
+        def matches?(value)
+          value.equal?(self.value)
+        end
+
+      private
+
+        # Intialize object
+        #
+        # @param [Object] value
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(value)
+          @value = value
+        end
+
+        TRUE  = Identity.new(true)
+        FALSE = Identity.new(false)
+        NIL   = Identity.new(nil)
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/nullary/inclusion.rb

@@ -0,0 +1,67 @@
+module Vanguard
+  class Matcher
+    class Nullary
+
+      # Matcher that tests for inclusion of value
+      class Inclusion < self
+        include Equalizer.new(:accepted)
+
+        # Return accepted values
+        #
+        # @return [#include?]
+        #
+        # @api private
+        #
+        attr_reader :accepted
+
+        # Test if value is included
+        #
+        # @param [Object] value
+        #
+        # @return [true]
+        #   if value is included
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def matches?(value)
+          accepted.include?(value)
+        end
+
+      private
+
+        # Initialize object
+        #
+        # @param [#include?] accepted
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(accepted)
+          @accepted = accepted
+        end
+
+        # Build inclusion matcher
+        #
+        # @param [Object] value
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def self.build(value)
+          if value.respond_to?(:include?)
+            Inclusion.new(value)
+          elsif value.respond_to?(:call)
+            Proc.new(value)
+          else
+            raise "Cannot build inclusion matcher from: #{value.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/nullary/less_than.rb

@@ -0,0 +1,48 @@
+module Vanguard
+  class Matcher
+    class Nullary
+
+      # Less than matcher
+      class LessThan < self
+        include Equalizer.new(:value)
+
+        # Test if value is greater
+        #
+        # @param [Object] value
+        #
+        # @return [true]
+        #
+        # @return [false]
+        #
+        # @api private
+        #
+        def matches?(value)
+          value < self.value
+        end
+
+        # Return value
+        #
+        # @return [Object]
+        #
+        # @api private
+        #
+        attr_reader :value
+
+      private
+
+        # Initialize object
+        #
+        # @param [Object] value
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(value)
+          @value = value
+        end
+
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/nullary/primitive.rb

@@ -0,0 +1,47 @@
+module Vanguard
+  class Matcher
+    class Nullary
+
+      # Matcher that matches primitive types
+      class Primitive < self
+        include Equalizer.new(:primitive)
+
+        # Return primitive
+        #
+        # @return [Class] primitive
+        #
+        # @api private
+        #
+        attr_reader :primitive
+
+        # Test if value is kind of primitive
+        #
+        # @return [true]
+        #   if value is kind of primitive
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def matches?(value)
+          value.kind_of?(primitive)
+        end
+
+      private
+
+        # Initialize object
+        #
+        # @param [Class] primitive
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(primitive)
+          @primitive = primitive
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/nullary/proc.rb

@@ -0,0 +1,44 @@
+module Vanguard
+  class Matcher
+    class Nullary
+
+      # A matcher that delegates to block
+      class Proc < self
+        include Equalizer.new(:block)
+
+        # Return block
+        #
+        # @return [Proc]
+        #
+        # @api private
+        #
+        attr_reader :block
+
+        # Test if value matches
+        #
+        # @return [true]
+        #   if block returns non falsy value
+        #
+        # @return [false]
+        #   otherwise
+        #
+        def matches?(input)
+          !!@block.call(input)
+        end
+
+        # Initialize object
+        #
+        # @param [Proc] block
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(block)
+          @block = block
+        end
+
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/nullary/value.rb

@@ -0,0 +1,32 @@
+module Vanguard
+  class Matcher
+    class Nullary
+
+      # Module for generating value matchers
+      #
+      # TODO: Move somehere else
+      #
+      module Value
+
+        # Build value matcher
+        #
+        # @param [Object] value
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def self.build(value)
+          case value
+          when Range
+            Inclusion.new(value)
+          when Fixnum
+            Equality.new(value)
+          else
+            raise "Cannot build value matcher from: #{value.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/unary.rb

@@ -0,0 +1,45 @@
+module Vanguard
+  class Matcher
+
+    # Abstract base class for unary matchers
+    class Unary < self
+      include AbstractType, Equalizer.new(:operand)
+
+      # Return operand
+      #
+      # @return [Matcher]
+      #
+      # @api private
+      #
+      attr_reader :operand
+
+    private
+
+      # Test if operand matches
+      #
+      # @param [Object] value
+      #
+      # @return [true]
+      #
+      # @return [false]
+      #
+      # @api private
+      #
+      def operand_matches?(value)
+        operand.matches?(value)
+      end
+
+
+      # Initialize object
+      #
+      # @param [Matcher] operand
+      #
+      # @api private
+      #
+      def initialize(operand)
+        @operand = operand
+      end
+
+    end
+  end
+end

data/lib/vanguard/matcher/unary/attribute.rb

@@ -0,0 +1,49 @@
+module Vanguard
+  class Matcher
+    class Unary
+
+      # Matcher that matches on attribute of value
+      class Attribute < self
+
+        # Return operand result for length of value
+        #
+        # @return [true]
+        #   if operand returns false
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def matches?(value)
+          operand_matches?(value.public_send(attribute_name))
+        end
+
+        # Return attribute name
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        attr_reader :attribute_name
+
+      private
+
+        # Initialize object
+        #
+        # @param [Matcher] operand
+        # @param [Symbol] attribute_name
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(attribute_name, operand)
+          @attribute_name = attribute_name
+          super(operand)
+        end
+
+      end
+    end
+  end
+end

data/lib/vanguard/matcher/unary/not.rb

@@ -0,0 +1,25 @@
+module Vanguard
+  class Matcher
+    class Unary
+
+      # Boolean not matcher
+      class NOT < self
+
+        # Return inverse of operand
+        #
+        # @return [true]
+        #   if operand returns false
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def matches?(value)
+          !operand_matches?(value)
+        end
+
+      end
+    end
+  end
+end

data/lib/vanguard/result.rb

@@ -0,0 +1,93 @@
+# -*- encoding: utf-8 -*-
+
+module Vanguard
+
+  # Result of a resource validation
+  class Result
+    include Adamantium::Flat, Enumerable, Equalizer.new(:violations, :validator)
+
+    # Test if result is valid
+    #
+    # @return [true]
+    #   if no rules where violated
+    #
+    # @return [false]
+    #   otherwise
+    #
+    # @api private
+    #
+    def valid?
+      violations.empty?
+    end
+
+    alias_method :success?, :valid?
+
+    # Return violations for resource
+    #
+    # @param [Resource] resource
+    #
+    # @api private
+    #
+    def violations
+      validator.rules.each_with_object(Set.new) do |rule, violations|
+        violations.merge(rule.violations(resource))
+      end
+    end
+    memoize :violations
+
+    # The validation output
+    #
+    # @return [Object, Set<Violation>]
+    #   the valid resource, or a set of violations
+    #
+    # @api private
+    #
+    def output
+      valid? ? resource : violations
+    end
+
+    # Return violations on attribute name
+    #
+    # @param [Symbol] attribute_name
+    #
+    # @return [Enumerable<Violation>]
+    #
+    # @api private
+    #
+    def on(attribute_name)
+      violations.select { |violation| violation.attribute_name == attribute_name }
+    end
+
+    # Return resource
+    #
+    # @return [Resource]
+    #
+    # @api private
+    #
+    attr_reader :resource
+
+    # Return validator
+    #
+    # @return [Validator]
+    #
+    # @api private
+    #
+    attr_reader :validator
+
+  private
+
+    # Initialize object
+    #
+    # @param [Validator] validator
+    # @param [Resource] resource
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(validator, resource)
+      @validator, @resource = validator, resource
+    end
+
+  end # class ViolationSet
+end # module Vanguard