addressing 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8233bf8cb2abbf1e8d8fca6a882ee00505806169c94963c8ab896af7b41c0e48
-  data.tar.gz: 3c48631e3abe58f8a9c8be302937ac1216ca64f7414de2a18488dae48f445e56
+  metadata.gz: 25d057964fdb1ec9c73f9652e2ce82974abf5309b52047e0927a51d51aed78da
+  data.tar.gz: 2c6e90b8c9db02dfb442e65a2bd11d5e6fa690f9e9772d30545a9feba6c9a9c4
 SHA512:
-  metadata.gz: d4d1ebb1ac87064dc5be3a9680e07bcc2884744f2d0cbc14686b2944dabc98c1384a57af43e32357b59e0d9321c6c3321f31a25e6691fb5f499d0054d12b71cf
-  data.tar.gz: 88ded891be8e5c5e4ebcb13c7015280bf6f73b7249498d28f80fb13d37d2beaf911a9bccf0975196513aa288a2666cb83093dfdbdab99ae46bf99fcff049cf18
+  metadata.gz: 8cd5595a0644d74eafcb7e859576ab24e9aaf4e684981cbe5d4ec9039fd425cb5659c6c33c5b9111f22c7e9ba6d8cc5d46821341c4124f22670c15cb54e4df69
+  data.tar.gz: 844a1e91ec57d11b867aa8c9d381661e6e560bc5d4f1b797bf363eb66528fbf345f9ff324214a1bcafd50b125aa789c5961bda732e7d0c056fd5e4fe7738700e

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 All notable changes to `addressing` will be documented in this file.
 
+## 1.1.0 (2025-10-03)
+
+- Add formatter-level caching for Country.list
+- Refactor FieldOverrides initialization to be more idiomatic
+- Add equality methods to Address class
+- Refactor complex values method in DefaultFormatter
+- Extract magic strings to constants
+- Simplify boolean validation in formatter options
+- use .new() for UnknownLocaleError
+- Added RDoc documentation
+- Replaced class variables with class instance variables
+- Add custom exception classes for better error handling
+- Refactor Address class
+- Fix test bug in address_test.rb
+- Remove duplicate code in Model validation
+- add missing % to generic address format
+
 ## 1.0.0 (2024-10-21)
 
 - Sync data with commerceguys repository (v2.2.2)

data/lib/addressing/address.rb

@@ -1,9 +1,47 @@
 # frozen_string_literal: true
 
 module Addressing
+  # Represents a postal address with attributes for country, administrative areas,
+  # postal code, address lines, and recipient information.
+  #
+  # Address objects are immutable - use the +with_*+ methods to create modified copies.
+  #
+  # @example Creating an address
+  #   address = Addressing::Address.new(
+  #     country_code: "US",
+  #     administrative_area: "CA",
+  #     locality: "Mountain View",
+  #     postal_code: "94043",
+  #     address_line1: "1600 Amphitheatre Parkway"
+  #   )
+  #
+  # @example Modifying an address
+  #   updated = address.with_postal_code("94044")
   class Address
-    attr_reader :country_code, :administrative_area, :locality, :dependent_locality, :postal_code, :sorting_code, :address_line1, :address_line2, :address_line3, :organization, :given_name, :additional_name, :family_name, :locale
-
+    FIELDS = %i[
+      country_code administrative_area locality dependent_locality
+      postal_code sorting_code address_line1 address_line2 address_line3
+      organization given_name additional_name family_name locale
+    ].freeze
+
+    attr_reader(*FIELDS)
+
+    # Creates a new Address instance.
+    #
+    # @param country_code [String] ISO 3166-1 alpha-2 country code
+    # @param administrative_area [String] Top-level administrative subdivision (state, province, etc.)
+    # @param locality [String] City or locality
+    # @param dependent_locality [String] Dependent locality (neighborhood, suburb, district, etc.)
+    # @param postal_code [String] Postal code
+    # @param sorting_code [String] Sorting code (used in some countries)
+    # @param address_line1 [String] First line of the street address
+    # @param address_line2 [String] Second line of the street address
+    # @param address_line3 [String] Third line of the street address
+    # @param organization [String] Organization name
+    # @param given_name [String] Given name (first name)
+    # @param additional_name [String] Additional name (middle name, patronymic)
+    # @param family_name [String] Family name (last name)
+    # @param locale [String] Locale code for the address
     def initialize(country_code: "", administrative_area: "", locality: "", dependent_locality: "", postal_code: "", sorting_code: "", address_line1: "", address_line2: "", address_line3: "", organization: "", given_name: "", additional_name: "", family_name: "", locale: "und")
       @country_code = country_code
       @administrative_area = administrative_area
