vanguard 0.0.3

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

@@ -0,0 +1,10 @@
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+        class Predicate < self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+
+        # Rule for testing attribute presance
+        class Presence < self
+          TYPE = :presence
+          MATCHER = Matcher::Unary::NOT.new(Matcher::Nullary::BLANK)
+          register :validates_presence_of
+
+        private
+
+          # Initalize object
+          #
+          # @param [Symbol] attribute_name
+          # @param [Matcher] matcher
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def initialize(attribute_name, matcher = MATCHER)
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+      class Attribute
+
+        # Rule for testing primitives
+        class Primitive < self
+          TYPE = :primitive
+
+          # Builder for primitive rules
+          class Builder < Nullary::Builder
+            REQUIRED_OPTIONS = [:primitive].freeze
+
+          private
+
+            # Return matcher
+            #
+            # @return [MAtcher]
+            #
+            # @api private
+            #
+            def matcher
+              Matcher::Nullary::Primitive.new(options.fetch(:primitive))
+            end
+            memoize :matcher
+          end
+
+          register :validates_primitive_of
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,210 @@
+#encoding: utf-8
+
+module Vanguard
+  class Rule
+    class Nullary
+
+      # For for testing attribute confirmations
+      class Confirmation < self
+        include Equalizer.new(:attribute_name, :confirmation_attribute_name)
+
+        TYPE = :confirmation
+
+        # Builder for confirmation
+        class Builder < Nullary::Builder
+          OPTIONS = [:confirm]
+
+          # Abstract base class for confirmation attribute name generators
+          class Confirm
+            include Adamantium::Flat, AbstractType
+
+            Vanguard.singleton_constant(self, :DEFAULT) do
+
+              # Return confirmation attribute name
+              #
+              # @param [Symbol] attribute_name
+              #
+              # @return [Symbol]
+              #
+              # @api private
+              #
+              def confirmation_attribute_name(attribute_name)
+                :"#{attribute_name}_confirmation"
+              end
+
+            end
+
+            # Build confirm object
+            #
+            # @return [Confirm]
+            #
+            # @api private
+            #
+            def self.build(value)
+              case value
+              when value.respond_to?(:call)
+                Block.new(value)
+              when Symbol, String
+                Static.new(value.to_sym)
+              else
+                raise "Cannot build confirm option from: #{value.inspect}"
+              end
+            end
+
+            # Confirm attribute from block
+            class Block
+
+              # Return confirmation attribute name
+              #
+              # @param [Symbol] attribute_name
+              #
+              # @return [Symbol]
+              #
+              # @api private
+              #
+              def confirmation_attribute_name(attribute_name)
+                @block.call(attribute_name)
+              end
+
+            private
+
+              # Initialize object
+              #
+              # @param [Proc] block
+              #
+              # @return [undefined]
+              #
+              # @api private
+              def initialize(block)
+                @block = block
+              end
+            end
+
+            # Static confirmation attribute
+            class Static
+
+              # Return confirmation attribute name
+              #
+              # @param [Symbol] _attribute_name
+              #
+              # @return [Symbol]
+              #
+              # @api private
+              #
+              def confirmation_attribute_name(_attribute_name)
+                @confirmation_attribute_name
+              end
+
+            private
+
+              # Initialize object
+              #
+              # @param [Symbol] confirmation_attribute_name
+              #
+              # @return [undefined]
+              #
+              # @api private
+              #
+              def initialize(confirmation_attribute_name)
+                @confirmation_attribute_name = confirmation_attribute_name
+              end
+            end
+          end
+
+        private
+
+          # Return rule
+          #
+          # @param [Symbol] attribute_name
+          #
+          # @api private
+          #
+          def rule(attribute_name)
+            klass.new(attribute_name, confirm_option.confirmation_attribute_name(attribute_name))
+          end
+
+          # Return confirm object
+          #
+          # @return [Confirm]
+          #
+          # @api private
+          #
+          def confirm_option
+            option = options.fetch(:confirm) do
+              return Confirm::DEFAULT
+            end
+
+            Confirm.build(option)
+          end
+          memoize :confirm_option
+        end
+
+        register :validates_confirmation_of
+
+        # Return attribute name
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        attr_reader :attribute_name
+
+        # Return confirmation attribute name
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        attr_reader :confirmation_attribute_name
+
+        # Initialize object
+        #
+        # @param [Symbol] attribute_name
+        # @param [Symbol] confirmation_attribute_name
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(attribute_name, confirmation_attribute_name)
+          @attribute_name,
+          @confirmation_attribute_name =
+            attribute_name,
+            confirmation_attribute_name
+        end
+
+        # Evaluator for confirmation rule
+        class Evaluator < Vanguard::Evaluator
+          # Test if value is valid?
+          #
+          # @return [true]
+          #   if value is valid
+          #
+          # @return [false]
+          #   if value is valid
+          #
+          # @api private
+          #
+          def valid?
+            value.eql?(confirmation_value)
+          end
+          memoize :valid?
+
+        private
+
+          # Return confirmation value
+          #
+          # @return [Object]
+          #
+          # @api private
+          #
+          def confirmation_value
+            resource.public_send(rule.confirmation_attribute_name)
+          end
+          memoize :confirmation_value
+        end
+
+      end
+    end
+  end
+end

