company_number 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4730b631eea536093350f53559626fb2ed03dd1ca63fb31169a5c9c0e0a1b1c7
-  data.tar.gz: 555444d1b274831d7bb4a2476af3d173976c59b9f44894d78198e427d88fa755
+  metadata.gz: 0d4b40991721f4eb047e7060a428f3d85593cc4ce3dd15bb427d95ed629cbb37
+  data.tar.gz: cfedbc59ad70b411b385ba55813e5ebf32247ebaf2b2628f324b3d77799b6aed
 SHA512:
-  metadata.gz: 4f6b3a8f6c65310e782b9fd099da1edd05f70b8b66c9e7b1e690387be6f28f086b4d72a5adf4d641148c3729dbbfd4ec28db41766c0e5837bc54bff112671dcb
-  data.tar.gz: 776f84d792a78b870ce940302b61dcf264f70e10282747bd1e5e6e9029ffad0d30b66ff289c1ba6b4223174e467b413e22ad91eaa96a13bbaad0b0d3edd4a7e1
+  metadata.gz: 7f012c7724dddab12ef370a57d7e5f5d00d6f556cbd5bb4aa5f0b11c33298bcc2eee4a523cce73dbcb1e669c4824d57bd14c8a67780741bb3186b65ed568ac68
+  data.tar.gz: d51f55008b3cfd58a48e312af82a9538f00e75f6e857b0601d83c684bbfdd30612f031e89ee809811ccc99614e91af1653f761106cda6f00f1c7d34959bab1c4

data/.github/workflows/build.yml

@@ -87,7 +87,7 @@ jobs:
       - uses: actions/setup-ruby@v1
       - name: Setup
         run : |
-          gem install bundler bundler-audit
+          gem install bundler:2.2.25 bundler-audit:0.9.0.1
           bundle install
       - name: Run Bundler Audit
         run : bundle audit --update

data/.rubocop.yml

@@ -19,3 +19,6 @@ Metrics/MethodLength:
 
 Layout/LineLength:
   Max: 80
+
+Naming/MemoizedInstanceVariableName:
+   EnforcedStyleForLeadingUnderscores: optional

data/CHANGELOG.md

@@ -1,5 +1,19 @@
-# Changelog
+## Changelog
 
-## 0.1.0 [☰](https://github.com/victorauthiat/company_number)
+### 0.1.1 - 2022-04-04
+  * Features:
+    * Add dictionary to return the company number metadata - b19c8d9
 
-- Initial release
+  * Deprecations:
+    * Remove `regexp` attr_reader (moved to metadata) - #3
+    * Remove `countries` attr_reader to use `CompanyNumber::Number#valid_countries` - #3
+
+  * Bug fixes:
+    * Fix `CompanyNumber::Number#to_s` method not to return trailing whitespace when country code is not filled in - 9b4f3c53
+
+  * Enhancements:
+    * Update RuboCop configuration - e34eca5
+
+### 0.1.0 - 2021-09-24
+
+  * Initial release

data/README.md

@@ -27,7 +27,7 @@ You can obtain a `CompanyNumber::Number` object calling `parse` method:
 ```ruby
 company_number = CompanyNumber.parse('123456789', :fr)
 
-# => #<CompanyNumber::Number:0x00007fd945013d50 @company_number="123456789", @countries=[:bg, :fr, :gr, :lt, :no, :pt, :si, :ch, :gb], @country_code=:fr, @regexp=/^(\d{9}|\d{14})$/>
+# => #<CompanyNumber::Number:0x00007fc015d04e18 @company_number="123456789", @country_code=:fr, @metadata={:country=>"France", :name=>"Numéro SIREN ou SIRET", :regexp=>"^(\\d{9}|\\d{14})$", :pattern=>"9 numbers (XXXXXXXXX) or 14 numbers (XXXXXXXXXXXXXX)"}>
 ```
 
 Then you can run validation methods
@@ -41,13 +41,20 @@ company_number.valid_for_country?(:at)
 # => false
 ```
 
-You can also fetch matched countries
+You can also fetch valid countries
 
 ```ruby
