relaton 3.0.0.pre.alpha.16 → 3.0.0.pre.alpha.18

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/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.

data/lib/relaton/omg/CLAUDE.md

@@ -0,0 +1,137 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+relaton-omg is a Ruby gem that searches and fetches standards from The Object Management Group (OMG) at https://www.omg.org. It is part of the larger Relaton family of bibliographic data gems (v2.0.0-alpha.1).
+
+## Commands
+
+- **Run all tests:** `bundle exec rspec`
+- **Run a single test:** `bundle exec rspec spec/relaton/omg/item_spec.rb`
+- **Lint:** `bundle exec rubocop` (follows Ribose OSS style guide)
+- **Lint with autofix:** `bundle exec rubocop -a`
+- **Install deps:** `bundle install`
+
+## Architecture
+
+### Module structure
+
+All source lives under `lib/relaton/omg/`. The main entry point is `lib/relaton/omg.rb` which loads everything under the `Relaton::Omg` module namespace.
+
+### Class hierarchy
+
+The gem extends `relaton-bib` (~> 2.0.0-alpha.1), the core Relaton bibliographic data library:
+
+- `Relaton::Omg::Item` < `Bib::Item` — base item class, uses `Omg::ItemData` model (subclass of `Bib::ItemData`)
+- `Relaton::Omg::Ext` < `Bib::Ext` — overrides `get_schema_version` to return the OMG model version
+- `Relaton::Omg::Bibitem` < `Item` — includes `Bib::BibitemShared`, for `<bibitem>` XML
+- `Relaton::Omg::Bibdata` < `Item` — includes `Bib::BibdataShared`, for `<bibdata>` XML
+- `Relaton::Omg::Docidentifier` < `Bib::Docidentifier` — the document id, backed by `Pubid::Omg`; `Item` declares it, so XML and YAML deserialization produce it too
+- `Relaton::Omg::Processor` < `Core::Processor` — relaton-core integration, delegates to `Bibliography`, `Bibitem`, `Item`
+- `Relaton::Omg::Bibliography` — fetches standards via `Scraper`
+- `Relaton::Omg::Scraper` — scrapes https://www.omg.org/spec for bibliographic data
+
+### References are parsed with pubid
+
+OMG uses `Pubid::Omg` and no hand regex. The flavor historically had no index
+and no data repository (the BSI and CEN shape: parse the reference, and back
+the document id with pubid). That changed: **relaton-data-omg** now crawls
+www.omg.org/spec and serves the machine index on Pages (the relaton#206
+contract), and `Relaton::Omg::INDEXFILE = "index-v2"` names it — the gem-side
+consumer flip (reading the machine index in `Bibliography` the way the other
+flavors do) is the follow-up; retrieval still scrapes live.
+
+The grammar is `OMG <ACRONYM>[ <VERSION>][<sep><PART>]`, where `<sep>` is a
+space, or a slash after a version. The version can carry a beta label (`2.5 beta`,
+`2.0 beta 1`). The part is a volume or a format name (`Superstructure`, `PDF`).
+
+- **`get` takes a String or a `Pubid::Omg::Identifier`** (the parse that
+  `Relaton::Db` routed with, relaton#205). `Scraper.scrape_page` parses only a
+  String, and the log keys print `ref.to_s`.
+- **An unrecognized reference raises.** `Scraper.scrape_page` lets
+  `Pubid::Errors::ParseError` propagate, so
+  `OMG Model Driven Architecture Guide rev. 2.0` raises and does not show as
+  "Not found". Only the transport errors are rescued, by name.
+- **The request URL is the acronym and the version, and nothing else.**
+  `get_doc` builds `https://www.omg.org/spec/<ACRONYM>/<VERSION>`, with each
+  space of the version turned into `/` (`1.0 beta 2` becomes `1.0/beta/2`). The
+  part stays out of the URL: `fetch_link` uses it to find the part's PDF link
+  on the version page, and `fetch_title` appends it. The cassettes replay only
+  while the URL does not change.
+- **The docid version comes from the page, not from the query.** That is why
+  `get "OMG AMI4CCM"` answers `OMG AMI4CCM 1.1`. `fetch_docid` and the History
+  ids of `fetch_relation` are rendered by
+  `Pubid::Omg::Identifiers::Specification`, not by parsing a joined string.
+- **pubid renders one separator.** `OMG DDS 1.4/PDF` renders back as
+  `OMG DDS 1.4 PDF`. Both spellings name the same document, and one rendering
+  keeps `==` and `matches?` true between them. If you echo a caller's
+  reference, echo the string, not `pubid.to_s`.
+- **Known limit.** OMG's URL spelling `Beta2` (label and number joined) parses
+  as a part, not a version. It round-trips, so nothing is lost.
+- **The acronym is the URL segment, verbatim.** 30 of the 270 acronyms in the
+  OMG catalog carry a hyphen, a slash, a plus, or start in lower case
+  (`DDS-XTypes`, `EDMC-FIBO/BE`, `VSIPL++`, `smartant`). pubid PR #376 accepts
+  all 270. A slash **before** the version belongs to the acronym
+  (`OMG EDMC-FIBO/BE 1.1` fetches `spec/EDMC-FIBO/BE/1.1`); a slash **after**
+  the version separates the part. So `OMG UML/Superstructure` is the acronym
+  `UML/Superstructure`; write the part behind a space. With pubid `ce2f75ef`
+  (PR #372) those 30 raised, and the migration waited for #376. Fix a grammar
+  gap in pubid; do not split the acronym in the flavor.
+
+`Docidentifier` parses its `content` on the data side and rescues the parse, so
+a value that is not an OMG identifier stays verbatim with a nil `pubid`. Its
+mutators:
+
+- `remove_date!` drops the **version**. OMG identifiers carry no date, and the
+  version is the discriminator, as IALA maps `remove_date!` onto its edition.
+  So `to_most_recent_reference` turns `OMG AMI4CCM 1.0` into `OMG AMI4CCM`.
+- `remove_part!` drops the part: `OMG UML 2.1.1 Superstructure` becomes
+  `OMG UML 2.1.1`.
+- `to_all_parts!` is the inherited no-op. An OMG part is a name, not a numbered
+  part, so there is no "all parts" form.
+
+The processor sets `@pubid_flavor = :Omg`. That changes nothing today:
+`Pubid::Omg.prefixes` is `["OMG"]`, the same as `@prefix`.
+
+### Publication date comes from JSON-LD, not the visible text
+
+`Scraper#pub_date` reads the `publicationDate` value out of the page's
+`application/ld+json` block, not the `<dt>Publication Date:</dt>` text. Two
+reasons, both verified against cassettes:
+
+- **Locale.** The OMG server renders the month name in its own locale, and
+  Cloudflare caches that variant. A response can carry `Content-Language: zh-CN`
+  with an otherwise English page (`<html lang="en">`) and a `<dd>七月 2007</dd>`,
+  which made `Date.parse` raise `Date::Error`. The request already sends
+  `Accept-Language: en-us,en;q=0.5`; the CDN answers `Vary: accept-encoding`
+  only, so it does not vary on language and no request header can prevent this.
+- **Precision.** The visible text is a lossy render of the same value:
+  `2013-03-31` prints as "March 2013". Parsing the text rounded every OMG date
+  down to day 01.
+
+The `<dd>` text stays as a fallback for a page with no JSON-LD, and a month name
+it cannot parse logs a warning instead of raising.
+`spec/omg/relaton/omg/scraper_spec.rb` guards all three paths with
+`spec/omg/fixtures/localized_date.html`. Do not "simplify" the parser back to
+the `<dd>` text.
+
+### Serialization formats
+
+Items can be serialized to/from YAML and XML. Tests verify round-trip fidelity for all three classes. XML output is validated against RELAX NG schemas in `grammars/`.
+
+### Test patterns
+
+- RSpec with `expect` syntax (monkey patching disabled)
+- `equivalent-xml` for XML comparison
+- `ruby-jing` for RELAX NG schema validation against `grammars/relaton-omg-compile.rng`
+- VCR cassettes in `spec/vcr_cassettes/` for HTTP interaction recording
+- Fixtures in `spec/fixtures/` (YAML and XML reference files)
+- Tests follow a round-trip pattern: load fixture → parse → serialize → compare to fixture
+
+## Style
+
+- Ruby >= 3.1.0
+- Rubocop inherits from Ribose OSS guide with `rubocop-rails` required but Rails cops disabled
+- OMG document reference format: `OMG {ACRONYM}[ {VERSION}][ {PART}]` (e.g., `OMG AMI4CCM 1.0`, `OMG UML 2.1.1 Superstructure`)