aequitas 0.0.1 → 0.0.2

data/lib/aequitas/violation_set.rb

@@ -79,7 +79,7 @@ module Aequitas
     # @param [Symbol] attribute_name
     #   The name of the field you want an violation for.
     #
-    # @return [Array(Violation, String), NilClass]
+    # @return [Array(Violation, String)]
     #   Array of Violations, if there are violations on +attribute_name+
     #   nil if there are no violations on +attribute_name+
     # 
@@ -87,8 +87,7 @@ module Aequitas
     # 
     # TODO: use a data structure that ensures uniqueness
     def on(attribute_name)
-      attribute_violations = violations[attribute_name]
-      attribute_violations.empty? ? nil : attribute_violations.uniq
+      violations[attribute_name].uniq
     end
 
     # @api public

data/lib/aequitas/virtus_integration.rb

@@ -0,0 +1,31 @@
+require 'aequitas'
+require 'aequitas/virtus_integration/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::VirtusIntegration::ClassMethods
+    end
+  end
+
+  module VirtusIntegration
+    module ClassMethods
+      # WARNING: overriding Virtus' private API here, this is fragile
+      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_integration/inline_attribute_rule_extractor.rb

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+module Aequitas
+  module VirtusIntegration
+    module InlineAttributeRuleExtractor
+
+      def self.extract(attribute)
+        type = 
+          case attribute
+          when ::Virtus::Attribute::Boolean;  self::Boolean
+          when ::Virtus::Attribute::String;   self::String
+          when ::Virtus::Attribute::Array;    self::Array
+          # when ::Virtus::Attribute::Decimal;  self::Decimal
+          # when ::Virtus::Attribute::Float;    self::Float
+          when ::Virtus::Attribute::Numeric;  self::Numeric
+          when ::Virtus::Attribute::Object;   self::Object
+          end
+
+        type.new(attribute).extract
+      end
+
+    end # module InlineAttributeRuleExtractor
+  end # module VirtusIntegration
+end # module Aequitas
+
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/object'
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/array'
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/boolean'
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/string'
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/numeric'

data/lib/aequitas/virtus_integration/inline_attribute_rule_extractor/array.rb

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/object'
+
+module Aequitas
+  module VirtusIntegration
+    module InlineAttributeRuleExtractor
+      class Array < Object
+
+        def extract
+          rules = super
+          rules.concat Array(extract_length_rules)
+        end
+
+        def extract_length_rules
+          length = options.fetch(:length, false)
+
+          case length
+          when ::Integer; Rule::Length::Equal.new(attribute.name, :expected => length)
+          when ::Range;   Rule::Length::Range.new(attribute.name, :range    => length)
+          when ::FalseClass;
+          else raise ArgumentError, "expected Integer or Range :length, got: #{length.inspect}"
+          end
+        end
+
+      end # class Array
+    end # module InlineAttributeRuleExtractor
+  end # module VirtusIntegration
+end # module Aequitas

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

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

data/lib/aequitas/virtus_integration/inline_attribute_rule_extractor/numeric.rb

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/object'
+
+module Aequitas
+  module VirtusIntegration
+    module InlineAttributeRuleExtractor
+      class Numeric < Object
+
+        def extract
+          rules = super
+          rules.concat Array(extract_value_rules)
+        end
+
+        def extract_value_rules
+          Rule::Value.rules_for(attribute.name, options)
+        end
+
+      end # class Numeric
+    end # module InlineAttributeRuleExtractor
+  end # module VirtusIntegration
+end # module Aequitas

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

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor'
+
+module Aequitas
+  module VirtusIntegration
+    module InlineAttributeRuleExtractor
+      class Object
+
+        attr_reader :attribute
+
+        def initialize(attribute)
+          @attribute = attribute
+        end
+
+        def options
+          attribute.options
+        end
+
+        def extract
+          inline_rules = []
+          inline_rules.concat Array(extract_presence_rule)
+          # inline_rules.concat Array(extract_primitive_type_rule)
+        end
+
+        def extract_presence_rule
+          required = options.fetch(:required, false)
+          Rule::Presence::NotBlank.new(attribute.name) if required
+        end
+
+        def extract_primitive_type_rule
+          Rule::PrimitiveType::Virtus.new(attribute.name, :attribute => attribute)
+        end
+
+      end # class Object
+    end # module InlineAttributeRuleExtractor
+  end # module VirtusIntegration
+end # module Aequitas

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