-company_number.countries
+company_number.valid_countries
 # => [:bg, :fr, :gr, :lt, :no, :pt, :si, :ch, :gb]
 ```
 
+Additionally you can get metadata
+
+```ruby
+company_number.metadata
+# => {:country=>"France", :name=>"Numéro SIREN ou SIRET", :regexp=>"^(\\d{9}|\\d{14})$", :pattern=>"9 numbers (XXXXXXXXX) or 14 numbers (XXXXXXXXXXXXXX)"}
+```
+
 There is a `to_s` method, which returns the company number with the country code.
 
 ```ruby
@@ -59,7 +66,7 @@ There is a `to_h` method, which returns all attr_reader
 
 ```ruby
 company_number.to_h
-# => {:company_number=>"123456789", :country_code=>:fr, :countries=>[:bg, :fr, :gr, :lt, :no, :pt, :si, :ch, :gb], :regexp=>/^(\d{9}|\d{14})$/}
+# => {:company_number=>"123456789", :country_code=>:fr, :metadata=>{:country=>"France", :name=>"Numéro SIREN ou SIRET", :regexp=>"^(\\d{9}|\\d{14})$", :pattern=>"9 numbers (XXXXXXXXX) or 14 numbers (XXXXXXXXXXXXXX)"}}
 ```
 
 You can compare 2 instances of `CompanyNumber::Number` with `==` method
@@ -69,6 +76,12 @@ CompanyNumber.parse('123') == CompanyNumber.parse('123')
 # => true
 ```
 
+Finally you can get the whole dictionary
+```ruby
+CompanyNumber.dictionary
+# => {:at=>{:country=>"Austria", :name=>"Firmenbuchnummer", :regexp=>"^([a-zA-Z]{2}\\d{1,6}|\\d{1,6})[A-Z]$", :pattern=>"2 letters + 6 numbers + 1 letter (LLXXXXXXL)", :variations=>"1-6 numbers + 1 letter (XXXXXXL)"}, ...}
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/config/dictionary.yml

