valvat 0.5.0 → 0.6.0

data/spec/spec_helper.rb

@@ -1,5 +1,9 @@
 require 'rspec'
-require 'active_model'
+begin
+  require 'active_model'
+rescue LoadError => err
+  puts "Running specs without active_model extension"
+end
 require 'fakeweb'
 
 require File.dirname(__FILE__) + '/../lib/valvat.rb'
@@ -14,18 +18,20 @@ RSpec.configure do |config|
   config.backtrace_exclusion_patterns = [/rspec\/(core|expectations)/]
 end
 
-class ModelBase
-  include ActiveModel::Serialization
-  include ActiveModel::Validations
+if defined?(ActiveModel)
+  class ModelBase
+    include ActiveModel::Serialization
+    include ActiveModel::Validations
 
-  attr_accessor :attributes
+    attr_accessor :attributes
 
-  def initialize(attributes = {})
-    @attributes = attributes
-  end
+    def initialize(attributes = {})
+      @attributes = attributes
+    end
 
-  def read_attribute_for_validation(key)
-    @attributes[key]
+    def read_attribute_for_validation(key)
+      @attributes[key]
+    end
   end
 end
 

data/spec/valvat/lookup_spec.rb

@@ -5,17 +5,17 @@ describe Valvat::Lookup do
     context "existing vat number" do
 
       it "returns true" do
-        Valvat::Lookup.validate("BE0817331995").should eql(true)
+        Valvat::Lookup.validate("DE259597697").should eql(true)
       end
 
       it "allows Valvat instance as input" do
-        Valvat::Lookup.validate(Valvat.new("BE0817331995")).should eql(true)
+        Valvat::Lookup.validate(Valvat.new("DE259597697")).should eql(true)
       end
     end
 
     context "not existing vat number" do
       it "returns false" do
-        Valvat::Lookup.validate("BE08173319921").should eql(false)
+        Valvat::Lookup.validate("DE259597696").should eql(false)
       end
     end
 
@@ -30,41 +30,52 @@ describe Valvat::Lookup do
 
     context "with details" do
       it "returns hash of details instead of true" do
-        Valvat::Lookup.validate("IE6388047V", :detail => true).should eql({
-          :country_code=>"IE",
-          :vat_number=>"6388047V",
-          :request_date=> Date.today,
-          :name=>"GOOGLE IRELAND LIMITED",
-          :address=>"1ST & 2ND FLOOR ,GORDON HOUSE ,BARROW STREET ,DUBLIN 4"
-        })
+        result = Valvat::Lookup.validate("IE6388047V", :detail => true)
 
-        Valvat::Lookup.validate("LU21416127", :detail => true).should eql({
-          :country_code=>"LU",
-          :vat_number=>"21416127",
-          :request_date=> Date.today,
-          :name=>"EBAY EUROPE S.A R.L.",
-          :address=>"22, BOULEVARD ROYAL\nL-2449  LUXEMBOURG"
-        })
+         if result
+          result.delete(:request_date).should be_kind_of(Date)
+          result.should eql({
+            :country_code=>"IE",
+            :vat_number=>"6388047V",
+            :name=>"GOOGLE IRELAND LIMITED",
+            :address=>"1ST & 2ND FLOOR ,GORDON HOUSE ,BARROW STREET ,DUBLIN 4"
+          })
+        else
+          puts "Skipping IE vies lookup spec; result = #{result.inspect}"
+        end
+
+        result = Valvat::Lookup.validate("LU21416127", :detail => true)
+
+        if result
+          result.delete(:request_date).should be_kind_of(Date)
+          result.should eql({
+            :country_code=>"LU",
+            :vat_number=>"21416127",
+            :name=>"EBAY EUROPE S.A R.L.",
+            :address=>"22, BOULEVARD ROYAL\nL-2449  LUXEMBOURG"
+          })
+        else
+          puts "Skipping LU vies lookup spec; result = #{result.inspect}"
+        end
       end
 
       it "still returns false on not existing vat number" do
-        Valvat::Lookup.validate("BE08173319921", :detail => true).should eql(false)
+        Valvat::Lookup.validate("DE259597696", :detail => true).should eql(false)
       end
     end
 
     context "with request identifier" do
       it "returns hash of details instead of true" do
