pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/oiml/parser.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Oiml
+    class Parser < ::Pubid::Parser::Grammar
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      root :identifier
+
+      # Additional basic rules not in CommonParseRules
+      rule(:colon) { str(":") }
+      rule(:lparen) { str("(") }
+      rule(:rparen) { str(")") }
+      rule(:slash) { str("/") }
+
+      # Main identifier pattern - check supplements first
+      rule(:identifier) do
+        amendment_identifier | amendment_short | annex_letter_identifier |
+          annex_identifier | plus_supplement_identifier |
+          trailing_supplement_identifier | bulletin_identifier | base
+      end
+
+      # Publisher - always "OIML"
+      rule(:publisher) { str("OIML").as(:publisher) >> space }
+
+      # Document type - single letter
+      rule(:doc_type) { match("[BDEGRSVX]").as(:type) >> space }
+
+      # Bulletin locator — structured form. Year optionally followed by
+      # 2-digit issue and 2-digit sequence:
+      #   "OIML Bulletin", "OIML Bulletin 1960",
+      #   "OIML Bulletin 1960-03", "OIML Bulletin 1960-03-01"
+      # All four shapes appear as primary docids in relaton-data-oiml.
+      rule(:bulletin_date) do
+        space >> year_digits.as(:year) >>
+          (dash >> two_digits.as(:issue)).maybe >>
+          (dash >> two_digits.as(:sequence)).maybe
+      end
+
+      # Two-digit zero-padded number (used for issue / sequence).
+      rule(:two_digits) { match('\d').repeat(2, 2) }
+
+      # Roman numeral token composed of I,V,X,L,C,D,M (uppercase, matching
+      # OIML's print convention). Captured so the builder can cross-check
+      # the declared volume against the year implied by the article_id.
+      rule(:roman_numeral) { match("[IVXLCDM]").repeat(1).as(:volume_roman) }
+
+      # Bulletin locator — citation form. The format OIML prints on the
+      # article page is: "LXVII(2) 20260211" where LXVII is the volume in
+      # roman numerals, (2) is the issue in arabic without zero padding,
+      # and 20260211 is the 8-digit oiml.org article id (YYYYNNSS).
+      rule(:bulletin_citation) do
+        space >> roman_numeral >>
+          lparen >> digits.as(:issue_arabic) >> rparen >>
+          space >> match('\d').repeat(8, 8).as(:article_id)
+      end
+
+      # Bulletin identifier — no code; the locator (when present) is the
+      # (year, issue, sequence) tuple drawn from either the structured
+      # YYYY-II-SS form or the citation VOLUME(ISSUE) ARTID form. Both
+      # decode to the same record. Tried before base because
+      # "Bulletin" is a word that the single-letter doc_type rule cannot
+      # match.
+      rule(:bulletin_identifier) do
+        publisher >> str("Bulletin").as(:type) >>
+          (bulletin_citation | bulletin_date).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Number with optional part and subpart
+      rule(:number_only) { digits.as(:number) }
+
+      # Part number, optionally a slashed multi-part continuation captured
+      # verbatim, e.g. "1/-2" in "OIML R 46-1/-2:2012".
+      rule(:part_number) do
+        dash >> (digits >> (slash >> dash >> digits).repeat).as(:part)
+      end
+
+      rule(:subpart_number) { dash >> digits.as(:subpart) }
+
+      # Free-form named/lettered code suffix glued after the numeric part:
+      #   -GUM 1, -special, -sup, -erratum, -A, -ISO3930, -Amend, -Amended_2012
+      # plus the space-separated "Brochure" label. "GUM <n>" is tried first so
+      # its trailing number isn't lost to the bare-word alternative. The
+      # trailing `(_?digits)*` captures joint codes ("ISO3930") and the
+      # "Amended_2012" amendment label (the hand-off treats these as part
+      # suffixes, preserved verbatim for round-trip).
+      rule(:named_suffix) do
+        (dash >> (
+          (str("GUM") >> space >> digits) |
+          (match("[A-Za-z]").repeat(1) >> (str("_").maybe >> digits).repeat)
+        ).as(:code_suffix)) |
+          (space >> str("Brochure").as(:code_suffix) >> str("").as(:space_suffix))
+      end
+
+      rule(:full_number) do
+        (number_only >> part_number >> subpart_number >> named_suffix.maybe) |
+          (number_only >> part_number >> named_suffix.maybe) |
+          (number_only >> named_suffix.maybe)
+      end
+
+      # Edition number - ordinal numbers
+      rule(:edition_number) do
+        (
+          str("6th") | str("5th") | str("4th") | str("3rd") |
+          str("2nd") | str("1st") |
+          (digits >> (str("th") | str("nd") | str("rd") | str("st")))
+        ).as(:edition)
+      end
+
+      # Edition text - uppercase or lowercase
+      rule(:edition_text) { str("Edition") | str("edition") }
+
+      # Edition portion - handles "6th Edition 2015" or "Edition 2013" or ", edition 1992"
+      rule(:edition_portion) do
+        (
+          (str(", ") | space) >>
+          edition_number.maybe >> space.maybe >> edition_text >> space.maybe >> year_digits.as(:year)
+        ).as(:edition_format) # Wrap entire match to capture that Edition was used
+      end
+
+      # Date - year after colon OR edition portion (with optional space before year)
+      rule(:date) do
+        edition_portion | (colon >> space.maybe >> year_digits.as(:year))
+      end
+
+      # Draft stage - WD or CD with optional iteration
+      rule(:stage_iteration) do
+        (
+          (digits >> str(".") >> digits) | # 3.1
+          digits # 1, 2, 3
+        ).as(:iteration)
+      end
+
+      rule(:stage_abbr) do
+        (str("WD") | str("CD")).as(:stage)
+      end
+
+      rule(:draft_stage) do
+        space >> stage_iteration.maybe >> stage_abbr
+      end
+
+      # Language codes
+      #
+      # relaton-data-oiml encodes the publication language with its own code
+      # set (lib/oiml_fetcher.rb DOCID_LANG_CODE): single uppercase letters
+      # E F D R S C A U X, plus two-letter PO/PT/PE/SR. The two-letter OIML
+      # codes must be tried before the single-letter rule so e.g. "PE" isn't
+      # left with a dangling "E".
+      rule(:lang_single) do
+        match("[EFRXDSCAU]")
+      end
+
+      rule(:lang_multi_oiml) do
+        str("PO") | str("PT") | str("PE") | str("SR")
+      end
+
+      rule(:lang_multi) do
+        match("[a-z]").repeat(2, 2) # Two letters: en, fr, etc.
+      end
+
+      rule(:language_code) do
+        (
+          (lang_single >> slash >> lang_single) | # E/F
+          lang_multi_oiml |                        # PO, PT, PE, SR
+          lang_single |                            # E, F, D, R, S, C, A, U, X
+          lang_multi                               # en, fr
+        ).as(:language)
+      end
+
+      rule(:language_with_space) do
+        space >> lparen >> language_code >> rparen >> str("").as(:space_before_lang)
+      end
+
+      rule(:language_without_space) do
+        lparen >> language_code >> rparen
+      end
+
+      rule(:language_portion) do
+        language_with_space | language_without_space
+      end
+
+      # Amendment identifier - "Amendment (YYYY) to BASE"
+      rule(:amendment_identifier) do
+        str("Amendment") >> space >> lparen >> year_digits.as(:year) >> rparen >>
+          space >> str("to") >> space >>
+          base_without_language.as(:base) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Short amendment forms - "OIML TYPE NUMBER Amendment Edition YYYY" or "Amendment: YYYY"
+      rule(:amendment_short) do
+        publisher >>
+          doc_type >>
+          full_number.as(:base_code) >>
+          space >> str("Amendment").as(:amd_marker) >>
+          (
+            (space >> edition_text >> space.maybe >> year_digits.as(:year)).as(:edition_format) |
+            (colon >> space.maybe >> year_digits.as(:year))
+          ) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Trailing supplement word - "BASE Amendment" / "BASE Errata" where the
+      # publication year stays on the base (e.g. "OIML R 138:2009 Amendment").
+      # amendment_short is tried first; it only matches when a year follows the
+      # word, so the no-year trailing form falls through to here.
+      rule(:trailing_supplement_identifier) do
+        base_without_language.as(:base) >>
+          space >> (str("Amendment") | str("Errata")).as(:trailing_marker) >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Plus-joined supplement - "BASE:YEAR+Supplement:YEAR" form where both
+      # the base and the supplement carry their own year. Used for amendments
+      # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
+      # Annexes already encode the year-on-base intent via their own model.
+      rule(:plus_supplement_identifier) do
+        base_without_language.as(:base) >>
+          str("+") >>
+          (str("Amendment") | str("Errata")).as(:plus_marker) >>
+          (colon >> year_digits.as(:year)).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
+      # "BASE:YYYY Annexes" (year on the base, no annex year).
+      rule(:annex_identifier) do
+        base_without_language.as(:base) >>
+          space >> str("Annexes").as(:annex_marker) >>
+          (
+            (space >> edition_text >> space >> year_digits.as(:year)).as(:edition_format) |
+            (colon >> year_digits.as(:year))
+          ).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Annex letter or letter range, e.g. "A" or "B-C".
+      rule(:annex_letter_value) do
+        (match("[A-Z]") >> (dash >> match("[A-Z]")).maybe).as(:annex_letter)
+      end
+
+      # Annex with letter - "BASE Annex A Edition YYYY" / "BASE:YYYY Annex B-C"
+      rule(:annex_letter_identifier) do
+        base_without_language.as(:base) >>
+          space >> str("Annex") >> space >> annex_letter_value >>
+          ((space >> edition_text >> space >> year_digits.as(:year)) | (colon >> year_digits.as(:year))).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
+      # Base identifier without language (for use in supplements)
+      rule(:base_without_language) do
+        publisher >>
+          doc_type >>
+          full_number >>
+          date.maybe >>
+          draft_stage.maybe
+      end
+
+      # Base identifier for recursion and standalone parsing
+      rule(:base) do
+        publisher >>
+          doc_type >>
+          full_number >>
+          date.maybe >>
+          draft_stage.maybe >>
+          language_portion.maybe
+      end
+    end
+  end
+end

