vanguard 0.0.3

data/lib/vanguard/builder.rb

@@ -0,0 +1,14 @@
+module Vanguard
+  # Abstract base class for builders
+  class Builder
+    include Adamantium::Flat, AbstractType
+
+    # Return rules
+    #
+    # @return [Enumerable<Rule>]
+    #
+    # @api private
+    #
+    abstract_method :rules
+  end
+end

data/lib/vanguard/builder/nullary.rb

@@ -0,0 +1,182 @@
+module Vanguard
+  class Builder
+    # Abstract base class for nullary builders
+    class Nullary < self
+      include AbstractType
+
+      OPTIONS          = [].freeze
+      REQUIRED_OPTIONS = [].freeze
+
+      # Return options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      attr_reader :options
+
+      # Return arguments
+      #
+      # @return [Class]
+      #
+      # @api private
+      #
+      attr_reader :klass
+
+      # Return arguments
+      #
+      # @return [Enumerable<Object>]
+      #
+      # @api private
+      #
+      attr_reader :arguments
+
+      # Return rule for attribute name
+      #
+      # @param [Symbol] attribute_name
+      #
+      # @return [Rule]
+      #
+      # @api private
+      #
+      def rule(attribute_name)
+        klass.new(attribute_name, matcher)
+      end
+
+      # Return matcher
+      #
+      # @return [Matcher]
+      #
+      # @api private
+      #
+      def matcher
+        klass::MATCHER
+      end
+
+      # Return rules
+      #
+      # @api private
+      #
+      def rules
+        arguments.map do |attribute_name|
+          rule(attribute_name)
+        end
+      end
+      memoize :rules
+
+      # Return allowed options
+      #
+      # @return [Enumerable<Symbol>]
+      #
+      # @api private
+      #
+      def allowed_options
+        self.class::OPTIONS
+      end
+
+      # Return required options
+      #
+      # @return [Enumerable<Symbol>]
+      #
+      # @api private
+      #
+      def required_options
+        self.class::REQUIRED_OPTIONS
+      end
+
+      # Run builder
+      #
+      # @return [Enumerable<Rule>]
+      #
+      # @api private
+      #
+      def self.run(*arguments)
+        new(*arguments).rules
+      end
+
+    private
+
+      # Initialize object
+      #
+      # @param [Class] klass
+      # @param [Enumerable<Object>] arguments
+      # @param [Hash] options
+      #
+      # @api private
+      #
+      def initialize(klass, arguments, options)
+        @klass, @arguments, @options = klass, arguments, options
+        assert_known_options
+        assert_required_options
+        assert_arguments
+      end
+
+      # Assert arguments are present
+      #
+      # TODO: Raise more specific expection
+      #
+      # @return [undefined]
+      #
+      # @raise [RuntimeError]
+      #   if arguments are empty
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def assert_arguments
+        if arguments.empty?
+          raise "#{klass} needs at least one attribute name"
+        end
+      end
+
+      # Assert no unknown options are present
+      #
+      # TODO: Raise more specific exception
+      #
+      # @raise [RuntimeError]
+      #   if unknown options are present
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def assert_known_options
+        unknown = present_keys - (allowed_options + required_options)
+
+        unless unknown.empty?
+          raise "Unknown options: #{unknown.inspect}"
+        end
+      end
+
+      # Return present option keys
+      #
+      # @return [Enumerable<Object>]
+      #
+      # @api private
+      #
+      def present_keys
+        options.keys
+      end
+
+      # Assert required options are present
+      #
+      # TODO: Raise more specific exception
+      #
+      # @raise [RuntimeException]
+      #   if required options are not present
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def assert_required_options
+        missing = required_options - present_keys
+
+        unless missing.empty?
+          raise "Missing options: #{missing.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/vanguard/dsl.rb

@@ -0,0 +1,43 @@
+# -*- encoding: utf-8 -*-
+
+module Vanguard
+  # Mixin for the Vanguard dsl
+  module DSL
+
+    REGISTRY = {}
+
+    # Register macro
+    #
+    # @param [Symbol] name
+    #
+    # @param [Class] klass
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def self.register(name, klass)
+      REGISTRY[name] = klass
+      self
+    end
+
+    # Hook called when method is missing
+    #
+    # @param [Symbol] method_name
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def method_missing(method_name, *arguments)
+      klass = REGISTRY.fetch(method_name) { super }
+
+      Evaluator.new(klass, arguments).rules.each do |rule|
+        add(rule)
+      end
+
+      self
+    end
+
+  end # module Macros
+end # module Vanguard

data/lib/vanguard/dsl/evaluator.rb