@@ -21,92 +59,42 @@ module Addressing
       @locale = locale
     end
 
-    def with_country_code(country_code)
-      address = clone
-      address.country_code = country_code
-      address
-    end
-
-    def with_administrative_area(administrative_area)
-      address = clone
-      address.administrative_area = administrative_area
-      address
-    end
-
-    def with_locality(locality)
-      address = clone
-      address.locality = locality
-      address
-    end
-
-    def with_dependent_locality(dependent_locality)
-      address = clone
-      address.dependent_locality = dependent_locality
-      address
-    end
-
-    def with_postal_code(postal_code)
-      address = clone
-      address.postal_code = postal_code
-      address
-    end
-
-    def with_sorting_code(sorting_code)
-      address = clone
-      address.sorting_code = sorting_code
-      address
-    end
-
-    def with_address_line1(address_line1)
-      address = clone
-      address.address_line1 = address_line1
-      address
-    end
-
-    def with_address_line2(address_line2)
-      address = clone
-      address.address_line2 = address_line2
-      address
+    # Define with_* methods for all fields
+    FIELDS.each do |field|
+      define_method(:"with_#{field}") do |value|
+        address = clone
+        address.send(:"#{field}=", value)
+        address
+      end
     end
 
-    def with_address_line3(address_line3)
-      address = clone
-      address.address_line3 = address_line3
-      address
-    end
-
-    def with_organization(organization)
-      address = clone
-      address.organization = organization
-      address
-    end
-
-    def with_given_name(given_name)
-      address = clone
-      address.given_name = given_name
-      address
-    end
+    # Compares two addresses for equality based on all field values.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] true if all fields are equal
+    def ==(other)
+      return false unless other.is_a?(Address)
 
-    def with_additional_name(additional_name)
-      address = clone
-      address.additional_name = additional_name
-      address
+      FIELDS.all? { |field| send(field) == other.send(field) }
     end
 
-    def with_family_name(family_name)
-      address = clone
-      address.family_name = family_name
-      address
+    # Compares two addresses for equality (alias for ==).
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] true if all fields are equal
+    def eql?(other)
+      self == other
     end
 
-    def with_locale(locale)
-      address = clone
-      address.locale = locale
-      address
+    # Generates a hash code for the address based on all field values.
+    #
+    # @return [Integer] hash code
+    def hash
+      FIELDS.map { |field| send(field) }.hash
     end
 
     protected
 
-    attr_writer :country_code, :administrative_area, :locality, :dependent_locality, :postal_code, :sorting_code, :address_line1, :address_line2, :address_line3, :organization, :given_name, :additional_name, :family_name, :locale
+    attr_writer(*FIELDS)
   end
 end

data/lib/addressing/address_format.rb

@@ -1,20 +1,31 @@
 # frozen_string_literal: true
 
 module Addressing
+  # Provides address format information for countries.
+  #
+  # Address formats define which fields are used, their order, requirements,
+  # and formatting rules for postal addresses in different countries.
+  #
+  # @example Get address format for Brazil
+  #   format = Addressing::AddressFormat.get('BR')
+  #   format.used_fields      # => ["given_name", "family_name", ...]
+  #   format.required_fields  # => ["address_line1", "locality", ...]
   class AddressFormat
     class << self
