pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/oiml/identifier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class Identifier < Pubid::Identifier
+      # Maps each concrete identifier's polymorphic_name => class name, so
+      # key_value (de)serialization can re-instantiate the correct subclass
+      # from the `_type` discriminator. Kept in sync with the Identifiers
+      # namespace by a spec assertion (see spec/pubid/oiml/to_hash_spec.rb).
+      OIML_TYPE_MAP = {
+        "pubid:oiml:recommendation" => "Pubid::Oiml::Identifiers::Recommendation",
+        "pubid:oiml:basic-publication" => "Pubid::Oiml::Identifiers::BasicPublication",
+        "pubid:oiml:bulletin" => "Pubid::Oiml::Identifiers::Bulletin",
+        "pubid:oiml:document" => "Pubid::Oiml::Identifiers::Document",
+        "pubid:oiml:guide" => "Pubid::Oiml::Identifiers::Guide",
+        "pubid:oiml:vocabulary" => "Pubid::Oiml::Identifiers::Vocabulary",
+        "pubid:oiml:expert-report" => "Pubid::Oiml::Identifiers::ExpertReport",
+        "pubid:oiml:seminar-report" => "Pubid::Oiml::Identifiers::SeminarReport",
+        "pubid:oiml:amendment" => "Pubid::Oiml::Identifiers::Amendment",
+        "pubid:oiml:errata" => "Pubid::Oiml::Identifiers::Errata",
+        "pubid:oiml:annex" => "Pubid::Oiml::Identifiers::Annex",
+      }.freeze
+
+      # The base Pubid::Identifier no longer auto-maps attributes, so OIML must
+      # declare its own key_value mapping. SingleIdentifier and
+      # SupplementIdentifier (siblings) add their disjoint attribute deltas on
+      # top of this shared block. `type` is deliberately NOT mapped: OIML's
+      # `type` is a String-returning method (e.g. "R"), incompatible with the
+      # inherited Components::Type attribute — and the `_type` discriminator
+      # already pins the concrete subclass (and thus the type letter).
+      key_value do
+        map "_type", to: :_type, polymorphic_map: OIML_TYPE_MAP
+        map "language", to: :language
+        map "parsed_format", to: :parsed_format
+      end
+
+      # lutaml's polymorphic_map only validates `_type` on deserialization; it
+      # does not re-instantiate the concrete subclass. Route by `_type` so
+      # `Pubid::Oiml::Identifier.from_hash(h)` returns the right class (and its
+      # nested base), mirroring Pubid::Iso::Identifier.from_hash.
+      def self.from_hash(data, options = {})
+        type = data["_type"] || data[:_type]
+        klass_name = OIML_TYPE_MAP[type]
+        if klass_name
+          klass = Object.const_get(klass_name)
+          return klass.from_hash(data, options) unless klass == self
+        end
+        super
+      end
+
+      # Uniform class-level parse entry, mirroring every other flavor's
+      # `Pubid::<Flavor>::Identifier.parse`. OIML's real logic lives in the
+      # module method, so delegate to it (same pattern as jcgm/nist/plateau).
+      # The `Pubid::MAX_INPUT_LENGTH` ReDoS guard lives in `Pubid::Oiml.parse`.
+      def self.parse(identifier)
+        Pubid::Oiml.parse(identifier)
+      end
+
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/amendment.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Amendment < SupplementIdentifier
+        def supplement_type
+          "Amendment"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/annex.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Annex < SupplementIdentifier
+        attribute :letter, :string # For "Annex A", "Annex B", "Annex B-C"
+        # True when the publication year is glued to the base ("OIML R 60:2017
+        # Annexes") rather than the marker ("OIML R 60 Annexes:2017"); drives
+        # exact round-trip in the renderer.
+        attribute :year_on_base, :boolean, default: false
+
+        key_value do
+          map "letter", to: :letter
+          map "year_on_base", to: :year_on_base
+        end
+
+        def supplement_type
+          letter ? "Annex #{letter}" : "Annexes"
+        end
+
+        def to_s(format: nil, **opts)
+          @requested_format = format
+          render(format: :human, **opts)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/basic_publication.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class BasicPublication < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "B"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/bulletin.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # OIML Bulletin issues and articles. Carries no code — the locator is
+      # the (year, issue, sequence) tuple drawn from the issue's place in the
+      # periodical hierarchy.
+      #
+      # Two input forms are accepted, both referring to the same article:
+      #
+      #   structured:  "OIML Bulletin 2026-02-11"
+      #   citation:    "OIML Bulletin LXVII(2) 20260211"
+      #
+      # The structured form is the dataset's primary docid (sortable,
+      # deterministic). The citation form is what OIML prints on the article
+      # page (`Citation: AUTHOR YEAR OIML Bulletin VOLUME(ISSUE) ARTID`).
+      #
+      # Volume tracks year deterministically: 1960 = I, year - 1959 = volume.
+      # The 8-digit article id is YYYYNNSS — the same three values concatenated,
+      # so the citation form is decoded entirely from the article id; the
+      # roman volume and parenthesised issue are redundant display.
+      #
+      # Shapes in relaton-data-oiml:
+      #   "OIML Bulletin"                       (periodical)
+      #   "OIML Bulletin 1960"                  (volume / year)
+      #   "OIML Bulletin 1960-03"               (issue)
+      #   "OIML Bulletin 1960-03-01"            (article, structured)
+      #   "OIML Bulletin LXVII(2) 20260211"     (article, citation)
+      class Bulletin < SingleIdentifier
+        # OIML Bulletin volume I was issued in 1960. Volume N corresponds to
+        # year (N + BASE_YEAR_OFFSET). Used to translate between the year
+        # carried in the structured form and the roman volume in citations.
+        BASE_YEAR_OFFSET = 1959
+
+        # Zero-padded issue number within the year ("01".."04", plus "07"/"10"
+        # for the online-bulletin series). Always 2 digits.
+        attribute :issue, :string
+        # Zero-padded sequence within the issue ("00" = editorial, "01"+ for
+        # articles). Always 2 digits.
+        attribute :sequence, :string
+
+        key_value do
+          map "issue", to: :issue
+          map "sequence", to: :sequence
+        end
+
+        # relaton-index keys on `id.root.number.to_s`. Bulletin is the one OIML
+        # leaf with no code (it does not include Identifiers::CodeNumber), so
+        # it derives the key from the year it already stores: every issue and
+        # article of a volume clusters into one bucket, with per-article
+        # distinctness coming from the MR slug instead. That is the BIPM
+        # Metrologia-volume precedent recorded in CLAUDE.md.
+        #
+        # A DERIVED READER, deliberately not an attribute: storing it would
+        # duplicate `year` in every row, and the key_value block above maps no
+        # "number", so nothing is added to the wire format. Safe as a plain
+        # method because Bulletin declares no `number` attribute of its own
+        # (the ITU itu/identifiers/base.rb precedent).
+        #
+        # nil for the bare periodical reference "OIML Bulletin", which names no
+        # year — a deliberate gap, pinned in spec/pubid/oiml/root_number_spec.rb.
+        def number
+          date&.year&.to_s
+        end
+
+        # The index key above is deliberately coarse — a whole volume in one
+        # bucket — which is only defensible because the MR slug stays
+        # per-article. The inherited hook reads through `code`, which Bulletin
+        # does not have, so it would return nil and collapse every article of a
+        # year onto `oiml.bulletin.<year>`; `to_slug` is an output FILENAME, so
+        # that is an overwrite. Emit the rest of the locator instead.
+        #
+        # The year is deliberately NOT included: Renderers::MrString already
+        # gives it its own segment (`mr_year`), so repeating it here would
+        # render `oiml.bulletin.1960-03-01.1960`.
+        def mr_number_with_part
+          segments = [issue, sequence].compact
+          return nil if segments.empty?
+
+          segments.join("-")
+        end
+
+        def type_string
+          "Bulletin"
+        end
+
+        # Volume as an arabic string ("67"), derived from the year. nil when
+        # the year is absent (bare periodical reference).
+        def volume_arabic
+          return nil unless date&.year
+
+          (date.year.to_i - BASE_YEAR_OFFSET).to_s
+        end
+
+        # Volume as a roman-numeral string ("LXVII"), derived from the year.
+        # nil when the year is absent.
+        def volume_roman
+          number = volume_arabic&.to_i
+          return nil unless number&.positive?
+
+          self.class.to_roman(number)
+        end
+
+        # 8-digit oiml.org article id ("20260211"). Composed by concatenating
+        # year + issue + sequence. nil unless all three are present.
+        def article_id
+          return nil unless date&.year && issue && sequence
+
+          "#{date.year}#{issue}#{sequence}"
+        end
+
+        class << self
+          # Convert a positive integer to its roman-numeral representation.
+          # Used to render the citation form. The dataset already stores the
+          # roman volume verbatim in `extent.locality`, so this conversion is
+          # only needed when rendering from the structured form.
+          def to_roman(number)
+            raise ArgumentError, "volume must be > 0" unless number.positive?
+
+            ROMAN_TABLE.each_with_object(+"") do |(value, sym), result|
+              quotient, number = number.divmod(value)
+              result << (sym * quotient)
+            end.freeze
+          end
+
+          ROMAN_TABLE = [
+            [1000, "M"], [900, "CM"], [500, "D"], [400, "CD"],
+            [100, "C"], [90, "XC"], [50, "L"], [40, "XL"],
+            [10, "X"], [9, "IX"], [5, "V"], [4, "IV"],
+            [1, "I"]
+          ].freeze
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/code_number.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # Installs the flat, index-friendly code columns and their serialization
+      # on the seven concrete OIML document leaves (Recommendation, Document,
+      # Vocabulary, Guide, BasicPublication, ExpertReport, SeminarReport).
+      #
+      # Why the leaves and not Pubid::Oiml::SingleIdentifier, which they all
+      # inherit from: `number` redefines the parent ::Pubid::Identifier's
+      # `attribute :number, Components::Code` as a plain :string (and `part` /
+      # `subpart` likewise). Declaring that on a class the concrete types
+      # INHERIT from resolves against the parent definition nondeterministically
+      # under multi-flavor load — it passes an OIML-only run and can flip
+      # `root.number` to "" under the full suite (the IEEE lesson; see
+      # lib/pubid/ieee/identifiers/code_number.rb and CLAUDE.md). Declaring on
+      # each leaf removes the ambiguity at the point of use.
+      #
+      # This matters because relaton-index sorts and bsearches every row on
+      # `id.root.number.to_s`. OIML kept the code in an Oiml::Components::Code
+      # under a `code` attribute and never set `number`, so all 12,226 lines of
+      # the published relaton-data-oiml index-v2 keyed "".
+      #
+      # The serialized hash ALREADY had these as bare top-level scalars — the
+      # old converters merely read them through `code` — so the wire format is
+      # byte-identical and that index needs no regeneration.
+      #
+      # Bulletin deliberately does NOT include this module. It carries no code
+      # at all (its locator is the year/issue/sequence tuple), so it would only
+      # gain a permanently-nil `number` and a `number` key that never appears.
+      # It derives its index key from the year instead; see bulletin.rb.
+      module CodeNumber
+        def self.included(base)
+          install_attributes(base)
+          install_mappings(base)
+        end
+
+        def self.install_attributes(base)
+          # Bare document number ("144"), the relaton index key. The part is a
+          # sibling column, never folded in, so every part of a document shares
+          # one bucket and a part-less reference finds them all.
+          base.attribute :number, :string
+          base.attribute :part, :string
+          base.attribute :subpart, :string
+          # Free-form trailing suffix glued to the code, e.g. "sup", "A",
+          # "erratum", "GUM 1", "ISO3930". Preserved verbatim for round-trip.
+          base.attribute :suffix, :string
+          # When true the suffix is space-separated ("D 1 Brochure") rather
+          # than the default dash ("R 60-sup"). Named for the RARE case with a
+          # false default, so the canonical to_hash drops it from every
+          # ordinary row.
+          base.attribute :space_suffix, :boolean, default: -> { false }
+        end
+
+        # Merged by lutaml with the block SingleIdentifier declares, which
+        # carries publisher/year/edition/stage/iteration.
+        def self.install_mappings(base)
+          base.key_value do
+            map "number", to: :number
+            map "part", to: :part
+            map "subpart", to: :subpart
+            map "suffix", to: :suffix
+            map "space_suffix", to: :space_suffix
+          end
+        end
+
+        # The composed document code, rebuilt on demand from the split columns
+        # so the renderer and the URN generator keep one place to ask for the
+        # printed form ("144-1", "60-sup"). Deliberately NOT an attribute and
+        # NOT memoised: the columns are writable (the base #exclude rebuilds
+        # through them), so a cached Code would go stale.
+        #
+        # nil when there is no number, preserving the old nil-`code` semantics
+        # the URN generator branches on.
+        def code
+          return nil if number.nil?
+
+          Components::Code.new(
+            number: number,
+            part: part,
+            subpart: subpart,
+            suffix: suffix,
+            space_suffix: space_suffix,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/document.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Document < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "D"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/errata.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      # Errata supplement, used by the trailing-word shorthand
+      # "OIML R 126:2015 Errata" (the publication year lives on the base).
+      class Errata < SupplementIdentifier
+        def supplement_type
+          "Errata"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/expert_report.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class ExpertReport < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "E"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/guide.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Guide < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "G"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/recommendation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Recommendation < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "R"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/seminar_report.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class SeminarReport < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "S"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers/vocabulary.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      class Vocabulary < SingleIdentifier
+        include CodeNumber
+
+        def type_string
+          "V"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/oiml/identifiers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    module Identifiers
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
+      autoload :Annex, "#{__dir__}/identifiers/annex"
+      autoload :BasicPublication, "#{__dir__}/identifiers/basic_publication"
+      autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :CodeNumber, "#{__dir__}/identifiers/code_number"
+      autoload :Document, "#{__dir__}/identifiers/document"
+      autoload :Errata, "#{__dir__}/identifiers/errata"
+      autoload :ExpertReport, "#{__dir__}/identifiers/expert_report"
+      autoload :Guide, "#{__dir__}/identifiers/guide"
+      autoload :Recommendation, "#{__dir__}/identifiers/recommendation"
+      autoload :SeminarReport, "#{__dir__}/identifiers/seminar_report"
+      autoload :Vocabulary, "#{__dir__}/identifiers/vocabulary"
+    end
+  end
+end