vanguard 0.0.3

data/lib/vanguard/rule.rb

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+module Vanguard
+
+  # Abstract base class for resource rules
+  class Rule
+    include AbstractType, Adamantium::Flat
+
+    # Return violations for resource
+    #
+    # @param [Resource] resource
+    #
+    # @return [Enumerable<Violations>]
+    #
+    def violations(resource)
+      evaluate(resource).violations
+    end
+
+    # Return evaluator for resource
+    #
+    # @param [Object] resource
+    #   the target object to be validated
+    #
+    # @return [Evaluator]
+    #
+    # @api private
+    #
+    def evaluate(resource)
+      evaluator.new(self, resource)
+    end
+
+    # Return evaluator
+    #
+    # @return [Class:Evaluator]
+    #
+    # @api private
+    #
+    def evaluator
+      self.class::Evaluator
+    end
+
+  end # class Rule
+end # module Vanguard

data/lib/vanguard/rule/guard.rb

@@ -0,0 +1,103 @@
+module Vanguard
+  class Rule
+    class Guard < self
+      # Return matcher
+      #
+      # @return [Matcher]
+      #
+      # @api private
+      #
+      attr_reader :matcher
+
+      # Return operand
+      #
+      # @return [Rule]
+      #
+      # @api private
+      #
+      attr_reader :operand
+
+      # Return attribute name
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def attribute_name
+        operand.attribute_name
+      end
+      memoize :attribute_name
+
+      # Return symbolic type
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def type
+        operand.type
+      end
+
+    private
+
+      # Intialize object
+      #
+      # @param [Matcher] matcher
+      #
+      # @param [Rule] operand
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(matcher, operand)
+        @matcher, @operand = matcher, operand
+      end
+
+      class Evaluator < Vanguard::Evaluator
+        # Test if resource is valid
+        #
+        # @return [true]
+        #   when guard matches and operand also
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def valid?
+          resource = self.resource
+
+          unless matcher.matches?(resource)
+            return true
+          end
+
+          operand.evaluate(resource).valid?
+        end
+
+      private
+
+        # Return matcher
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        def matcher
+          rule.matcher
+        end
+
+        # Return operand
+        #
+        # @return [Rule]
+        #
+        # @api private
+        #
+        def operand
+          rule.operand
+        end
+      end
+
+    end
+  end
+end

data/lib/vanguard/rule/nullary.rb

@@ -0,0 +1,81 @@
+module Vanguard
+  class Rule
+
+    # Abstract base class for nullary resource rules
+    class Nullary < self
+
+      # Register dsl method
+      #
+      # @param [Symbol] name
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def self.register(name)
+        DSL.register(name, Proxy.new(builder, self))
+        self
+      end
+      private_class_method :register
+
+      # Return builder for nullary rule
+      #
+      # @return [Class:Builder]
+      #
+      # @api private
+      #
+      def self.builder
+        self::Builder
+      end
+
+      # Return symbolic type of rule
+      #
+      # @return [Symbol]
+      #
+      # @api private
+      #
+      def type
+        self.class::TYPE
+      end
+
+      # Proxy class to simplify builder registration
+      class Proxy
+        include Adamantium::Flat
+
+        # Run builder with arguments
+        #
+        # @param [Enumerable<Object>] arguments
+        #
+        # @return [Enumerable<Rule>]
+        #
+        # @api private
+        #
+        def run(*arguments)
+          @builder.run(@klass, *arguments)
+        end
+
+      private
+
+        # Initialize object
+        #
+        # @param [Class:Builder] builder
+        # @param [Class:Rule] klass
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(builder, klass)
+          @builder, @klass = builder, klass
+        end
+      end
+
+      # Base class for nullary builders
+      #
+      # TODO: Remove this
+      #
+      class Builder < Builder::Nullary
+      end
+    end
+
+  end
+end

data/lib/vanguard/rule/nullary/attribute.rb

@@ -0,0 +1,69 @@
+module Vanguard
+  class Rule
+    # Abstract base class for nullary rules
+    class Nullary
+
+      class Attribute < self
+        include Equalizer.new(:attribute_name, :matcher)
+
+        # Return attribute name
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        attr_reader :attribute_name
+
+        # Return matcher
+        #
+        # @return [Matcher]
+        #
+        # @api private
+        #
+        attr_reader :matcher
+
+        # Initialize object
+        #
+        # @param [Symbol] attribute_name
+        #   the name of the attribute to validate.
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(attribute_name, matcher)
+          @attribute_name, @matcher = attribute_name, matcher
+        end
+
+        # Default evaluator
+        class Evaluator < Vanguard::Evaluator
+          # Test if value is valid
+          #
+          # @return [true]
+          #   if value is matched by matcher
+          #
+          # @return [false]
+          #   otherwise
+          #
+          # @api private
+          #
+          def valid?
+            matcher.matches?(value)
+          end
+          memoize :valid?
+
+          # Return matcher
+          #
+          # @return [Matcher]
+          #
+          # @api private
+          #
+          def matcher
+            rule.matcher
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/rule/nullary/attribute/absence.rb

@@ -0,0 +1,19 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+
+        # Attribute absence rule
+        class Absence < self
+
+          register :validates_absence_of
+          MATCHER = Matcher::Nullary::BLANK
+
+        end
+
+      end
+    end
+  end
+end

data/lib/vanguard/rule/nullary/attribute/format.rb