@@ -0,0 +1,214 @@
+at:
+  country: Austria
+  name: Firmenbuchnummer
+  regexp: ^([a-zA-Z]{2}\d{1,6}|\d{1,6})[A-Z]$
+  pattern: 2 letters + 6 numbers + 1 letter (LLXXXXXXL)
+  variations: 1-6 numbers + 1 letter (XXXXXXL)
+
+be:
+  country: Belgium
+  name: Numéro d'entreprise Vestigingseenheidsnummer
+  regexp: ^\d{10}$
+  pattern: 10 numbers (XXXXXXXXXX)
+
+bg:
+  country: Bulgaria
+  name: ЕИК (EIK)/ПИК (PIK) (UIC/PIC)
+  regexp: ^(\d{9}|\d{13})$
+  pattern: 9 numbers (XXXXXXXXX)
+  variations: 13 numbers (XXXXXXXXXXXXX)
+
+hr:
+  country: Croatia
+  name: Matični broj poslovnog subjekta (MBS)
+  regexp: ^(\d{8}|\d{11})$
+  pattern: 11 numbers (XXXXXXXXXXX)
+  variations: 8 numbers (XXXXXXXX)
+
+cy:
+  country: Cyprus
+  regexp: ^[a-zA-Z]{2}\d{6}$
+  name: Αριθμός Μητρώου Εταιρίας Şirket kayıt numarası
+  pattern: 2 letters + 6 numbers (HEXXXXXX)
+
+cz:
+  country: Czech Republic
+  name: Identifikační číslo
+  regexp: ^\d{8}$
+  pattern: 8 numbers (XXXXXXXX)
+
+dk:
+  country: Denmark
+  name: CVR-nummer
+  regexp: ^\d{8}$
+  pattern: 8 numbers (XXXXXXXX)
+
+ee:
+  country: Estonia
+  name: Kood
+  regexp: ^\d{8}$
+  pattern: 8 numbers (XXXXXXXX)
+
+fi:
+  country: Finland
+  name: Y-tunnus FO-nummer
+  regexp: ^\d{8}$
+  pattern: 8 numbers (XXXXXXXX)
+
+fr:
+  country: France
+  name: Numéro SIREN ou SIRET
+  regexp: ^(\d{9}|\d{14})$
+  pattern: 9 numbers (XXXXXXXXX) or 14 numbers (XXXXXXXXXXXXXX)
+
+de:
+  country: Germany
+  name: Nummer der Firma Registernummer
+  regexp: ^[a-zA-Z]{1,3}\d{1,6}[a-zA-Z]{0,3}$
+  pattern: 2-3 letters + 6 numbers (LLXXXXXX)
+  variations: |
+    2-3 letters + 1-6 numbers (LLLXXXX)
+    or 2-3 letters + 1-6 numbers + 1 letter (LLLXXXXXXL)
+    or 2-3 letters + 1-6 numbers + 1-2 letter (LLLXXXXXXLL)
+
+gr:
+  country: Greece
+  name: Αριθμό Φορολογικού Μητρώου (Α.Φ.Μ.)
+  regexp: ^(\d{9}|\d{12})$
+  pattern: 12 numbers (XXXXXXXXXXXX)
+  variations: 9 numbers (XXXXXXXXX)
+
+hu:
+  country: Hungary
+  name: Cégjegyzékszáma
+  regexp: ^[a-zA-Z]{2}\d{10}$
+  pattern: 2 letters + 10 numbers (LLXXXXXXXXXX)
+
+ie:
+  country: Ireland
+  name: Company Number
+  regexp: ^(\d{5}|\d{6})$
+  pattern: 6 numbers (XXXXXX)
+  variations: 5 numbers (XXXXX)
+
+is:
+  country: Island
+  name: TIN
+  regexp: ^\d{10}$
+  pattern: 10 numbers (XXXXXXXXXX)
+
+it:
+  country: Italy
+  name: Codice fiscale
+  regexp: ^[a-zA-Z]{2}\d{7}|\d{11}$
+  pattern: 11 numbers (XXXXXXXXXXX)
+  variations: 2 letters + 7 numbers (LLXXXXXXX)
+
+lv:
+  country: Latvia
+  name: Reģistrācijas numurs
+  regexp: ^\d{11}$
+  pattern: 11 numbers (XXXXXXXXXXX)
+
+li:
+  country: Liechtenstein
+  name: UID
+  regexp: ^[a-zA-Z]{3}\d{3}\s\d{3}\s\d{3}$
+  pattern: 3 letters + 9 numbers (LLLXXX XXX XXX)
+
+lt:
+  country: Lithuania
+  name: Juridinio asmens kodas
+  regexp: ^\d{9}$
+  pattern: 9 numbers (XXXXXXXXX)
+
+lu:
+  country: Luxembourg
+  name: Numéro d'immatriculation
+  regexp: ^[a-zA-Z]{1}\d{6}|[a-jA-J]\d{3}$
+  pattern: 1 letter + 6 numbers (LXXXXXX)'
+  variations: 1 letter (from A to J) + 3 numbers (AXXX)
+
+mt:
+  country: Malta
+  name: Registration Number
+  regexp: ^[a-zA-Z]{1}\d{5}$
+  pattern: 1 letter + 5 numbers (LXXXXX)
+
+nl:
+  country: Netherlands
+  name: KvK-nummer
+  regexp: ^\d{8}$
+  pattern: 8 numbers (XXXXXXXX)
+
+"no":
+  country: Norway
+  name: TIN
+  regexp: ^(\d{9}|\d{11})$
+  pattern: 11 numbers (XXXXXXXXXXX)
+  variations: 9 numbers (XXXXXXXXX)
+
+pl:
+  country: Poland
+  name: Numer w Krajowym Rejestrze Sądowym (numer KRS)
+  regexp: ^(\d{6}|\d{8})$
+  pattern: 8 numbers (XXXXXXXX)
+  variations: 6 numbers (XXXXXX)
+
+pt:
+  country: Portugal
+  name: Número de Identificação Pessoa Coletiva (NIPC)
+  regexp: ^(\d{9}|\d{3,6})$
+  pattern: 9 numbers (XXXXXXXXX)
+  variations: 3-6 numbers (XXXXXX)
+
+ro:
+  country: Romania
+  name: Număr de ordine în Registrul Comerţului
+  regexp: ^\d{3}\s\d{2}\s\d{3}$
+  pattern: 8 numbers (XXX XX XXX)
+
+sk:
+  country: Slovakia
+  name: Identifikačného čísla Identification number
+  regexp: ^\d{3}\s\d{2}\s\d{3}$
+  pattern: 8 numbers (XXX XX XXX)
+
+si:
+  country: Slovenia
+  name: Matična številka
+  regexp: ^\d{10}|\d{7,10}$
+  pattern: 10 numbers (XXXXXXXXXX)
+  variations: 7 - 10 numbers (XXXXXXXXXX)
+
+es:
+  country: Spain
+  name: Número de identificación fiscal (NIF)
+  regexp: ^[a-zA-Z]{1}(\d{8}|\d{7}[a-zA-Z]{1})$
+  pattern: 1 letter + 8 numbers (LXXXXXXXX)
+  variations: 1 letter + 7 numbers + 1 letter (LXXXXXXXL)
+
+se:
+  country: Sweden
+  name: Registreringsnummer
+  regexp: ^\d{10}$
+  pattern: 10 numbers (XXXXXXXXXX)
+
+ch:
+  country: Switzerland
+  name: UID
+  regexp: ^CHE\d{9}|\d{9}$
+  pattern: 9 numbers (XXXXXXXXX)
+  variations: CHE + 9 numbers
+
+gb:
+  country: United Kingdom
+  name: Company Number Registration Number
+  regexp: ^\d{8}|(OC|SC|NI)\d{6}|R\d{7}|IP\d{5}R$
+  pattern: 8 numbers (XXXXXXX)
+  variations: |
+    OC + 6 numbers (OCXXXXXX)
+    or SC + 6 numbers (SCXXXXXX)
+    or NI + 6 numbers (NIXXXXXX)
+    or R + 7 numbers (RXXXXXXX)
+    or IP + 5 numbers + R (IPXXXXXR)

