standalone_validator 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bca879be6bf42bd2a02eae2221a168206782348c
-  data.tar.gz: a82ee314d96bf3d10b3dbc16538de68d6311fbbe
+  metadata.gz: 43bfee850787c7744539eb0695223feae9bce1d5
+  data.tar.gz: dbf0df8cce8600097a85a8aefef28633febc0fae
 SHA512:
-  metadata.gz: 1eb6e22ab8bd654da4d87a0917b52d1ffa25a4ae81bf9e6ab30dc9c07460bd8a7de3022f4dc7a74ecee7c3259b69e75284009fe27c3cdfec07e45a88f57ba9cf
-  data.tar.gz: 97822fabfa6deb523853f135df9ce830b2b05b3f785a524e6f0f3fc02a1dce48df91353037d38711d5e94bf2519b321fe8b0991cdcb7015b182ec6a73e75c6c6
+  metadata.gz: e6e66ab4b98ec778fd1e8f8aaaecb30446ac6c2582ee3f5fdc92418cda5ba147733c6814a094c0460430b142d30539f73452be950068ccb046563ed9b070976a
+  data.tar.gz: 3abd3dd8ed13f2b94b3e91d639c23525c025203b239e679b315b98a9851df4de931d92674cd35df4bfd0d9f74928b22322a285d3ff6ca2c2de88cb3050cab743

data/lib/standalone_validator/named_validations/validates_numericality_of.rb

@@ -0,0 +1,78 @@
+require 'standalone_validator'
+require_relative 'common_rails_options'
+
+class StandaloneValidator
+  module NamedValidations
+    class ValidatesNumericalityOf < StandaloneValidator
+      register_as :validates_numericality_of
+
+      include CommonRailsOptions
+
+      # Stolen from ActiveSupport
+      INTEGER_REGEX = /\A[+-]?\d+\Z/.freeze
+
+      COMPARISON_OPTIONS = {
+        :greater_than             => lambda { |base, x| x >  base },
+        :greater_than_or_equal_to => lambda { |base, x| x >= base },
+        :equal_to                 => lambda { |base, x| x == base },
+        :less_than                => lambda { |base, x| x <  base },
+        :less_than_or_equal_to    => lambda { |base, x| x <= base },
+      }.freeze
+
+      include_validation do |object, result|
+        each_validated_attribute_on(object) do |attribute_name, value|
+          next if ignore_value?(value)
+
+          begin
+            coerced_value = coerce_to_number(value)
+
+            each_comparison_violation_of(coerced_value) do |violation, base|
+              result.add_violation(attribute_name, violation, :count => base)
+            end
+          rescue TypeError, ArgumentError
+            result.add_violation(attribute_name, :not_a_number)
+          end
+        end
+      end
+
+    private
+
+      def ignore_value?(value)
+        if options[:allow_nil]
+          value.nil?
+        elsif options[:allow_blank]
+          value.blank?
+        else
+          false
+        end
+      end
+
+      def each_comparison_violation_of(value)
+        selected_comparisons.each do |option, (base, check)|
+          yield(option, base) unless check.call(base, value)
+        end
+
+        self
+      end
+
+      def selected_comparisons
+        return @selected_comparisons if defined?(@selected_comparisons)
+
+        passed = COMPARISON_OPTIONS.keys & options.keys
+        @selected_comparisons = passed.each_with_object({}) do |option, result|
+          result[option] = [options[option], COMPARISON_OPTIONS[option]]
+        end
+      end
+
+      def coerce_to_number(value)
+        if options[:only_integer]
+          raise ArgumentError unless value.to_s =~ INTEGER_REGEX
+          Kernel.Integer(value)
+        else
+          Kernel.Float(value)
+        end
+      end
+
+    end
+  end
+end

data/lib/standalone_validator/named_validations/validates_presence_of.rb

@@ -15,6 +15,10 @@ class StandaloneValidator
           end
         end
       end
+
+      def requires_field?(field)
+        attributes.include?(field.to_sym)
+      end
     end
   end
 end

data/lib/standalone_validator/validation_result.rb

@@ -25,6 +25,8 @@ class StandaloneValidator
       @violations = violations.to_list
     end
 
+    OK = new({})
+
     def add_errors_to(errors_object)
       violations.each do |violation|
         violation.add_to(errors_object)
@@ -33,15 +35,13 @@ class StandaloneValidator
       self
     end
 
-    OK = new({})
-
     include Enumerable
 
     def each(&block)
       violations.each(&block)
     end
 
-    def empty
+    def empty?
       violations.empty?
     end
 
@@ -50,5 +50,26 @@ class StandaloneValidator
     end
 
     alias_method :valid?, :ok?
+
+    def [](attribute)
+      violations.select do |violation|
+        violation.attribute == attribute
+      end
+    end
+
+    def of_type(type)
+      subset { |violation| violation.type == type }
+    end
+
+    def on_attribute(attribute)
+      subset { |violation| violation.attribute == attribute }
+    end
+
+  private
+
+    def subset(&block)
+      self.class.new(:violations       => violations.select(&block),
+                     :validated_object => validated_object)
+    end
   end
 end

