aequitas 0.0.1

data/lib/aequitas/message_transformer.rb

@@ -0,0 +1,127 @@
+# -*- encoding: utf-8 -*-
+
+module Aequitas
+  # Transforms Violations to error message strings.
+  #
+  # @abstract
+  #   Subclass and override {#transform} to implement a custom message
+  #   transformer. Use {Violation.message_transformer=} to set a new
+  #   message transformer or pass the transformer to {Violation#message}.
+  class MessageTransformer
+    def self.default
+      defined?(I18n) ? DefaultI18n.new : Default.new
+    end
+
+    # Transforms the specified Violation to an error message string.
+    #
+    # @param [Violation] violation
+    #   The Violation to transform.
+    # 
+    # @return [String]
+    #   The transformed message.
+    #
+    # @raise [ArgumentError]
+    #   +violation+ is +nil+.
+    def transform(violation)
+      raise NotImplementedError, "#{self.class}#transform has not been implemented"
+    end
+
+    class Default < self
+      @error_messages = {
+        :nil                      => '%s must not be nil',
+        :blank                    => '%s must not be blank',
+        :not_nil                  => '%s must be nil',
+        :not_blank                => '%s must be blank',
+        :invalid                  => '%s has an invalid format',
+        :inclusion                => '%s must be one of %s',
+        :accepted                 => '%s is not accepted',
+        :confirmation             => '%s does not match the confirmation',
+        :length_between           => '%s must be between %s and %s characters long',
+        :too_long                 => '%s must be at most %s characters long',
+        :too_short                => '%s must be at least %s characters long',
+        :wrong_length             => '%s must be %s characters long',
+        :not_a_number             => '%s must be a number',
+        :not_an_integer           => '%s must be an integer',
+        :greater_than             => '%s must be greater than %s',
+        :greater_than_or_equal_to => '%s must be greater than or equal to %s',
+        :equal_to                 => '%s must be equal to %s',
+        :not_equal_to             => '%s must not be equal to %s',
+        :less_than                => '%s must be less than %s',
+        :less_than_or_equal_to    => '%s must be less than or equal to %s',
+        :value_between            => '%s must be between %s and %s',
+        :not_unique               => '%s is already taken',
+        :primitive                => '%s must be of type %s'
+      }
+
+      class << self
+        # Gets the hash of error messages used to transform violations.
+        #
+        # @return [Hash{Symbol=>String}]
+        attr_reader :error_messages
+      end
+
+      # Merges the specified +error_messages+ hash into the internal hash of
+      # error messages.
+      #
+      # @param [Hash{Symbol=>String}] error_messages
+      #   The error messages to be merged.
+      def self.error_messages=(error_messages)
+        unless error_messages.is_a?(Hash)
+          raise ArgumentError, "+error_messages+ must be a hash" 
+        end
+
+        self.error_messages.merge!(error_messages)
+      end
+
+      def self.error_message(violation_type, attribute_name, violation_values)
+        if message = self.error_messages[violation_type]
+          attribute_name = DataMapper::Inflector.humanize(attribute_name)
+          message % [attribute_name, *violation_values].flatten
+        else
+          violation_type.to_s
+        end
+      end
+
+      def transform(violation)
+        raise ArgumentError, "+violation+ must be specified" if violation.nil?
+
+        attribute_name = violation.attribute_name
+
+        self.class.error_message(violation.type, attribute_name, violation.values)
+      end
+    end # class Default
+
+    class DefaultI18n < self
+      def initialize
+        require 'i18n'
+      end
+
+      def transform(violation)
+        raise ArgumentError, "+violation+ must be specified" if violation.nil?
+
+        resource       = violation.resource
+        model_name     = resource.model.model_name
+        attribute_name = violation.attribute_name
+        # TODO: Include attribute value in Violation; it may have changed by now
+        # attribute_value = violation.attribute_value
+
+        options = {
+          :model     => ::I18n.translate("models.#{model_name}"),
+          :attribute => ::I18n.translate("attributes.#{model_name}.#{attribute_name}"),
+          # TODO: Include attribute value in Violation; it may have changed by now
+          :value     => resource.validation_attribute_value(attribute_name)
+        }.merge(violation.info)
+
+        ::I18n.translate("#{i18n_namespace}.#{violation.type}", options)
+      end
+
+      # configure the I18n namespace used for looking up error message text
+      attr_writer :i18n_namespace
+
+      def i18n_namespace
+        @i18n_namespace || 'aequitas.validation.errors'
+      end
+    end # class DefaultI18n
+
+  end # class MessageTransformer
+end # module Aequitas

