unlocodes 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b94b2f3a3a7f5b4968db10f04c5dac3c3745c318025c81a09ed5f49e82f4727e
-  data.tar.gz: 61eeac2c2f2836b9abcd9fdce8b9142a217b0af48efe0abe4f5f374c9d2a931e
+  metadata.gz: 2a6607eb57e2219a161a11a3a5504d8b5ba3ba727b6a89c27d2a0de65b20dc36
+  data.tar.gz: 43fc8e683ac3af63d1f2a126313c6a9ec935ff6bacd03ecaa3fda39909bcef13
 SHA512:
-  metadata.gz: 0e2e189ebbdea9c82a990961b52b952f9b31826603a9ef99e2113f81cb868dc744e21b7ac1708d65acb63c51130c361a45183fa5354b3014d9563976c3f00522
-  data.tar.gz: 2924a2a74d14cb06dcdb5250e4adaa574812a52a16c0432cc11482519f0230e2473894f82ba879dada0f9bb69e6764d6cd85a936ce21258610938c1c10af889e
+  metadata.gz: 4e6da102b2aea85d965a601c2539400a4d978ac04723cbc989f8bd867628352ce26d03fa26b181a66ccd652d618f68e13ee5d668a3dac41971058fcacdca25d8
+  data.tar.gz: 9fa6a655a4c2ed962975e2311920264ba3657311163156843be590e639592fa480715493bfee7e7c9f59019d8ccee60c4c29f95cae65e8fec7828b17ef53f7be

data/README.adoc

@@ -1,34 +1,96 @@
-= unlocode
+= unlocodes
 :toc: macro
-:homepage: https://github.com/metanorma/unlocode
+:homepage: https://github.com/metanorma/unlocodes
 
-`unlocode` is a Ruby gem that exposes the UN/LOCODE dataset (United Nations Code for Trade and Transport Locations) as a queryable in-memory registry.
+`unlocodes` is a Ruby gem that exposes the UN/LOCODE dataset (United Nations Code for Trade and Transport Locations) as a queryable in-memory registry.
 
 The dataset is sourced from the UNECE/UNCEFACT LOCODE vocabulary, version-tagged `2025-1`: https://opensource.unicc.org/un/unece/uncefact/vocab-locode/-/tags/2025-1
 
-The full 2025-1 dataset (115,928 LOCODEs across 249 countries) is bundled inside the gem as `lib/unlocode/data/locode.jsonld` and loads lazily into a typed registry on first use.
+The full 2025-1 dataset (115,928 LOCODEs across 249 countries, ~39 MB) is bundled inside the gem as `lib/unlocodes/data/locode.jsonld` and loads lazily into a typed registry on first use.
 
 == Installation
 
+Ruby 3.1 or newer is required.
+
 Add to your Gemfile:
 
 [source,ruby]
 ----
-gem 'unlocode'
+gem 'unlocodes'
+----
+
+Or install directly:
+
+[source,sh]
+----
+gem install unlocodes
 ----
 
 == Usage
 
 [source,ruby]
 ----
-require 'unlocode'
+require 'unlocodes'
+
+# Lookup by 5-char LOCODE (case-insensitive)
+Unlocodes.find('CNSHA')                    # => #<Unlocodes::Entry code="CNSHA" name="Shanghai Hongqiao International Apt">
+Unlocodes['NLRTM'].name                    # => "Rotterdam" ([] is an alias for find)
+
+# Filters — single value or array (any-of)
+Unlocodes.where(country: 'CN').count       # => 1670
+Unlocodes.where(country: %w[CN HK]).count  # => entries in China OR Hong Kong
+Unlocodes.where(function: 'B').count       # => 17912 (sea ports)
+Unlocodes.where(function: 'A').count       # => 9009  (airports)
+Unlocodes.where(function: %w[B A]).count   # => 25136 (port OR airport)
+Unlocodes.where(subdivision: 'CNSH').count # => entries in the Shanghai subdivision
+
+# Filters combine
+Unlocodes.where(country: 'CN', function: 'A').count  # => CN airports
+
+# Name search — Regexp (substring) or String (case-insensitive equality)
+Unlocodes.where(name: /shanghai/i).map(&:code)
+Unlocodes.where(name: 'rotterdam').map(&:code)
+
+# Iteration
+Unlocodes.each { |e| puts e.code if e.port? }
+
+# Country listing
+Unlocodes.countries                        # => ["AD", "AE", ..., "ZW"] (249 codes)
+Unlocodes.counts_by_country.first(5)       # => [["US", 20852], ["FR", 14325], ...]
 