@@ -0,0 +1,197 @@
+module Vanguard
+  module DSL
+    class Evaluator
+      include Adamantium::Flat
+
+      # Return klass
+      #
+      # @return [Class]
+      #
+      # @api private
+      #
+      attr_reader :klass
+
+      # Return options hash
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      attr_reader :options
+
+      # Return arguments array
+      #
+      # @return [Array]
+      #
+      # @api private
+      #
+      attr_reader :arguments
+
+      # Return rules
+      #
+      # @return [Enumerable<Rule>]
+      #
+      # @api private
+      #
+      def rules
+        klass.run(arguments, rule_options).map do |rule|
+          connector.connect(rule)
+        end
+      end
+      memoize :rules
+
+    private
+
+      # Initialize object
+      #
+      # @param [Class] klass
+      # @param [Enumerable<Object>] arguments
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(klass, arguments)
+        @klass     = klass
+        @options   = arguments.last.kind_of?(Hash) ? arguments.pop : {}
+        @arguments = arguments
+        assert_no_conflict
+      end
+
+      # Return connector
+      #
+      # @return [Connector]
+      #
+      # @api private
+      #
+      def connector
+        if_connector || unless_connector || Connector::NONE
+      end
+      memoize :connector
+
+      class Connector
+        include Adamantium::Flat, Equalizer.new(:klass, :left)
+
+        # Return klass
+        #
+        # @return [Class]
+        #
+        # @api private
+        #
+        attr_reader :klass
+
+        # Return left rule
+        #
+        # @return [Rule]
+        #
+        # @api private
+        #
+        attr_reader :left
+
+        # Return connected rule
+        #
+        # @return [Rule] right
+        #
+        # @api private
+        #
+        def connect(right)
+          @klass.new(left, right)
+        end
+
+        Vanguard.singleton_constant(self, :NONE) do
+
+          # Return connector
+          #
+          # @param [Rule] right
+          #
+          # @return [Rule]
+          #
+          # @api private
+          #
+          def connect(right)
+            right
+          end
+
+        private
+
+          # Initialize object
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def initialize; end
+
+        end
+
+      private
+
+        # Initialize object
+        #
+        # @param [Class] klass
+        # @param [Rule] left
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(klass, left)
+          @klass, @left = klass, left
+        end
+      end
+
+      # Return if connector
+      #
+      # @return [Connector]
+      #   if :if option is present
+      #
+      # @api private
+      #
+      def if_connector
+        name = options.fetch(:if) { return }
+        predicate = Matcher::Unary::Attribute.new(name, Matcher::Nullary::Identity::TRUE)
+        Connector.new(Rule::Guard, predicate)
+      end
+
+      # Return unless connector
+      #
+      # @return [Connector]
+      #   if :unless option is present
+      #
+      # @api private
+      #
+      def unless_connector
+        name = options.fetch(:unless) { return }
+        predicate = Matcher::Unary::Attribute.new(name, Matcher::Nullary::Identity::TRUE)
+        predicate = Matcher::Unary::NOT.new(perdicate)
+        Connector.new(Rule::Guard, rule)
+      end
+
+      # Assert no conflicting connectors are present
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def assert_no_conflict
+        if if_connector and unless_connector
+          raise "Cannot specify both :if and :unless options"
+        end
+      end
+
+      # Return rule options
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      def rule_options
+        options = self.options.dup
+        options.delete(:if)
+        options.delete(:unless)
+        options
+      end
+      memoize :rule_options
+    end
+  end
+end

data/lib/vanguard/evaluator.rb

@@ -0,0 +1,72 @@
+module Vanguard
+  # Abstract base class for rule evaluators
+  class Evaluator
+    include Adamantium::Flat, AbstractType, Equalizer.new(:rule, :resource, :valid?)
+
+    # Return validated resource
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    attr_reader :resource
+
+    # Return rule
+    #
+    # @return [Rule]
+    #
+    # @api private
+    #
+    attr_reader :rule
+
+    # Initialize object
+    #
+    # @param [Rule] rule
+    # @param [Object] resource
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(rule, resource)
+      @rule, @resource = rule, resource
+    end
+
+    # Return value to be validated
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    def value
+      resource.public_send(rule.attribute_name)
+    end
+    memoize :value
+
+    # Return violation
+    #
+    # @return [Violation]
+    #
+    # @api private
+    #
+    def violation
+      Violation.new(rule, resource)
+    end
+    memoize :violation
+
+    # Return violations
+    #
+    # @return [Enumerable<Violation>]
+    #
+    # @api private
+    #
+    def violations
+      unless valid?
+        [violation]
+      else
+        []
+      end
+    end
+    memoize :violations
+  end
+end