data/lib/company_number/number.rb

@@ -1,14 +1,30 @@
 module CompanyNumber
   class Number
-    attr_reader :company_number, :country_code, :countries, :regexp
+    attr_reader :company_number, :country_code, :metadata
 
     def initialize(company_number, country_code = nil)
-      validate_attributes(company_number, country_code)
+      check_param_type(company_number, [String])
+      check_param_type(country_code, [NilClass, Symbol, String])
 
       @company_number = company_number
-      @country_code = country_code&.downcase&.to_sym
-      @countries = fetch_countries
-      @regexp = CompanyNumber::VALIDATIONS[@country_code]
+      @country_code   = country_code&.downcase&.to_sym
+      @metadata       = CompanyNumber.dictionary[@country_code] || {}
+    end
+
+    def to_h
+      {
+        company_number: @company_number,
+        country_code: @country_code,
+        metadata: @metadata
+      }
+    end
+
+    def to_s
+      "#{@company_number} #{@country_code}".strip
+    end
+
+    def ==(other)
+      self.class == other.class && other.to_s == to_s
     end
 
     def valid?
@@ -16,48 +32,37 @@ module CompanyNumber
     end
 
     def valid_country?
-      CompanyNumber::VALIDATIONS.keys.include?(@country_code)
+      CompanyNumber.dictionary.keys.include?(@country_code)
     end
 
     def valid_for_country?(country_code)
-      !!(@company_number =~ CompanyNumber::VALIDATIONS[country_code])
-    end
+      check_param_type(country_code, [Symbol])
 
-    def to_s
-      "#{@company_number} #{@country_code}"
+      !!(@company_number =~ country_code_regexp(country_code))
     end
 
-    def to_h
-      {
-        company_number: @company_number,
-        country_code: @country_code,
-        countries: @countries,
-        regexp: @regexp
-      }
-    end
+    def valid_countries
+      return [] if !valid_country? && @country_code
 
-    def ==(other)
-      self.class == other.class && other.to_s == to_s
+      CompanyNumber
+        .dictionary
+        .keys
+        .select { |country_code| valid_for_country?(country_code) }
     end
 
     private
 