data/lib/aequitas/rule.rb

@@ -0,0 +1,153 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/support/blank'
+require 'aequitas/support/equalizable'
+require 'aequitas/rule/guard'
+require 'aequitas/rule/skip_condition'
+require 'aequitas/violation'
+
+module Aequitas
+  class Rule
+    extend Equalizable
+
+    equalize_on :attribute_name, :custom_message, :guard, :skip_condition
+
+    # @api private
+    attr_reader :attribute_name
+    # @api private
+    attr_reader :custom_message
+    # @api private
+    attr_reader :guard
+    # @api private
+    attr_reader :skip_condition
+
+    # Get the validators for the given attribute_name and options
+    # 
+    # @param [Symbol] attribute_name
+    #   the name of the attribute to which the returned validators will be bound
+    # @param [Hash] options
+    #   the options with which to configure the returned validators
+    # 
+    # @return [#each(Rule)]
+    #   a collection of validators which collectively
+    # 
+    def self.rules_for(attribute_name, options, &block)
+      Array(new(attribute_name, options, &block))
+    end
+
+    # Construct a validator. Capture the :if and :unless clauses when
+    # present.
+    #
+    # @param [String, Symbol] attribute_name
+    #   The name of the attribute to validate.
+    #
+    # TODO: remove Hash as a value for :message
+    #   (see Violation#[] in backwards.rb)
+    # 
+    # @option [String, Hash] :message
+    #   A custom message that will be used for any violations of this rule
+    # @option [Symbol, Proc] :if
+    #   The name of a method (on the valiated resource) or a Proc to call
+    #   (with the resource) to determine if the rule should be applied.
+    # @option [Symbol, Proc] :unless
+    #   The name of a method (on the valiated resource) or a Proc to call
+    #   (with the resource) to determine if the rule should *not* be applied.
+    # @option [Boolean] :allow_nil
+    #   Whether to skip applying this rule on nil values
+    # @option [Boolean] :allow_blank
+    #   Whether to skip applying this rule on blank values
+    def initialize(attribute_name, options = {})
+      @attribute_name = attribute_name
+      @custom_message = options.fetch(:message, nil)
+      @guard          = options.fetch(:guard)          { Guard.new(options) }
+      @skip_condition = options.fetch(:skip_condition) { SkipCondition.new(options) }
+    end
+
+    # Validate the +resource+ arg against this Rule
+    # 
+    # @param [Object] resource
+    #   the target object to be validated
+    # 
+    # @return [NilClass, Violation]
+    #   NilClass if +resource+ is valid
+    #   Violation with additional info if +resource+ is invalid
+    def validate(resource)
+      if valid?(resource)
+        nil
+      else
+        Violation.new(resource, custom_message, self)
+      end
+    end
+
+    # Determines if this validator should be run against the resource
+    # by delegating to the guard configured for this rule
+    def execute?(resource)
+      guard.allow?(resource)
+    end
+
+    # Test the value to see if it is blank or nil, and if it is allowed.
+    # Note that allowing blank without explicitly denying nil allows nil
+    # values, since nil.blank? is true.
+    #
+    # @param [Object] value
+    #   The value to test.
+    #
+    # @return [Boolean]
+    #   true if blank/nil is allowed, and the value is blank/nil.
+    #
+    # @api private
+    def skip?(value)
+      skip_condition.skip?(value)
+    end
+
+    def attribute_value(resource)
+      resource.validation_attribute_value(attribute_name)
+    end
+
+    # @api private
+    def violation_info(resource)
+      Hash[ violation_data(resource) ]
+    end
+
+    # @api private
+    def violation_values(resource)
+      violation_data(resource).map { |(_, value)| value }
+    end
+
+    # @api private
+    def violation_data(resource)
+      [ ]
+    end
+
+    alias_method :to_s, :inspect
+
+  private
+
+    # def allow_nil!
+    #   @allow_nil = true
+    # end
+
+    # def allow_blank!
+    #   @allow_blank = true
+    # end
+
+    # Get the corresponding Resource property, if it exists.
+    #
+    # Note: DataMapper validations can be used on non-DataMapper resources.
+    # In such cases, the return value will be nil.
+    # 
+    # @api private
+    def get_resource_property(resource, property_name)
+      model = resource.model if resource.respond_to?(:model)
+      repository = resource.repository               if model
+      properties = model.properties(repository.name) if model
+      properties[property_name]                      if properties
+    end
+
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/absence.rb

@@ -0,0 +1,14 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    class Absence < Rule
+
+    end # class Absence
+  end # class Rule
+end # module Aequitas
+
+require 'aequitas/rule/absence/blank'
+require 'aequitas/rule/absence/nil'

data/lib/aequitas/rule/absence/blank.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/absence'
+
+module Aequitas
+  class Rule
+    class Absence
+      class Blank < Absence
+
+        def valid?(resource)
+          Aequitas.blank?(attribute_value(resource))
+        end
+
+        def violation_type(resource)
+          :not_blank
+        end
+
+      end # class Blank
+    end # class Absence
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/absence/nil.rb

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule/absence'
+
+module Aequitas
+  class Rule
+    class Absence
+      class Nil < Absence
+
+        def valid?(resource)
+          attribute_value(resource).nil?
+        end
+
+        def violation_type(resource)
+          :not_nil
+        end
+
+      end # class Nil
+    end # class Absence
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/acceptance.rb

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    # TODO: update this to inherit from Rule::Within::Set
+    class Acceptance < Rule
+
+      equalize_on *(superclass.equalizer.keys + [:accept])
+
+      DEFAULT_ACCEPTED_VALUES = [ '1', 1, 'true', true, 't' ]
+
+      attr_reader :accept
+
+      def initialize(attribute_name, options = {})
+        super
+
+        @accept = Array(options.fetch(:accept, DEFAULT_ACCEPTED_VALUES))
+
+        skip_condition.default_to_allowing_nil!
+      end
+
+      def valid?(resource)
+        value = attribute_value(resource)
+
+        skip?(value) || accept.include?(value)
+      end
+
+      def violation_type(resource)
+        :accepted
+      end
+
+    end # class Acceptance
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/block.rb

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    class Block < Rule
+
+      attr_reader :block
+
+      def initialize(attribute_name, options, &block)
+        unless block_given?
+          raise ArgumentError, 'cannot initialize a Block validator without a block'
+        end
+
+        super
+
+        @block = block
+      end
+
+      def validate(resource)
+        result, error_message = resource.instance_eval(&self.block)
+
+        if result
+          nil
+        else
+          Violation.new(resource, error_message, self)
+        end
+      end
+
+    end # class Block
+  end # class Rule
+end # module Aequitas

data/lib/aequitas/rule/confirmation.rb

@@ -0,0 +1,41 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/rule'
+
+module Aequitas
+  class Rule
+    class Confirmation < Rule
+
+      equalize_on *(superclass.equalizer.keys + [:confirmation_attribute_name])
+
+      attr_reader :confirmation_attribute_name
+
+
+      def initialize(attribute_name, options = {})
+        super
+
+        @confirmation_attribute_name = options.fetch(:confirm) do
+          :"#{attribute_name}_confirmation"
+        end
+
+        skip_condition.default_to_allowing_nil!
+        skip_condition.default_to_allowing_blank!
+      end
+
+      def valid?(resource)
+        value = attribute_value(resource)
+
+        skip?(value) || value == confirmation_value(resource)
+      end
+
+      def confirmation_value(resource)
+        resource.instance_variable_get("@#{@confirmation_attribute_name}")
+      end
+
+      def violation_type(resource)
+        :confirmation
+      end
+
+    end # class Confirmation
+  end # class Rule
+end # module Aequitas