relaton 3.0.0.pre.alpha.17 → 3.0.0.pre.alpha.19

data/lib/relaton/ogc/CLAUDE.md

@@ -0,0 +1,242 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+relaton-ogc is a Ruby gem for retrieving and managing OGC (Open Geospatial Consortium) Standards metadata. It is part of the Relaton ecosystem for bibliographic data management. The gem implements the OGC flavor on top of `relaton-iso`, which itself builds on `relaton-bib`.
+
+## Commands
+
+```bash
+# Install dependencies
+bundle install
+
+# Run all tests
+bundle exec rspec
+
+# Run a single test file
+bundle exec rspec spec/relaton/ogc/item_spec.rb
+
+# Run a single test by line number
+bundle exec rspec spec/relaton/ogc/item_spec.rb:7
+
+# Lint
+bundle exec rubocop
+
+# Lint with auto-correct
+bundle exec rubocop -A
+
+# Interactive console
+bin/console
+
+# Build and install gem locally
+bundle exec rake install
+```
+
+## Architecture
+
+### Class Hierarchy
+
+All model classes use `Lutaml::Model::Serializable` for XML/YAML serialization with declarative attribute and mapping definitions.
+
+```
+Iso::Item (from relaton-iso)
+└── Relaton::Ogc::Item          # serializer, extends Iso::Item with `ext` and `docidentifier`
+    ├── Relaton::Ogc::Bibitem   # includes Bib::BibitemShared
+    └── Relaton::Ogc::Bibdata   # includes Bib::BibdataShared
+
+Bib::ItemData (from relaton-bib)
+└── Relaton::Ogc::ItemData      # data model returned by Item.from_xml / Item.from_yaml
+```
+
+- **Item** (`lib/relaton/ogc/item.rb`) — serializer; extends `Iso::Item`, declares `model ItemData`, adds `ext` (Ext) and `docidentifier` (Docidentifier) attributes
+- **ItemData** (`lib/relaton/ogc/item_data.rb`) — plain data model extending `Bib::ItemData`
+- **Ext** (`lib/relaton/ogc/ext.rb`) — OGC extension data: doctype, subdoctype (with constrained values)
+- **Doctype** (`lib/relaton/ogc/doctype.rb`) — enumerated OGC document types (standard, engineering-report, best-practice, etc.)
+- **Docidentifier** (`lib/relaton/ogc/docidentifier.rb`) — parses its `content`
+  into a `Pubid::Ogc::Identifier` exposed as `#pubid`; see **Pubid-backed
+  docidentifier**
+- **Bibitem** / **Bibdata** — thin wrappers mixing in shared serialization behavior from `relaton-bib`
+
+### Search & Fetch Pipeline
+
+- **Bibliography** (`lib/relaton/ogc/bibliography.rb`) — entry point: `search(text)` and `get(code, year, opts)`
+- **HitCollection** (`lib/relaton/ogc/hit_collection.rb`) — fetches from the `relaton-data-ogc` repo (`v2` branch) and resolves the reference against the index; see **Index (`index-v2`, pubid-keyed)**
+- **Hit** (`lib/relaton/ogc/hit.rb`) — wraps a single search result; lazy-fetches `ItemData` on `#item`
+- **Processor** (`lib/relaton/ogc/processor.rb`) — `Core::Processor` implementation for Relaton registry integration
+
+### Pubid-backed docidentifier
+
+`Relaton::Ogc::Docidentifier` parses its `content` into a
+`Pubid::Ogc::Identifier` kept in `@pubid`, while the lutaml `content` attribute
+stays a plain **string** for serialization. Parsing is **soft**: `content=`
+lazily requires pubid and rescues `LoadError`/`StandardError`, so a missing gem
+or non-OGC content leaves `@pubid` nil rather than raising.
+
+It was an empty subclass before, which meant it inherited
+`Bib::Docidentifier`'s `remove_part!` / `remove_date!` / `to_all_parts!` — each
+of which raises `NotImplementedError`. `Bib::ItemData` broadcasts all three to
+every docidentifier (`item_data.rb:74`, `:87`), so `#to_all_parts` and
+`#to_most_recent_reference` **raised on every OGC item**, and because
+`NotImplementedError` descends from `ScriptError` a caller's `rescue => e` did
+not catch it. The mapping is OGC-specific:
+
+- **`remove_date!` → clears `revision`.** OGC carries no date component;
+  `revision` is its version discriminator — the same component a reference may
+  omit, which `HitCollection#best_match` then treats as a wildcard — so clearing
+  it yields the version-agnostic ("most recent") reference: `12-128r19` →
+  `12-128`.
+- **`year` is never cleared.** It looks date-like but is half the document
+  number (`12-128`), not a publication qualifier; dropping it would leave
+  `-128`, which identifies nothing.
+- **`remove_part!` → clears the (unused) `part`/`subpart`.** A no-op for the
+  rendered string today — OGC models no part — but implemented so it never
+  raises, and it starts working if pubid-ogc ever adds one. (The IALA
+  precedent.)
+- **`to_all_parts!` → both, then wraps `@pubid` in pubid's `AllParts`.**
+  `content` stays the plain stripped id — OGC's own renderer has no
+  "(all parts)" marker, and `content` is cached from the pre-wrap pubid on
+  purpose. `#pubid` itself, read directly, now answers `all_parts? == true`
+  and renders WITH pubid's generic marker (`#to_s`), since it's the wrapper.
+
+`refresh_content!` renders a bare `to_s`. The OGC printed form carries no
+publisher token and the stored `content` does not either, so — unlike 3GPP,
+whose `refresh_content!` must pass `with_publisher: true` — this one must not.
+
+### Index (`index-v2`, pubid-keyed)
+
+`INDEXFILE` is the pubid-backed `index-v2`: rows are `Pubid::Ogc::Identifier`
+hashes (`_type: pubid:ogc:document` with `year`/`number`/`revision`). The
+consumer (`HitCollection#index`) and the producer (`DataFetcher#index`) pass
+`pubid_class: ::Pubid::Ogc::Identifier`. That is what makes `Relaton::Index`
+deserialize the rows into identifiers, sort them by `id.root.number`, and let
+`Type#search` bsearch. Omitting it on the **producer** side writes v1-shaped
+rows under a v2 name, silently (`FileIO#save` only calls `to_hash` when the
+value is an instance of `pubid_class`); omitting it on the **consumer** side
+leaves the rows raw hashes with `FileIO#sorted` false, so every lookup scans
+all ~1,258 rows. `Processor#remove_index_file` passes `url: true` and `file:`
+only: the delete never reads the index (see `lib/relaton/index/CLAUDE.md`).
+
+`HitCollection#best_match` follows the ETSI/W3C/IALA idiom:
+
+- **Pass the pubid, not the string.** `Type#search_candidates` narrows only
+  when the argument is not a `String`, so passing the reference text — which
+  this flavor used to do — disables the binary search however the index was
+  built. `pubid_class:` alone fixes nothing; both had to change together.
+- **Selection is pubid's asymmetric subset match** (`Pubid::SubsetMatch`):
+  `pubid === r[:id]`, the reference on the left. A component the reference omits
+  matches any value, so a bare `OGC 12-128` finds the `r19` row, while
+  `OGC 12-128r19` reaches only its own. `revision` is OGC's only optional
+  component. Measured over the whole fixture index (1,258 rows, 19,590
+  comparisons): the subset match and the old `matches?(…, ignore: [:revision])`
+  agree on every pair.
+- **`year` is always stated.** The bsearch key is the `<nnn>` field alone, so
+  one bucket holds every year that reused the number — `05-015`, `08-015r2`,
+  `26-015r1` all sit in bucket `015` (179 buckets, largest 20). `year` is what
+  tells them apart.
+- **An unparseable reference raises**, and the previous full-scan substring
+  match on `id.to_s` is gone with the rescue: it answered an ambiguous
+  reference with whichever row sorted first.
+
+#### Ordering: latest revision wins
+
+`min_by { |r| r[:id] }` compared raw strings, so a bare `12-128` returned
+`r10` — `"r10" < "r14"` as text. The key is now the revision, with its number
+compared **as an integer** (`r19` beats `r2`) and the token itself breaking the
+tie (`r3a` above `r3`, `r12a` above `r12`), because the index sort is not
+stable.
+
+Scored against each document's own `date[0].at` over the 106 multi-revision
+documents in the published index:
+
+| Key | Picks the newest published document |
+|---|---|
+| revision number, numeric | 105/106 — **99%** |
+| the old `min_by { r[:id] }` | 1/106 — **1%** |
+
+Only 106 of 1,110 documents carry more than one revision, so the change is
+narrow — but for those it was returning the oldest revision almost every time.
+
+#### Two ids that do not round-trip
+
+Measured over all 1,258 published rows, 1,256 render back byte-identically. The
+two that do not are **data defects upstream**, which pubid canonicalizes:
+`"20-001r2 "` (trailing space) and `"11-038R2"` (uppercase revision). Migrating
+fixes both — the v2 rows store the canonical form — so a lookup of either
+spelling now resolves. Do not "fix" them by special-casing the parser.
+
+#### Verified against the published index
+
+`relaton-data-ogc` publishes `index-v2.zip`. Loaded through
+`HitCollection#index`: 1,258 rows, all deserialized to identifiers, sorted, **0**
+keying on `""`, and a `12-128` lookup narrows to **11 of 1,258**. Live fetches
+resolve every shape the flavor has to handle — a bare `OGC 12-128` → `r19`
+(2024-02-06), an explicit `12-128r14` → 2017, the letter-suffixed `12-128r12a`,
+the two upstream data defects (`11-038R2`, `20-001r2`), the revision-less
+`16-079`, both sides of the shared `015` bucket (`05-015` and `26-015r1`), and a
+reference with no `OGC ` token.
+
+The published rows are byte-for-byte what this gem's `DataFetcher` writes: when
+the fixture was still being converted from `index-v1` locally, the converted set
+and the published one held the same 1,258 rows.
+
+### Data Fetching
+
+- **DataFetcher** (`lib/relaton/ogc/data_fetcher.rb`) — bulk-fetches OGC documents from the NamingAuthority JSON endpoint
+- **Scraper** (`lib/relaton/ogc/scraper.rb`) — parses individual OGC document JSON into `ItemData`
+
+### Key Dependencies
+
+- `relaton-iso` — provides `Iso::Item` base class and ISO bibliographic structures
+- `relaton-bib` (transitive via relaton-iso) — core types: `Bib::ItemData`, `Bib::Doctype`, `Bib::Ext`, etc.
+- `lutaml-model` (transitive) — serialization framework for XML/YAML mapping
+- `faraday` — HTTP client for fetching remote data
+- `relaton-index` — index-based document lookup from GitHub-hosted data repos
+
+### Serialization Pattern
+
+Models declare attributes and XML mappings in the same class. `Item` is the serializer (handles `from_xml`, `from_yaml`, `to_xml`), `ItemData` is the plain data object returned. Round-trip fidelity (parse → serialize → parse) is the primary correctness criterion tested in specs.
+
+### Test Setup
+
+- **RSpec** with `--format documentation`
+- **VCR** + **WebMock** for HTTP interaction recording (`spec/vcr_cassettes/`)
+- **Jing** for RelaxNG schema validation against `grammars/relaton-ogc-compile.rng`
+- **equivalent-xml** for XML comparison in tests
+- Fixtures live in `spec/fixtures/` (YAML, XML)
+- Integration tests in `spec/relaton/ogc/integration_spec.rb` exercise the full search → fetch → serialize pipeline
+
+### Grammars
+
+RelaxNG schemas in `grammars/` define the valid XML structure. `relaton-ogc-compile.rng` is the combined schema used for test validation.
+
+### API Notes
+
+- `Bib::Docidentifier` uses `.content` (not `.id`) for the identifier string
+- `Bib::Date` uses `.at` returning a `StringDate::Value`; parse with `::Date.parse(d.at.to_s)` to extract year
+
+## Linting
+
+RuboCop inherits from the [Ribose OSS style guide](https://github.com/riboseinc/oss-guides). Target Ruby version is 3.1. Rails cops are loaded but disabled.
+
+## CI
+
+GitHub Actions workflows in `.github/workflows/` are auto-generated by Cimas — avoid manual edits. `rake.yml` runs tests on push/PR; `release.yml` handles gem publishing.
+
+## Testing
+
+- Run the suite with `bundle exec rake spec:ogc` from the repo root; specs live
+  in `spec/ogc/` and run self-contained (see the root `CLAUDE.md`).
+- **Index fixture:** `spec/ogc/fixtures/index-v2.zip` is seeded into the
+  `Relaton::Index` pool by `spec/ogc/support/webmock.rb` — in `before(:each)`,
+  not only `before(:suite)`, because `Index::Pool#type` replaces the pooled
+  entry whenever `actual?` says no and `DataFetcher#index` asks for the same
+  type without a `url:`. The pool key is `type.upcase.to_sym`, so the flavor's
+  `:ogc` is pooled as `:OGC`. It is built **with `pubid_class:`**; without it
+  the suite would pass while exercising something the runtime never does.
+- Refresh it with `bundle exec rake spec:update_index_ogc`. Unlike 3GPP's, this
+  fixture is the whole published index (~1,258 rows) rather than a curated
+  subset — small enough that keeping all of it costs nothing. Rows are copied
+  **verbatim** from the published `index-v2.zip`; `#build` refuses a v1 source
+  rather than writing a fixture `Relaton::Index` would reject wholesale.

data/lib/relaton/ogc/README.adoc

@@ -0,0 +1,134 @@
+= Relaton::Ogc
+
+Relaton::Ogc is a Ruby gem that implements the https://github.com/metanorma/metanorma-model-iso#iso-bibliographic-item[IsoBibliographicItem model].
+
+You can use it to retrieve metadata of OGC Standards from the https://github.com/relaton/relaton-data-ogc[relaton-data-ogc] dataset, and access such metadata through the `Relaton::Ogc::ItemData` object.
+
+== Usage
+
+=== Search for a standard using keywords
+
+[source,ruby]
+----
+require 'relaton/ogc'
+=> true
+
+hits = Relaton::Ogc::Bibliography.search("OGC 19-025r1")
+=> <Relaton::Ogc::HitCollection:0x00000000001230 @ref=19-025r1 @fetched=false>
+
+item = hits[0].item
+=> #<Relaton::Ogc::ItemData:0x0000000127b1d870
+...
+----
+
+=== XML serialization
+[source,ruby]
+----
+item.to_xml
+=> "<bibitem id="19025r1" type="standard" schema-version="v1.4.1">
+      <fetched>2026-02-27</fetched>
+      <title language="en" script="Latn" type="title-main">Development of Spatial Data Infrastructures for Marine Data Management</title>
+      <title language="en" script="Latn" type="main">Development of Spatial Data Infrastructures for Marine Data Management</title>
+      <uri type="src">http://www.opengis.net/doc/per/marine-sdi</uri>
+      <uri type="pdf">https://portal.ogc.org/files/?artifact_id=88037</uri>
+      <docidentifier type="OGC" primary="true">19-025r1</docidentifier>
+      ...
+    </bibitem>"
+----
+With argument `bibdata: true` it outputs XML wrapped by `bibdata` element and adds flavor `ext` element.
+[source,ruby]
+----
+item.to_xml bibdata: true
+=> "<bibdata type="standard" schema-version="v1.4.1">
+      <fetched>2026-02-27</fetched>
+      <title language="en" script="Latn" type="title-main">Development of Spatial Data Infrastructures for Marine Data Management</title>
+      <title language="en" script="Latn" type="main">Development of Spatial Data Infrastructures for Marine Data Management</title>
+      <uri type="src">http://www.opengis.net/doc/per/marine-sdi</uri>
+      <uri type="pdf">https://portal.ogc.org/files/?artifact_id=88037</uri>
+      <docidentifier type="OGC" primary="true">19-025r1</docidentifier>
+      ...
+      <ext schema-version="v1.0.1">
+        <doctype>engineering-report</doctype>
+        <flavor>ogc</flavor>
+      </ext>
+    </bibdata>"
+----
+
+=== Get code, and year
+[source,ruby]
+----
+Relaton::Ogc::Bibliography.get "OGC 19-025r1", "2019"
+[relaton-ogc] INFO: (OGC 19-025r1) Fetching from Relaton repository ...
+[relaton-ogc] INFO: (OGC 19-025r1) Found: `19-025r1`
+=> #<Relaton::Ogc::ItemData:0x00000001283d6f48
+...
+----
+
+=== Create bibliographic item from XML
+[source,ruby]
+----
+Relaton::Ogc::Item.from_xml File.read('spec/fixtures/12_128r14.xml')
+=> #<Relaton::Ogc::ItemData:0x000000012835e610
+...
+----
+
+=== Typed links
+
+Each OGC document has `scr` type source link.
+
+[source,ruby]
+----
+item.source[0].type
+=> "obp"
+
+item.source[0].content
+=> "http://www.opengis.net/doc/per/marine-sdi"
+----
+
+=== Create bibliographic item from YAML
+[source,ruby]
+----
+Relaton::Ogc::Item.from_yaml File.read('spec/fixtures/item.yaml')
+=> #<Relaton::Ogc::ItemData:0x0000000124b19d90
+...
+----
+
+=== Fetch data
+
+This gem uses the https://raw.githubusercontent.com/opengeospatial/NamingAuthority/master/definitions/docs/docs.json[OGC NamingAuthority] dataset as a data source.
+
+The method `Relaton::Ogc::DataFetcher.fetch(output: "data", format: "yaml")` fetches all the documents from the dataset and saves them to the `./data` folder in YAML format.
+Arguments:
+
+- `output` - folder to save documents (default './data').
+- `format` - the format in which the documents are saved. Possible formats are: `yaml`, `xml`, `bibxml` (default `yaml`).
+
+[source,ruby]
+----
+require "relaton/ogc/data_fetcher"
+
+Relaton::Ogc::DataFetcher.fetch
+Started at: 2026-02-27 11:21:46 +0200
+Stopped at: 2026-02-27 11:21:48 +0200
+=> nil
+----
+
+=== Logging
+
+Relaton::Ogc uses the relaton-logger gem for logging. By default, it logs to STDOUT. To change the log levels and add other loggers, read the https://github.com/relaton/relaton-logger#usage[relaton-logger] documentation.
+
+== Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To update the index test fixture (used by tests), run `rake spec:update_index`. This downloads the latest `index-v1.zip` from the https://github.com/relaton/relaton-data-ogc[relaton-data-ogc] repository.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+== Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/relaton/relaton-ogc.
+
+== License
+
+The gem is available as open source under the terms of the https://opensource.org/licenses/MIT[MIT License].

data/lib/relaton/ogc/data_fetcher.rb

@@ -46,9 +46,13 @@ module Relaton
 
       def fetch_doc(hit)
         return if hit["type"] == "CC"
+        # The list entry carries the whole record payload, so an unchanged
+        # entry skips the parse and the write (the digest ledger).
+        return if unchanged?(hit["identifier"], hit)
 
         bib = Scraper.parse_page hit, @errors
-        write_document bib
+        file = write_document bib
+        note_digest(hit["identifier"], hit, file: file) if file
         true
       rescue StandardError => e
         Util.error "Fetching document: #{hit['identifier']}\n" \
@@ -56,17 +60,19 @@ module Relaton
         false
       end
 
+      # @return [String, nil] the file written, or nil for a duplicate
       def write_document(bib) # rubocop:disable Metrics/AbcSize
         docid = bib.docidentifier[0].content
         if @docids.include?(docid)
           @dupids << docid
-          return
+          return nil
         end
 
         @docids << docid
         file = file_name bib
         index.add_or_update index_id(docid), file
-        File.write file, serialize(bib), encoding: "UTF-8"
+        force_write file, serialize(bib)
+        file
       end
 
       #

data/lib/relaton/oiml/CLAUDE.md

@@ -0,0 +1,47 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+relaton-oiml retrieves International Organization of Legal Metrology (OIML) publications using the Relaton model. It is **index-backed** (no scraping): it searches a pre-built index via `Relaton::Index` and fetches per-document YAML from the `relaton/relaton-data-oiml` GitHub repo. OIML reference parsing uses `Pubid::Oiml::Identifier`.
+
+## Development
+
+```bash
+bundle exec rake                 # default task → rspec
+bundle exec rspec spec/relaton/oiml/bibliography_spec.rb   # single file
+bundle exec rake spec:update_index   # refresh the OIML index fixture from relaton-data-oiml
+```
+
+(No gem-local rubocop config; the monorepo root config applies.)
+
+## Architecture
+
+Namespace: `Relaton::Oiml`. Retrieval flow:
+
+1. **Bibliography** (`lib/relaton/oiml/bibliography.rb`) — `get(code, year)` / `search`; parses the reference with `Pubid::Oiml.parse`, looks it up in the index, and fetches the matching YAML. `get` suppresses the edition year for an **undated** citation (mirroring ISO): when the reference carries no year (and `opts[:keep_year]` is not set) it returns `item.to_most_recent_reference`, so `OIML B 18` renders undated, while a dated citation (`OIML B 18:2022`, or an explicit `year`) still pins that edition. This relies on `Oiml::Docidentifier#remove_date!` refreshing `content` from the dateless pubid — mutating the wrapped `@pubid` alone leaves the rendered `content` dated (issue #72).
+2. **Index** — `Relaton::Index.find_or_create(:oiml, url: ..., pubid_class: Pubid::Oiml::Identifier)`. `INDEXFILE` is defined in `lib/relaton/oiml.rb`. `Bibliography#best_row` matches a **Bulletin** exactly (`index.search(query, exact: true)`), and every other type by `pubid_match?`: the year-and-language-stripped "stem" is equal, the language is equal, and the year is equal when the reference or the `year` argument names one; the latest edition wins. A Bulletin needs the exact match because its year is part of its locator: the issue and the sequence render after the year, so the stem reduced every article of one year to `OIML Bulletin`, and a lookup returned an arbitrary one of them.
+
+**OIML does not use pubid's subset match `===` yet**, unlike the other flavors that pubid#408 unblocked. Measured over the full `relaton-data-oiml` index (5,646 rows), `===` disagrees with `pubid_match?` outside the Bulletins on 192 pairs, and each one is a regression: `language` is not `subset_strict`, so a language-less Amendment, Annex or Errata reference reaches its translations (156 pairs); `subpart` is not strict, so `OIML R 137-1 (F)` reaches `OIML R 137-1-2:2012 (F)` (6); and the `year_on_base` render flag is compared, so `OIML R 102 Annex B-C` misses `OIML R 102:1995 Annex B-C` (30). A plain Recommendation escapes the first one only because its render hint `parsed_format` differs, which is luck. The hand-off `metanorma__pubid__oiml-subset-match-strict-language` asks pubid for the fix. `spec/oiml/relaton/oiml/bibliography_spec.rb` pins all of these with an in-memory index ("where the subset match would disagree"), so a later switch must pass them.
+
+**Dual-published identifiers** (relaton#180, pubid#437): OIML sometimes co-publishes a document jointly with another SDO (ISO confirmed so far), printed with both identifiers joined by a bare `|`, e.g. `ISO 4064-1:2024|OIML R 49-1:2024`. pubid models this as `Pubid::Oiml::Identifiers::DualPublished`, which wraps `first`/`second` (each a real, independently-typed `::Pubid::Identifier`, in original print order) and delegates `#root`/`#code`/`#type`/`#stage`/`#iteration`/`#publisher`/the `mr_*` hooks to whichever side `#oiml_identifier` finds — but deliberately **not** `#year`, `#date`, `#part`, or `#language`: reading or mutating those directly on the wrapper is a silent no-op (the wrapper's own copies of those attributes are simply never populated). Only the generic, immutable `#exclude(:attr)` correctly recurses into both sides, because it walks the wrapper's declared attributes and, for the two that are nested identifiers (`first`/`second`), recurses into each.
+
+Because `#root` already delegates to the OIML side, `Relaton::Index` needs no change — a dual-published row buckets under its OIML number exactly like a plain one. The gap was in `Bibliography` and `Docidentifier`, both of which read/mutate a pubid's flat attributes directly:
+
+- `Bibliography#oiml_side(pubid)` unwraps a `DualPublished` to its OIML side (a plain pubid passes through unchanged), and `stem`/`pubid_match?`/`best_row`'s edition `max_by` all route through it before touching `.year`/`.language`. Without this, a plain query's stem (`"OIML R 49-1"`) can never equal a dual-published row's stem (`"ISO 4064-1|OIML R 49-1"` at full string), and `.year`/`.language` read directly off a `DualPublished` are always nil/no-op — silently breaking edition selection and language matching. Reducing both sides to the OIML identifier also makes stem comparison print-order-independent (`OIML R 49-1|ISO 4064-1` and `ISO 4064-1|OIML R 49-1` match identically).
+- `Docidentifier#remove_date!`/`#remove_part!` compute the mutated string via `@pubid.exclude(:date)`/`@pubid.exclude(:part)` and reassign through `content=` (which reparses and resyncs `@pubid`), instead of the old `@pubid.date = nil`/`@pubid.part = nil` in-place mutation — the in-place form is indistinguishable from success (no exception) but silently does nothing on a `DualPublished`. `#exclude` behaves identically to the old in-place mutation for a plain (non-dual) pubid, so this is a safe rewrite, not just a dual-published-only branch.
+
+No second `docidentifier` array entry is added for the external (ISO) side — pubid's `DualPublished` already exposes both sides structurally off the one docidentifier's `pubid` (`oiml_identifier`/`external_identifier`), so a consumer that needs the ISO side reads it from there.
+3. **Item / ItemData / Ext** (`item.rb`, `item_data.rb`, `ext.rb`) — `Item` extends `Bib::Item`; `Ext` carries OIML-specific fields (scope, quantity, measuring_instrument, focus_area, sustainability_framework, doi). `Item.from_yaml` deserializes the fetched document.
+4. **Processor** (`lib/relaton/oiml/processor.rb`) — registry integration; `@prefix = "OIML"`, `@defaultprefix = %r{^OIML\s}`. Lazy-`require_relative`s `../oiml` in its methods, including `remove_index_file`.
+
+There are no scrapers — everything comes from the curated index + GitHub YAML.
+
+## External dependencies
+
+`pubid ~> 2.0.0.pre.alpha.3`, `base64`, `relaton-core`, `relaton-bib`, `relaton-index`.
+
+## Testing
+
+RSpec with WebMock + VCR. The offline index fixture `spec/fixtures/index-v2.zip` is pre-loaded into the `Relaton::Index` pool in `before(:suite)` (configured in `spec/support/webmock.rb`); per-document data requests are stubbed by WebMock and served from `spec/fixtures/data/*.yaml`. Run `rake spec:update_index` to refresh the fixture.

data/lib/relaton/oiml/README.adoc

@@ -0,0 +1,70 @@
+= Relaton OIML
+
+RelatonOiml is a library to fetch bibliographic items for OIML
+(International Organization of Legal Metrology) publications from the
+https://github.com/relaton/relaton-data-oiml[relaton-data-oiml] repository.
+The result is a Relaton bibliographic item that can be serialised to Relaton
+XML or YAML.
+
+It is a part of the https://github.com/relaton/relaton[Relaton] project.
+
+== Supported document types
+
+OIML publications are identified with https://github.com/metanorma/pubid[pubid]
+(`Pubid::Oiml`). The following document types are covered:
+
+* Recommendations (`R`)
+* Documents (`D`)
+* Guides (`G`)
+* Vocabularies (`V`)
+* Basic Publications (`B`)
+* Expert Reports (`E`)
+* Seminar Reports (`S`)
+
+== Usage
+
+=== Search for a standard using keywords
+
+[source,ruby]
+----
+require "relaton/oiml"
+
+item = Relaton::Oiml::Bibliography.get "OIML R 138"
+# [relaton-oiml] INFO: (OIML R 138) Fetching from Relaton repository ...
+# [relaton-oiml] INFO: (OIML R 138) Found: `OIML R 138:2007`
+=> #<Relaton::Oiml::Item:0x...>
+
+item.docidentifier.first.content
+=> "OIML R 138:2007"
+----
+
+A specific edition and language can be requested:
+
+[source,ruby]
+----
+Relaton::Oiml::Bibliography.get "OIML R 138:2007 (E)"
+----
+
+=== Serialization
+
+[source,ruby]
+----
+item.to_xml bibdata: true
+item.to_yaml
+----
+
+== OIML-specific metadata
+
+Enhanced OIML Recommendations carry additional structured metadata exposed via
+the bibliographic item extension (`item.ext`):
+
+* `scope`
+* `quantity`
+* `measuring_instrument`
+* `focus_area`
+* `sustainability_framework`
+* `doi`
+
+== License
+
+Copyright Ribose. BSD 2-clause licensed.