-    def validate_attributes(company_number, country_code)
-      unless company_number.is_a?(String)
-        raise ArgumentError, 'Expect company_number to be String'
-      end
-
-      return if [NilClass, Symbol, String].include?(country_code.class)
+    def country_code_regexp(country_code)
+      regexp = CompanyNumber.dictionary.dig(country_code, :regexp)
 
-      raise ArgumentError, 'Expect country_code to be String, Symbol or nil'
+      Regexp.new(regexp) unless regexp.nil?
     end
 
-    def fetch_countries
-      return [] if !valid_country? && @country_code
+    def check_param_type(param, expected_classes = [])
+      return if expected_classes.include?(param.class)
 
-      CompanyNumber::VALIDATIONS.select do |country_code, regexp|
-        country_code if @company_number =~ regexp
-      end.keys
+      raise ArgumentError,
+            "Expect class of #{param} to be #{expected_classes.join(', ')}"
     end
   end
 end

data/lib/company_number/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CompanyNumber
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/company_number.rb

@@ -1,45 +1,21 @@
 # frozen_string_literal: true
 
+require "yaml"
 require_relative "company_number/version"
 
 module CompanyNumber
   autoload :Number, 'company_number/number'
 
-  VALIDATIONS = {
-    at: /^([a-zA-Z]{2}\d{1,6}|\d{1,6})[A-Z]$/,
-    be: /^\d{10}$/,
-    bg: /^(\d{9}|\d{13})$/,
-    hr: /^(\d{8}|\d{11})$/,
-    cz: /^\d{8}$/,
-    dk: /^\d{8}$/,
-    ee: /^\d{8}$/,
-    fi: /^\d{8}$/,
-    fr: /^(\d{9}|\d{14})$/,
-    de: /^[a-zA-Z]{1,3}\d{1,6}[a-zA-Z]{0,3}$/,
-    gr: /^(\d{9}|\d{12})$/,
-    hu: /^[a-zA-Z]{2}\d{10}$/,
-    ie: /^(\d{5}|\d{6})$/,
-    is: /^\d{10}$/,
-    it: /^[a-zA-Z]{2}\d{7}|\d{11}$/,
-    lv: /^\d{11}$/,
-    li: /^[a-zA-Z]{3}\d{3}\s\d{3}\s\d{3}$/,
-    lt: /^\d{9}$/,
-    lu: /^[a-zA-Z]{1}\d{6}|[a-jA-J]\d{3}$/,
-    mt: /^[a-zA-Z]{1}\d{5}$/,
-    nl: /^\d{8}$/,
-    no: /^(\d{9}|\d{11})$/,
-    pl: /^(\d{6}|\d{8})$/,
-    pt: /^(\d{9}|\d{3,6})$/,
-    ro: /^\d{3}\s\d{2}\s\d{3}$/,
-    sk: /^\d{3}\s\d{2}\s\d{3}$/,
-    si: /^\d{10}|\d{7,10}$/,
-    es: /^[a-zA-Z]{1}(\d{8}|\d{7}[a-zA-Z]{1})$/,
-    se: /^\d{10}$/,
-    ch: /^CHE\d{9}|\d{9}$/,
-    gb: /^\d{8}|(OC|SC|NI)\d{6}|R\d{7}|IP\d{5}R$/
-  }.freeze
+  class << self
+    def parse(company_number, country_code = nil)
+      CompanyNumber::Number.new(company_number, country_code)
+    end
 
-  def self.parse(company_number, country_code = nil)
-    CompanyNumber::Number.new(company_number, country_code)
+    def dictionary
+      @_dictionary ||= YAML.safe_load(
+        File.read(File.join(File.dirname(__FILE__), '../config/dictionary.yml')),
+        symbolize_names: true
+      )
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: company_number
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - victorauthiat
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-09-24 00:00:00.000000000 Z
+date: 2022-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -100,6 +100,7 @@ files:
 - bin/console
 - bin/setup
 - company_number.gemspec
+- config/dictionary.yml
 - lib/company_number.rb
 - lib/company_number/number.rb
 - lib/company_number/version.rb
@@ -122,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Validate a company number according to a country code