valvat 1.1.4 → 1.2.0

data/lib/valvat/error.rb

@@ -3,32 +3,32 @@
 class Valvat
   Error = Class.new(RuntimeError)
 
-  class ViesError < Error
-    def initialize(faultstring = 'UNKNOWN', exception = nil)
-      @faultstring = faultstring || exception.inspect
-      @exception = exception
-      super(faultstring)
+  class LookupError < Error
+    def initialize(message, kind)
+      @message = message.to_s
+      @kind = kind.is_a?(Class) ? kind.name.split('::').last : kind.to_s
+      super(@message)
     end
 
     def to_s
-      "The VIES web service returned the error '#{@faultstring}'."
+      "The #{@kind} web service returned the error: #{@message}"
     end
 
     def eql?(other)
       to_s.eql?(other.to_s)
     end
   end
-  ViesMaintenanceError = Class.new(ViesError)
+  MaintenanceError = Class.new(LookupError)
 
-  ServiceUnavailable = Class.new(ViesMaintenanceError)
-  MemberStateUnavailable = Class.new(ViesMaintenanceError)
+  ServiceUnavailable = Class.new(MaintenanceError)
+  MemberStateUnavailable = Class.new(MaintenanceError)
 
-  OperationUnknown = Class.new(ViesError)
-  HTTPError = Class.new(ViesError)
-  Timeout = Class.new(ViesError)
-  InvalidRequester = Class.new(ViesError)
-  BlockedError = Class.new(ViesError)
-  RateLimitError = Class.new(ViesError)
+  Timeout = Class.new(LookupError)
+  InvalidRequester = Class.new(LookupError)
+  BlockedError = Class.new(LookupError)
+  RateLimitError = Class.new(LookupError)
 
-  UnknownViesError = Class.new(ViesError)
+  UnknownLookupError = Class.new(LookupError)
+
+  HTTPError = Class.new(LookupError)
 end

data/lib/valvat/local.rb

@@ -1,52 +1,5 @@
 # frozen_string_literal: true
 
-class Valvat
-  def initialize(raw)
-    @raw = Valvat::Utils.normalize(raw || '')
-    @vat_country_code, @to_s_wo_country = to_a
-  end
+puts "DEPRECATED: Requiring 'valvat/local' is deprecated. Please require 'valvat' directly."
 
-  attr_reader :raw, :vat_country_code, :to_s_wo_country
-
-  def blank?
-    raw.nil? || raw.strip == ''
-  end
-
-  def valid?
-    Valvat::Syntax.validate(self)
-  end
-
-  def valid_checksum?
-    Valvat::Checksum.validate(self)
-  end
-
-  def iso_country_code
-    Valvat::Utils.vat_country_to_iso_country(vat_country_code)
-  end
-
-  # TODO: Remove method / not in use
-  def european?
-    Valvat::Utils::EU_MEMBER_STATES.include?(iso_country_code)
-  end
-
-  def to_a
-    Valvat::Utils.split(raw)
-  end
-
-  def to_s
-    raw
-  end
-
-  def inspect
-    "#<Valvat #{[raw, iso_country_code].compact.join(' ')}>"
-  end
-end
-
-def Valvat(vat) # rubocop:disable Naming/MethodName
-  vat.is_a?(Valvat) ? vat : Valvat.new(vat)
-end
-
-require 'valvat/utils'
-require 'valvat/syntax'
-require 'valvat/checksum'
-require 'valvat/version'
+require_relative '../valvat'