data/lib/standalone_validator/validation_result_builder.rb

@@ -10,10 +10,11 @@ class StandaloneValidator
       self
     end
 
-    def add_violation(attribute_name, violation_type_or_message)
+    def add_violation(attribute_name, violation_type_or_message, options = {})
       creation_attributes = {
         :attribute     => attribute_name.to_sym,
-        :source_object => validated_object
+        :source_object => validated_object,
+        :options       => options,
       }
 
       if violation_type_or_message.kind_of?(Symbol)

data/lib/standalone_validator/version.rb

@@ -1,3 +1,3 @@
 class StandaloneValidator
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/standalone_validator/violation.rb

@@ -8,9 +8,10 @@ class StandaloneValidator
     attribute :attribute,     Symbol, :default => :base
     attribute :type,          Symbol, :default => :invalid
     attribute :message,       String, :default => nil
+    attribute :options,       Hash,   :default => {}
 
     def add_to(errors_object)
-      errors_object.add(attribute, message || type)
+      errors_object.add(attribute, message || type, options)
       self
     end
   end

data/lib/standalone_validator.rb

@@ -32,21 +32,35 @@ class StandaloneValidator
       end
     end
 
+    def required_fields
+      return @required_fields if defined?(@required_fields)
+
+      if superclass.kind_of?(StandaloneValidator)
+        @required_fields = superclass.required_fields
+      else
+        @required_fields = Hamster.set
+      end
+    end
+
   private
 
     def include_validation(*args, &block)
       validation = Definitions.coerce_to_validation(*args, &block)
       @validations = validations.add(validation)
     end
+
+    def requires_field(name)
+      @required_fields = required_fields.add(name.to_sym)
+    end
   end
 
   require 'standalone_validator/named_validations'
 
-  def violations_of(object)
-    builder = ValidationResultBuilder.new
+  def violations_of(object, appliable_validations = validations)
+    builder = StandaloneValidator::ValidationResultBuilder.new
     builder.validated_object = object
 
-    validations.each do |validation|
+    appliable_validations.each do |validation|
       if validation.respond_to?(:to_proc)
         result = instance_exec(object, &validation)
       else
@@ -67,6 +81,16 @@ class StandaloneValidator
     validation_result
   end
 
+  def requires_field?(field)
+    return true if self.class.required_fields.include?(field.to_sym)
+
+    validations.any? do |validation|
+      if validation.respond_to?(:requires_field?)
+        validation.requires_field?(field)
+      end
+    end
+  end
+
 private
 
   def validations

data/spec/named_validations/validates_numericality_of_spec.rb

