aequitas 0.0.1

data/lib/aequitas/version.rb

@@ -0,0 +1,5 @@
+# -*- encoding: utf-8 -*-
+
+module Aequitas
+  VERSION = "0.0.1"
+end

data/lib/aequitas/violation.rb

@@ -0,0 +1,116 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/exceptions'
+require 'aequitas/support/equalizable'
+require 'aequitas/message_transformer'
+
+module Aequitas
+  class Violation
+    extend Aequitas::Equalizable
+
+    equalize_on :resource, :rule, :custom_message, :attribute_name
+
+    def self.default_transformer
+      @default_transformer ||= MessageTransformer.default
+    end
+
+    def self.default_transformer=(transformer)
+      @default_transformer = transformer
+    end
+
+    attr_reader :resource
+    attr_reader :custom_message
+    attr_reader :rule
+    attr_reader :attribute_name
+
+    # Configure a Violation instance
+    # 
+    # @param [Object] resource
+    #   the validated object
+    # @param [String, #call, Hash] message
+    #   an optional custom message for this Violation
+    # @param [Rule] rule
+    #   the Rule whose violation triggered the creation of the receiver
+    # @param [Symbol] attribute_name
+    #   the name of the attribute whose validation rule was violated
+    #   or nil, if a Rule was provided.
+    # 
+    def initialize(resource, message = nil, rule = nil, attribute_name = nil)
+      unless message || rule
+        raise ArgumentError, "expected +message+ or +rule+"
+      end
+
+      @resource       = resource
+      @rule           = rule
+      @attribute_name = attribute_name
+      @custom_message = evaluate_message(message)
+    end
+
+    # @api public
+    def message(transformer = Undefined)
+      return @custom_message if @custom_message
+
+      transformer = Undefined == transformer ? self.transformer : transformer
+
+      transformer.transform(self)
+    end
+
+    # @api public
+    alias_method :to_s, :message
+
+    # @api public
+    def attribute_name
+      if @attribute_name
+        @attribute_name
+      elsif rule
+        rule.attribute_name
+      end
+    end
+
+    # @api public
+    def type
+      rule ? rule.violation_type(resource) : nil
+    end
+
+    # @api public
+    def info
+      rule ? rule.violation_info(resource) : { }
+    end
+
+    def values
+      rule ? rule.violation_values(resource) : [ ]
+    end
+
+    def transformer
+      if resource.respond_to?(:validation_rules) && transformer = resource.validation_rules.transformer
+        transformer
+      else
+        Violation.default_transformer
+      end
+    end
+
+    def evaluate_message(message)
+      if message.respond_to?(:call)
+        if resource.respond_to?(:model) && resource.model.respond_to?(:properties)
+          property = resource.model.properties[attribute_name]
+          message.call(resource, property)
+        else
+          message.call(resource)
+        end
+      else
+        message
+      end
+    end
+
+    # In general we want Aequitas::Equalizable-type equality/equivalence,
+    # but this allows direct equivalency test against Strings, which is handy
+    def ==(other)
+      if other.respond_to?(:to_str)
+        self.to_s == other.to_str
+      else
+        super
+      end
+    end
+
+  end # class Violation
+end # module Aequitas

data/lib/aequitas/violation_set.rb