data/lib/valvat/lookup/base.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+class Valvat
+  class Lookup
+    class Base
+      def initialize(vat, options = {})
+        @vat = Valvat(vat)
+        @options = options
+        @requester = @options[:requester] && Valvat(@options[:requester])
+      end
+
+      def perform
+        response = fetch(endpoint_uri)
+
+        case response
+        when Net::HTTPSuccess
+          parse(response.body)
+        else
+          { error: Valvat::HTTPError.new(response.code, self.class) }
+        end
+      end
+
+      private
+
+      def endpoint_uri
+        raise NotImplementedError
+      end
+
+      def build_request(uri)
+        raise NotImplementedError
+      end
+
+      def parse(body)
+        raise NotImplementedError
+      end
+
+      def fetch(uri, limit = 0)
+        response = send_request(uri)
+
+        if Net::HTTPRedirection == response && limit < 5
+          fetch(URI.parse(response['Location']), limit + 1)
+        else
+          response
+        end
+      rescue Errno::ECONNRESET
+        raise if limit > 5
+
+        fetch(uri, limit + 1)
+      end
+
+      def send_request(uri)
+        request = build_request(uri)
+
+        Net::HTTP.start(uri.host, uri.port, options_for(uri)) do |http|
+          http.request(request)
+        end
+      end
+
+      def options_for(uri)
+        options = if @options.key?(:savon)
+                    puts 'DEPRECATED: The option :savon is deprecated. Use :http instead.'
+                    @options[:savon]
+                  else
+                    @options[:http]
+                  end || {}
+
+        options.merge({ use_ssl: URI::HTTPS === uri })
+      end
+    end
+  end
+end