@@ -0,0 +1,166 @@
+require "spec_helper"
+require "ostruct"
+require "standalone_validator"
+
+module StandaloneValidator::NamedValidations
+  describe "validates_numericality_of" do
+    let(:object)    { OpenStruct.new }
+    let(:validator) { ValidatesNumericalityOf.new(:foo) }
+
+    it "adds a 'not_a_number' violation if the attribute isn't a number" do
+      object.foo = "not a number"
+      violations = validator.violations_of(object).on_attribute(:foo)
+      expect(violations.of_type(:not_a_number)).to_not be_empty
+    end
+
+    it "doesn't add the violation if the attribute is a number" do
+      object.foo = 10
+      violations = validator.violations_of(object).on_attribute(:foo)
+      expect(violations.of_type(:not_a_number)).to be_empty
+    end
+
+    it "accepts strings that represent integer numbers" do
+      object.foo = "10"
+      violations = validator.violations_of(object).on_attribute(:foo)
+      expect(violations.of_type(:not_a_number)).to be_empty
+    end
+
+    describe "the :only_integer option" do
+      context "when the :only_integer option is set to true" do
+        let(:validator) { ValidatesNumericalityOf.new(:foo, :only_integer => true) }
+
+        it "does not accept floats" do
+          object.foo = 10.5
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations.of_type(:not_a_number)).to_not be_empty
+        end
+
+        it "does not accept strings that represent floating numbers" do
+          object.foo = "10.5"
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations.of_type(:not_a_number)).to_not be_empty
+        end
+      end
+
+      context "when the :only_integer is not set" do
+        let(:validator) { ValidatesNumericalityOf.new(:foo) }
+
+        it "accepts floats" do
+          object.foo = 10.5
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations.of_type(:not_a_number)).to be_empty
+        end
+
+        it "accepts strings that represent floating numbers" do
+          object.foo = "10.5"
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations.of_type(:not_a_number)).to be_empty
+        end
+      end
+    end
+
+    describe "the :allow_blank option" do
+      context "when the :allow_blank option is set" do
+        let(:validator) { ValidatesNumericalityOf.new(:foo, :allow_blank => true) }
+
+        it "ignores 'blank' values" do
+          object.foo = stub(:blank? => true, :to_f => 0)
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations).to be_empty
+        end
+      end
+
+      context "when the :allow_blank option is not set" do
+        let(:validator) { ValidatesNumericalityOf.new(:foo) }
+
+        it "does not ignore 'blank' values" do
+          object.foo = stub(:blank? => true, :to_f => 0)
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations.of_type(:not_a_number)).to_not be_empty
+        end
+      end
+    end
+
+    describe "the :allow_nil option" do
+      context "when the :allow_nil option is set" do
+        let(:validator) { ValidatesNumericalityOf.new(:foo, :allow_nil => true) }
+
+        it "ignores nil values" do
+          object.foo = nil
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations).to be_empty
+        end
+      end
+
+      context "when the :allow_blank option is not set" do
+        let(:validator) { ValidatesNumericalityOf.new(:foo) }
+
+        it "does not ignore 'nil' values" do
+          object.foo = nil
+          violations = validator.violations_of(object).on_attribute(:foo)
+          expect(violations.of_type(:not_a_number)).to_not be_empty
+        end
+      end
+    end
+
+    compared_value = v = 1
+
+    comparison_options = {
+      :greater_than =>             {:ok => v + 1,      :not_ok => [v, v - 1]    },
+      :greater_than_or_equal_to => {:ok => [v, v + 1], :not_ok => v - 1         },
+      :equal_to =>                 {:ok => v,          :not_ok => [v - 1, v + 1]},
+      :less_than =>                {:ok => v - 1,      :not_ok => [v, v + 1]    },
+      :less_than_or_equal_to =>    {:ok => [v, v - 1], :not_ok => v + 1         },
+    }.freeze
+
+    comparison_options.each do |option_name, comparisons|
+      describe "when '#{compared_value}' is given on :#{option_name}" do
+        let(:validator) do
+          ValidatesNumericalityOf.new(:foo, option_name => compared_value)
+        end
+
+        Array(comparisons[:ok]).each do |ok_value|
+          it "accepts the value '#{ok_value}'" do
+            object.foo = ok_value
+            violations = validator.violations_of(object).on_attribute(:foo)
+            expect(violations.of_type(option_name)).to be_empty
+          end
+        end
+
+        Array(comparisons[:not_ok]).each do |not_ok_value|
+          it "rejects the value '#{not_ok_value}'" do
+            object.foo = not_ok_value
+            violations = validator.violations_of(object).on_attribute(:foo)
+            expect(violations.of_type(option_name)).to_not be_empty
+          end
+        end
+      end
+    end
+
+    it "accepts an :if condition that can block the validation" do
+      validator = ValidatesNumericalityOf.new :foo, :if => :bar
+
+      triggers       = stub(:foo => "not a number", :bar => true)
+      doesnt_trigger = stub(:foo => "not a number", :bar => false)
+
+      result = validator.violations_of(triggers)
+      expect(result).to_not be_ok
+
+      result = validator.violations_of(doesnt_trigger)
+      expect(result).to be_ok
+    end
+
+    it "accepts an :unless condition that can block the validation" do
+      validator = ValidatesNumericalityOf.new :foo, :unless => :bar
+
+      triggers       = stub(:foo => "not a number", :bar => false)
+      doesnt_trigger = stub(:foo => "not a number", :bar => true)
+
+      result = validator.violations_of(triggers)
+      expect(result).to_not be_ok
+
+      result = validator.violations_of(doesnt_trigger)
+      expect(result).to be_ok
+    end
+  end
+end

data/spec/named_validations/validates_presence_of_spec.rb

@@ -43,5 +43,11 @@ module StandaloneValidator::NamedValidations
       result = validator.violations_of(doesnt_trigger)
       expect(result).to be_ok
     end
+
+    it "requires the attributes it was given on construction" do
+      validator = ValidatesPresenceOf.new :foo
+      expect(validator.requires_field?(:foo)).to be_true
+      expect(validator.requires_field?(:bar)).to be_false
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standalone_validator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Renato Zannon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-07 00:00:00.000000000 Z
+date: 2013-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backports
@@ -114,12 +114,14 @@ files:
 - lib/standalone_validator/definitions.rb
 - lib/standalone_validator/named_validations.rb
 - lib/standalone_validator/named_validations/common_rails_options.rb
+- lib/standalone_validator/named_validations/validates_numericality_of.rb
 - lib/standalone_validator/named_validations/validates_presence_of.rb
 - lib/standalone_validator/validation_result.rb
 - lib/standalone_validator/validation_result_builder.rb
 - lib/standalone_validator/version.rb
 - lib/standalone_validator/violation.rb
 - spec/integration_spec.rb
+- spec/named_validations/validates_numericality_of_spec.rb
 - spec/named_validations/validates_presence_of_spec.rb
 - spec/spec_helper.rb
 - standalone_validator.gemspec
@@ -143,12 +145,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.0
+rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: PORO standalone validators compatible with ActiveRecord
 test_files:
 - spec/integration_spec.rb
+- spec/named_validations/validates_numericality_of_spec.rb
 - spec/named_validations/validates_presence_of_spec.rb
 - spec/spec_helper.rb
 has_rdoc: