pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/jcgm/parser.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Jcgm
+    class Parser < ::Pubid::Parser::Grammar
+      include ::Pubid::Parser::CommonParseRules
+      include ::Pubid::Parser::CommonParseMethods
+
+      root :identifier
+
+      rule(:identifier) do
+        meeting_identifier | amendment_identifier | corrigendum_identifier |
+          numbered_corrigendum_identifier | base | named_guide_identifier
+      end
+
+      # "JCGM 200:2008 Corrigendum" — a base guide plus a trailing
+      # " Corrigendum" word (no number). Must precede base: Parslet
+      # is an ordered PEG that commits to the first matching alternative, so if
+      # base ran first it would consume "JCGM 200:2008" and root
+      # would fail on the leftover " Corrigendum". Emits type_with_stage so the
+      # builder routes it to Corrigendum.
+      rule(:corrigendum_identifier) do
+        base.as(:base) >> space >>
+          str("Corrigendum").as(:type_with_stage)
+      end
+
+      # "JCGM 101:2008/Cor 1:2009" — a base guide plus a slash-separated
+      # numbered corrigendum (mirrors the ISO/IEC supplement form). The
+      # trailing :YYYY is optional so "JCGM 101:2008/Cor 1" also parses.
+      # Must precede base for the same PEG-commit reason as corrigendum_identifier.
+      rule(:numbered_corrigendum_identifier) do
+        base.as(:base) >>
+          str("/") >> str("Cor").as(:type_with_stage) >>
+          space >> digits.as(:number) >>
+          corrigendum_date.maybe
+      end
+
+      # Dateless "named" guides: "JCGM GUM", "JCGM VIM-3" (and future "VIM-N").
+      # Last in the alternation — only reached when base fully fails
+      # (these have no date, so number_portion/date_portion never match).
+      rule(:named_guide_identifier) do
+        publisher >> space >> named_number
+      end
+
+      rule(:named_number) do
+        (str("GUM") | (str("VIM") >> (str("-") >> digits).maybe)).as(:number)
+      end
+
+      # Committee/meeting record, e.g. "JCGM 17th Meeting (2012)". Diverges
+      # from base right after the digits (base wants ":", meeting
+      # wants the ordinal suffix), so ordered choice is unambiguous. Emits the
+      # same tokens as a guide plus type_with_stage "Meeting", so the generic
+      # builder path resolves it to Identifiers::Meeting (like "Amd").
+      #
+      # The trailing " (YYYY)" group is optional, so the partial reference
+      # "JCGM 11st Meeting" parses with `date` left nil. JCGM numbers its
+      # meetings in one sequence, so the ordinal alone names the event and the
+      # year is redundant detail. The whole group is `.maybe` (not the year
+      # inside it), so a dangling "(" or a truncated year still fails —
+      # the same shape as `date_portion.maybe` in `rule(:base)`.
+      rule(:meeting_identifier) do
+        publisher >> space >> digits.as(:number) >> ordinal_suffix >>
+          space >> str("Meeting").as(:type_with_stage) >>
+          (space >> str("(") >> year_digits.as(:date) >> str(")")).maybe
+      end
+
+      rule(:ordinal_suffix) do
+        str("st") | str("nd") | str("rd") | str("th")
+      end
+
+      # `date_portion` is optional so a partial reference that omits the
+      # trailing `:YYYY` date (e.g. "JCGM 100") parses with `date` left nil,
+      # letting relaton match a collection via `matches?(row, ignore: [:date])`.
+      # The whole sub-rule is `.maybe` (not the year inside it) so a dangling
+      # ":" still fails. Mirrors ETSI (lib/pubid/etsi/parser.rb).
+      rule(:base) do
+        publisher >> space >> number_portion >>
+          date_portion.maybe >> language_portion.maybe
+      end
+
+      rule(:amendment_identifier) do
+        base.as(:base) >>
+          str("/") >> amendment_type >>
+          space >> digits.as(:number) >>
+          amendment_date.maybe
+      end
+
+      rule(:publisher) do
+        str("JCGM").as(:publisher)
+      end
+
+      # Number can be plain (100, 200) or GUM-prefixed (GUM-1, GUM-6)
+      rule(:number_portion) do
+        gum_number | standard_number
+      end
+
+      rule(:standard_number) do
+        digits.as(:number)
+      end
+
+      rule(:gum_number) do
+        str("GUM-") >> digits.as(:gum_number)
+      end
+
+      # Date can be YYYY or YYYY-MM-DD
+      rule(:date_portion) do
+        str(":") >> (full_date | year_only)
+      end
+
+      rule(:year_only) do
+        year_digits.as(:date)
+      end
+
+      rule(:full_date) do
+        (year_digits >> str("-") >> month_digits >> str("-") >> day_digits).as(:date)
+      end
+
+      # Language: "(E)", "(F)", "(E/F)", "(F/E)"
+      rule(:language_portion) do
+        str("(") >>
+          (
+            # Multi-language: E/F, F/E
+            (str("E/F") | str("F/E")) |
+            # Single language: E, F, R, etc.
+            match("[A-Z]")
+          ).as(:languages) >>
+          str(")")
+      end
+
+      # Amendment support
+      rule(:amendment_type) do
+        str("Amd").as(:type_with_stage)
+      end
+
+      rule(:amendment_number) do
+        digits.as(:number)
+      end
+
+      rule(:amendment_date) do
+        str(":") >> (full_date | year_only)
+      end
+
+      # Numbered corrigendum date: same shape as amendment_date.
+      rule(:corrigendum_date) do
+        str(":") >> (full_date | year_only)
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/renderer.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Human-readable renderer for JCGM identifiers.
+    #
+    # Produces strings like:
+    #   "JCGM 100:2008"
+    #   "JCGM 100:2008/Amd 1:2023"
+    #   "JCGM GUM-6:2020"
+    #
+    # The renderer is registered as the `:human` format in the JCGM format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        case @id
+        when Identifiers::Amendment then render_amendment(@id, context)
+        when Identifiers::Corrigendum then render_corrigendum(@id)
+        when Identifiers::GumGuide then render_gum_guide(@id, context)
+        when Identifiers::Meeting then render_meeting(@id)
+        else render_single(@id)
+        end
+      end
+
+      private
+
+      def render_corrigendum(id)
+        # Two surface forms:
+        #   "JCGM 200:2008 Corrigendum"  — number absent (word form)
+        #   "JCGM 101:2008/Cor 1:2009"   — number present (numbered form)
+        return "#{id.base}/Cor #{id.number}#{corrigendum_date_suffix(id)}" if id.number
+
+        "#{id.base} Corrigendum"
+      end
+
+      def corrigendum_date_suffix(id)
+        id.date ? ":#{id.date}" : ""
+      end
+
+      # Two surface forms:
+      #   "JCGM 17th Meeting (2012)"  — date present (published records)
+      #   "JCGM 17th Meeting"         — date absent (partial reference)
+      # The ordinal alone names the meeting, so the dateless form is a valid
+      # identifier and must stay re-parseable (the parser makes the " (YYYY)"
+      # group optional to match).
+      def render_meeting(id)
+        base = "JCGM #{id.ordinal} Meeting"
+        id.date ? "#{base} (#{id.date.year})" : base
+      end
+
+      def render_single(id)
+        parts = [id.publisher_portion]
+        parts << id.number_portion unless id.number_portion.empty?
+        result = parts.join(" ")
+        result += id.language_portion if id.languages&.any?
+        result
+      end
+
+      def render_amendment(id, context)
+        result = id.base.to_s if id.base
+        result += "/Amd"
+        result += " #{id.number}" if id.number
+        result += ":#{id.date}" if id.date
+        result
+      end
+
+      def render_gum_guide(id, context)
+        parts = []
+        parts << id.publisher.publisher if id.publisher
+        parts << "GUM-#{id.number}" if id.number
+
+        result = parts.join(" ")
+        result += ":#{id.date}" if id.date
+        result += gum_language_portion(id) if id.languages&.any?
+        result
+      end
+
+      def gum_language_portion(id)
+        return "" unless id.languages&.any?
+
+        codes = id.languages.map do |lang|
+          lang.original_code || lang.code
+        end
+
+        "(#{codes.join('/')})"
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/single_identifier.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class SingleIdentifier < Identifier
+      attribute :publisher, Jcgm::Components::Publisher,
+                default: -> { self.class.default_publisher }
+      attribute :typed_stage, Pubid::Components::TypedStage,
+                default: -> { self.class.published_typed_stage }
+      attribute :date, Pubid::Components::Date
+      attribute :languages, Pubid::Components::Language, collection: true
+      attribute :stage, Pubid::Components::Stage
+      attribute :type, Pubid::Components::Type
+
+      # Compact serialization: only per-instance information is mapped. The
+      # publisher (always "JCGM") and the derived type / stage / typed_stage
+      # (fully determined by the class, i.e. `_type`) are intentionally NOT
+      # mapped — they are reconstructed from the class on load via the
+      # attribute defaults above. Components collapse to bare scalars:
+      # number is already a bare :string; date -> year/month/day scalars.
+      # Mirrors ISO (lib/pubid/iso/identifier.rb) and OIML.
+      key_value do
+        map "_type", to: :_type
+        map "number", with: { to: :number_to_kv, from: :number_from_kv }
+        map "year", with: { to: :year_to_kv, from: :year_from_kv }
+        map "month", with: { to: :month_to_kv, from: :month_from_kv }
+        map "day", with: { to: :day_to_kv, from: :day_from_kv }
+        map "languages", to: :languages
+      end
+
+      # The publisher implied when none is serialized — always JCGM.
+      def self.default_publisher
+        Jcgm::Components::Publisher.new(publisher: Jcgm::PREFIXES.first)
+      end
+
+      # The class's published typed_stage (canonical surface form). Each JCGM
+      # class registers exactly one, all :published; `_type` fixes the class,
+      # so an omitted typed_stage reconstructs deterministically on from_hash.
+      #
+      # `original_abbr` is deliberately LEFT NIL. It records the spelling the
+      # input used and is not serialized, so it cannot survive a round trip —
+      # and this method is one of the two paths that fill `typed_stage`. The
+      # other is the parse path (`Builder#locate_typed_stage` ->
+      # `Jcgm.locate_stage`), which returns the registry entry untouched.
+      # Setting it here made the two disagree, so `from_hash(to_hash) != parse`
+      # for every type the grammar tags (Meeting, Corrigendum, Amendment) —
+      # and because `#matches?` is `exclude(...) == other.exclude(...)`, a
+      # relaton index lookup then silently matched nothing. Nothing in JCGM
+      # reads the field: the renderer hardcodes its surface words, the URN
+      # generator reads only `type_code`, and `TypedStage#abbreviation` chooses
+      # among long_abbr/short_abbr/abbr.first. Recording the *matched* token
+      # instead would not work either — "/Cor 1" would store "Cor" where
+      # from_hash rebuilds "Corrigendum".
+      def self.published_typed_stage
+        return nil unless const_defined?(:TYPED_STAGES)
+
+        ts = self::TYPED_STAGES.find { |t| t.stage_code.to_s == "published" }
+        # dup: locate_stage hands out the shared object from the frozen
+        # TYPED_STAGES array (the array is frozen, its elements are not), so a
+        # future in-place mutation would otherwise leak globally.
+        ts&.dup
+      end
+
+      # type and stage are derived from typed_stage, never stored — so the
+      # doctype (fixed by the class / _type) is not carried in the hash.
+      def type
+        typed_stage&.to_type
+      end
+
+      def stage
+        typed_stage&.to_stage
+      end
+
+      # --- number ---
+      def number_to_kv(model, doc) = emit_kv(doc, "number", model.number)
+      def number_from_kv(model, value) = model.number = value.to_s
+
+      # --- date flattened to top-level year/month/day scalars ---
+      def year_to_kv(model, doc) = emit_kv(doc, "year", model.date&.year)
+      def month_to_kv(model, doc) = emit_kv(doc, "month", model.date&.month)
+      def day_to_kv(model, doc) = emit_kv(doc, "day", model.date&.day)
+      def year_from_kv(model, value) = date_for(model).year = value.to_s
+      def month_from_kv(model, value) = date_for(model).month = value.to_s
+      def day_from_kv(model, value) = date_for(model).day = value.to_s
+
+      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
+
+      def date_for(model)
+        model.date ||= Pubid::Components::Date.new
+      end
+
+      def publisher_portion
+        publisher.to_s
+      end
+
+      def number_portion
+        parts = []
+        parts << number if number
+        parts << ":#{date.year}" if date
+        parts.join
+      end
+
+      def language_portion
+        return "" unless languages&.any?
+
+        [
+          "(",
+          languages.map(&:original_code).join("/"),
+          ")",
+        ].join
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/supplement_identifier.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    # Base class for JCGM supplement identifiers (amendments, corrigenda, etc.)
+    #
+    # The supplement's OWN number (the "1" in "/Cor 1", the "2" in "/Amd 2")
+    # is stored in the inherited `number` attribute — NOT a separate
+    # `iteration` attribute. Each supplement is itself a numbered document,
+    # just like the base. The base document's number is accessed via
+    # `base.number`. This mirrors how pubid-Iso models supplements.
+    class SupplementIdentifier < SingleIdentifier
+      attribute :base, Identifier, polymorphic: true
+
+      # The base document nests under the compact key "base" (mirrors ISO/JIS),
+      # serialized via its own to_hash so it collapses to {_type, number, year}.
+      # On load the sub-hash is re-dispatched through Jcgm::Identifier.from_hash,
+      # which resolves `_type` to the concrete Guide/GumGuide — a bare
+      # polymorphic cast would rebuild it as a plain Identifier and later fail
+      # on publisher_portion. This custom mapping replaces the former
+      # self.from_hash override.
+      #
+      # `number` (the supplement's own number) is mapped by SingleIdentifier's
+      # key_value block via number_to_kv / number_from_kv — no override needed.
+      key_value do
+        map "base", with: { to: :base_to_kv, from: :base_from_kv }
+      end
+
+      def base_to_kv(model, doc)
+        return unless model.base
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new(
+            "base", model.base.to_hash
+          ),
+        )
+      end
+
+      def base_from_kv(model, value)
+        return unless value
+
+        model.base = ::Pubid::Jcgm::Identifier.from_hash(value)
+      end
+
+      # Delegate publisher to base
+      def publisher
+        base&.publisher
+      end
+    end
+  end
+end