-      # The instantiated address formats, keyed by country code.
-      @@address_formats = {}
-
+      # Gets the address format for the provided country code.
+      #
+      # @param country_code [String] ISO 3166-1 alpha-2 country code
+      # @return [AddressFormat] Address format instance
       def get(country_code)
         country_code = country_code.upcase
+        @address_formats ||= {}
 
-        unless @@address_formats.key?(country_code)
+        unless @address_formats.key?(country_code)
           definition = process_definition(definitions[country_code] || {country_code: country_code})
-          @@address_formats[country_code] = new(definition)
+          @address_formats[country_code] = new(definition)
         end
 
-        @@address_formats[country_code]
+        @address_formats[country_code]
       end
 
       def all
@@ -27,7 +38,7 @@ module Addressing
       private
 
       def definitions
-        @@definitions ||= Marshal.load(File.read(File.expand_path("../../../data/address_formats.dump", __FILE__).to_s))
+        @definitions ||= Marshal.load(File.read(File.expand_path("../../../data/address_formats.dump", __FILE__).to_s))
       end
 
       def process_definition(definition)
@@ -42,7 +53,7 @@ module Addressing
 
       def generic_definition
         {
-          format: "%given_name %family_name\n%organization\n%address_line1\n%address_line2\n\address_line3\n%locality",
+          format: "%given_name %family_name\n%organization\n%address_line1\n%address_line2\n%address_line3\n%locality",
           required_fields: [
             "address_line1", "locality"
           ],

data/lib/addressing/country.rb

@@ -1,11 +1,23 @@
 # frozen_string_literal: true
 
 module Addressing
+  # Provides country information including names, codes, currency, and timezones.
+  #
+  # Country names are available in over 250 locales powered by CLDR data.
+  #
+  # @example Get a country by code
+  #   brazil = Addressing::Country.get('BR')
+  #   brazil.name          # => "Brazil"
+  #   brazil.currency_code # => "BRL"
+  #
+  # @example Get all countries
+  #   countries = Addressing::Country.all('fr-FR')
+  #
+  # @example Get a simple list of countries
+  #   list = Addressing::Country.list('en')
   class Country
     class << self
-      @@definitions = {}
-
-      @@available_locales = [
+      AVAILABLE_LOCALES = [
         "af", "am", "ar", "ar-LY", "ar-SA", "as", "az", "be", "bg", "bn",
         "bn-IN", "bs", "ca", "chr", "cs", "cy", "da", "de", "de-AT", "de-CH",
         "dsb", "el", "el-polyton", "en", "en-001", "en-AU", "en-CA", "en-ID",
@@ -23,12 +35,19 @@ module Addressing
         "uz", "vi", "yue", "yue-Hans", "zh", "zh-Hant", "zh-Hant-HK", "zu"
       ]
 
+      # Gets a Country instance for the provided country code.
+      #
+      # @param country_code [String] ISO 3166-1 alpha-2 country code
+      # @param locale [String] Locale for the country name (default: "en")
+      # @param fallback_locale [String] Fallback locale if requested locale is unavailable
+      # @return [Country] Country instance
+      # @raise [UnknownCountryError] if the country code is not recognized
       def get(country_code, locale = "en", fallback_locale = "en")
         country_code = country_code.upcase
 
-        raise UnknownCountryError, country_code unless base_definitions.key?(country_code)
+        raise UnknownCountryError.new(country_code) unless base_definitions.key?(country_code)
 
-        locale = Locale.resolve(@@available_locales, locale, fallback_locale)
+        locale = Locale.resolve(AVAILABLE_LOCALES, locale, fallback_locale)
         definitions = load_definitions(locale)
 
         new(
@@ -41,8 +60,13 @@ module Addressing
         )
       end
 
+      # Gets all Country instances.
+      #
+      # @param locale [String] Locale for country names (default: "en")
+      # @param fallback_locale [String] Fallback locale if requested locale is unavailable
+      # @return [Hash<String, Country>] Hash of country code => Country instance
       def all(locale = "en", fallback_locale = "en")
-        locale = Locale.resolve(@@available_locales, locale, fallback_locale)
+        locale = Locale.resolve(AVAILABLE_LOCALES, locale, fallback_locale)
         definitions = load_definitions(locale)
 
         definitions.map do |country_code, country_name|
@@ -59,8 +83,13 @@ module Addressing
         end.to_h
       end
 
+      # Gets a list of country codes and names.
+      #
+      # @param locale [String] Locale for country names (default: "en")
+      # @param fallback_locale [String] Fallback locale if requested locale is unavailable
+      # @return [Hash<String, String>] Hash of country code => country name
       def list(locale = "en", fallback_locale = "en")
-        locale = Locale.resolve(@@available_locales, locale, fallback_locale)
+        locale = Locale.resolve(AVAILABLE_LOCALES, locale, fallback_locale)
         definitions = load_definitions(locale)
 
         definitions.map do |country_code, country_name|
@@ -72,19 +101,20 @@ module Addressing
 
       # Loads the country definitions for the provided locale.
       def load_definitions(locale)
-        unless @@definitions.key?(locale)
+        @definitions ||= {}
+        unless @definitions.key?(locale)
           filename = File.join(File.expand_path("../../../data/country", __FILE__).to_s, "#{locale}.json")
-          @@definitions[locale] = JSON.parse(File.read(filename))
+          @definitions[locale] = JSON.parse(File.read(filename))
         end
 
-        @@definitions[locale]
+        @definitions[locale]
       end
 
       # Gets the base country definitions.
       #
       # Contains data common to all locales: three letter code, numeric code.
       def base_definitions
-        @@base_definitions ||= {
+        @base_definitions ||= {
           "AC" => ["ASC", nil, "SHP"],
           "AD" => ["AND", "020", "EUR"],
           "AE" => ["ARE", "784", "AED"],

data/lib/addressing/default_formatter.rb

@@ -2,8 +2,13 @@
 
 module Addressing
   class DefaultFormatter
+    DEFAULT_LOCALE = "en"
+    FORMAT_PLACEHOLDER_PATTERN = /%[a-z1-9_]+/
+    LEADING_TRAILING_PUNCTUATION_PATTERN = /\A[ \-,]+|[ \-,]+\z/
+    MULTIPLE_SPACES_PATTERN = /\s\s+/
+
     DEFAULT_OPTIONS = {
-      locale: "en",
+      locale: DEFAULT_LOCALE,
       html: true,
       html_tag: "p",
       html_attributes: {translate: "no"}
@@ -13,6 +18,7 @@ module Addressing
       assert_options(default_options)
 
       @default_options = self.class::DEFAULT_OPTIONS.merge(default_options)
+      @country_list_cache = {}
     end
 
     def format(address, options = {})
@@ -33,7 +39,7 @@ module Addressing
       view = render_view(view)
 
       replacements = view.map { |key, element| ["%#{key}", element] }.to_h
-      output = format_string.gsub(/%[a-z1-9_]+/) { |m| replacements[m] }
+      output = format_string.gsub(FORMAT_PLACEHOLDER_PATTERN) { |m| replacements[m] }
       output = clean_output(output)
 
       if options[:html]
@@ -49,7 +55,7 @@ module Addressing
 
     # Builds the view for the given address.
     def build_view(address, address_format, options)
-      countries = Country.list(options[:locale])
+      countries = country_list(options[:locale])
       values = values(address, address_format).merge({"country" => countries.key?(address.country_code) ? countries[address.country_code] : address.country_code})
       used_fields = address_format.used_fields + ["country"]
 
@@ -58,6 +64,11 @@ module Addressing
       end.to_h
     end
 
+    # Gets the country list for a locale, with caching.
+    def country_list(locale)
+      @country_list_cache[locale] ||= Country.list(locale)
+    end
+
     # Renders the given view.
     def render_view(view)
       view.map do |key, element|
@@ -90,27 +101,34 @@ module Addressing
 
     # Removes empty lines, leading punctuation, excess whitespace.
     def clean_output(output)
-      output.split("\n").map { |line| line.gsub(/\A[ \-,]+|[ \-,]+\z/, "").strip.gsub(/\s\s+/, " ") }.reject(&:empty?).join("\n")
+      output.split("\n").map { |line| line.gsub(LEADING_TRAILING_PUNCTUATION_PATTERN, "").strip.gsub(MULTIPLE_SPACES_PATTERN, " ") }.reject(&:empty?).join("\n")
     end
 
     # Gets the address values used to build the view.
     def values(address, address_format)
-      values = AddressField.all.map { |_, field| [field, address.send(field)] }.to_h
+      values = extract_address_values(address)
+      resolve_subdivision_values(values, address, address_format)
+      values
+    end
+
+    # Extracts all address field values.
+    def extract_address_values(address)
+      AddressField.all.map { |_, field| [field, address.send(field)] }.to_h
+    end
+
+    # Resolves subdivision values to their display codes.
+    def resolve_subdivision_values(values, address, address_format)
       subdivision_fields = address_format.used_subdivision_fields
 
       # Replace the subdivision values with the names of any predefined ones.
       subdivision_fields.each_with_index.inject([{}, []]) do |(original_values, parents), (field, index)|
-        if values[field].nil?
-          # This level is empty, so there can be no sublevels.
-          break
-        end
+        # This level is empty, so there can be no sublevels.
+        break if values[field].nil?
 
         parents << ((index > 0) ? original_values[subdivision_fields[index - 1]] : address.country_code)
 
         subdivision = Subdivision.get(values[field], parents)
-        if subdivision.nil?
-          break
-        end
+        break if subdivision.nil?
 
         # Remember the original value so that it can be used for parents.
         original_values[field] = values[field]
@@ -119,15 +137,11 @@ module Addressing
         use_local_name = Locale.match_candidates(address.locale, subdivision.locale)
         values[field] = use_local_name ? subdivision.local_code : subdivision.code
 
-        if !subdivision.children?
-          # The current subdivision has no children, stop.
-          break
-        end
+        # The current subdivision has no children, stop.
+        break unless subdivision.children?
 
         [original_values, parents]
       end
-
-      values
     end
 
     private
@@ -142,7 +156,7 @@ module Addressing
         end
       end
 
-      if options.key?(:html) && !options[:html].is_a?(TrueClass) && !options[:html].is_a?(FalseClass)
+      if options.key?(:html) && ![true, false].include?(options[:html])
         raise ArgumentError, "The option `html` must be a boolean."
       end
 

data/lib/addressing/enum.rb

@@ -3,15 +3,14 @@
 module Addressing
   class Enum
     class << self
-      @@values = {}
-
       # Gets all available values.
       def all
-        if !@@values.key?(name)
-          @@values[name] = constants.map { |constant| [constant, const_get(constant)] }.to_h
+        @values ||= {}
+        if !@values.key?(name)
+          @values[name] = constants.map { |constant| [constant, const_get(constant)] }.to_h
         end
 
-        @@values[name]
+        @values[name]
       end
 
       # Gets the key of the provided value.

data/lib/addressing/exceptions.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Addressing
+  # Base error class for all Addressing errors
+  class Error < StandardError; end
+
+  # Raised when an unknown country code is provided
+  class UnknownCountryError < Error
+    def initialize(country_code)
+      super("Unknown country code: #{country_code}")
+      @country_code = country_code
+    end
+
+    attr_reader :country_code
+  end
+
+  # Raised when an unknown locale is provided
+  class UnknownLocaleError < Error
+    def initialize(locale)
+      super("Unknown locale: #{locale}")
+      @locale = locale
+    end
+
+    attr_reader :locale
+  end
+
+  # Raised when an invalid argument is provided
+  class InvalidArgumentError < Error; end
+end

data/lib/addressing/field_override.rb

@@ -14,20 +14,13 @@ module Addressing
       AddressField.assert_all_exist(definition.keys)
       FieldOverride.assert_all_exist(definition.values)
 
-      @hidden_fields = []
-      @optional_fields = []
-      @required_fields = []
+      # Group fields by their override type
+      grouped = definition.group_by { |_field, override| override }
+        .transform_values { |pairs| pairs.map(&:first) }
 
-      definition.each do |field, override|
-        case override
-        when FieldOverride::HIDDEN
-          @hidden_fields << field
-        when FieldOverride::OPTIONAL
-          @optional_fields << field
-        when FieldOverride::REQUIRED
-          @required_fields << field
-        end
-      end
+      @hidden_fields = grouped[FieldOverride::HIDDEN] || []
+      @optional_fields = grouped[FieldOverride::OPTIONAL] || []
+      @required_fields = grouped[FieldOverride::REQUIRED] || []
     end
   end
 end

data/lib/addressing/locale.rb

@@ -251,7 +251,7 @@ module Addressing
       end
 
       # No locale could be resolved, stop here.
-      raise UnknownLocaleError, locale if resolved_locale.nil?
+      raise UnknownLocaleError.new(locale) if resolved_locale.nil?
 
       resolved_locale
     end

data/lib/addressing/model.rb

@@ -20,12 +20,6 @@ module Addressing
           return unless address.country_code.present?
 
           address_format = AddressFormat.get(address.country_code)
-          address_format.used_fields
-
-          return unless address.country_code.present?
-
-          address_format = AddressFormat.get(address.country_code)
-          address_format.used_fields
 
           # Validate the presence of required fields.
           AddressFormatHelper.required_fields(address_format, field_overrides).each do |required_field|

data/lib/addressing/postal_label_formatter.rb

@@ -3,7 +3,7 @@
 module Addressing
   class PostalLabelFormatter < DefaultFormatter
     DEFAULT_OPTIONS = {
-      locale: "en",
+      locale: DEFAULT_LOCALE,
       html: false,
       html_tag: "p",
       html_attributes: {translate: "no"},

data/lib/addressing/subdivision.rb

@@ -1,25 +1,36 @@
 # frozen_string_literal: true
 
 module Addressing
+  # Represents administrative subdivisions within countries.
+  #
+  # Subdivisions can be hierarchical with up to three levels:
+  # Administrative Area -> Locality -> Dependent Locality
+  #
+  # @example Get subdivisions for Brazil
+  #   states = Addressing::Subdivision.all(['BR'])
+  #   states.each do |code, state|
+  #     puts "#{code}: #{state.name}"
+  #     municipalities = state.children
+  #   end
+  #
+  # @example Get subdivisions for a Brazilian state
+  #   municipalities = Addressing::Subdivision.all(['BR', 'CE'])
   class Subdivision
     class << self
-      # Subdivision definitions.
-      @@definitions = {}
-
-      # Parent subdivisions.
+      # Gets a Subdivision instance by ID and parent hierarchy.
       #
-      # Used as a cache to speed up instantiating subdivisions with the same
-      # parent. Contains only parents instead of all instantiated subdivisions
-      # to minimize duplicating the data in $this->definitions, thus reducing
-      # memory usage.
-      @@parents = {}
-
+      # @param id [String] Subdivision ID
+      # @param parents [Array<String>] Parent hierarchy (e.g., ['BR'] or ['BR', 'CE'])
+      # @return [Subdivision, nil] Subdivision instance or nil if not found
       def get(id, parents)
         definitions = load_definitions(parents)
         create_subdivision_from_definitions(id, definitions)
       end
 
       # Returns all subdivision instances for the provided parents.
+      #
+      # @param parents [Array<String>] Parent hierarchy (e.g., ['BR'] or ['BR', 'CE'])
+      # @return [Hash<String, Subdivision>] Hash of subdivision ID => Subdivision instance
       def all(parents)
         definitions = load_definitions(parents)
         return {} if definitions.empty?
@@ -57,9 +68,10 @@ module Addressing
           grandparents = parents.dup
           parent_id = grandparents.pop
           parent_group = build_group(grandparents.dup)
+          @definitions ||= {}
 
-          if @@definitions.dig(parent_group, "subdivisions", parent_id)
-            definition = @@definitions[parent_group]["subdivisions"][parent_id]
+          if @definitions.dig(parent_group, "subdivisions", parent_id)
+            definition = @definitions[parent_group]["subdivisions"][parent_id]
             return !!definition["has_children"]
           else
             # The parent definition wasn't loaded previously, fallback to guessing based on depth.
@@ -73,12 +85,13 @@ module Addressing
 
       # Loads the subdivision definitions for the provided parents.
       def load_definitions(parents)
+        @definitions ||= {}
         group = build_group(parents.dup)
-        if @@definitions.key?(group)
-          return @@definitions[group]
+        if @definitions.key?(group)
+          return @definitions[group]
         end
 
-        @@definitions[group] = {}
+        @definitions[group] = {}
 
         # If there are predefined subdivisions at this level, try to load them.
         if has_data(parents)
@@ -86,12 +99,12 @@ module Addressing
 
           if File.exist?(filename)
             raw_definition = File.read(filename)
-            @@definitions[group] = JSON.parse(raw_definition)
-            @@definitions[group] = process_definitions(@@definitions[group])
+            @definitions[group] = JSON.parse(raw_definition)
+            @definitions[group] = process_definitions(@definitions[group])
           end
         end
 
-        @@definitions[group]
+        @definitions[group]
       end
 
       # Processes the loaded definitions.
@@ -164,13 +177,14 @@ module Addressing
           grandparents = parents.dup
           parent_id = grandparents.pop
           parent_group = build_group(grandparents.dup)
+          @parents ||= {}
 
-          if !@@parents.dig(parent_group, parent_id)
-            @@parents[parent_group] ||= {}
-            @@parents[parent_group][parent_id] = get(parent_id, grandparents)
+          if !@parents.dig(parent_group, parent_id)
+            @parents[parent_group] ||= {}
+            @parents[parent_group][parent_id] = get(parent_id, grandparents)
           end
 
-          definition["parent"] = @@parents[parent_group][parent_id]
+          definition["parent"] = @parents[parent_group][parent_id]
         end
 
         # Prepare children.

data/lib/addressing/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Addressing
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/lib/addressing.rb

@@ -6,6 +6,7 @@ require "digest"
 require "json"
 
 # modules
+require "addressing/exceptions"
 require "addressing/enum"
 require "addressing/address"
 require "addressing/address_field"
@@ -23,14 +24,6 @@ require "addressing/postal_label_formatter"
 require "addressing/subdivision"
 require "addressing/version"
 
-module Addressing
-  class Error < StandardError; end
-
-  class UnknownCountryError < Error; end
-
-  class UnknownLocaleError < Error; end
-end
-
 if defined?(ActiveSupport.on_load)
   ActiveSupport.on_load(:active_record) do
     require "addressing/model"

metadata

@@ -1,16 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: addressing
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Robin van der Vleuten
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-21 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description:
 email: robinvdvleuten@gmail.com
 executables: []
 extensions: []
@@ -712,6 +710,7 @@ files:
 - lib/addressing/default_formatter.rb
 - lib/addressing/dependent_locality_type.rb
 - lib/addressing/enum.rb
+- lib/addressing/exceptions.rb
 - lib/addressing/field_override.rb
 - lib/addressing/lazy_subdivisions.rb
 - lib/addressing/locale.rb
@@ -727,7 +726,6 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/robinvdvleuten/addressing/issues
   changelog_uri: https://github.com/robinvdvleuten/addressing/blob/main/CHANGELOG.md
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -742,8 +740,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
-signing_key:
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Addressing library powered by CLDR and Google's address data
 test_files: []