data/lib/vanguard/support/blank.rb

@@ -0,0 +1,29 @@
+module Vanguard
+
+  # Determines whether the specified +value+ is blank
+  #
+  # @param [Object] value
+  #
+  # @return [true]
+  #   if object is fale empty or a whitespace string
+  #
+  # @return [false]
+  #   otherwise
+  #
+  # @api private
+  #
+  def self.blank?(value)
+    case value
+    when ::NilClass, ::FalseClass
+      true
+    when ::TrueClass, ::Numeric
+      false
+    when ::Array, ::Hash
+      value.empty?
+    when ::String
+      value !~ /\S/
+    else
+      value.nil? || (value.respond_to?(:empty?) && value.empty?)
+    end
+  end
+end

data/lib/vanguard/validator.rb

@@ -0,0 +1,116 @@
+module Vanguard
+  # Validator compsed from many rules
+  class Validator
+    include Adamantium, Enumerable
+
+    # Run validator on resource
+    #
+    # @param [Resource] resource
+    #
+    # @return [Result]
+    #
+    # @api private
+    #
+    def call(resource)
+      Result.new(self, resource)
+    end
+
+    # Build validator
+    #
+    # @return [Validator]
+    #
+    # @api private
+    #
+    def self.build(&block)
+      Builder.new(&block).validator
+    end
+
+    # Return rules set with rule added
+    #
+    # @param [Rule] rule
+    #
+    # @return [Validator]
+    #
+    # @api private
+    #
+    def add(rule)
+      self.class.new(rules.dup << rule)
+    end
+
+    # Return rules on attribute name
+    #
+    # @param [Symbol] attribute_name
+    #
+    # @return [Enumerable<Rule>]
+    #
+    # @api private
+    #
+    def on(attribute_name)
+      rules.select { |rule| rule.attribute_name == attribute_name }
+    end
+
+    # Return rules
+    #
+    # @return [Set<Rule>]
+    #
+    # @api private
+    #
+    attr_reader :rules
+
+    # Enumerate rules
+    #
+    # @return [self]
+    #   if block given
+    #
+    # @return [Enumerator]
+    #   otherwise
+    #
+    # @api private
+    #
+    def each
+      return to_enum unless block_given?
+
+      rules.each { |rule| yield rule }
+
+      self
+    end
+
+  private
+
+    # Initialize object
+    #
+    # @param [Enumerable<Rule>] rules
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(rules)
+      @rules = rules.to_set
+    end
+
+    Vanguard.singleton_constant(self, :EMPTY) do
+
+      # Return rule set with added rule
+      #
+      # @param [Rule] rule
+      #
+      # @api private
+      #
+      def add(rule)
+        Validator.new([rule])
+      end
+
+    private
+
+      # Initialize object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize; end
+    end
+  end
+
+end

data/lib/vanguard/validator/builder.rb

@@ -0,0 +1,52 @@
+module Vanguard
+  class Validator
+    class Builder
+      include Vanguard::DSL
+
+      # Return rules
+      #
+      # @return [Enumerator<Rule>]
+      #
+      # @api private
+      #
+      attr_reader :rules
+
+      # Initialize object
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(&block)
+        @rules = []
+        if block_given?
+          instance_exec(&block)
+        end
+      end
+
+      # Add rule
+      #
+      # @param [Rule] rule
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def add(rule)
+        @rules << rule
+        self
+      end
+
+      # Return validator
+      #
+      # @return [Validator]
+      #
+      # @api private
+      #
+      def validator
+        Validator.new(rules)
+      end
+
+    end
+  end
+end