data/lib/pubid/jcgm/urn_generator.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Jcgm
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        if identifier.is_a?(Identifiers::Meeting)
+          generate_meeting_urn
+        elsif identifier.is_a?(SupplementIdentifier)
+          generate_supplement_urn
+        else
+          generate_base_urn
+        end
+      end
+
+      protected
+
+      # urn:jcgm:meeting:<number>:<year>, e.g. urn:jcgm:meeting:17:2012
+      def generate_meeting_urn
+        parts = ["urn", "jcgm", "meeting"]
+        parts << identifier.number if identifier.number
+        parts << identifier.date.year if identifier.date
+        parts.join(":")
+      end
+
+      def generate_base_urn
+        parts = ["urn", "jcgm"]
+
+        if identifier.is_a?(Identifiers::GumGuide) && identifier.number
+          parts << "gum.#{identifier.number}"
+        elsif identifier.number
+          parts << identifier.number.to_s
+        end
+
+        part = maybe(:part)
+        if part
+          p = part.to_s
+          parts << "-#{p}"
+        end
+
+        subpart = maybe(:subpart)
+        if subpart
+          sp = subpart.to_s
+          parts << "-#{sp}"
+        end
+
+        if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+          parts << identifier.date.render(context: URN_CONTEXT)
+        elsif maybe(:year)
+          parts << maybe(:year).to_s
+        end
+
+        edition = maybe(:edition)
+        if edition
+          e = edition.number || edition.to_s
+          parts << "ed.#{e}"
+        end
+
+        stage_iteration = maybe(:stage_iteration)
+        if stage_iteration
+          iter = stage_iteration.to_s
+          parts << "iter.#{iter}"
+        end
+
+        # Guide and GUM-guide are already implied by the number form (bare
+        # number vs "gum.N"), so their type_code is not appended.
+        if identifier.typed_stage
+          type_code = identifier.typed_stage.type_code
+          if type_code && !%w[guide gum_guide].include?(type_code.to_s)
+            parts << type_code.to_s
+          end
+        end
+
+        if identifier.languages&.any?
+          lang_codes = identifier.languages.map(&:code).join(",")
+          parts << lang_codes
+        end
+
+        parts.join(":")
+      end
+
+      def generate_supplement_urn
+        parts = ["urn", "jcgm"]
+
+        base_id = maybe(:base)
+        if base_id
+          base_gen = self.class.new(base_id)
+          base_urn = base_gen.generate_base_urn
+
+          base_part = base_urn.sub(/^urn:jcgm:/, "")
+          base_parts = base_part.split(":")
+
+          parts.concat(base_parts)
+
+          if identifier.typed_stage
+            supp_type = identifier.typed_stage.type_code.to_s
+            parts << supp_type if supp_type
+          end
+
+          # The supplement's own number (the "1" in "/Cor 1") — NOT iteration.
+          if identifier.number
+            parts << identifier.number.to_s
+          end
+
+          if identifier.date&.is_a?(::Pubid::Components::Date) && identifier.date.present?
+            parts << identifier.date.render(context: URN_CONTEXT)
+          end
+        else
+          parts << "unknown"
+        end
+
+        parts.join(":")
+      end
+    end
+  end
+end