data/lib/pubid/oiml/renderer.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    # Human-readable renderer for OIML identifiers.
+    #
+    # Produces strings like:
+    #   "OIML R 60:2000"
+    #   "OIML R 60 Edition 2013"
+    #   "OIML R 60 Annex A Edition 2013 (E)"
+    #   "OIML R 60 Annexes:2021 (E)"
+    #
+    # The renderer is registered as the `:human` format in the OIML format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::Annex
+          render_annex(id)
+        when Identifiers::Bulletin
+          render_bulletin(id)
+        when SupplementIdentifier
+          render_supplement(id)
+        when SingleIdentifier
+          render_single(id)
+        else
+          id.to_s
+        end
+      end
+
+      private
+
+      # Render the Bulletin in the requested or parsed form. Default is the
+      # structured "YYYY-II-SS" form (the dataset's primary docid). The
+      # citation form ("LXVII(2) 20260211") is emitted when the user asks
+      # for it via `to_s(format: :citation)` or when the identifier was
+      # itself parsed from a citation string (parsed_format == "citation").
+      def render_bulletin(id)
+        if citation_form?(id)
+          render_bulletin_citation(id)
+        else
+          render_bulletin_structured(id)
+        end
+      end
+
+      # User's explicit format request takes precedence over the parsed
+      # form, so `parse("LXVII(2) 20260211").to_s(format: :short)` returns
+      # the structured form. With no explicit request, the parsed form is
+      # preserved for round-trip fidelity.
+      def citation_form?(id)
+        case id.requested_format
+        when :citation then true
+        when :short, :structured then false
+        else
+          id.parsed_format == "citation"
+        end
+      end
+
+      # "OIML Bulletin" / "OIML Bulletin 1960" / "OIML Bulletin 1960-03" /
+      # "OIML Bulletin 1960-03-01". No code; the locator is space-separated.
+      def render_bulletin_structured(id)
+        result = "#{id.publisher} Bulletin"
+        if id.date&.year
+          result += " #{id.date.year}"
+          result += "-#{id.issue}" if id.issue
+          result += "-#{id.sequence}" if id.sequence
+        end
+        result += " (#{id.language})" if id.language
+        result
+      end
+
+      # "OIML Bulletin LXVII(2) 20260211". Only emitted for full articles
+      # (year + issue + sequence all present); lower tiers fall back to
+      # structured since OIML's citation format doesn't define volume-only
+      # or issue-only variants.
+      def render_bulletin_citation(id)
+        return render_bulletin_structured(id) unless id.date&.year && id.issue && id.sequence
+
+        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.issue.to_i}) #{id.article_id}"
+      end
+
+      def effective_format(id)
+        id.requested_format ||
+          (id.parsed_format == "long" ? :long : :short)
+      end
+
+      # Strip a trailing language group "(...)" from a rendered base string so
+      # the supplement can re-attach its own language at the end.
+      def strip_language(str)
+        str.sub(/\s*\([^)]+\)\s*$/, "").strip
+      end
+
+      def render_single(id)
+        format = effective_format(id)
+
+        result = "#{id.publisher} #{id.type_string} #{id.code}"
+
+        using_edition_format = false
+
+        if id.edition && id.date
+          result += " #{id.edition} Edition #{id.date.render(context: @context)}"
+          using_edition_format = true
+        elsif id.edition
+          result += " #{id.edition}"
+          using_edition_format = true
+        elsif id.date
+          if format == :long
+            result += " Edition #{id.date.render(context: @context)}"
+            using_edition_format = true
+          else
+            result += ":#{id.date.render(context: @context)}"
+          end
+        end
+
+        if id.stage || id.iteration
+          result += " "
+          result += id.iteration.to_s if id.iteration
+          result += id.stage.to_s if id.stage
+        end
+
+        if id.language
+          result += if using_edition_format || id.parsed_format == "short_with_space"
+                      " (#{id.language})"
+                    else
+                      "(#{id.language})"
+                    end
+        end
+
+        result
+      end
+
+      def render_supplement(id)
+        format = effective_format(id)
+
+        # Plus-joined: "BASE+Amendment:YEAR" / "BASE+Errata:YEAR" with both
+        # the base and the supplement carrying their own year.
+        if id.joined
+          base_str = strip_language(id.base.to_s)
+          result = "#{base_str}+#{id.supplement_type}"
+          result += ":#{id.year}" if id.year
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
+        # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
+        # publication year kept on the base identifier. The word comes from the
+        # concrete supplement class.
+        if id.trailing
+          base_str = strip_language(id.base.to_s)
+          result = "#{base_str} #{id.supplement_type}"
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
+        base_format = if format && format != :short
+                        format
+                      elsif id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        base_str = if id.base.is_a?(SingleIdentifier)
+                     id.base.to_s(format: base_format)
+                   else
+                     id.base.to_s
+                   end
+        base_str = strip_language(base_str)
+
+        result = "#{id.supplement_type} (#{id.year}) to #{base_str}"
+        result += " (#{id.language})" if id.language
+
+        result
+      end
+
+      def render_annex(id)
+        format = effective_format(id)
+
+        # "BASE:YYYY Annex(es)" — the year is glued to the base, the marker
+        # carries none. Keep the base date instead of stripping it.
+        if id.year_on_base
+          base_str = strip_language(id.base.to_s)
+          marker = id.letter ? "Annex #{id.letter}" : "Annexes"
+          result = "#{base_str} #{marker}"
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
+        base_format = if id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        annex_format = if format
+                         format
+                       elsif id.class.attributes.key?(:parsed_format) && id.parsed_format == "long"
+                         :long
+                       else
+                         :short
+                       end
+
+        base_str = if id.base.is_a?(SingleIdentifier)
+                     id.base.to_s(format: base_format)
+                   else
+                     id.base.to_s
+                   end
+        result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
+          /\(.*\)/, ""
+        ).strip
+
+        if id.letter
+          result += " Annex #{id.letter}"
+          result += " Edition #{id.year}" if id.year
+        else
+          result += " Annexes"
+          if id.year
+            result += annex_format == :long ? " Edition #{id.year}" : ":#{id.year}"
+          elsif id.base.date
+            result += annex_format == :long ? " Edition #{id.base.date.render(context: @context)}" : ":#{id.base.date.render(context: @context)}"
+          end
+        end
+
+        result += " (#{id.language})" if id.language
+        result
+      end
+    end
+  end
+end