@@ -0,0 +1,46 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+
+        # Rule that tests inputs against formats
+        class Format < self
+          TYPE = :invalid
+
+          # Builder for format rule
+          class Builder < Builder::Nullary
+            REQUIRED_OPTIONS = [:format].freeze
+
+          private
+
+            # Return rule for attribute name
+            #
+            # @return [Rule]
+            #
+            # @api private
+            #
+            def rule(name)
+              klass.new(name, matcher)
+            end
+
+            # Return format matcher
+            #
+            # @return [Matcher::Format]
+            #
+            # @api private
+            #
+            def matcher
+              Matcher::Nullary::Format.build(options.fetch(:format))
+            end
+            memoize :matcher
+          end
+
+          register :validates_format_of
+
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/rule/nullary/attribute/inclusion.rb

@@ -0,0 +1,62 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+
+        # Rule that tests for inclusion
+        class Inclusion < self
+          TYPE = :inclusion
+
+          # Builder for inclusion rule
+          class Builder < Nullary::Builder
+            REQUIRED_OPTIONS = [:within]
+
+          private
+
+            # Return matcher
+            #
+            # @return [Matcher]
+            #
+            # @api private
+            #
+            def matcher
+              Matcher::Nullary::Inclusion.build(options.fetch(:within))
+            end
+            memoize :matcher
+          end
+
+          register :validates_inclusion_of
+
+
+          # Rule that tests for acceptance
+          class Acceptance < self
+            TYPE = :acceptance
+            DEFAULT_ACCEPTED_VALUES = [ '1', 1, 'true', true, 't' ].to_set.deep_freeze
+
+            # Builder for acceptance rule
+            class Builder < Nullary::Builder
+              OPTIONS = [:accept]
+
+            private
+
+              # Return matcher
+              #
+              # @return [Matcher]
+              #
+              # @api private
+              #
+              def matcher
+                Matcher::Nullary::Inclusion.new(options.fetch(:acccept) { DEFAULT_ACCEPTED_VALUES })
+              end
+              memoize :matcher
+            end
+
+            register :validates_acceptance_of
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/rule/nullary/attribute/length.rb

@@ -0,0 +1,184 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+
+        # Rule that for length of attribute
+        class Length < self
+          TYPE = :length
+
+          # Builder for length rule
+          class Builder < Nullary::Builder
+            OPTIONS = [:length, :minimum, :maximum]
+
+          private
+
+            # Return matcher
+            #
+            # @return [Matcher]
+            #
+            # @api private
+            #
+            def matcher
+              assert_not_empty
+              assert_no_conflict
+
+              length || minmax || minimum || maximum
+            end
+            memoize :matcher
+
+            # Return minmax matcher
+            #
+            # @return [Matcher]
+            #   if :minimum and :maximum are present
+            #
+            # @return [nil]
+            #   otherwise
+            #
+            # @api private
+            #
+            def minmax
+              min, max = minimum, maximum
+
+              if min and max
+                return Matcher::Binary::AND.new(min, max)
+              end
+            end
+            memoize :minmax
+
+            # Assert options are not in conflict
+            #
+            # @return [undefined]
+            #
+            # @raise
+            #   if options are in conflict
+            #
+            # @api private
+            #
+            def assert_no_conflict
+              if length and (minimum or maximum)
+                raise ":length option is XOR to (:minimum or :maximum)"
+              end
+            end
+
+            # Assert options are not empty
+            #
+            # @return [undefined]
+            #
+            # @raise
+            #   if non option is given
+            #
+            # @api private
+            #
+            def assert_not_empty
+              if options.empty?
+                raise ":length, :maxmimum or :minimum must be given as option"
+              end
+            end
+
+            # Return minium matcher
+            #
+            # @return [Matcher]
+            #   if :minimum option is specified
+            #
+            # @return [nil]
+            #   otherwise
+            #
+            # @api private
+            #
+            def minimum
+              process(:minimum, Matcher::Nullary::GreaterThan)
+            end
+            memoize :minimum
+
+            # Return maxmimum matcher
+            #
+            # @return [Matcher]
+            #   if :maximum option is specified
+            #
+            # @return [nil]
+            #   otherwise
+            #
+            # @api private
+            #
+            def maximum
+              process(:maximum, Matcher::Nullary::LessThan)
+            end
+            memoize :maximum
+
+            # Return matcher
+            #
+            # @param [Symbol] key
+            # @param [Class] klass
+            #
+            # @return [Matcher]
+            #   if key option is present
+            #
+            # @return [nil]
+            #   otherwise
+            #
+            # @api private
+            #
+            def process(key, klass)
+              option = options.fetch(key) { return }
+              Matcher::Binary::OR.new(
+                klass.new(option),
+                Matcher::Nullary::Equality.new(option)
+              )
+            end
+
+            # Return length matcher
+            #
+            # @return [Matcher]
+            #   if :length option is specified
+            #
+            # @return [nil]
+            #   otherwise
+            #
+            # @api private
+            #
+            def length
+              option = options.fetch(:length) { return }
+              Matcher::Nullary::Value.build(option)
+            end
+            memoize :length
+          end
+          register :validates_length_of
+
+          # Evaluator for length rules
+          class Evaluator < Attribute::Evaluator
+
+            # Test if value is valid
+            #
+            # @return [true]
+            #   if value is valid
+            #
+            # @return [false]
+            #   otherwise
+            #
+            # @api private
+            #
+            def valid?
+              matcher.matches?(length)
+            end
+            memoize :valid?
+
+            # Return length
+            #
+            # @return [Fixnum]
+            #
+            # @api private
+            #
+            def length
+              value.length
+            end
+            memoize :length
+
+          end
+        end
+      end
+    end
+  end
+end