@@ -0,0 +1,35 @@
+# -*- encoding: utf-8 -*-
+
+require 'aequitas/virtus_integration/inline_attribute_rule_extractor/object'
+
+module Aequitas
+  module VirtusIntegration
+    module InlineAttributeRuleExtractor
+      class String < Object
+
+        def extract
+          rules = super
+          rules.concat(Array(extract_length_rules))
+          rules.concat(Array(extract_format_rules))
+        end
+
+        def extract_length_rules
+          length = options.fetch(:length, false)
+
+          case length
+          when ::Integer; Rule::Length::Equal.new(attribute.name, :expected => length)
+          when ::Range;   Rule::Length::Range.new(attribute.name, :range    => length)
+          when ::FalseClass;
+          else raise ArgumentError, "expected Integer or Range :length, got: #{length.inspect}"
+          end
+        end
+
+        def extract_format_rules
+          format = options.fetch(:format, false)
+          Rule::Format.rules_for(attribute.name, :with => format) if format
+        end
+
+      end # class String
+    end # module InlineAttributeRuleExtractor
+  end # module VirtusIntegration
+end # module Aequitas

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

@@ -8,7 +8,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
       class_under_test.validates_numericalness_of attribute_name
     end
 
-    describe 'when validated attribute is a non-integer number' do
+    describe 'when validated attribute is a float' do
       let(:attribute_value) { 1.0 }
 
       it_should_be_a_valid_instance
@@ -38,7 +38,13 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
       it_should_be_a_valid_instance
     end
 
-    describe 'when validated attribute is not an integer' do
+    describe 'when validated attribute is a float' do
+      let(:attribute_value) { 1.0 }
+
+      it_should_be_an_invalid_instance
+    end
+
+    describe 'when validated attribute is non-numeric' do
       let(:attribute_value) { 'a' }
 
       it_should_be_an_invalid_instance
@@ -52,7 +58,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
 
     let(:bound) { 1 }
     let(:class_of_violated_validation_rule) do
-      Aequitas::Rule::Numericalness::Equal
+      Aequitas::Rule::Value::Equal
     end
 
     describe 'when validated attribute is greater than bound' do
@@ -81,7 +87,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
 
     let(:bound) { 1 }
     let(:class_of_violated_validation_rule) do
-      Aequitas::Rule::Numericalness::NotEqual
+      Aequitas::Rule::Value::NotEqual
     end
 
     describe 'when validated attribute is greater than bound' do
@@ -110,7 +116,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
 
     let(:bound) { 1 }
     let(:class_of_violated_validation_rule) do
-      Aequitas::Rule::Numericalness::GreaterThan
+      Aequitas::Rule::Value::GreaterThan
     end
 
     describe 'when validated attribute is greater than bound' do
@@ -139,7 +145,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
 
     let(:bound) { 1 }
     let(:class_of_violated_validation_rule) do
-      Aequitas::Rule::Numericalness::LessThan
+      Aequitas::Rule::Value::LessThan
     end
 
     describe 'when validated attribute is greater than bound' do
@@ -168,7 +174,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
 
     let(:bound) { 1 }
     let(:class_of_violated_validation_rule) do
-      Aequitas::Rule::Numericalness::GreaterThanOrEqual
+      Aequitas::Rule::Value::GreaterThanOrEqual
     end
 
     describe 'when validated attribute is greater than bound' do
@@ -197,7 +203,7 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
 
     let(:bound) { 1 }
     let(:class_of_violated_validation_rule) do
-      Aequitas::Rule::Numericalness::LessThanOrEqual
+      Aequitas::Rule::Value::LessThanOrEqual
     end
 
     describe 'when validated attribute is greater than bound' do
@@ -218,4 +224,67 @@ Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_numeric
       it_should_be_a_valid_instance
     end
   end
