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

data/lib/relaton/itu/README.adoc

@@ -0,0 +1,188 @@
+= Relaton::Itu: retrieve ITU Standards for bibliographic use using the BibliographicItem model
+
+RelatonItu is a Ruby gem that implements the https://github.com/metanorma/metanorma-model-iso#iso-bibliographic-item[IsoBibliographicItem model].
+
+== Usage
+
+=== Search for a standard using keywords
+
+[source,ruby]
+----
+require 'relaton/itu'
+=> true
+
+hit_collection = Relaton::Itu::Bibliography.search("ITU-T L.163")
+=> <Relaton::Itu::HitCollection:0x00000000001700 @ref=ITU-T L.163 @fetched=false>
+
+item = hit_collection[1].item
+=> #<Relaton::Itu::ItemData:0x000000012541b8f8
+ ...
+----
+
+=== XML serialization
+
+[source,ruby]
+----
+item.to_xml
+=> "<bibitem id="ITUTLSuppl39092020" type="standard" schema-version="v1.4.1">
+      <fetched>2026-02-24</fetched>
+      <title language="en" script="Latn" type="title-intro">ITU-T L.1470</title>
+      <title language="en" script="Latn" type="title-main">Optical fibre cable Recommendations and standardization guideline</title>
+      <title language="en" script="Latn" type="main">ITU-T L.1470 - Optical fibre cable Recommendations and standardization guideline</title>
+      <uri type="src">https://handle.itu.int/11.1002/1000/14547</uri>
+      <uri type="pdf">https://www.itu.int/rec/dologin_pub.asp?lang=e&amp;id=T-REC-L.Sup39-202009-I!!PDF-E&amp;type=items</uri>
+      <docidentifier type="ITU" primary="true">ITU-T L Suppl. 39 (09/2020)</docidentifier>
+      ...
+    </bibitem>"
+----
+
+With `bibdata: true` option XML output is wrapped with `bibdata` element and `ext` element added.
+
+[source,ruby]
+----
+item.to_xml bibdata: true
+=> "<bibdata type="standard" schema-version="v1.4.1">
+      <fetched>2026-02-24</fetched>
+      <title language="en" script="Latn" type="title-intro">ITU-T L.1470</title>
+      <title language="en" script="Latn" type="title-main">Optical fibre cable Recommendations and standardization guideline</title>
+      <title language="en" script="Latn" type="main">ITU-T L.1470 - Optical fibre cable Recommendations and standardization guideline</title>
+      <uri type="src">https://handle.itu.int/11.1002/1000/14547</uri>
+      <uri type="pdf">https://www.itu.int/rec/dologin_pub.asp?lang=e&amp;id=T-REC-L.Sup39-202009-I!!PDF-E&amp;type=items</uri>
+      <docidentifier type="ITU" primary="true">ITU-T L Suppl. 39 (09/2020)</docidentifier>
+      ...
+      <ext schema-version="v1.0.2">
+        <doctype>recommendation</doctype>
+        <flavor>itu</flavor>
+      </ext>
+    </bibdata>"
+----
+
+=== Get document by code and year
+[source,ruby]
+----
+Relaton::Itu::Bibliography.get("ITU-T L.163", "2018", {})
+[relaton-itu] INFO: (ITU-T L.163 (2018)) Fetching from www.itu.int ...
+[relaton-itu] INFO: (ITU-T L.163 (2018)) Found: `ITU-T L.163 (11/2018)`
+=> #<Relaton::Itu::ItemData:0x000000010f92a288
+...
+----
+
+=== Get amendment
+[source,ruby]
+----
+Relaton::Itu::Bibliography.get "ITU-T G.989.2 (2019)/Amd 1"
+[relaton-itu] INFO: (ITU-T G.989.2 (2019)) Fetching from www.itu.int ...
+[relaton-itu] INFO: (ITU-T G.989.2 (2019)) Found: `ITU-T G.989.2 (02/2019)`
+=> #<Relaton::Itu::ItemData:0x000000010fa4f3c0
+...
+----
+
+=== Get ITU-R documents
+
+[source,ruby]
+----
+Relaton::Itu::Bibliography.get "ITU-R BO.600-1"
+[relaton-itu] INFO: (ITU-R BO.600-1) Fetching from Relaton repository ...
+[relaton-itu] INFO: (ITU-R BO.600-1) Found: `ITU-R BO.600-1`
+=> #<Relaton::Itu::ItemData:0x000000010fa4a3c0
+...
+----
+
+=== Get ITU-R Radio Regulations (RR)
+
+[source,ruby]
+----
+Relaton::Itu::Bibliography.get 'ITU-R RR (2020)'
+[relaton-itu] INFO: (ITU-R RR (2020)) Fetching from www.itu.int ...
+[relaton-itu] INFO: (ITU-R RR (2020)) Found: `ITU-R RR (2020)`
+=> #<Relaton::Itu::ItemData:0x000000010fa41e00
+...
+----
+
+=== Typed source links
+
+Each ITU document has `src` type link and optional `obp` and `word` link types.
+
+[source,ruby]
+----
+item.source[0].type
+=> "src"
+
+item.source[0].content
+=> "https://handle.itu.int/11.1002/1000/14547"
+----
+
+=== Create a bibliographic item from XML
+
+[source,ruby]
+----
+item = Relaton::Itu::Item.from_xml File.read("spec/fixtures/bibdata.xml")
+=> #<Relaton::Itu::ItemData:0x000000010fa28ea0
+...
+----
+
+=== Create a bibliographic item from YAML
+
+[source,ruby]
+----
+item = Relaton::Itu::Item.from_yaml File.read("spec/fixtures/item.yaml")
+=> #<Relaton::Itu::ItemData:0x000000010f9848a0
+...
+----
+
+=== Fetch data
+
+The method `Relaton::Itu::DataFetcher.fetch("itu-t", output: "data", format: "yaml")` harvests every ITU-T recommendation edition (from the `mws/api/recommendations/searchRecs` index) and saves the documents to the `./data` folder in YAML format.
+Arguments:
+
+- `source` - source name (`itu-t`).
+- `output` - folder to save documents (default `data`).
+- `format` - the format in which the documents are saved. Possible formats are: `yaml`, `xml`, `bibxxml` (default `yaml`).
+
+[source,ruby]
+----
+Relaton::Itu::DataFetcher.fetch "itu-t", output: "dir", format: "xml"
+Started at: 2026-08-12 09:21:16 -0400
+Stopped at: 2026-08-12 11:27:45 -0400
+Done in: 7589 sec.
+=> nil
+----
+
+NOTE: **ITU-R harvesting is disabled.** ITU decommissioned the RunSearch bulk-enumeration endpoint the ITU-R crawler paged through, so `fetch("itu-r")` (and the argument-less `fetch`) raises a `Relaton::RequestError` pointing at https://github.com/relaton/relaton/issues/75[issue #75] instead of rebuilding an empty dataset. The published ITU-R records are preserved in https://github.com/relaton/relaton-data-itu[relaton-data-itu] and re-indexed on each crawl via `DataFetcher#index_files("data/itu-r-*.yaml")`; runtime ITU-R lookups are unaffected.
+
+`Relaton::Itu::DataCrawlerR` prototypes a replacement crawl over ITU's still-server-rendered `/pub` + `/rec` pages (Recommendations and Reports), and `Relaton::Itu::DataMergeR` merges what it finds into the existing dataset without ever rewriting a published date. Neither is wired into `fetch` — reaching them takes an explicit `require`:
+
+[source,ruby]
+----
+require "relaton/itu/data_crawler_r"
+require "relaton/itu/data_merge_r"
+
+fetcher = Relaton::Itu::DataFetcher.new "data", "yaml"
+crawler = Relaton::Itu::DataCrawlerR.new
+items = crawler.harvest("BO", only: %w[R-REC-BO.1130 R-REC-BO.1212]) +
+        crawler.harvest("BO", family: "R-REP", only: %w[R-REP-BO.1227 R-REP-BO.2006])
+Relaton::Itu::DataMergeR.write_all items, fetcher
+=> {added: 0, backfilled: 4, unchanged: 6, skipped: 0, collisions: []}
+----
+
+Those counts are from that ten-record run against the published dataset: four records gained the PDF link they were missing, six were left byte-identical, and no publication date was touched. Drop `only:` to harvest a whole series (54 recommendation documents / 82 editions for `BO`).
+
+=== Logging
+
+RelatonItu 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 `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+The index test fixture (used by tests) is a trimmed copy of the published pubid-structured `index-v2.zip` (rows are `_type: pubid:itu:…` hashes) from the `main` branch of the combined https://github.com/relaton/relaton-data-itu[relaton-data-itu] repository, kept at `spec/fixtures/index-v2.zip`. Refresh it with the regeneration snippet in `lib/relaton/itu/CLAUDE.md` (it must deserialize under the pinned pubid).
+
+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-itu.
+
+== License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/relaton/jcgm/CLAUDE.md

@@ -0,0 +1,107 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with
+code in this repository.
+
+## Project Overview
+
+`Relaton::Jcgm` retrieves **JCGM** (Joint Committee for Guides in Metrology)
+publications — the metrology **guides/GUM/VIM** and the committee **meeting**
+proceedings. It is **index-backed** (no scraping): a reference is parsed with
+`Pubid::Jcgm`, matched against a pre-built index, and the matching per-document
+YAML is fetched from the `relaton/relaton-data-jcgm` GitHub repo.
+
+JCGM was previously served **inside the BIPM flavor** (its records lived under
+`relaton-data-bipm`). It is now its own SDO/flavor: the BIPM flavor no longer
+matches `JCGM` in its default-prefix, no longer parses JCGM ids, and no longer
+harvests the `jcgm` dir.
+
+## Architecture
+
+Namespace `Relaton::Jcgm`; require path `relaton/jcgm`. Retrieval flow:
+
+1. **Bibliography** (`bibliography.rb`) — `get`/`search`: parses the reference
+   with `::Pubid::Jcgm.parse`, looks it up in the index, fetches the matching
+   YAML over HTTP. `ENDPOINT` points at `relaton-data-jcgm`. An unparseable
+   reference **raises** `Pubid::Errors::ParseError`; the `search` rescue lists
+   transport errors only, so it does not swallow it.
+2. **Index** — `Relaton::Index.find_or_create(:jcgm, url:, file:, pubid_class:
+   ::Pubid::Jcgm::Identifier)`. Because rows are stored as `Pubid::Jcgm`
+   identifiers, the generated index carries the structured `_type:
+   pubid:jcgm:{guide,gum-guide,amendment,meeting}` form (not BIPM's bespoke
+   `{group,type,number,year}` hash). Matching is `pubid_match?`: pubid's
+   asymmetric subset match (`query === row_id`, `Pubid::SubsetMatch`) plus an
+   optional exact-year filter for the `year` argument. Guide editions
+   (`200:2008` vs `200:2012`) differ only by year, so a year-less reference
+   reaches both and the latest is chosen via `max_by(&:year)`; meetings differ
+   by number, which the reference states. The document type is the identifier's
+   class, and `===` requires the same class, so a guide never answers for its
+   corrigendum.
+3. **Model** (`item.rb`, `ext.rb`, `doctype.rb`, `structured_identifier.rb`,
+   `docidentifier.rb`, …) — the records are **BIPM-shaped** (meetings are
+   `type: proceedings` / `ext.doctype: meeting-report`; guides are `type:
+   standard`), so the model mirrors `Relaton::Bipm`'s (a JCGM `Doctype`, a single
+   `structuredidentifier`) rather than OIML's. `docidentifier.rb` is pubid-backed
+   like OIML's. The bibliography/index *wiring* follows OIML; the *model* follows
+   BIPM.
+4. **Processor** (`processor.rb`) — `@prefix = "JCGM"`, `@defaultprefix =
+   %r{^JCGM\s}`, `@pubid_flavor = :Jcgm` (prefixes sourced from
+   `Pubid::Jcgm.prefixes`). Lazy-`require_relative`s `../jcgm` in its methods.
+5. **DataFetcher** (`data_fetcher.rb`, `meetings_parser.rb`) — (re)builds the
+   `relaton-data-jcgm` dataset. `fetch("bipm-data-outcomes")` harvests meeting
+   proceedings from a local checkout of `metanorma/bipm-data-outcomes`'s
+   `jcgm/meetings-{en,fr}` dirs (the JCGM-only slice of BIPM's
+   `DataOutcomesParser`; JCGM has no sub-resolutions or parts). The curated
+   guide/GUM/VIM records are **not** harvested — they are hand-maintained YAMLs
+   in the data repo's top-level `static/` dir, so `relaton-data-jcgm`'s
+   `crawler.rb` indexes them itself (like relaton-data-bipm's crawler) by looping
+   `static/**` and calling the public, guarded `DataFetcher#add_to_index`. Rows
+   are indexed via the `Pubid::Jcgm::Identifier` object (with `pubid_class:` on
+   the index), so `Relaton::Index` sorts the index by id number on save and
+   serialises each id to its `_type: pubid:jcgm:*` hash — the published index is
+   already sorted (no "not sorted by id number" warning on consumer fetch).
+   `add_to_index` **guards** each id: an unparseable one (the legacy `JCGM GUM` /
+   `JCGM VIM-3` / `Corrigendum` records) is skipped with a warning rather than
+   corrupting the whole index.
+
+## The naive ordinal (11st / 12nd / 13rd)
+
+Meeting docnumbers print the ordinal with a **naive last-digit rule** (1→st,
+2→nd, 3→rd, else th) and **no** 11/12/13 teens exception, so the real records
+read `JCGM 11st Meeting (2006)`, `12nd`, `13rd`. This matches the source data and
+`Pubid::Jcgm::Identifiers::Meeting.ordinal`, so the printed form round-trips
+through pubid. The DataFetcher delegates to `Meeting.ordinal` (single source of
+truth) rather than re-implementing it. Any validation MUST expect `11st`, not
+`11th`.
+
+## Record types & the index guard
+
+The five `Pubid::Jcgm` types the index carries: `pubid:jcgm:{guide, gum-guide,
+amendment, corrigendum, meeting}`. The bare `GUM`/`VIM-N` records parse as
+`guide`, and `JCGM 200:2008 Corrigendum` parses as `corrigendum` (whose hash
+nests its `base` guide) — all on pubid **main** (see Dependencies). `Relaton::Index`
+rejects the whole index if a single row fails `from_hash`, so
+`DataFetcher#add_to_index` **guards** each id defensively and skips an unparseable
+docnumber with a warning rather than corrupting the index. Every current JCGM
+record parses; the guard protects against a future malformed one.
+
+## Testing
+
+RSpec with WebMock. The offline index fixture `spec/jcgm/fixtures/index-v1.zip`
+is pre-loaded into the `Relaton::Index` pool in `before(:suite)`
+(`spec/jcgm/support/webmock.rb`); per-document requests are served from
+`spec/jcgm/fixtures/{data,static}/**`. `spec/jcgm/fixtures/bipm-data-outcomes/**`
+holds minimal source fixtures for the DataFetcher spec (the real upstream is not
+vendored). `spec/jcgm/relaton/jcgm/pubid_spec.rb` guards the naive ordinals and
+the `_type` forms.
+
+## Dependencies
+
+`pubid` (umbrella gem, provides `Pubid::Jcgm`), `relaton-bib`, `relaton-index`,
+`relaton-core`.
+
+> **Dependency pin:** the JCGM support (meetings, bare `GUM`/`VIM-N` guides, the
+> `Corrigendum` type, and the flattened compact `to_hash`) first shipped in the
+> released pubid `2.0.0.pre.alpha.13`, which the gemspec pins. Its `lib/` is
+> identical to the pubid `main` that built the published `relaton-data-jcgm`
+> index — a mismatched pubid would make `Relaton::Index` reject that index.

data/lib/relaton/jis/CLAUDE.md

@@ -0,0 +1,64 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+relaton-jis is a Ruby gem that retrieves Japanese Industrial Standards (JIS) metadata from webdesk.jsa.or.jp and models them as Relaton bibliographic items with XML/YAML serialization and RelaxNG schema validation.
+
+## Commands
+
+- `bundle exec rake spec` — run all tests
+- `bundle exec rspec spec/relaton/jis/item_spec.rb` — run a single test file
+- `bundle exec rspec spec/relaton/jis/item_spec.rb:15` — run a single test by line number
+- `bundle exec rake rubocop` — lint
+- `bundle exec rake` — default task (runs specs)
+
+## Architecture
+
+The gem is currently on the `lutaml-integration` branch, a major refactoring from the old `RelatonJis::` namespace to `Relaton::Jis::` using lutaml-model for data modeling.
+
+### Class Hierarchy
+
+All classes live under `lib/relaton/jis/`:
+
+- **`Item`** (extends `Iso::Item`) — core bibliographic item; defines the `Ext` attribute for JIS extensions; uses model `Bib::ItemData`
+- **`Bibitem`** (extends `Item`, includes `Bib::BibitemShared`) — XML bibitem serialization
+- **`Bibdata`** (extends `Item`, includes `Bib::BibdataShared`) — XML bibdata wrapper
+- **`Ext`** (extends `Iso::Ext`) — JIS-specific extension data (schema_version, doctype)
+- **`Docidentifier`** (extends `Bib::Docidentifier`) — `#pubid` parses `content` with `Pubid::Jis::Identifier` on first use (lazy, memoized, soft: nil if it does not parse). The mutators change the pubid and render it back; there is no regex. `remove_part!` clears every part level (`JIS C 0364-2-21` → `JIS C 0364`), `remove_date!` clears the year and the reaffirmation `R`, and on a supplement both act on the base — the supplement keeps its own year, because pubid renders a year-less supplement as `…/AMD 1:`. `to_all_parts!` wraps `@pubid` in pubid's `AllParts` (so `#pubid.all_parts?` reads true) but writes `content`'s own marker ` (all parts)` from the pre-wrap rendering, not pubid's `（規格群）` (which is what `#pubid.to_s`, read directly, would print). The `JIS ` publisher is rendered only if the source has it (`TR Z 0010:2008` stays without it); everything else is the pubid canonical spelling (`AMENDMENT 1` → `AMD 1`).
+- **`Doctype`** (extends `Bib::Doctype`) — allowed types: `japanese-industrial-standard`, `technical-report`, `technical-specification`, `amendment`
+- **`Scraper`** — scrapes individual JIS document pages from webdesk.jsa.or.jp; returns `Bib::ItemData`; editorial group is modeled as a contributor with `Bib::Subdivision` (not `EditorialGroup`)
+- **`DataFetcher`** (extends `Core::DataFetcher`) — bulk-fetches all JIS documents via threaded scraping; implements `to_yaml`/`to_xml`/`to_bibxml` for serialization dispatch; loaded on-demand via `require "relaton/jis/data_fetcher"`
+- **`Processor`** (extends `Core::Processor`) — Relaton processor registration; provides `get`, `fetch_data`, `from_xml`, `from_yaml`, `grammar_hash`; prefix `JIS`, defaultprefix `^(JIS|TR)\s`
+- **`Util`** (includes `Relaton::Bib::Util`) — logging with PROGNAME "relaton-jis"
+
+### Key Dependencies
+
+- **relaton-iso / relaton-bib** — parent bibliographic item models this gem extends
+- **lutaml-model** — DSL for `attribute` definitions and serialization
+- **mechanize** — web scraping from JSA website
+
+### Serialization & Validation
+
+- YAML and XML round-trip serialization via lutaml-model
+- RelaxNG grammars in `grammars/` validate XML output; `relaton-jis.rng` defines JIS-specific elements (DocumentType, structuredidentifier, stagename)
+- Tests validate XML against these grammars using ruby-jing
+
+### Test Patterns
+
+- **Round-trip tests**: YAML → Object → YAML and XML → Object → XML (fixtures in `spec/fixtures/`)
+- **Schema validation**: Jing validates generated XML against RelaxNG grammars
+- **HTTP mocking**: VCR cassettes (`spec/vcr_cassettes/`) record external HTTP interactions; WebMock disables real network calls in tests
+
+## Code Conventions
+
+- All files use `# frozen_string_literal: true`
+- Linting follows [Ribose OSS style](https://github.com/riboseinc/oss-guides); target Ruby 3.1
+- Ruby >= 3.1.0 required
+
+## Testing
+
+- **Index fixture:** `spec/fixtures/index-v2.zip` (the pubid-based `index-v2`) is deserialized via `Pubid::Jis::Identifier` and pre-loaded into the `Relaton::Index` pool in `before(:suite)` (configured in `spec/support/webmock.rb`). No rake task refreshes it: download `index-v2.zip` from the `v2` branch of relaton-data-jis into `spec/jis/fixtures/`.
+- **Lookup path:** `Bibliography.get`/`search` parse the reference with `pubid`. An unrecognized reference raises `Pubid::Errors::ParseError`; do not rescue it to nil. `HitCollection` takes the candidates that share the base series and number from `index-v2` (a supplement is filed under its base number). `Hit#matches?` is `Pubid::Identifier#matches?` with `ignore: %i[year reaffirmed]` (plus `:parts` for all parts), so the base document of a supplement, its parts, and the `SYMBOL` are compared. The reaffirmation mark `R` goes with the year, because `exclude(:year)` keeps it. For a dated reference, `find_by_year` picks the exact printed id first, then the same id without `R`. Two pubid gaps shape this code. `Pubid::Jis::Identifier#==` does not compare the class (`JIS TR X 0014:1999 == JIS X 0014:1999`), so `Hit#matches?` checks `instance_of?`. `SupplementIdentifier#==` ignores `symbol` and `reaffirmed`, so the exact printed id comes first. Before this rule, 301 of the 21,496 published ids resolved to a different record; `hit_collection_spec.rb` holds one example for each shape. The `DataFetcher` writes `index-v2` only. relaton-data-jis rebuilds the legacy string `index-v1` from `data/` in its own crawler, because the released `relaton-jis` gem still reads `index-v1.zip` from the `v2` branch.
+- **pubid dependency:** the gemspec requires `pubid ~> 2.0.0.pre.alpha.3`, the published release carrying the working lutaml-model `from_hash` (the earlier `2.0.0.pre.alpha.2` was broken). Override to a local checkout with `bundle config set local.pubid /path/to/pubid`.

data/lib/relaton/jis/README.adoc

@@ -0,0 +1,167 @@
+= Relaton::Jis: retrieve JIS Standards for bibliographic use using the BibliographicItem model
+
+RelatonJis 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 JIS Standards from https://webdesk.jsa.or.jp, and access such metadata through the `Relaton::Jis::ItemData` object.
+
+== Usage
+
+=== Search for standards using keywords
+
+[source,ruby]
+----
+require 'relaton/jis'
+=> true
+
+hit_collection = Relaton::Jis::Bibliography.search("JIS X 0208")
+=> <Relaton::Jis::HitCollection:0x000000000014a0 @ref=JIS X 0208 @fetched=false>
+
+hit_collection.first
+=> <Relaton::Jis::Hit:0x00000000001a20 @reference="JIS X 0208" @fetched="false" @docidentifier="">
+
+item = hit_collection[1].item
+=> #<Relaton::Jis::ItemData:0x000000012a880790
+...
+
+item.docidentifier[0].type
+=> "JIS"
+
+item.docidentifier[0].content
+=> "JIS X 0208:1997/AMENDMENT 1:2012"
+----
+
+=== Fetch document by reference and year
+
+[source,ruby]
+----
+item = Relaton::Jis::Bibliography.get "JIS X 0208:1997"
+[relaton-jis] INFO: (JIS X 0208:1997) Fetching from webdesk.jsa.or.jp ...
+[relaton-jis] INFO: (JIS X 0208:1997) Found: `JIS X 0208:1997`
+=> #<Relaton::Jis::ItemData:0x000000012c0f2440
+...
+
+item = Relaton::Jis::Bibliography.get "JIS X 0208", "1997"
+[relaton-jis] INFO: (JIS X 0208) Fetching from webdesk.jsa.or.jp ...
+[relaton-jis] INFO: (JIS X 0208) Found: `JIS X 0208:1997`
+=> #<Relaton::Jis::ItemData:0x000000012c1d7810
+...
+
+item.docidentifier[0].content
+=> "JIS X 0208:1997"
+----
+
+=== Fetch all parts of a standard
+
+[source,ruby]
+----
+item = Relaton::Jis::Bibliography.get "JIS B 0060 (all parts)"
+[relaton-jis] INFO: (JIS B 0060 (all parts)) Fetching from webdesk.jsa.or.jp ...
+[relaton-jis] INFO: (JIS B 0060 (all parts)) Found: `JIS B 0060 (all parts)`
+=> #<Relaton::Jis::ItemData:0x00000001273c8840
+...
+
+item.docidentifier[0].content
+=> "JIS B 0060 (all parts)"
+
+item = Relaton::Jis::Bibliography.get "JIS B 0060 (規格群)"
+[relaton-jis] INFO: (JIS B 0060 (規格群)) Fetching from webdesk.jsa.or.jp ...
+[relaton-jis] INFO: (JIS B 0060 (規格群)) Found: `JIS B 0060 (all parts)`
+=> #<Relaton::Jis::ItemData:0x000000012cb367d0
+...
+
+item.docidentifier[0].content
+=> "JIS B 0060 (all parts)"
+----
+
+=== XML serialization
+
+Possible options:
+
+- *bibdata* - If true then wrapp item with _bibdata_ element and add _ext_ element.
+
+[source,ruby]
+----
+item.to_xml
+=> "<bibitem id="JISB006012015" type="standard" schema-version="v1.4.1">
+      <fetched>2026-02-25</fetched>
+      <title language="ja" script="Jpan">デジタル製品技術文書情報―第１部：総則</title>
+      <title language="en" script="Latn">Digital technical product documentation (DTPD) -- Part 1: General code of practices</title>
+      <uri type="src">https://webdesk.jsa.or.jp/books/W11M0090/index/?bunsyo_id=JIS+B+0060-1%3A2015</uri>
+      <docidentifier type="JIS" primary="true">JIS B 0060 (all parts)</docidentifier>
+      ...
+    </bibitem>"
+
+item.to_xml bibdata: true
+=> "<bibdata type="standard" schema-version="v1.4.1">
+      <fetched>2026-02-25</fetched>
+      <title language="ja" script="Jpan">デジタル製品技術文書情報―第１部：総則</title>
+      <title language="en" script="Latn">Digital technical product documentation (DTPD) -- Part 1: General code of practices</title>
+      <uri type="src">https://webdesk.jsa.or.jp/books/W11M0090/index/?bunsyo_id=JIS+B+0060-1%3A2015</uri>
+      <docidentifier type="JIS" primary="true">JIS B 0060 (all parts)</docidentifier>
+      ...
+      <ext schema-version="v0.0.1">
+        <doctype>japanese-industrial-standard</doctype>
+        <flavor>jis</flavor>
+        <ics>
+          <code>01.110</code>
+          <text>Technical product documentation</text>
+        </ics>
+        <structuredidentifier type="JIS">
+          <project-number>B0060 (all parts)</project-number>
+        </structuredidentifier>
+      </ext>
+    </bibdata>"
+----
+
+=== Typed source links
+
+Each JIS document has `src` type source link and optional `pdf`.
+
+[source,ruby]
+----
+item.source[0].type
+=> "src"
+
+item.source[0].content
+=> "https://webdesk.jsa.or.jp/books/W11M0090/index/?bunsyo_id=JIS+B+0060-1%3A2015"
+----
+
+=== Fetch data
+
+This gem scrapes the https://webdesk.jsa.or.jp/books/W11M0270 pages to fetch the JIS Standards metadata. By default the data is saved in the `./data` folder in YAML format.
+
+The method `Relaton::Jis::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/jis/data_fetcher"
+
+Relaton::Jis::DataFetcher.fetch
+Started at: 2024-09-27 17:49:40 -0400
+Done in: 3031 sec.
+=> nil
+----
+
+=== Logging
+
+RelatonJis 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 `rake spec` 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), download the latest `index-v2.zip` from the `v2` branch of the https://github.com/relaton/relaton-data-jis[relaton-data-jis] repository into `spec/jis/fixtures/`.
+
+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 the created tag, 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-jis.
+
+== License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/relaton/logger/CLAUDE.md

@@ -0,0 +1,37 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+relaton-logger is the logging infrastructure for the Relaton family. It extends Ruby's stdlib `Logger` with a **logger pool** (named loggers), **per-logger level sets** (fine-grained filtering instead of a single threshold), pluggable formatters (string and JSON), and a GitHub-issue reporting channel for bulk-fetch error summaries. Flavor gems log through it (e.g. `Relaton::Bib::Util` extends it with a `PROGNAME`).
+
+## Development
+
+```bash
+bundle exec rake        # default task → rspec
+bundle exec rspec spec/relaton/logger/log_spec.rb   # single file
+bundle exec rake rubocop  # lint (separate task)
+```
+
+## Architecture
+
+Namespace: `Relaton::Logger`. Key classes in `lib/relaton/logger/`:
+
+- **`Log`** (`log.rb`) — subclass of `::Logger`. Replaces the single severity threshold with a `levels` Set (`add_level`/`remove_level`); `Log#add` writes only when the severity is in `levels`. Each call accepts a `progname` and a `key:` keyword used by formatters.
+- **`Pool`** (`pool.rb`) — a container of named loggers (`[:default]`, `[:file]`, …); logging calls fan out to every logger in the pool.
+- **`Config`** (`config.rb`) — `Relaton.configure { |c| ... }` / `Relaton.configuration`; the default `Configuration` seeds a `Pool` with a `:default` stderr logger at levels info/warn/error/fatal.
+- **Formatters** — `FormatterString` emits `[progname] SEVERITY: (key) message`; `FormatterJSON` emits a JSON line merging the call's keyword args.
+- **`Channels::GhIssue`** (`channels/gh_issue.rb`) — accumulates de-duplicated log lines and opens a GitHub issue via the REST API on `close` (needs `GITHUB_TOKEN`; silently skips when unset or empty). Used by `Relaton::Core::DataFetcher` to report bulk-ingest errors.
+
+### Entry point
+
+`Relaton.logger_pool` returns the configured pool; `Relaton.logger_pool.info "msg"` broadcasts to all loggers, and `Relaton.logger_pool[:default]` accesses one by name.
+
+## External dependencies
+
+`logger ~> 1.6`.
+
+## Testing
+
+RSpec with SimpleCov; specs mirror the lib structure under `spec/relaton/logger/`.