valvat 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2@valvat

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in valvat.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    valvat (0.0.1)
+      savon (>= 0.8.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    configuration (1.2.0)
+    crack (0.1.8)
+    diff-lcs (1.1.2)
+    growl (1.0.3)
+    guard (0.2.2)
+      open_gem (~> 1.4.2)
+      thor (~> 0.14.3)
+    guard-rspec (0.1.9)
+      guard (>= 0.2.2)
+    gyoku (0.1.1)
+      builder (>= 2.1.2)
+    httpi (0.7.7)
+      rack
+    launchy (0.3.7)
+      configuration (>= 0.0.5)
+      rake (>= 0.8.1)
+    open_gem (1.4.2)
+      launchy (~> 0.3.5)
+    rack (1.2.1)
+    rake (0.8.7)
+    rb-fsevent (0.3.9)
+    rspec (2.4.0)
+      rspec-core (~> 2.4.0)
+      rspec-expectations (~> 2.4.0)
+      rspec-mocks (~> 2.4.0)
+    rspec-core (2.4.0)
+    rspec-expectations (2.4.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.4.0)
+    savon (0.8.2)
+      builder (>= 2.1.2)
+      crack (~> 0.1.8)
+      gyoku (>= 0.1.1)
+      httpi (>= 0.7.5)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  growl (>= 1.0.3)
+  guard-rspec (>= 0.1.9)
+  rb-fsevent (>= 0.3.9)
+  rspec (>= 2.4.0)
+  savon (>= 0.8.2)
+  valvat!

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2 do
+  watch('^spec/(.*)_spec.rb')
+  watch('^lib/(.*)\.rb')                              { |m| "spec/#{m[1]}_spec.rb" }
+  watch('^spec/spec_helper.rb')                       { "spec" }
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Yolk Sebastian Munz & Julia Soergel GbR
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,33 @@
+== valvat
+
+Validates european vat numbers. Supports simple syntax verification and lookup via the VIES web service.
+
+== Installation
+
+  gem install valvat
+
+== Basic Usage
+
+To verify the syntax of an vat number:
+
+  Valvat::Syntax.validate("DE345789003")
+  => true or false
+  
+To check if the given vat number exists:
+
+  Valvat::Lookup.validate("DE345789003")
+  => true or false or nil
+  
+Keep in mind that the VIES webservice might be offline at some time for some countries. If this happens Valvat::Lookup.validate returns nil.
+
+See http://ec.europa.eu/taxation_customs/vies/viesspec.do for more accurate information at what time the service for a specific country will be down.
+
+== Links
+
+* http://ec.europa.eu/taxation_customs/vies
+* http://www.bzst.de/DE/Steuern_International/USt_Identifikationsnummer/Merkblaetter/Aufbau_USt_IdNr.html (german)
+* http://en.wikipedia.org/wiki/European_Union_Value_Added_Tax
+
+== BlaBla
+
+Copyright (c) 2011 Yolk Sebastian Munz & Julia Soergel GbR

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/valvat/lookup.rb

@@ -0,0 +1,33 @@
+require 'valvat/utils'
+
+module Valvat
+  module Lookup
+    
+    def self.validate(vat)
+      country_code, vat_number = Valvat::Utils.split(vat)
+      response = client.request "n1", "checkVat" do
+        soap.body = {"n1:countryCode" => country_code, "n1:vatNumber" => vat_number}
+        soap.namespaces["xmlns:n1"] = "urn:ec.europa.eu:taxud:vies:services:checkVat:types"
+      end
+      response.to_hash[:check_vat_response][:valid]
+    rescue => err
+      false if err.to_hash[:fault] && err.to_hash[:faultstring] = 'INVALID_INPUT'
+      nil
+    end
+    
+    def self.client
+      @client ||= begin
+        # Require Savon only if really needed!
+        require 'savon' unless defined?(Savon)
+        
+        # Quiet down Savon and HTTPI
+        Savon.logger.level = Logger::WARN
+        HTTPI.logger.level = Logger::WARN
+        
+        Savon::Client.new do
+          wsdl.document = 'http://ec.europa.eu/taxation_customs/vies/checkVatService.wsdl'
+        end
+      end
+    end
+  end
+end

data/lib/valvat/syntax.rb

@@ -0,0 +1,48 @@
+require 'valvat/utils'
+
+module Valvat
+  class InvalidSyntax < StandardError;end
+  
+  module Syntax
+    
+    VAT_PATTERNS = {
+        'AT' => /\AATU[0-9]{8}\Z/,                                          # Austria
+        'BE' => /\ABE[0-9]{10}\Z/,                                          # Belgium
+        'BG' => /\ABG[0-9]{9,10}\Z/,                                        # Bulgaria
+        'CY' => /\ACY[0-9]{8}[A-Z]\Z/,                                      # Cyprus
+        'CZ' => /\ACZ[0-9]{8,10}\Z/,                                        # Czech Republic
+        'DE' => /\ADE[0-9]{9}\Z/,                                           # Germany
+        'DK' => /\ADK[0-9]{8}\Z/,                                           # Denmark
+        'EE' => /\AEE[0-9]{9}\Z/,                                           # Estonia
+        'EL' => /\AEL[0-9]{9}\Z/,                                           # Greece
+        'ES' => /\AES([A-Z][0-9]{8}|[0-9]{8}[A-Z]|[A-Z][0-9]{7}[A-Z])\Z/,   # Spain
+        'FI' => /\AFI[0-9]{8}\Z/,                                           # Finland
+        'FR' => /\AFR[A-Z0-9]{2}[0-9]{9}\Z/,                                # France
+        'GB' => /\AGB([0-9]{9}|[0-9]{12}|(HA|GD)[0-9]{3})\Z/,               # United Kingdom
+        'HU' => /\AHU[0-9]{8}\Z/,                                           # Hungary
+        'IE' => /\AIE([0-9][A-Z][0-9]{5}|[0-9]{7})[A-Z]\Z/,                 # Ireland
+        'IT' => /\AIT[0-9]{11}\Z/,                                          # Italy
+        'LT' => /\ALT([0-9]{9}|[0-9]{12})\Z/,                               # Lithuania
+        'LU' => /\ALU[0-9]{8}\Z/,                                           # Luxembourg
+        'LV' => /\ALV[0-9]{11}\Z/,                                          # Latvia
+        'MT' => /\AMT[0-9]{8}\Z/,                                           # Malta
+        'NL' => /\ANL[0-9]{9}B[0-9]{2}\Z/,                                  # Netherlands
+        'PL' => /\APL[0-9]{10}\Z/,                                          # Poland
+        'PT' => /\APT[0-9]{9}\Z/,                                           # Portugal
+        'RO' => /\ARO[1-9][0-9]{1,9}\Z/,                                    # Romania
+        'SE' => /\ASE[0-9]{10}01\Z/,                                        # Sweden
+        'SI' => /\ASI[0-9]{8}\Z/,                                           # Slovenia
+        'SK' => /\ASK[0-9]{10}\Z/                                           # Slovakia
+      }
+
+    def self.validate(vat)
+      pattern = VAT_PATTERNS[Valvat::Utils.split(vat)[0]]
+      !!(pattern && pattern =~ vat)
+    end
+  
+    def self.validate!(vat)
+      validate(vat) || raise(Valvat::InvalidSyntax.new("#{vat.inspect} is an invalid vat number!"))
+    end
+  end
+
+end

data/lib/valvat/utils.rb

@@ -0,0 +1,15 @@
+module Valvat
+  module Utils
+    
+    COUNTRY_PATTERN = /\A([A-Z]{2})(.+)\Z/
+    
+    def self.split(vat)
+      COUNTRY_PATTERN =~ vat 
+      [$1, $2]
+    end
+    
+    def self.normalize(vat)
+      vat.upcase.gsub(/\A\s+|\s+\Z/, "")
+    end
+  end
+end

data/lib/valvat/version.rb

@@ -0,0 +1,3 @@
+module Valvat
+  VERSION = "0.0.1"
+end

data/lib/valvat.rb

@@ -0,0 +1,8 @@
+module Valvat
+  
+end
+
+require 'valvat/utils'
+require 'valvat/syntax'
+require 'valvat/lookup'
+require 'valvat/version'

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+require File.dirname(__FILE__) + '/../lib/valvat.rb'

data/spec/valvat/lookup_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Valvat::Lookup do
+  context "#validate" do
+    it "returns true on existing vat number" do
+      Valvat::Lookup.validate("BE0817331995").should eql(true)
+    end
+    
+    it "returns false on not existing vat number" do
+      Valvat::Lookup.validate("BE0817331994").should eql(false)
+    end
+    
+    it "returns nil on invalid input" do
+      Valvat::Lookup.validate("AE259597697").should eql(nil)
+    end
+  end
+end

data/spec/valvat/syntax_spec.rb

@@ -0,0 +1,280 @@
+require 'spec_helper'
+
+describe Valvat::Syntax do
+  context "#validate" do
+    it "validates a DE vat number" do
+      Valvat::Syntax.validate("DE345889003").should eql(true)
+      
+      Valvat::Syntax.validate("DE34588900").should eql(false)
+      Valvat::Syntax.validate("DE3458890090").should eql(false)
+      Valvat::Syntax.validate("DE34588900C").should eql(false)
+    end
+
+    it "validates a AT vat number" do
+      Valvat::Syntax.validate("ATU03458890").should eql(true)
+      
+      Valvat::Syntax.validate("ATU034588908").should eql(false)
+      Valvat::Syntax.validate("ATU0345908").should eql(false)
+      Valvat::Syntax.validate("ATU0345889Y").should eql(false)
+    end
+
+    it "should validate BE vat number" do
+      Valvat::Syntax.validate("BE0817331995").should eql(true)
+      
+      Valvat::Syntax.validate("BE081733199").should eql(false)
+      Valvat::Syntax.validate("BE08173319944").should eql(false)
+      Valvat::Syntax.validate("BE081733199H").should eql(false)
+    end
+
+    it "validates a BG vat number" do
+      Valvat::Syntax.validate("BG468134789").should eql(true)
+      Valvat::Syntax.validate("BG4681347897").should eql(true)
+
+      Valvat::Syntax.validate("BG46813478979").should eql(false)
+      Valvat::Syntax.validate("BG4681347897C").should eql(false)
+      Valvat::Syntax.validate("BG46813478G").should eql(false)
+      Valvat::Syntax.validate("BG46813478").should eql(false)
+    end
+
+    it "validates a CY vat number" do
+      Valvat::Syntax.validate("CY36579347A").should eql(true)
+      Valvat::Syntax.validate("CY36579347C").should eql(true)
+
+      Valvat::Syntax.validate("CY36579347").should eql(false)
+      Valvat::Syntax.validate("CY365793478").should eql(false)
+      Valvat::Syntax.validate("CY365793478A").should eql(false)
+      Valvat::Syntax.validate("CY365793G").should eql(false)
+    end
+
+    it "validates a DK vat number" do
+      Valvat::Syntax.validate("DK67893463").should eql(true)
+
+      Valvat::Syntax.validate("DK678934637").should eql(false)
+      Valvat::Syntax.validate("DK6789346").should eql(false)
+      Valvat::Syntax.validate("DK6789346H").should eql(false)
+    end
+
+    it "validates a ES vat number" do
+      Valvat::Syntax.validate("ESX67345987").should eql(true)
+      Valvat::Syntax.validate("ESA6734598B").should eql(true)
+      Valvat::Syntax.validate("ES56734598C").should eql(true)
+
+      Valvat::Syntax.validate("ES167345987").should eql(false)
+      Valvat::Syntax.validate("ESX6734598").should eql(false)
+      Valvat::Syntax.validate("ESX673459890").should eql(false)
+    end
+
+    it "validates a EE vat number" do
+      Valvat::Syntax.validate("EE678678456").should eql(true)
+      Valvat::Syntax.validate("EE6786784560").should eql(false)
+      Valvat::Syntax.validate("EE67867845").should eql(false)
+      Valvat::Syntax.validate("EE67867845K").should eql(false)
+    end
+
+    it "validates a FI vat number" do
+      Valvat::Syntax.validate("FI67845638").should eql(true)
+
+      Valvat::Syntax.validate("FI678456389").should eql(false)
+      Valvat::Syntax.validate("FI6784563").should eql(false)
+      Valvat::Syntax.validate("FI6784563K").should eql(false)
+    end
+
+    it "validates a FR vat number" do
+      Valvat::Syntax.validate("FR99123543267").should eql(true)
+      Valvat::Syntax.validate("FRBB123543267").should eql(true)
+      Valvat::Syntax.validate("FR9B123543267").should eql(true)
+      Valvat::Syntax.validate("FRB9123543267").should eql(true)
+
+      Valvat::Syntax.validate("FR99123543267B").should eql(false)
+      Valvat::Syntax.validate("FRBB12354326").should eql(false)
+      Valvat::Syntax.validate("FR9B123543F67").should eql(false)
+      Valvat::Syntax.validate("FRB9123543").should eql(false)
+    end
+
+    it "validates a EL vat number" do
+      Valvat::Syntax.validate("EL678456345").should eql(true)
+
+      Valvat::Syntax.validate("EL67845634").should eql(false)
+      Valvat::Syntax.validate("EL6784563459").should eql(false)
+      Valvat::Syntax.validate("EL67845634P").should eql(false)
+    end
+
+    it "validates a HU vat number" do
+      Valvat::Syntax.validate("HU67894595").should eql(true)
+
+      Valvat::Syntax.validate("HU6789459").should eql(false)
+      Valvat::Syntax.validate("HU67894595L").should eql(false)
+      Valvat::Syntax.validate("HU6789459J").should eql(false)
+    end
+
+    it "validates a IE vat number" do
+      Valvat::Syntax.validate("IE1B12345J").should eql(true)
+      Valvat::Syntax.validate("IE1234567B").should eql(true)
+
+      Valvat::Syntax.validate("IE1B123459").should eql(false)
+      Valvat::Syntax.validate("IE19123450").should eql(false)
+      Valvat::Syntax.validate("IEA9123450").should eql(false)
+    end
+
+    it "validates a IT vat number" do
+      Valvat::Syntax.validate("IT45875359285").should eql(true)
+
+      Valvat::Syntax.validate("IT458753592859").should eql(false)
+      Valvat::Syntax.validate("IT4587535928G").should eql(false)
+      Valvat::Syntax.validate("IT4587535928").should eql(false)
+    end
+
+    it "validates a LV vat number" do
+      Valvat::Syntax.validate("LV85678368906").should eql(true)
+
+      Valvat::Syntax.validate("LV8567836890").should eql(false)
+      Valvat::Syntax.validate("LV856783689066").should eql(false)
+      Valvat::Syntax.validate("LV8567836890S").should eql(false)
+    end
+
+    it "validates a LT vat number" do
+      Valvat::Syntax.validate("LT678678987").should eql(true)
+      Valvat::Syntax.validate("LT678678987956").should eql(true)
+
+      Valvat::Syntax.validate("LT67867898").should eql(false)
+      Valvat::Syntax.validate("LT6786789870").should eql(false)
+      Valvat::Syntax.validate("LT678678987K").should eql(false)
+      Valvat::Syntax.validate("LT67867898709").should eql(false)
+      Valvat::Syntax.validate("LT6786789870C").should eql(false)
+      Valvat::Syntax.validate("LT67867898795H").should eql(false)
+    end
+
+    it "validates a LU vat number" do
+      Valvat::Syntax.validate("LU45679456").should eql(true)
+
+      Valvat::Syntax.validate("LU4567945").should eql(false)
+      Valvat::Syntax.validate("LU456794560").should eql(false)
+      Valvat::Syntax.validate("LU4567945J").should eql(false)
+    end
+
+    it "validates a MT vat number" do
+      Valvat::Syntax.validate("MT64569367").should eql(true)
+
+      Valvat::Syntax.validate("MT6456936").should eql(false)
+      Valvat::Syntax.validate("MT645693679").should eql(false)
+      Valvat::Syntax.validate("MT6456936L").should eql(false)
+    end
+
+    it "validates a NL vat number" do
+      Valvat::Syntax.validate("NL673739491B77").should eql(true)
+
+      Valvat::Syntax.validate("NL673739491977").should eql(false)
+      Valvat::Syntax.validate("NL673739491A77").should eql(false)
+      Valvat::Syntax.validate("NL673739491B771").should eql(false)
+      Valvat::Syntax.validate("NL673739491B7").should eql(false)
+      Valvat::Syntax.validate("NL6737394917B7").should eql(false)
+    end
+
+    it "validates a PL vat number" do
+      Valvat::Syntax.validate("PL6784567284").should eql(true)
+
+      Valvat::Syntax.validate("PL678456728").should eql(false)
+      Valvat::Syntax.validate("PL67845672849").should eql(false)
+      Valvat::Syntax.validate("PL678456728K").should eql(false)
+    end
+
+    it "validates a PT vat number" do
+      Valvat::Syntax.validate("PT346296476").should eql(true)
+
+      Valvat::Syntax.validate("PT34629647").should eql(false)
+      Valvat::Syntax.validate("PT3462964769").should eql(false)
+    end
+
+    it "validates a GB vat number" do
+      Valvat::Syntax.validate("GB123456789").should eql(true)
+      Valvat::Syntax.validate("GB123456789012").should eql(true)
+      Valvat::Syntax.validate("GBGD123").should eql(true)
+      Valvat::Syntax.validate("GBHA123").should eql(true)
+
+      Valvat::Syntax.validate("GB12345678").should eql(false)
+      Valvat::Syntax.validate("GB1234567890").should eql(false)
+      Valvat::Syntax.validate("GB12345678901").should eql(false)
+      Valvat::Syntax.validate("GB1234567890123").should eql(false)
+      Valvat::Syntax.validate("GBAB123").should eql(false)
+      Valvat::Syntax.validate("GBAA123").should eql(false)
+      Valvat::Syntax.validate("GBHH123").should eql(false)
+      Valvat::Syntax.validate("GBGD1234").should eql(false)
+      Valvat::Syntax.validate("GBGD12").should eql(false)
+    end
+
+    it "validates a RO vat number" do
+      Valvat::Syntax.validate("RO1234567890").should eql(true)
+      Valvat::Syntax.validate("RO123456789").should eql(true)
+      Valvat::Syntax.validate("RO12345678").should eql(true)
+      Valvat::Syntax.validate("RO1234567").should eql(true)
+      Valvat::Syntax.validate("RO123456").should eql(true)
+      Valvat::Syntax.validate("RO12345").should eql(true)
+      Valvat::Syntax.validate("RO1234").should eql(true)
+      Valvat::Syntax.validate("RO123").should eql(true)
+      Valvat::Syntax.validate("RO12").should eql(true)
+
+      Valvat::Syntax.validate("RO1").should eql(false)
+      Valvat::Syntax.validate("RO0234567890").should eql(false)
+      Valvat::Syntax.validate("RO023456789").should eql(false)
+      Valvat::Syntax.validate("RO02345678").should eql(false)
+      Valvat::Syntax.validate("RO0234567").should eql(false)
+      Valvat::Syntax.validate("RO023456").should eql(false)
+      Valvat::Syntax.validate("RO02345").should eql(false)
+      Valvat::Syntax.validate("RO0234").should eql(false)
+      Valvat::Syntax.validate("RO023").should eql(false)
+      Valvat::Syntax.validate("RO02").should eql(false)
+      Valvat::Syntax.validate("RO12345678901").should eql(false)
+    end
+
+    it "validates a SK vat number" do
+      Valvat::Syntax.validate("SK5683075682").should eql(true)
+      
+      Valvat::Syntax.validate("SK56830756821").should eql(false)
+      Valvat::Syntax.validate("SK568307568").should eql(false)
+    end
+
+    it "validates a SI vat number" do
+      Valvat::Syntax.validate("SI74357893").should eql(true)
+      
+      Valvat::Syntax.validate("SI743578931").should eql(false)
+      Valvat::Syntax.validate("SI7435789").should eql(false)
+    end
+
+    it "validates a SE vat number" do
+      Valvat::Syntax.validate("SE567396352701").should eql(true)
+
+      Valvat::Syntax.validate("SE56739635201").should eql(false)
+      Valvat::Syntax.validate("SE5673963527701").should eql(false)
+      Valvat::Syntax.validate("SE567396352702").should eql(false)
+      Valvat::Syntax.validate("SE567396352711").should eql(false)
+    end
+
+    it "validates a CZ vat number" do
+      Valvat::Syntax.validate("CZ56389267").should eql(true)
+      Valvat::Syntax.validate("CZ563892670").should eql(true)
+      Valvat::Syntax.validate("CZ5638926790").should eql(true)
+
+      Valvat::Syntax.validate("CZ5638926").should eql(false)
+      Valvat::Syntax.validate("CZ56389268901").should eql(false)
+    end
+
+    it "returns false on blank/non-sense vat number" do
+      Valvat::Syntax.validate("").should eql(false)
+      Valvat::Syntax.validate(" ").should eql(false)
+      Valvat::Syntax.validate("DE").should eql(false)
+      Valvat::Syntax.validate("atu123xyz").should eql(false)
+      Valvat::Syntax.validate("xxxxxxxxxx").should eql(false)
+      Valvat::Syntax.validate("BEFR").should eql(false)
+    end
+  end
+
+  context "#validate!" do
+    it "returns true on valid vat number" do
+      Valvat::Syntax.validate!("DE345889003").should eql(true)
+    end
+    
+    it "raises Valvat::InvalidSyntax on invalid vat number" do
+      lambda { Valvat::Syntax.validate!("DE34588900") }.should raise_error(Valvat::InvalidSyntax)
+    end
+  end
+end

data/spec/valvat/utils_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Valvat::Utils do
+  context "#split" do
+    it "returns country and rest on vat number as array" do
+      Valvat::Utils.split("DE345889003").should eql(["DE", "345889003"])
+      Valvat::Utils.split("XY345889003").should eql(["XY", "345889003"])
+    end
+    
+    it "returns two nils on non-sense input as array" do
+      Valvat::Utils.split("DE").should eql([nil, nil])
+      Valvat::Utils.split("X345889003").should eql([nil, nil])
+      Valvat::Utils.split("").should eql([nil, nil])
+      Valvat::Utils.split("1234").should eql([nil, nil])
+      Valvat::Utils.split(" ").should eql([nil, nil])
+    end
+  end
+  
+  context "#normalize" do
+    it "returns vat number with upcase chars" do
+      Valvat::Utils.normalize("de345889003").should eql("DE345889003")
+      Valvat::Utils.normalize("EsX4588900y").should eql("ESX4588900Y")
+    end
+    
+    it "returns trimmed vat number" do
+      Valvat::Utils.normalize(" DE345889003").should eql("DE345889003")
+      Valvat::Utils.normalize("  DE345889003  ").should eql("DE345889003")
+      Valvat::Utils.normalize("DE345889003 ").should eql("DE345889003")
+    end
+    
+    it "dors not change already normalized vat numbers" do
+      Valvat::Utils.normalize("DE345889003").should eql("DE345889003")
+      Valvat::Utils.normalize("ESX4588900X").should eql("ESX4588900X")
+    end
+  end
+end

data/spec/valvat_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Valvat do
+  
+end

data/valvat.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "valvat/version"
+
+Gem::Specification.new do |s|
+  s.name        = "valvat"
+  s.version     = Valvat::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sebastian Munz"]
+  s.email       = ["sebastian@yo.lk"]
+  s.homepage    = "https://github.com/yolk/valvat"
+  s.summary     = %q{Validates european vat numbers. Supports simple syntax verification and lookup via the VIES web service.}
+  s.description = %q{Validates european vat numbers. Supports simple syntax verification and lookup via the VIES web service.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_dependency 'savon', '>=0.8.2'
+  
+  s.add_development_dependency 'rspec', '>= 2.4.0'
+  s.add_development_dependency 'guard-rspec', '>=0.1.9'
+  s.add_development_dependency 'growl', '>=1.0.3'
+  s.add_development_dependency 'rb-fsevent', '>=0.3.9'
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification 
+name: valvat
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sebastian Munz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-06 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: savon
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 2
+        version: 0.8.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 4
+        - 0
+        version: 2.4.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: guard-rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 9
+        version: 0.1.9
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: growl
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 3
+        version: 1.0.3
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rb-fsevent
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        - 9
+        version: 0.3.9
+  type: :development
+  version_requirements: *id005
+description: Validates european vat numbers. Supports simple syntax verification and lookup via the VIES web service.
+email: 
+- sebastian@yo.lk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/valvat.rb
+- lib/valvat/lookup.rb
+- lib/valvat/syntax.rb
+- lib/valvat/utils.rb
+- lib/valvat/version.rb
+- spec/spec_helper.rb
+- spec/valvat/lookup_spec.rb
+- spec/valvat/syntax_spec.rb
+- spec/valvat/utils_spec.rb
+- spec/valvat_spec.rb
+- valvat.gemspec
+has_rdoc: true
+homepage: https://github.com/yolk/valvat
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Validates european vat numbers. Supports simple syntax verification and lookup via the VIES web service.
+test_files: 
+- spec/spec_helper.rb
+- spec/valvat/lookup_spec.rb
+- spec/valvat/syntax_spec.rb
+- spec/valvat/utils_spec.rb
+- spec/valvat_spec.rb