-        response = Valvat::Lookup.validate("LU21416127", :requester_vat => "IE6388047V")
+        response = Valvat::Lookup.validate("DE259597697", :requester_vat => "IE6388047V")
         response[:request_identifier].size.should eql(16)
-        response[:request_identifier] = "some_uniq_string"
+        request_identifier = response[:request_identifier]
+        response.delete(:request_date).should be_kind_of(Date)
         response.should eql({
-          :country_code=>"LU",
-          :vat_number=>"21416127",
-          :request_date=> Date.today,
-          :name => "EBAY EUROPE S.A R.L.",
-          :address => "22, BOULEVARD ROYAL\nL-2449  LUXEMBOURG",
-          :company_type => nil,
-          :request_identifier => "some_uniq_string"
+          :country_code=>"DE",
+          :vat_number=>"259597697",
+          :name => nil,
+          :company_type=>nil,
+          :request_identifier=> request_identifier
         })
       end
     end

data/spec/valvat/syntax_spec.rb

@@ -119,10 +119,13 @@ describe Valvat::Syntax do
     it "validates a IE vat number" do
       subject.validate("IE1B12345J").should eql(true)
       subject.validate("IE1234567B").should eql(true)
+      subject.validate("IE1234567XX").should eql(true)
 
       subject.validate("IE1B123459").should eql(false)
       subject.validate("IE19123450").should eql(false)
       subject.validate("IEA9123450").should eql(false)
+      subject.validate("IE1B12345XX").should eql(false)
+      subject.validate("IE1X34567XX").should eql(false)
     end
 
     it "validates a IT vat number" do

data/valvat.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_dependency             'savon',       '>=2.2.0'
+  s.add_dependency             'savon',       '>=2.3.0'
 
   s.add_development_dependency 'rspec',       '>= 2.4.0'
   s.add_development_dependency 'guard-rspec', '>=0.1.9'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valvat
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Sebastian Munz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2013-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: savon
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
-        version: 2.2.0
+        version: 2.3.0
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -125,14 +125,18 @@ files:
 - .gitignore
 - .rbenv-gemsets
 - .rbenv-version
+- .travis.yml
 - CHANGES.md
 - Gemfile
 - Guardfile
 - MIT-LICENSE
 - README.md
 - Rakefile
+- gemfiles/activemodel-3-2
+- gemfiles/activemodel-4
+- gemfiles/standalone
+- lib/active_model/validations/valvat_validator.rb
 - lib/valvat.rb
-- lib/valvat/active_model.rb
 - lib/valvat/checksum.rb
 - lib/valvat/checksum/at.rb
 - lib/valvat/checksum/be.rb
@@ -165,8 +169,8 @@ files:
 - lib/valvat/syntax.rb
 - lib/valvat/utils.rb
 - lib/valvat/version.rb
+- spec/active_model/validations/valvat_validator_spec.rb
 - spec/spec_helper.rb
-- spec/valvat/active_model_spec.rb
 - spec/valvat/checksum/at_spec.rb
 - spec/valvat/checksum/be_spec.rb
 - spec/valvat/checksum/bg_spec.rb
@@ -214,8 +218,8 @@ signing_key:
 specification_version: 4
 summary: Validates european vat numbers. Standalone or as a ActiveModel validator.
 test_files:
+- spec/active_model/validations/valvat_validator_spec.rb
 - spec/spec_helper.rb
-- spec/valvat/active_model_spec.rb
 - spec/valvat/checksum/at_spec.rb
 - spec/valvat/checksum/be_spec.rb
 - spec/valvat/checksum/bg_spec.rb

data/lib/valvat/active_model.rb

@@ -1,45 +0,0 @@
-require 'active_model'
-require 'valvat/syntax'
-require 'valvat/lookup'
-
-module ActiveModel
-  module Validations
-    class ValvatValidator < ::ActiveModel::EachValidator
-
-      def validate_each(record, attribute, value)
-        vat = Valvat(value)
-        iso_country_code = vat.iso_country_code
-        is_valid = true
-
-        if options[:match_country]
-          iso_country_code = (record.send(options[:match_country]) || "").upcase
-          is_valid = iso_country_code == vat.iso_country_code
-        end
-
-        if is_valid
-          is_valid = vat.valid?
-
-          is_valid = vat.valid_checksum? if is_valid && options[:checksum]
-          is_valid = vat.exists? if is_valid && options[:lookup]
-
-          if is_valid.nil?
-            is_valid = options[:lookup] != :fail_if_down
-          end
-        end
-
-        unless is_valid
-          iso_country_code = "eu" if iso_country_code.blank?
-          record.errors.add(attribute, :invalid_vat,
-            :message => options[:message],
-            :country_adjective => I18n.t(
-              :"valvat.country_adjectives.#{iso_country_code.downcase}",
-              :default => [:"valvat.country_adjectives.eu", "european"]
-            )
-          )
-        end
-      end
-    end
-  end
-end
-
-I18n.load_path += Dir["#{File.dirname(__FILE__)}/locales/*.yml"]