@@ -0,0 +1,123 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/support/blank'
+require 'aequitas/support/ordered_hash'
+require 'aequitas/violation'
+
+module Aequitas
+  class ViolationSet
+
+    include Enumerable
+
+    # @api private
+    attr_reader :resource
+
+    # @api private
+    attr_reader :violations
+    # TODO: why was this private?
+    private :violations
+
+    # TODO: replace OrderedHash with OrderedSet and remove vendor'd OrderedHash
+    def initialize(resource)
+      @resource   = resource
+      @violations = OrderedHash.new { |h,k| h[k] = [] }
+    end
+
+    # Clear existing validation violations.
+    # 
+    # @api public
+    def clear
+      violations.clear
+    end
+
+    # Add a validation error. Use the attribute_name :general if the violations
+    # does not apply to a specific field of the Resource.
+    #
+    # @param [Symbol, Violation] attribute_name_or_violation
+    #   The name of the field that caused the violation, or
+    #   the Violation which describes the validation violation
+    # @param [NilClass, String, #call, Hash] message
+    #   The message to add.
+    # 
+    # @see Violation#initialize
+    # 
+    # @api public
+    def add(attribute_name_or_violation, message = nil)
+      violation = 
+        if attribute_name_or_violation.kind_of?(Violation)
+          attribute_name_or_violation
+        else
+          # TODO: Violation.from_message(resource, message, attribute_name_or_violation)
+          Violation.new(resource, message, nil, attribute_name_or_violation)
+        end
+
+      self << violation
+    end
+
+    def <<(violation)
+      violations[violation.attribute_name] << violation
+      self
+    end
+
+    def concat(other)
+      other.each { |violation| self << violation }
+    end
+
+    # Collect all violations into a single list.
+    # 
+    # @api public
+    def full_messages
+      violations.inject([]) do |list, (attribute_name, violations)|
+        messages = violations
+        messages = violations.full_messages if violations.respond_to?(:full_messages)
+        list.concat(messages)
+      end
+    end
+
+    # Return validation violations for a particular attribute_name.
+    #
+    # @param [Symbol] attribute_name
+    #   The name of the field you want an violation for.
+    #
+    # @return [Array(Violation, String), NilClass]
+    #   Array of Violations, if there are violations on +attribute_name+
+    #   nil if there are no violations on +attribute_name+
+    # 
+    # @api public
+    # 
+    # TODO: use a data structure that ensures uniqueness
+    def on(attribute_name)
+      attribute_violations = violations[attribute_name]
+      attribute_violations.empty? ? nil : attribute_violations.uniq
+    end
+
+    # @api public
+    def each
+      violations.each_value do |v|
+        yield(v) unless Aequitas.blank?(v)
+      end
+    end
+
+    # @api public
+    def empty?
+      violations.all? { |_, violations| violations.empty? }
+    end
+
+    # @api public
+    # 
+    # FIXME: calling #to_sym on uncontrolled input is an
+    # invitation for a memory leak
+    def [](attribute_name)
+      violations[attribute_name.to_sym]
+    end
+
+    def method_missing(meth, *args, &block)
+      violations.send(meth, *args, &block)
+    end
+
+    def respond_to?(method)
+      super || violations.respond_to?(method)
+    end
+
+  end # class ViolationSet
+end # module Aequitas

data/lib/aequitas/virtus.rb

@@ -0,0 +1,29 @@
+require 'aequitas/virtus/inline_attribute_rule_extractor'
+
+module Virtus
+  class Attribute
+    Object.accept_options  :required# , :prohibited, :forbidden # hmm...
+    String.accept_options  :length, :format
+    Decimal.accept_options :precision, :scale
+    Float.accept_options   :precision, :scale
+  end
+end
+
+module Aequitas
+  module ClassMethods
+    def self.extended(base)
+      super
+      base.extend Aequitas::Virtus::ClassMethodOverrides
+    end
+  end
+
+  module Virtus
+    module ClassMethodOverrides
+      def virtus_add_attribute(attribute)
+        super
+        inline_attribute_rules = InlineAttributeRuleExtractor.extract(attribute)
+        validation_rules.context(:default).concat(inline_attribute_rules)
+      end
+    end
+  end
+end

data/lib/aequitas/virtus/inline_attribute_rule_extractor.rb

@@ -0,0 +1,41 @@
+module Aequitas
+  module Virtus
+    class InlineAttributeRuleExtractor
+
+      def self.extract(attribute)
+        type = 
+          case attribute
+          when ::Virtus::Attribute::Boolean;  self::Boolean
+          when ::Virtus::Attribute::String;   self::String
+          # when ::Virtus::Attribute::Decimal;  self::Decimal
+          # when ::Virtus::Attribute::Float;    self::Float
+          when ::Virtus::Attribute::Object;   self::Object
+          end
+        type.new(attribute).extract
+      end
+
+      attr_reader :attribute
+
+      def initialize(attribute)
+        @attribute = attribute
+      end
+
+      def options
+        attribute.options
+      end
+
+      def extract
+        rules = []
+        rules.concat Array(extract_presence_rules) if options.fetch(:required, false)
+        rules.concat Array(extract_length_rules)   if options.fetch(:length,   false)
+        rules.concat Array(extract_format_rules)   if options.fetch(:format,   false)
+        rules
+      end
+
+    end
+  end # module Virtus
+end # module Aequitas
+
+require 'aequitas/virtus/inline_attribute_rule_extractor/object'
+require 'aequitas/virtus/inline_attribute_rule_extractor/boolean'
+require 'aequitas/virtus/inline_attribute_rule_extractor/string'

data/lib/aequitas/virtus/inline_attribute_rule_extractor/boolean.rb

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus/inline_attribute_rule_extractor/object'
+
+module Aequitas
+  module Virtus
+    class InlineAttributeRuleExtractor
+      class Boolean < Object
+
+        def extract_presence_rules
+          Rule::Presence::NotNil.new(attribute.name)
+        end
+
+      end # class Boolean
+    end # class InlineAttributeRuleExtractor
+  end # module Virtus
+end # module Aequitas

data/lib/aequitas/virtus/inline_attribute_rule_extractor/object.rb

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus/inline_attribute_rule_extractor'
+
+module Aequitas
+  module Virtus
+    class InlineAttributeRuleExtractor
+      class Object < InlineAttributeRuleExtractor
+
+        def extract_presence_rules
+          Rule::Presence::NotBlank.new(attribute.name)
+        end
+
+        def extract_length_rules
+          nil
+        end
+
+        def extract_format_rules
+          nil
+        end
+
+      end # class Object
+    end # class InlineAttributeRuleExtractor
+  end # module Virtus
+end # module Aequitas

data/lib/aequitas/virtus/inline_attribute_rule_extractor/string.rb

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus/inline_attribute_rule_extractor/object'
+
+module Aequitas
+  module Virtus
+    class InlineAttributeRuleExtractor
+      class String < Object
+
+        def extract_length_rules
+          length = attribute.options.fetch(:length)
+
+          case length
+          when Integer; Rule::Length::Equal.new(attribute.name, :expected => length)
+          when Range;   Rule::Length::Range.new(attribute.name, :range    => length)
+          end
+        end
+
+        def extract_format_rules
+          format = attribute.options.fetch(:format)
+          Rule::Format.new(attribute.name, :with => format)
+        end
+
+      end # class String
+    end # class InlineAttributeRuleExtractor
+  end # module Virtus
+end # module Aequitas

data/spec/integration/aequitas/macros/validates_absence_of_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../../spec_helper'
+require_relative '../../shared/macros/integration_spec'
+require 'aequitas'
+
+Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_absence_of' do
+  before { class_under_test.validates_absence_of attribute_name }
+
+  describe 'when validated attribute is present' do
+    let(:attribute_value) { :foo }
+
+    it_should_be_an_invalid_instance
+  end
+
+  describe 'when validated attribute is absent' do
+    let(:attribute_value) { nil }
+
+    it_should_be_a_valid_instance
+  end
+end

data/spec/integration/aequitas/macros/validates_acceptance_of_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../../spec_helper'
+require_relative '../../shared/macros/integration_spec'
+require 'aequitas'
+
+Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_acceptance_of' do
+  before { class_under_test.validates_acceptance_of attribute_name }
+
+  describe 'when attribute value is accepted' do
+    let(:attribute_value) { true }
+
+    it_should_be_a_valid_instance
+  end
+
+  describe 'when attribute value is not accepted' do
+    let(:attribute_value) { false }
+
+    it_should_be_an_invalid_instance
+  end
+end

data/spec/integration/aequitas/macros/validates_confirmation_of_spec.rb

@@ -0,0 +1,25 @@
+require_relative '../../../spec_helper'
+require_relative '../../shared/macros/integration_spec'
+require 'aequitas'
+
+Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_confirmation_of' do
+  before do
+    class_under_test.send(:attr_accessor, "#{attribute_name}_confirmation")
+    class_under_test.validates_confirmation_of attribute_name
+    subject.send("#{attribute_name}_confirmation=", confirmation_value)
+  end
+
+  describe 'when confirmation value matches' do
+    let(:attribute_value)    { :foo }
+    let(:confirmation_value) { :foo }
+
+    it_should_be_a_valid_instance
+  end
+
+  describe 'when confirmation value does not match' do
+    let(:attribute_value) { :foo }
+    let(:confirmation_value) { :bar }
+
+    it_should_be_an_invalid_instance
+  end
+end