-Unlocode.find('CNSHA')                          # => #<Unlocode::Entry code="CNSHA" ...>
-Unlocode.find('NLRTM').functions.map(&:code)    # => ["B", "R", "T", "A", "P"]
-Unlocode.where(country: 'CN').count             # => 1670
-Unlocode.where(function: 'B').count             # => 17912  (sea ports)
-Unlocode.where(function: 'A').count             # => 9009   (airports)
-Unlocode.find('CNPDG').coordinates              # => #<Coordinates lat=31.2333 lon=121.5000>
+# Indexed lookups (faster than `where` for a single value)
+Unlocodes.registry.by_country('CN').size   # => 1670
+Unlocodes.registry.by_function('B').size   # => 17912
+----
+
+=== What's in an Entry
+
+Each `Unlocodes::Entry` exposes the fields the JSON-LD vocabulary populates:
+
+[cols="1,2", options="header"]
+|===
+|Attribute|Description
+|`code`|5-char LOCODE (ISO country + 3-char location)
+|`country`|ISO 3166-1 alpha-2 country code
+|`subdivision`|ISO 3166-2 country subdivision code (e.g. `CNSH`)
+|`name`|Display name
+|`function_codes`|Array of single-letter function codes (see below)
+|`latitude`, `longitude`|WGS-84 decimal degrees
+|===
+
+Convenience predicates and value-type accessors:
+
+[source,ruby]
+----
+entry = Unlocodes.find('NLRTM')
+
+entry.port?             # => true  (function code B)
+entry.airport?          # => true  (function code A)
+entry.rail_terminal?    # => true  (function code R)
+entry.road_terminal?    # => true  (function code T)
+entry.functions.map(&:code)        # => ["B", "R", "T", "A", "P"]
+entry.functions.first.description  # => "Port (sea)"
+entry.coordinates       # => #<Unlocodes::Coordinates ...>
 ----
 
 === Function codes
@@ -49,40 +111,89 @@ The vocabulary publishes functions as `unlcdf:1`..`unlcdf:9`. The gem maps them
 |9|O|Other / border crossing
 |===
 
-Use the letters in `where(function: ...)`:
+Use the letters in `where(function: ...)`. Passing an array matches any-of (OR), not all-of (AND):
 
 [source,ruby]
 ----
-Unlocode.where(function: 'B').count             # sea ports
-Unlocode.where(function: %w[B A]).count         # entries that are both port and airport
+Unlocodes.where(function: 'B').count             # sea ports
+Unlocodes.where(function: %w[B A]).count         # port OR airport (union)
+# For AND (entries that are BOTH port AND airport), filter in Ruby:
+Unlocodes.entries.count { |e| e.port? && e.airport? }  # => 1785
 ----
 
-=== Distances
+=== Coordinates and distances
 
 [source,ruby]
 ----
-shanghai = Unlocode.find('CNPDG').coordinates
-rotterdam = Unlocode.find('NLRTM').coordinates
-shanghai.distance_to(rotterdam)                 # => 8922.0 (km, great-circle)
+shanghai = Unlocodes.find('CNPDG').coordinates   # Shanghai Pudong
+rotterdam = Unlocodes.find('NLRTM').coordinates
+
+shanghai.to_s              # => "31.2333 121.5000"
+shanghai.distance_to(rotterdam)  # => 8922.7 (km, great-circle via haversine)
 ----
 
-== Data refresh
+=== Fields NOT in the bundled vocabulary
 