data/spec/valvat/active_model_spec.rb

@@ -1,240 +0,0 @@
-require 'spec_helper'
-
-class Invoice < ModelBase
-  validates :vat_number, :valvat => true
-end
-
-class InvoiceWithLookup < ModelBase
-  validates :vat_number, :valvat => {:lookup => true}
-end
-
-class InvoiceWithLookupAndFailIfDown < ModelBase
-  validates :vat_number, :valvat => {:lookup => :fail_if_down}
-end
-
-class InvoiceAllowBlank < ModelBase
-  validates :vat_number, :valvat => {:allow_blank => true}
-end
-
-class InvoiceAllowBlankOnAll < ModelBase
-  validates :vat_number, :valvat => true, :allow_blank => true
-end
-
-class InvoiceCheckCountry < ModelBase
-  validates :vat_number, :valvat => {:match_country => :country}
-
-  def country
-    @attributes[:country]
-  end
-end
-
-class InvoiceCheckCountryWithLookup < ModelBase
-  validates :vat_number, :valvat => {:match_country => :country, :lookup => true}
-
-  def country
-    @attributes[:country]
-  end
-end
-
-class InvoiceWithChecksum < ModelBase
-  validates :vat_number, :valvat => {:checksum => true}
-end
-
-describe Invoice do
-  context "with valid vat number" do
-    it "should be valid" do
-      Invoice.new(:vat_number => "DE259597697").should be_valid
-    end
-  end
-
-  context "with invalid vat number" do
-    let(:invoice) { Invoice.new(:vat_number => "DE259597697123") }
-
-    it "should not be valid" do
-      invoice.should_not be_valid
-    end
-
-    it "should add default (country specific) error message" do
-      invoice.valid?
-      invoice.errors[:vat_number].should eql(["is not a valid German vat number"])
-    end
-
-    context "with i18n translation in place" do
-      before do
-        I18n.backend.store_translations(:en, :activemodel => {
-          :errors => {:models => {:invoice => {:invalid_vat => "is ugly."}}}
-        })
-      end
-
-      after { I18n.reload! }
-
-      it "should use translation" do
-        invoice.valid?
-        invoice.errors[:vat_number].should eql(["is ugly."])
-      end
-    end
-
-    context "with i18n translation with country adjective placeholder in place" do
-      before do
-        I18n.backend.store_translations(:en, :activemodel => {
-          :errors => {:models => {:invoice => {:invalid_vat => "is not a %{country_adjective} vat"}}}
-        })
-      end
-
-      after { I18n.reload! }
-
-      it "should replace country adjective placeholder" do
-        invoice = Invoice.new(:vat_number => "IE123")
-        invoice.valid?
-        invoice.errors[:vat_number].should eql(["is not a Irish vat"])
-      end
-
-      it "should fall back to 'European' if country is missing" do
-        invoice = Invoice.new(:vat_number => "XX123")
-        invoice.valid?
-        invoice.errors[:vat_number].should eql(["is not a European vat"])
-      end
-    end
-  end
-
-  context "with blank vat number" do
-    it "should not be valid" do
-      Invoice.new(:vat_number => "").should_not be_valid
-      Invoice.new(:vat_number => nil).should_not be_valid
-    end
-  end
-end
-
-describe InvoiceWithLookup do
-  context "with valid but not existing vat number" do
-    before do
-      Valvat::Syntax.stub(:validate => true)
-      Valvat::Lookup.stub(:validate => false)
-    end
-
-    it "should not be valid" do
-      InvoiceWithLookup.new(:vat_number => "DE123").should_not be_valid
-    end
-  end
-
-  context "with valid and existing vat number" do
-    before do
-      Valvat::Syntax.stub(:validate => true)
-      Valvat::Lookup.stub(:validate => true)
-    end
-
-    it "should be valid" do
-      InvoiceWithLookup.new(:vat_number => "DE123").should be_valid
-    end
-  end
-
-  context "with valid vat number and VIES country service down" do
-    before do
-      Valvat::Syntax.stub(:validate => true)
-      Valvat::Lookup.stub(:validate => nil)
-    end
-
-    it "should be valid" do
-      InvoiceWithLookup.new(:vat_number => "DE123").should be_valid
-    end
-  end
-end
-
-describe InvoiceWithLookupAndFailIfDown do
-  context "with valid vat number and VIES country service down" do
-    before do
-      Valvat::Syntax.stub(:validate => true)
-      Valvat::Lookup.stub(:validate => nil)
-    end
-
-    it "should not be valid" do
-      InvoiceWithLookupAndFailIfDown.new(:vat_number => "DE123").should_not be_valid
-    end
-  end
-end
-
-describe InvoiceAllowBlank do
-  context "with blank vat number" do
-    it "should be valid" do
-      InvoiceAllowBlank.new(:vat_number => "").should be_valid
-      InvoiceAllowBlank.new(:vat_number => nil).should be_valid
-    end
-  end
-end
-
-describe InvoiceAllowBlankOnAll do
-  context "with blank vat number" do
-    it "should be valid" do
-      InvoiceAllowBlankOnAll.new(:vat_number => "").should be_valid
-      InvoiceAllowBlankOnAll.new(:vat_number => nil).should be_valid
-    end
-  end
-end
-
-describe InvoiceCheckCountry do
-  it "should be not valid on blank country" do
-    InvoiceCheckCountry.new(:country => nil, :vat_number => "DE259597697").should_not be_valid
-    InvoiceCheckCountry.new(:country => "", :vat_number => "DE259597697").should_not be_valid
-  end
-
-  it "should be not valid on wired country" do
-    InvoiceCheckCountry.new(:country => "XAXXX", :vat_number => "DE259597697").should_not be_valid
-    InvoiceCheckCountry.new(:country => "ZO", :vat_number => "DE259597697").should_not be_valid
-  end
-
-  it "should be not valid on mismatching (eu) country" do
-    InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697").should_not be_valid
-    InvoiceCheckCountry.new(:country => "AT", :vat_number => "DE259597697").should_not be_valid
-    InvoiceCheckCountry.new(:country => "DE", :vat_number => "ATU65931334").should_not be_valid
-  end
-
-  it "should be valid on matching country" do
-    InvoiceCheckCountry.new(:country => "DE", :vat_number => "DE259597697").should be_valid
-    InvoiceCheckCountry.new(:country => "AT", :vat_number => "ATU65931334").should be_valid
-  end
-
-  it "should give back error message with country from :country_match" do
-    invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697")
-    invoice.valid?
-    invoice.errors[:vat_number].should eql(["is not a valid French vat number"])
-  end
-
-  it "should give back error message with country from :country_match even on invalid vat number" do
-    invoice = InvoiceCheckCountry.new(:country => "FR", :vat_number => "DE259597697123")
-    invoice.valid?
-    invoice.errors[:vat_number].should eql(["is not a valid French vat number"])
-  end
-end
-
-describe InvoiceCheckCountryWithLookup do
-  before do
-    Valvat::Syntax.stub(:validate => true)
-    Valvat::Lookup.stub(:validate => true)
-  end
-
-  it "avoids lookup or syntax check on failed because of mismatching country" do
-    Valvat::Syntax.should_not_receive(:validate)
-    Valvat::Lookup.should_not_receive(:validate)
-    InvoiceCheckCountryWithLookup.new(:country => "FR", :vat_number => "DE259597697").valid?
-  end
-
-  it "check syntax and looup on matching country" do
-    Valvat::Syntax.should_receive(:validate).and_return(true)
-    Valvat::Lookup.should_receive(:validate).and_return(true)
-    InvoiceCheckCountryWithLookup.new(:country => "DE", :vat_number => "DE259597697").valid?
-  end
-end
-
-describe InvoiceWithChecksum do
-  context "with valid vat number" do
-    it "should be valid" do
-      InvoiceWithChecksum.new(:vat_number => "DE259597697").should be_valid
-    end
-  end
-
-  context "with invalid vat number" do
-    it "should not be valid" do
-      InvoiceWithChecksum.new(:vat_number => "DE259597687").should_not be_valid
-    end
-  end
-end