data/lib/pubid/oiml/single_identifier.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class SingleIdentifier < Identifier
+      # Base class for OIML single identifiers (non-supplements)
+      attribute :publisher, :string
+      attribute :date, Pubid::Components::Date
+      attribute :edition, :string
+      attribute :stage, :string
+      attribute :iteration, :string
+      attribute :language, :string
+      attribute :parsed_format, :string, default: -> {
+        "short"
+      } # Track parsed format
+
+      # Serialization delta on top of Oiml::Identifier's shared block. The
+      # `date` (year) component is flattened to a top-level key rather than a
+      # nested hash, mirroring ISO (lib/pubid/iso/identifier.rb). `type` is
+      # intentionally omitted (recomputed from the class on load).
+      #
+      # The code columns (number/part/subpart/suffix/space_suffix) are NOT
+      # here: they are declared, and mapped, by Identifiers::CodeNumber on each
+      # concrete leaf, because redefining the inherited `number` on this class
+      # — which every leaf inherits — is the multi-flavor determinism landmine.
+      # Keeping the mapping with the attribute is also what lets Bulletin, the
+      # one leaf with no code, omit both.
+      key_value do
+        map "publisher", to: :publisher
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "edition", to: :edition
+        map "stage", to: :stage
+        map "iteration", to: :iteration
+      end
+
+      # --- date flattened to a top-level year ---
+      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
+
+      def year_from_kv(model, value)
+        (model.date ||= Pubid::Components::Date.new).year = value.to_s
+      end
+
+      def emit_kv(doc, key, value)
+        return if value.nil? || value.to_s.empty?
+
+        doc.add_child(Lutaml::KeyValue::DataModel::Element.new(key, value.to_s))
+      end
+
+      attr_reader :requested_format
+
+      # Type is determined by the subclass
+      def type
+        type_string
+      end
+
+      def to_s(format: nil, **opts)
+        # Store requested format so the renderer can access it
+        @requested_format = format
+        render(format: :human, **opts)
+      end
+
+      def edition_portion
+        # Deprecated - kept for compatibility
+        # Use to_s(format: :long) instead
+        if edition && date
+          "#{edition} Edition #{date.year}"
+        elsif date
+          "Edition #{date.year}"
+        else
+          edition
+        end
+      end
+
+      # Subclasses override this
+      def type_string
+        raise NotImplementedError, "Subclasses must implement type_string"
+      end
+
+      # OIML keeps identity in the code columns and `type_string` (e.g. "R",
+      # "V", "D"), not in the inherited `typed_stage` — the generic MrString
+      # renderer would otherwise drop both and produce `OIML.<year>`.
+      # Losslessness for issue #142 requires the type letter and document
+      # number to appear in MR.
+      #
+      # Reads through `code`, which every code-bearing leaf composes from its
+      # split columns (Identifiers::CodeNumber); Bulletin has no code and
+      # returns nil here, keeping its (year, issue, sequence) slug.
+      def mr_number_with_part
+        segments = []
+        segments << code&.number&.to_s if code&.number
+        segments << code&.part&.to_s if code&.part
+        segments << code&.subpart&.to_s if code&.subpart
+        segments << code&.suffix&.to_s if code&.suffix
+        return nil if segments.empty?
+
+        segments.join("-")
+      end
+
+      # Bulletin overrides `code`; every other leaf gets it from
+      # Identifiers::CodeNumber. Returning nil here keeps #== , the renderer
+      # and the URN generator total for the abstract class itself.
+      def code
+        nil
+      end
+
+      def mr_type
+        type_string&.downcase
+      end
+
+      # Subclasses override this
+    end
+  end
+end