+
+  describe 'with :in or :within options' do
+    describe 'with lower and upper bounds' do
+      before do
+        class_under_test.validates_numericalness_of attribute_name, :in => bound
+      end
+
+      let(:bound) { 1..5 }
+
+      describe 'when validated attribute value is within the range' do
+        let(:attribute_value) { bound.begin + 1 }
+
+        it_should_be_a_valid_instance
+      end
+
+      describe 'when validated attribute value is not within the range' do
+        let(:attribute_value) { bound.end + 1 }
+
+        it_should_be_an_invalid_instance
+      end
+    end
+
+    # describe 'with no lower bound' do
+    #   before do
+    #     class_under_test.validates_within attribute_name, :range => range
+    #   end
+    # 
+    #   let(:range) { -(1.0/0)..5 }
+    # 
+    #   describe 'when validated attribute value is within the range' do
+    #     let(:attribute_value) { range.end - 1 }
+    # 
+    #     it_should_be_a_valid_instance
+    #   end
+    # 
+    #   describe 'when validated attribute value is not within the range' do
+    #     let(:attribute_value) { range.end + 1 }
+    # 
+    #     it_should_be_an_invalid_instance
+    #   end
+    # end
+
+    # describe 'with no upper bound' do
+    #   before do
+    #     class_under_test.validates_within attribute_name, :range => range
+    #   end
+    # 
+    #   let(:range) { 1..(1.0/0) }
+    # 
+    #   describe 'when validated attribute value is within the range' do
+    #     let(:attribute_value) { range.begin + 1 }
+    # 
+    #     it_should_be_a_valid_instance
+    #   end
+    # 
+    #   describe 'when validated attribute value is not within the range' do
+    #     let(:attribute_value) { range.begin - 1 }
+    # 
+    #     it_should_be_an_invalid_instance
+    #   end
+    # end
+  end
+
 end

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

@@ -0,0 +1,27 @@
+require_relative '../../../spec_helper'
+require_relative '../../shared/macros/integration_spec'
+require 'aequitas'
+
+Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_value_of' do
+  require 'date'
+
+  describe 'with a lambda that returns lower and upper bounds' do
+    before do
+      class_under_test.validates_value_of attribute_name, :in => bound
+    end
+
+    let(:bound) { lambda { (Date.today - 5)..Date.today } }
+
+    describe 'when validated attribute value is within the range' do
+      let(:attribute_value) { bound.call.begin + 1 }
+
+      it_should_be_a_valid_instance
+    end
+
+    describe 'when validated attribute value is not within the range' do
+      let(:attribute_value) { bound.call.end + 1 }
+
+      it_should_be_an_invalid_instance
+    end
+  end
+end

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

@@ -3,85 +3,21 @@ require_relative '../../shared/macros/integration_spec'
 require 'aequitas'
 
 Aequitas::Macros::IntegrationSpec.describe Aequitas::Macros, '#validates_within' do
-  describe 'with Range option for :set' do
-    describe 'with lower and upper bounds' do
-      before do
-        class_under_test.validates_within attribute_name, :set => set
-      end
-
-      let(:set) { 1..5 }
-
-      describe 'when validated attribute value is within the range' do
-        let(:attribute_value) { set.begin + 1 }
-
-        it_should_be_a_valid_instance
-      end
-
-      describe 'when validated attribute value is not within the range' do
-        let(:attribute_value) { set.end + 1 }
-
-        it_should_be_an_invalid_instance
-      end
-    end
-
-    describe 'with no lower bound' do
-      before do
-        class_under_test.validates_within attribute_name, :set => set
-      end
-
-      let(:set) { -(1.0/0)..5 }
-
-      describe 'when validated attribute value is within the range' do
-        let(:attribute_value) { set.end - 1 }
-
-        it_should_be_a_valid_instance
-      end
-
-      describe 'when validated attribute value is not within the range' do
-        let(:attribute_value) { set.end + 1 }
-
-        it_should_be_an_invalid_instance
-      end
-    end
-
-    describe 'with no upper bound' do
-      before do
-        class_under_test.validates_within attribute_name, :set => set
-      end
-
-      let(:set) { 1..(1.0/0) }
-
-      describe 'when validated attribute value is within the range' do
-        let(:attribute_value) { set.begin + 1 }
-
-        it_should_be_a_valid_instance
-      end
-
-      describe 'when validated attribute value is not within the range' do
-        let(:attribute_value) { set.begin - 1 }
-
-        it_should_be_an_invalid_instance
-      end
-    end
+  before do
+    class_under_test.validates_within attribute_name, :set => Set[*set]
   end
 
-  describe 'with Set option for :set' do
-    before do
-      class_under_test.validates_within attribute_name, :set => Set[*set]
-    end
+  let(:set) { [:a, :b, :c] }
 
-    let(:set) { [:a, :b, :c] }
+  describe 'when validated attribute value is included in the set' do
+    let(:attribute_value) { set.first }
 
-    describe 'when validated attribute value is included in the set' do
-      let(:attribute_value) { set.first }
-
-      it_should_be_a_valid_instance
-    end
+    it_should_be_a_valid_instance
+  end
 
-    describe 'when validated attribute value is not included in the set' do
-      let(:attribute_value) { :foo }
+  describe 'when validated attribute value is not included in the set' do
+    let(:attribute_value) { :foo }
 
-      it_should_be_an_invalid_instance
-    end
+    it_should_be_an_invalid_instance
   end
 end