-To refresh the bundled dataset when a new UNCEFACT edition is released:
+The JSON-LD vocabulary only publishes `code`, `country`, `subdivision`, `name`, `functions`, and coordinates. The UN/LOCODE manual additionally defines a `status` change indicator (AA, RL, XX, …), IATA code, change date, and remarks — these are in the per-country CSV files upstream, not the JSON-LD vocab, and are intentionally not modelled here.
+
+Calling `where(status: ...)` or `where(iata: ...)` raises `ArgumentError` rather than silently returning empty results.
+
+=== Which edition is bundled?
+
+[source,ruby]
+----
+Unlocodes.data_tag  # => "2025-1"
+----
+
+This reads `lib/unlocodes/data/SOURCE_TAG` at runtime. The `Unlocodes::Status` value type is still shipped for callers who want to consult the manual's status-code descriptions out-of-band.
+
+== Staying current with upstream
+
+UN/LOCODE is published twice-yearly (typically `YYYY-1` around Q1, `YYYY-2` around Q3). The gem ships two workflows to keep the bundled data fresh:
+
+=== `check-upstream` (scheduled, weekly)
+
+`.github/workflows/check-upstream.yml` runs every Monday, asks the upstream GitLab project for its latest tag, and compares against the bundled `SOURCE_TAG`. When a new edition is detected it opens a GitHub issue labelled `data-update` describing the diff and the next steps. The workflow also runs on manual dispatch.
+
+=== `update-data` (manual dispatch)
+
+`.github/workflows/update-data.yml` is what a maintainer runs after `check-upstream` flags a new edition. It takes the new tag as input, fetches the data, commits to a branch, and opens a PR. Merging that PR does not, by itself, publish a new gem — it just lands the new data on `main`. To ship a new gem version, trigger the `release` workflow (see below).
+
+End-to-end refresh flow:
+
+. `check-upstream` opens issue: "new tag `2025-2` available, bundled is `2025-1`"
+. Maintainer runs `update-data` workflow with `tag=2025-2`
+. Workflow opens PR `chore/data-2025-2` with the refreshed `locode.jsonld` and `SOURCE_TAG`
+. Maintainer reviews and merges the PR
+. Maintainer triggers the `release` workflow with `next_version=patch` to publish a new gem version
+
+Manual local equivalent of the workflow:
 
 [source,sh]
 ----
-bundle exec rake unlocode:fetch          # default tag: 2025-1
-UNLOCODE_TAG=2025-2 rake unlocode:fetch
+bundle exec rake unlocodes:fetch         # default tag: 2025-1
+UNLOCODE_TAG=2025-2 bundle exec rake unlocodes:fetch
 ----
 
 If the upstream tag layout changes, point `UNLOCODE_PATH` at the full JSON-LD URL:
 
 [source,sh]
 ----
-UNLOCODE_PATH=https://example.org/path/unlocode.jsonld rake unlocode:fetch
+UNLOCODE_PATH=https://example.org/path/unlocode.jsonld bundle exec rake unlocodes:fetch
 ----
 
+== Development
+
+[source,sh]
+----
+bundle install                       # install dev deps
+bundle exec rake                     # spec + rubocop
+bundle exec rspec spec/path/to_spec.rb:42   # one example
+bundle exec rake unlocodes:fetch     # refresh bundled data
+----
+
+The 39 MB dataset at `lib/unlocodes/data/locode.jsonld` is committed so the gem works offline. The first call to `Unlocodes.registry` in a process pays the parse cost (~3-5 s); subsequent calls are cached.
+
 == License
 
 BSD-2-Clause. See link:LICENSE[].

data/lib/{unlocode → unlocodes}/coordinates.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Unlocode
+module Unlocodes
   # Geographic coordinates (WGS-84) for a LOCODE entry.
   #
   # Parsed from the LOCODE coordinate string ("DDMM[H]DDDMM[H]" where H is one

data/lib/unlocodes/data/SOURCE_TAG

@@ -0,0 +1 @@
+2025-1

data/lib/{unlocode → unlocodes}/data/fetcher.rb

@@ -4,21 +4,26 @@ require 'net/http'
 require 'uri'
 require 'fileutils'
 
-module Unlocode
+module Unlocodes
   module Data
     # Downloads the UNCEFACT UN/LOCODE vocabulary from the upstream GitLab
-    # repository and stores it as `lib/unlocode/data/locode.jsonld`.
+    # repository and stores it as `lib/unlocodes/data/locode.jsonld`.
     #
     # The upstream tag (e.g. "2025-1") points at a snapshot of the
     # `vocab-locode` project whose `vocab/unlocode.jsonld` is the canonical
     # full dataset. Override the source URL with the `UNLOCODE_PATH` env
     # variable if a different edition's path layout applies.