data/lib/valvat/lookup/hmrc.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'net/http'
+require 'json'
+
+class Valvat
+  class Lookup
+    class HMRC < Base
+      ENDPOINT_URL = 'https://api.service.hmrc.gov.uk/organisations/vat/check-vat-number/lookup'
+      HEADERS = {
+        # https://developer.service.hmrc.gov.uk/api-documentation/docs/reference-guide#versioning
+        'Accept' => 'application/vnd.hmrc.1.0+json'
+      }.freeze
+
+      def perform
+        return { valid: false } unless @options[:uk] == true
+
+        parse(fetch(endpoint_uri).body)
+      end
+
+      private
+
+      def endpoint_uri
+        endpoint = "/#{@vat.to_s_wo_country}"
+        endpoint += "/#{@requester.to_s_wo_country}" if @requester
+        URI.parse(ENDPOINT_URL + endpoint)
+      end
+
+      def build_request(uri)
+        Net::HTTP::Get.new(uri.request_uri, HEADERS)
+      end
+
+      def parse(body)
+        convert(JSON.parse(body))
+      end
+
+      # Return a similar format to VIES
+      # Main differences are:
+      # - request_date is a (more precise) Time instead of Date
+      # - address is newline separated instead of coma (also more precise)
+      def convert(raw)
+        return build_fault(raw) if raw.key?('code')
+
+        {
+          address: format_address(raw.dig('target', 'address')),
+          country_code: raw.dig('target', 'address', 'countryCode'),
+          name: raw.dig('target', 'name'),
+          vat_number: raw.dig('target', 'vatNumber'), valid: true
+        }.tap do |hash|
+          hash[:request_date] = Time.parse(raw['processingDate']) if raw.key?('processingDate')
+          hash[:request_identifier] = raw['consultationNumber'] if raw.key?('consultationNumber')
+        end
+      end
+
+      # Example raw address from the API:
+      # {
+      #   "line1": "HM REVENUE AND CUSTOMS",
+      #   "line2": "RUBY HOUSE",
+      #   "line3": "8 RUBY PLACE",
+      #   "line4": "ABERDEEN",
+      #   "postcode": "AB10 1ZP",
+      #   "countryCode": "GB"
+      # }
+      def format_address(address)
+        address&.values&.join("\n")
+      end
+
+      FAULTS = {
+        'MESSAGE_THROTTLED_OUT' => RateLimitError,
+        'SCHEDULED_MAINTENANCE' => ServiceUnavailable,
+        'SERVER_ERROR' => ServiceUnavailable,
+        'INVALID_REQUEST' => InvalidRequester,
+        'GATEWAY_TIMEOUT' => Timeout
+      }.freeze
+
+      def build_fault(raw)
+        fault = raw['code']
+        return { valid: false } if fault == 'NOT_FOUND'
+
+        exception = FAULTS[fault] || UnknownLookupError
+        { error: exception.new("#{fault}#{raw['message'] ? " (#{raw['message']})" : ''}", self.class) }
+      end
+    end
+  end
+end

data/lib/valvat/lookup/vies.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'net/http'
+require 'erb'
+require 'rexml'
+
+class Valvat
+  class Lookup
+    class VIES < Base
+      ENDPOINT_URI = URI('https://ec.europa.eu/taxation_customs/vies/services/checkVatService').freeze
+      HEADERS = {
+        'Accept' => 'text/xml;charset=UTF-8',
+        'Content-Type' => 'text/xml;charset=UTF-8',
+        'SOAPAction' => ''
+      }.freeze
+
+      BODY = <<-XML.gsub(/^\s+/, '')
+        <soapenv:Envelope
+        xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
+        xmlns:urn="urn:ec.europa.eu:taxud:vies:services:checkVat:types">
+          <soapenv:Header/>
+          <soapenv:Body>
+            <urn:checkVat<%= 'Approx' if @requester %>>
+                <urn:countryCode><%= @vat.vat_country_code %></urn:countryCode>
+                <urn:vatNumber><%= @vat.to_s_wo_country %></urn:vatNumber>
+                <% if @requester %>
+                <urn:requesterCountryCode><%= @vat.vat_country_code %></urn:requesterCountryCode>
+                <urn:requesterVatNumber><%= @vat.to_s_wo_country %></urn:requesterVatNumber>
+                <% end %>
+            </urn:checkVat<%= 'Approx' if @requester %>>
+          </soapenv:Body>
+        </soapenv:Envelope>
+      XML
+      BODY_TEMPLATE = ERB.new(BODY).freeze
+
+      private
+
+      def endpoint_uri
+        ENDPOINT_URI
+      end
+
+      def build_request(uri)
+        request = Net::HTTP::Post.new(uri.request_uri, HEADERS)
+        request.body = BODY_TEMPLATE.result(binding)
+        request
+      end
+
+      def parse(body)
+        doc = REXML::Document.new(body)
+        elements = doc.get_elements('/env:Envelope/env:Body').first.first
+        convert_values(elements.each_with_object({}) do |el, hash|
+          hash[convert_key(el.name)] = convert_value(el.text)
+        end)
+      end
+
+      def convert_key(key)
+        key.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr('-', '_')
+           .sub(/\Atrader_/, '')
+           .downcase.to_sym
+      end
+
+      def convert_value(value)
+        value == '---' ? nil : value
+      end
+
+      def convert_values(hash)
+        return build_fault(hash) if hash[:faultstring]
+
+        hash[:valid] = hash[:valid] == 'true' || (hash[:valid] == 'false' ? false : nil) if hash.key?(:valid)
+        hash[:request_date] = Date.parse(hash[:request_date]) if hash.key?(:request_date)
+        hash
+      end
+
+      FAULTS = {
+        'SERVICE_UNAVAILABLE' => ServiceUnavailable,
+        'MS_UNAVAILABLE' => MemberStateUnavailable,
+        'INVALID_REQUESTER_INFO' => InvalidRequester,
+        'TIMEOUT' => Timeout,
+        'VAT_BLOCKED' => BlockedError,
+        'IP_BLOCKED' => BlockedError,
+        'GLOBAL_MAX_CONCURRENT_REQ' => RateLimitError,
+        'GLOBAL_MAX_CONCURRENT_REQ_TIME' => RateLimitError,
+        'MS_MAX_CONCURRENT_REQ' => RateLimitError,
+        'MS_MAX_CONCURRENT_REQ_TIME' => RateLimitError
+      }.freeze
+
+      def build_fault(hash)
+        fault = hash[:faultstring]
+        return hash.merge({ valid: false }) if fault == 'INVALID_INPUT'
+
+        hash.merge({ error: (FAULTS[fault] || UnknownLookupError).new(fault, self.class) })
+      end
+    end
+  end
+end

data/lib/valvat/lookup.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative 'lookup/vies'
+require_relative 'lookup/hmrc'
+
 class Valvat
   class Lookup
     def initialize(vat, options = {})
@@ -10,9 +13,9 @@ class Valvat
 
     def validate
       return false if !@options[:skip_local_validation] && !@vat.valid?
-      return handle_vies_error(response[:error]) if response[:error]
+      return handle_error(response[:error]) if response[:error]
 
-      response[:valid] && show_details? ? response.to_hash : response[:valid]
+      response[:valid] && show_details? ? response : response[:valid]
     end
 
     class << self
@@ -28,15 +31,23 @@ class Valvat
     end
 
     def response
-      @response ||= Request.new(@vat, @options).perform
+      @response ||= webservice.new(@vat, @options).perform
+    end
+
+    def webservice
+      case @vat.vat_country_code
+      when 'GB' then HMRC
+      else
+        VIES
+      end
     end
 
     def show_details?
       @options[:requester] || @options[:detail]
     end
 
-    def handle_vies_error(error)
-      if error.is_a?(ViesMaintenanceError)
+    def handle_error(error)
+      if error.is_a?(MaintenanceError)
         raise error if @options[:raise_error]
       else
         raise error unless @options[:raise_error] == false

data/lib/valvat/utils.rb

@@ -6,7 +6,6 @@ class Valvat
   module Utils
     EU_MEMBER_STATES = %w[AT BE BG CY CZ DE DK EE ES FI FR GR HR HU IE IT LT LU LV MT NL PL PT RO SE SI SK].freeze
     SUPPORTED_STATES = EU_MEMBER_STATES + %w[GB]
-    EU_COUNTRIES = EU_MEMBER_STATES # TODO: Remove constant
     COUNTRY_PATTERN = /\A([A-Z]{2})(.+)\Z/.freeze
     NORMALIZE_PATTERN = /([[:punct:][:cntrl:]]|[[:space:]])+/.freeze
     CONVERT_VAT_TO_ISO_COUNTRY = { 'EL' => 'GR', 'XI' => 'GB' }.freeze

data/lib/valvat/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class Valvat
-  VERSION = '1.1.4'
+  VERSION = '1.2.0'
 end

data/lib/valvat.rb

@@ -1,16 +1,62 @@
 # frozen_string_literal: true
 
 require 'valvat/error'
-require 'valvat/local'
+require 'valvat/utils'
+require 'valvat/syntax'
+require 'valvat/checksum'
+require 'valvat/version'
 require 'valvat/lookup'
-require 'valvat/lookup/request'
-require 'valvat/lookup/response'
-require 'valvat/lookup/fault'
 require 'active_model/validations/valvat_validator' if defined?(ActiveModel)
 
 class Valvat
+  def initialize(raw)
+    @raw = Valvat::Utils.normalize(raw || '')
+    @vat_country_code, @to_s_wo_country = to_a
+  end
+
+  attr_reader :raw, :vat_country_code, :to_s_wo_country
+
+  def blank?
+    raw.nil? || raw.strip == ''
+  end
+
+  def valid?
+    Valvat::Syntax.validate(self)
+  end
+
+  def valid_checksum?
+    Valvat::Checksum.validate(self)
+  end
+
   def exists?(options = {})
     Valvat::Lookup.validate(self, options)
   end
   alias exist? exists?
+
+  def iso_country_code
+    Valvat::Utils.vat_country_to_iso_country(vat_country_code)
+  end
+
+  # TODO: Remove method / not in use
+  def european?
+    puts 'DEPRECATED: #european? is deprecated. Instead access Valvat::Utils::EU_MEMBER_STATES directly.'
+
+    Valvat::Utils::EU_MEMBER_STATES.include?(iso_country_code)
+  end
+
+  def to_a
+    Valvat::Utils.split(raw)
+  end
+
+  def to_s
+    raw
+  end
+
+  def inspect
+    "#<Valvat #{[raw, iso_country_code].compact.join(' ')}>"
+  end
+end
+
+def Valvat(vat) # rubocop:disable Naming/MethodName
+  vat.is_a?(Valvat) ? vat : Valvat.new(vat)
 end

data/spec/spec_helper.rb

@@ -8,12 +8,13 @@ rescue LoadError
 end
 
 require "#{File.dirname(__FILE__)}/../lib/valvat.rb"
+require 'webmock/rspec'
+WebMock.allow_net_connect!
 
 RSpec.configure do |config|
   config.mock_with :rspec
   config.filter_run focus: true
   config.run_all_when_everything_filtered = true
-  config.backtrace_exclusion_patterns = [%r{rspec/(core|expectations)}]
 end
 
 I18n.enforce_available_locales = false if defined?(I18n)

data/spec/valvat/checksum/es_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Valvat::Checksum::ES do
   %w[ESA13585625 ESB83871236 ESE54507058 ES25139013J ESQ1518001A ESQ5018001G ESX4942978W ESX7676464F ESB10317980
-     ESY3860557K ESY2207765D].each do |valid_vat|
+     ESY3860557K ESY2207765D ES28350472M ES41961720Z ESM1171170X ESK0928769Y].each do |valid_vat|
     it "returns true on valid VAT #{valid_vat}" do
       expect(Valvat::Checksum.validate(valid_vat)).to be(true)
     end
@@ -15,4 +15,51 @@ describe Valvat::Checksum::ES do
       expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
     end
   end
+
+  describe 'if starts with [KLMXYZ\\d], is always a natural person' do
+    invalid_vat = 'ESX65474207'
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+    end
+  end
+
+  describe 'some CIF categories (NPQRSW) require control-digit to be a letter' do
+    invalid_vat = 'ESP65474207'
+    valid_vat = 'ESP6547420G'
+
+    it "returns false on invalid VAT #{invalid_vat}" do
+      expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+    end
+
+    it "returns true on valid VAT #{valid_vat}" do
+      expect(Valvat::Checksum.validate(valid_vat)).to be(true)
+    end
+  end
+
+  describe 'some CIF categories (CDFGJNUV) allow both a numeric check digit and a letter' do
+    %w[ESC65474207 ESC6547420G].each do |valid_vat|
+      it "returns true on valid VAT #{valid_vat}" do
+        expect(Valvat::Checksum.validate(valid_vat)).to be(true)
+      end
+    end
+  end
+
+  describe 'applies special rules to validation' do
+    describe 'special NIF categories (KLM) require CD to be a letter and first two digits '\
+             'to be between 01 and 56 (inclusive)' do
+      %w[ESK8201230M ESK0001230B].each do |invalid_vat|
+        it "returns false on invalid VAT #{invalid_vat}" do
+          expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+        end
+      end
+    end
+
+    describe 'arbitrarily invalid VATs' do
+      %w[ESX0000000T ES00000001R ES00000000T ES99999999R].each do |invalid_vat|
+        it "returns false on invalid VAT #{invalid_vat}" do
+          expect(Valvat::Checksum.validate(invalid_vat)).to be(false)
+        end
+      end
+    end
+  end
 end

data/spec/valvat/checksum/gb_spec.rb

@@ -21,6 +21,7 @@ describe Valvat::Checksum::GB do
 
   it 'is true for a new format valid vat' do
     expect(Valvat::Checksum.validate('GB434031439')).to be true
+    expect(Valvat::Checksum.validate('GB727255821')).to be true
   end
 
   it 'is false for an old format VAT in forbidden group' do

data/spec/valvat/lookup/hmrc_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::HMRC do
+  before do
+    stub_const('Valvat::Lookup::HMRC::ENDPOINT_URL', 'https://test-api.service.hmrc.gov.uk/organisations/vat/check-vat-number/lookup')
+  end
+
+  it 'returns hash with valid: true on success' do
+    response = described_class.new('GB553557881', { uk: true }).perform
+
+    expect(response).to match({
+                                valid: true,
+                                address: "131B Barton Hamlet\nSW97 5CK\nGB",
+                                country_code: 'GB',
+                                vat_number: '553557881',
+                                name: 'Credite Sberger Donal Inc.',
+                                request_date: kind_of(Time)
+                              })
+  end
+
+  it 'returns hash with valid: false on invalid input' do
+    response = described_class.new('GB123456789', { uk: true }).perform
+    expect(response).to match({ valid: false })
+  end
+
+  it 'returns hash with valid: false on valid input with :uk option not set' do
+    response = described_class.new('GB553557881', {}).perform
+    expect(response).to match({ valid: false })
+  end
+end

data/spec/valvat/lookup/vies_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Valvat::Lookup::VIES do
+  it 'returns hash with valid: true on success' do
+    response = described_class.new('IE6388047V', {}).perform
+
+    expect(response).to match({
+                                valid: true,
+                                address: '3RD FLOOR, GORDON HOUSE, BARROW STREET, DUBLIN 4',
+                                country_code: 'IE',
+                                vat_number: '6388047V',
+                                name: 'GOOGLE IRELAND LIMITED',
+                                request_date: kind_of(Date)
+                              })
+  end
+
+  it 'returns hash with valid: false on invalid input' do
+    response = described_class.new('XC123123', {}).perform
+    expect(response.to_hash).to match({ valid: false, faultstring: 'INVALID_INPUT', faultcode: 'env:Server' })
+  end
+end