+    #
+    # After a successful fetch, the tag is written to `SOURCE_TAG` next to
+    # the data file so the gem (and the check-upstream workflow) always
+    # knows which edition is bundled.
     module Fetcher
       UPSTREAM_HOST = 'opensource.unicc.org'
       UPSTREAM_TAG_PATH = '/un/unece/uncefact/vocab-locode/-/raw/%<tag>s'
-      OUTPUT_PATH = File.expand_path('locode.jsonld', __dir__)
+      DATA_DIR = File.expand_path(__dir__)
+      OUTPUT_PATH = File.join(DATA_DIR, 'locode.jsonld')
+      SOURCE_TAG_PATH = File.join(DATA_DIR, 'SOURCE_TAG')
 
-      DEFAULT_FILENAME = 'vocab/unlocode.jsonld'
       CANDIDATE_PATHS = [
         'vocab/unlocode.jsonld',
         'vocab/unlocode-vocab.jsonld',
@@ -32,7 +37,7 @@ module Unlocode
         def call(tag:)
           uri = resolve_uri(tag)
           data = download(uri)
-          write(data)
+          write(data, tag: tag)
           warn "Fetched UN/LOCODE #{tag} (#{data.bytesize} bytes) -> #{OUTPUT_PATH}"
           OUTPUT_PATH
         end
@@ -67,9 +72,10 @@ module Unlocode
           end
         end
 
-        def write(data)
-          FileUtils.mkdir_p(File.dirname(OUTPUT_PATH))
+        def write(data, tag:)
+          FileUtils.mkdir_p(DATA_DIR)
           File.write(OUTPUT_PATH, data)
+          File.write(SOURCE_TAG_PATH, "#{tag}\n")
         end
       end
     end

data/lib/{unlocode → unlocodes}/data.rb

@@ -3,8 +3,8 @@
 # Bundled UN/LOCODE dataset.
 #
 # `locode.jsonld` is populated by `rake unlocode:fetch` and is the source
-# loaded by `Unlocode::Registry.load_default`.
-module Unlocode
+# loaded by `Unlocodes::Registry.load_default`.
+module Unlocodes
   module Data
     autoload :Fetcher, "#{__dir__}/data/fetcher"
   end

data/lib/{unlocode → unlocodes}/entry.rb

@@ -5,7 +5,7 @@ require_relative 'status'
 require_relative 'function'
 require_relative 'coordinates'
 
-module Unlocode
+module Unlocodes
   # A single UN/LOCODE entry.
   #
   # Stores wire-level fields as `lutaml-model` attributes and exposes typed

data/lib/{unlocode → unlocodes}/function.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Unlocode
+module Unlocodes
   # UN/LOCODE function classifier.
   #
   # Single-letter codes identifying the transport function a LOCODE serves.

data/lib/{unlocode → unlocodes}/loader.rb

@@ -3,7 +3,7 @@
 require 'json'
 require_relative 'entry'
 
-module Unlocode
+module Unlocodes
   # Parses a UN/LOCODE JSON-LD vocabulary file into {Entry} instances.
   #
   # The UNCEFACT vocabulary (`vocab/unlocode.jsonld`) is a single JSON-LD
@@ -39,21 +39,21 @@ module Unlocode
     class << self
       # Load entries from a file path on disk.
       # @param path [String] absolute or relative path to a JSON-LD file
-      # @return [Array<Unlocode::Entry>]
+      # @return [Array<Unlocodes::Entry>]
       def load_file(path)
         load_json(File.read(path))
       end
 
       # Load entries from a JSON-LD string.
       # @param json [String] a JSON-LD document
-      # @return [Array<Unlocode::Entry>]
+      # @return [Array<Unlocodes::Entry>]
       def load_json(json)
         parse(JSON.parse(json, symbolize_names: false))
       end
 
       # Load entries from a pre-parsed JSON-LD hash.
       # @param data [Hash] parsed JSON-LD
-      # @return [Array<Unlocode::Entry>]
+      # @return [Array<Unlocodes::Entry>]
       def parse(data)
         extract_graph(data).filter_map { |node| build_entry(node) if unlocode_node?(node) }
       end

data/lib/{unlocode → unlocodes}/registry.rb

@@ -3,7 +3,7 @@
 require 'forwardable'
 require_relative 'loader'
 
-module Unlocode
+module Unlocodes
   # In-memory, lazily-indexed registry over a set of {Entry} instances.
   #
   # The default registry is loaded from the vendored dataset bundled with the
@@ -18,13 +18,13 @@ module Unlocode
     def_delegators :@entries, :size, :count, :to_a, :empty?
 
     # Map of `#where` filter keys to the Entry attribute they read.
+    # Limited to attributes the JSON-LD vocabulary actually populates —
+    # status / iata / name_without_diacritics are NOT in the vocab, so
+    # they're intentionally absent here.
     SCALAR_FILTERS = {
       code: :code,
       country: :country,
-      status: :status_code,
-      status_code: :status_code,
-      subdivision: :subdivision,
-      iata: :iata
+      subdivision: :subdivision
     }.freeze
 
     def initialize(entries = [])
@@ -50,7 +50,7 @@ module Unlocode
       end
 
       # Build a registry from an existing list of entries.
-      # @param entries [Array<Unlocode::Entry>]
+      # @param entries [Array<Unlocodes::Entry>]
       # @return [Registry]
       def from_entries(entries)
         new(entries)
@@ -65,7 +65,7 @@ module Unlocode
 
     # Exact-code lookup.
     # @param code [String] 5-char LOCODE (case-insensitive)
-    # @return [Unlocode::Entry, nil]
+    # @return [Unlocodes::Entry, nil]
     def find(code)
       return nil if code.nil?
 
@@ -83,7 +83,7 @@ module Unlocode
     #   registry.where(country: %w[CN HK], function: 'B')
     #   registry.where(name: /shanghai/i)
     #
-    # @return [Array<Unlocode::Entry>]
+    # @return [Array<Unlocodes::Entry>]
     def where(filters)
       filters.reduce(entries) { |scope, (key, value)| apply_filter(scope, key, value) }
     end
@@ -108,10 +108,6 @@ module Unlocode
       by_function_index[letter.to_s.upcase] || []
     end
 
-    def by_status(code)
-      by_status_index[code.to_s.upcase] || []
-    end
-
     private
 
     def by_code
@@ -132,12 +128,6 @@ module Unlocode
       end
     end
 
-    def by_status_index
-      @by_status_index ||= entries.each_with_object({}) do |e, h|
-        (h[e.status_code.to_s.upcase] ||= []) << e if e.status_code
-      end
-    end
-
     def apply_filter(scope, key, value)
       if SCALAR_FILTERS.key?(key)
         filter_scalar(scope, SCALAR_FILTERS.fetch(key), value)

data/lib/{unlocode → unlocodes}/status.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module Unlocode
+module Unlocodes
   # UN/LOCODE status (change indicator).
   #
   # Two-letter codes documenting how a LOCODE entry was last amended relative

data/lib/unlocodes/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Unlocodes
+  VERSION = '0.1.4'
+end

data/lib/unlocodes.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'lutaml/model'
+require 'json'
+
+require_relative 'unlocodes/version'
+
+# Vendored UN/LOCODE dataset as a queryable Ruby registry.
+#
+# The dataset is sourced from the UNECE/UNCEFACT LOCODE vocabulary published at
+# https://opensource.unicc.org/un/unece/uncefact/vocab-locode and distributed
+# by this gem as a bundled, offline JSON-LD representation. The registry loads
+# once per process and exposes a typed query API over `Unlocodes::Entry`
+# instances.
+#
+# Which edition is bundled? See {Unlocodes.data_tag} (read from
+# `lib/unlocodes/data/SOURCE_TAG`).
+module Unlocodes
+  extend SingleForwardable
+
+  SOURCE_TAG_PATH = File.expand_path('unlocodes/data/SOURCE_TAG', __dir__)
+
+  class << self
+    # @return [Unlocodes::Registry] the process-wide registry, loaded lazily
+    def registry
+      @registry ||= Registry.load_default
+    end
+
+    # Reset the process-wide registry. Used by specs to swap fixtures.
+    def reset_registry!
+      @registry = nil
+    end
+
+    # The upstream UNCEFACT vocabulary tag bundled with this gem version
+    # (e.g. "2025-1"). Read from `lib/unlocodes/data/SOURCE_TAG` at runtime.
+    # @return [String, nil]
+    def data_tag
+      return @data_tag if defined?(@data_tag)
+
+      @data_tag = File.read(SOURCE_TAG_PATH, encoding: 'UTF-8').strip
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+
+  def_delegators :registry, :find, :where, :each, :size, :count, :countries
+
+  autoload :Status, 'unlocodes/status'
+  autoload :Function, 'unlocodes/function'
+  autoload :Coordinates, 'unlocodes/coordinates'
+  autoload :Entry, 'unlocodes/entry'
+  autoload :Loader, 'unlocodes/loader'
+  autoload :Registry, 'unlocodes/registry'
+  autoload :Data, 'unlocodes/data'
+end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unlocodes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Ribose Inc.
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-07-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json
@@ -50,26 +51,28 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.adoc
-- lib/unlocode.rb
-- lib/unlocode/coordinates.rb
-- lib/unlocode/data.rb
-- lib/unlocode/data/README.adoc
-- lib/unlocode/data/fetcher.rb
-- lib/unlocode/data/locode.jsonld
-- lib/unlocode/entry.rb
-- lib/unlocode/function.rb
-- lib/unlocode/loader.rb
-- lib/unlocode/registry.rb
-- lib/unlocode/status.rb
-- lib/unlocode/version.rb
-homepage: https://github.com/metanorma/unlocode
+- lib/unlocodes.rb
+- lib/unlocodes/coordinates.rb
+- lib/unlocodes/data.rb
+- lib/unlocodes/data/README.adoc
+- lib/unlocodes/data/SOURCE_TAG
+- lib/unlocodes/data/fetcher.rb
+- lib/unlocodes/data/locode.jsonld
+- lib/unlocodes/entry.rb
+- lib/unlocodes/function.rb
+- lib/unlocodes/loader.rb
+- lib/unlocodes/registry.rb
+- lib/unlocodes/status.rb
+- lib/unlocodes/version.rb
+homepage: https://github.com/metanorma/unlocodes
 licenses:
 - BSD-2-Clause
 metadata:
-  homepage_uri: https://github.com/metanorma/unlocode
-  source_code_uri: https://github.com/metanorma/unlocode
-  bug_tracker_uri: https://github.com/metanorma/unlocode/issues
+  homepage_uri: https://github.com/metanorma/unlocodes
+  source_code_uri: https://github.com/metanorma/unlocodes
+  bug_tracker_uri: https://github.com/metanorma/unlocodes/issues
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -84,7 +87,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: UN/LOCODE dataset as a queryable Ruby registry
 test_files: []

data/lib/unlocode/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Unlocode
-  VERSION = '0.1.0'
-end

data/lib/unlocode.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-require 'lutaml/model'
-require 'json'
-
-require_relative 'unlocode/version'
-
-# Vendored UN/LOCODE dataset as a queryable Ruby registry.
-#
-# The dataset is sourced from the UNECE/UNCEFACT LOCODE vocabulary published at
-# https://service.unece.org/trade/locode/ and distributed by this gem as a
-# bundled, offline JSON-LD representation. The registry loads once per process
-# and exposes a typed query API over `Unlocode::Entry` instances.
-module Unlocode
-  extend SingleForwardable
-
-  class << self
-    # @return [Unlocode::Registry] the process-wide registry, loaded lazily
-    def registry
-      @registry ||= Registry.load_default
-    end
-
-    # Reset the process-wide registry. Used by specs to swap fixtures.
-    def reset_registry!
-      @registry = nil
-    end
-  end
-
-  def_delegators :registry, :find, :where, :each, :size, :count, :countries
-
-  autoload :Status, 'unlocode/status'
-  autoload :Function, 'unlocode/function'
-  autoload :Coordinates, 'unlocode/coordinates'
-  autoload :Entry, 'unlocode/entry'
-  autoload :Loader, 'unlocode/loader'
-  autoload :Registry, 'unlocode/registry'
-  autoload :Data, 'unlocode/data'
-end