pubid 2.0.0.pre.alpha.8 → 2.0.0.pre.alpha.11

data/lib/pubid/jcgm/supplement_identifier.rb

@@ -3,13 +3,48 @@
 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, Identifier, polymorphic: true
-      attribute :iteration, Pubid::Components::Code
+      attribute :base, Identifier, polymorphic: true
 
-      # Delegate publisher to base_identifier
+      # 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_identifier&.publisher
+        base&.publisher
       end
     end
   end

data/lib/pubid/jcgm/urn_generator.rb

@@ -4,7 +4,9 @@ module Pubid
   module Jcgm
     class UrnGenerator < Pubid::UrnGenerator::Base
       def generate
-        if identifier.is_a?(SupplementIdentifier)
+        if identifier.is_a?(Identifiers::Meeting)
+          generate_meeting_urn
+        elsif identifier.is_a?(SupplementIdentifier)
           generate_supplement_urn
         else
           generate_base_urn
@@ -13,16 +15,21 @@ module Pubid
 
       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"]
 
-        gum_number = maybe(:gum_number)
-        if gum_number
-          number = gum_number.to_s
-          parts << "gum.#{number}"
+        if identifier.is_a?(Identifiers::GumGuide) && identifier.number
+          parts << "gum.#{identifier.number}"
         elsif identifier.number
-          number = identifier.number.to_s
-          parts << number
+          parts << identifier.number.to_s
         end
 
         part = maybe(:part)
@@ -55,9 +62,11 @@ module Pubid
           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 && type_code.to_s != "guide"
+          if type_code && !%w[guide gum_guide].include?(type_code.to_s)
             parts << type_code.to_s
           end
         end
@@ -73,7 +82,7 @@ module Pubid
       def generate_supplement_urn
         parts = ["urn", "jcgm"]
 
-        base_id = maybe(:base_identifier)
+        base_id = maybe(:base)
         if base_id
           base_gen = self.class.new(base_id)
           base_urn = base_gen.generate_base_urn
@@ -88,10 +97,9 @@ module Pubid
             parts << supp_type if supp_type
           end
 
-          iteration = maybe(:iteration)
-          if iteration
-            iter = iteration.to_s
-            parts << iter
+          # 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?

data/lib/pubid/jcgm/urn_parser.rb

@@ -4,19 +4,173 @@ module Pubid
   module Jcgm
     # Parses JCGM URNs back into identifiers.
     #
-    # UrnGenerator emits: `urn:jcgm:{number}:{year}`.
+    # Identifiers are rebuilt **directly from the URN segments** rather than
+    # rendered to a human-readable string and re-parsed (the BIPM UrnParser
+    # pattern). Round-tripping through the grammar flattened the segments into
+    # one string and silently lost everything the string form could not carry:
+    # a GUM guide (`urn:jcgm:gum.6:2020`) raised, and the language and
+    # supplement segments were dropped, so a corrigendum read back as the
+    # standard it amends — a different document, with no error.
     #
-    # Examples:
-    # - urn:jcgm:200:2012 → JCGM 200:2012
-    # - urn:jcgm:100:2008 → JCGM 100:2008
+    # Shapes emitted by UrnGenerator, and read back here:
+    #   urn:jcgm:200:2008                        → JCGM 200:2008
+    #   urn:jcgm:100:2008:en                     → JCGM 100:2008(E)
+    #   urn:jcgm:200:2012:en,fr                  → JCGM 200:2012(E/F)
+    #   urn:jcgm:GUM                             → JCGM GUM
+    #   urn:jcgm:gum.6:2020                      → JCGM GUM-6:2020
+    #   urn:jcgm:200:2008:corrigendum            → JCGM 200:2008 Corrigendum
+    #   urn:jcgm:101:2008:corrigendum:1:2009     → JCGM 101:2008/Cor 1:2009
+    #   urn:jcgm:100:2008:amendment:1:2023       → JCGM 100:2008/Amd 1:2023
+    #   urn:jcgm:meeting:17:2012                 → JCGM 17th Meeting (2012)
+    #   urn:jcgm:meeting:11                      → JCGM 11st Meeting
+    #
+    # KNOWN GAP, on the generator side and unchanged here: a full date is
+    # rendered as its year alone (`JCGM GUM-1:2022-11-28` →
+    # `urn:jcgm:gum.1:2022`), so a URN cannot restore the month and day.
+    # Widening it would change already-published URNs.
     class UrnParser < Pubid::UrnParser::Base
+      MEETING_MARKER = "meeting"
+
+      # The GUM-guide number is written "gum.<n>" by UrnGenerator.
+      GUM_PREFIX = "gum."
+
+      # The supplement marker UrnGenerator writes is the typed stage's
+      # `type_code`; the abbreviation is what `Jcgm.locate_stage` matches on.
+      SUPPLEMENT_ABBRS = {
+        "corrigendum" => "Cor",
+        "amendment" => "Amd",
+      }.freeze
+
+      MEETING_ABBR = "Meeting"
+
+      # Mirrors `year_digits` in the shared parser rules.
+      YEAR_PATTERN = /\A(?:19|20)\d{2}\z/
+
+      # A language segment is one or more comma-joined ISO codes.
+      LANGUAGES_PATTERN = /\A[a-z]{2}(?:,[a-z]{2})*\z/
+
+      # Language codes back to the single-letter form the identifier prints;
+      # the builder maps the other way when parsing "(E)" / "(E/F)".
+      LANGUAGE_LETTERS = Pubid::Builder::Base::LANG_CHAR_MAP.invert.freeze
+
       def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-        number, year = parts
-        text = "JCGM #{number}"
-        text += ":#{year}" if year
-        flavor_parse(text)
+        parts = split_parts(strip_namespace(urn))
+        return parse_meeting_urn(parts) if parts.first == MEETING_MARKER
+
+        parse_document_urn(parts)
+      end
+
+      private
+
+      # urn:jcgm:meeting:<number>[:<year>] -> Identifiers::Meeting
+      #
+      # The reconstruction must agree with a parsed identifier attribute for
+      # attribute, so `typed_stage` comes from the same registry lookup
+      # `Builder#locate_typed_stage` uses. (The attribute default now agrees
+      # too — it no longer sets `original_abbr` — so this mirrors the builder
+      # for clarity rather than out of necessity.)
+      def parse_meeting_urn(parts)
+        _, number, year = parts
+
+        Identifiers::Meeting.new(
+          number: meeting_number(number),
+          date: urn_date(year),
+          typed_stage: Jcgm.locate_stage(MEETING_ABBR),
+        )
+      end
+
+      # A guide, a GUM guide, or a supplement wrapping one of those. The
+      # supplement marker splits the segments: everything before it describes
+      # the base document, everything after is the supplement's own number and
+      # date.
+      def parse_document_urn(parts)
+        marker_at = parts.index { |segment| SUPPLEMENT_ABBRS.key?(segment) }
+        return build_document(parts) unless marker_at
+
+        build_supplement(
+          parts[marker_at],
+          build_document(parts[0...marker_at]),
+          parts[(marker_at + 1)..] || [],
+        )
+      end
+
+      # The class comes from the same registry the builder uses, so a URN and a
+      # parsed reference resolve to one class and one typed_stage.
+      def build_supplement(marker, base, tail)
+        typed_stage = Jcgm.locate_stage(SUPPLEMENT_ABBRS.fetch(marker))
+        number, year = tail
+
+        Jcgm.locate_type(typed_stage.type_code).new(
+          base: base,
+          number: (number.nil? || number.empty? ? nil : number.to_s),
+          date: urn_date(year),
+          typed_stage: typed_stage,
+        )
+      end
+
+      # <number>[:<year>][:<languages>] — the number segment carries the
+      # "gum." prefix for a GUM guide, which is what selects the class.
+      #
+      # Guide and GumGuide deliberately take their `typed_stage` from the
+      # attribute default: the grammar emits no type token for them, so
+      # `Builder#build` fills it from `published_typed_stage` too, and both
+      # paths agree.
+      def build_document(parts)
+        number, *rest = parts
+        require_number!(number)
+        gum = number.start_with?(GUM_PREFIX)
+
+        (gum ? Identifiers::GumGuide : Identifiers::Guide).new(
+          number: (gum ? number.delete_prefix(GUM_PREFIX) : number).to_s,
+          date: urn_date(segment_matching(rest, YEAR_PATTERN)),
+          languages: urn_languages(segment_matching(rest, LANGUAGES_PATTERN)),
+        )
+      end
+
+      def require_number!(segment)
+        return unless segment.nil? || segment.empty?
+
+        raise Pubid::UrnParser::Errors::ParseError,
+              "JCGM URN has no document number"
+      end
+
+      def segment_matching(segments, pattern)
+        segments.find { |segment| segment.match?(pattern) }
+      end
+
+      # The ordinal, normalized the way `Identifiers::Meeting.ordinal` does it
+      # (`number.to_i`), so "011" reads back as "11" and a missing or
+      # non-numeric segment as "0" — the behaviour of the previous
+      # render-and-re-parse implementation.
+      def meeting_number(segment)
+        segment.to_i.to_s
+      end
+
+      # nil for an absent year; a Date for a well-formed one. The grammar
+      # accepts only a 19xx/20xx year, so anything else is a malformed URN and
+      # must still be rejected now that no re-parse validates it.
+      def urn_date(segment)
+        return nil if segment.nil? || segment.empty?
+
+        unless segment.match?(YEAR_PATTERN)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid year in JCGM URN: #{segment.inspect}"
+        end
+
+        Pubid::Components::Date.new(year: segment)
+      end
+
+      # "en" -> (E), "en,fr" -> (E/F). `original_code` is what the renderer
+      # prints, so it is restored from the code rather than left nil.
+      def urn_languages(segment)
+        return nil if segment.nil? || segment.empty?
+
+        segment.split(",").map do |code|
+          Pubid::Components::Language.new(
+            code: code,
+            original_code: LANGUAGE_LETTERS.fetch(code, code),
+          )
+        end
       end
     end
   end

data/lib/pubid/jcgm.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Jcgm
     extend Pubid::PrefixesSupport
@@ -22,6 +23,15 @@ module Pubid
     # @param identifier [String] the identifier string to parse
     # @return [Identifier] the parsed identifier
     def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
       parser = Parser.new
       builder = Builder.new
 

data/lib/pubid/jis/identifier.rb

@@ -117,18 +117,77 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # JIS exposes its publisher as the `PUBLISHER` constant rather than the
+      # inherited `publisher` attribute, so the generic mr_publisher returns
+      # nil. Without this override every JIS id would lose its "JIS." prefix.
+      # Lowercased to match the all-lowercase MR convention.
+      def mr_publisher
+        PUBLISHER.downcase
+      end
+
+      # JIS stores its identity across `series` (division letter A–Z), `number`
+      # (string, may have leading zeros), and `parts` (multi-level). The
+      # generic mr_number_with_part only knows about `number`/`part`/`subpart`,
+      # so without these overrides every JIS id would collapse onto its
+      # document number and drop the division letter (issue #142).
+      # Lowercased to match the all-lowercase MR convention.
+      def mr_type
+        return nil unless respond_to?(:type_prefix)
+
+        type_prefix&.downcase
+      end
+
+      def mr_number_with_part
+        segments = []
+        segments << series.to_s.downcase if series
+        segments << number.to_s if number
+        parts&.each { |p| segments << p.to_s }
+        return nil if segments.empty?
+
+        segments.join("-")
+      end
+
+      # JIS stores the year as a bare integer (not a Components::Date), so the
+      # inherited mr_year (which reads `date`) returns nil. Emit it directly,
+      # including the reaffirmation marker so `JIS X:2019` and `JIS X:2019R`
+      # stay distinct in MR.
+      def mr_year
+        return nil unless year
+
+        year_with_reaffirmation.to_s
+      end
+
+      def mr_languages
+        return nil unless language
+
+        "(#{language})"
+      end
+
+      def mr_all_parts
+        return nil unless all_parts?
+
+        "all-parts"
+      end
+
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
       # JIS_TYPE_MAP remains as the key_value polymorphic_map.
 
       # Parse a JIS identifier string into an identifier object
       # @param identifier [String] The JIS identifier string to parse
       # @return [Identifier] The appropriate identifier object
-      # @raise [RuntimeError] If parsing fails
+      # @raise [Pubid::Errors::ParseError] If parsing fails
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse JIS identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/jis/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Jis
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Japanese character normalization
       rule(:jp_dash) { str("ｰ") } # Full-width dash
       rule(:jp_space) { str("　") }  # Full-width space

data/lib/pubid/jis.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Jis
     extend Pubid::PrefixesSupport

data/lib/pubid/nist/builder.rb

@@ -22,7 +22,7 @@ module Pubid
 
       # Build an identifier object from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [Identifiers::Base] the constructed identifier object
+      # @return [Identifier] the constructed identifier object
       def build(parsed)
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? flatten_array(parsed) : parsed
@@ -287,8 +287,6 @@ module Pubid
 
               identifier.number = Components::Code.new(value: "#{first_num.value}-#{number_part}")
               identifier.edition = edition_obj
-              identifier.edition_component = edition_obj
-              identifier.revision = "r#{edition_id}"
             # CS Emergency pattern: e104-43 -> number=104, edition_year=1943
             # Logic: e104-43 means "emergency 104 from 1943" (43 = 1943)
             elsif first_num.value.to_s.match?(/^e(\d{3})$/) &&
@@ -304,7 +302,6 @@ module Pubid
 
               identifier.number = Components::Code.new(value: number_part)
               identifier.edition = edition_obj
-              identifier.edition_component = edition_obj
             elsif first_num.value.to_s.match?(/^(\d+)e(\d+)$/) &&
                 second_num.value.to_s.match?(/^\d{2,4}$/)
               # Pattern: "11e2-1915" OR "123e2-50" parsed as first="11e2"|"123e2", second="1915"|"50"
@@ -326,7 +323,6 @@ module Pubid
               edition_obj = Components::Edition.new(type: "e",
                                                     id: edition_id, additional_text: year_part)
               identifier.edition = edition_obj
-              identifier.edition_component = edition_obj
             elsif first_num.value.to_s.match?(/^(\d+)supp?$/) &&
                 second_num.value.to_s.match?(/^\d{4}$/)
               # Pattern: "25supp-1924" parsed as first="25supp", second="1924"
@@ -351,7 +347,6 @@ module Pubid
               identifier.number = first_num
               edition_obj = Components::Edition.new(type: "e",
                                                     id: second_num.value.to_s)
-              identifier.edition_component = edition_obj
               identifier.edition = edition_obj
               identifier.edition_year = second_num.value.to_s
             elsif part_num && series.part_num_as_component?
@@ -379,11 +374,34 @@ module Pubid
                                                        id: extracted_revision.to_s)
         end
 
+        # Expose the SP subseries (Appendix A.2 of the NIST PubID Syntax) as
+        # a queryable attribute. For "NIST SP 800-53" the subseries is "800"
+        # (first_num) and the sequence is "53" (already folded into number).
+        # Pure metadata extraction — number is left intact so existing
+        # rendering and indexing stay byte-identical.
+        if identifier.is_a?(Identifiers::SpecialPublication) &&
+            first_num && identifier.respond_to?(:subseries=)
+          first_str = first_num.value.to_s
+          subseries_code =
+            if Identifiers::SpecialPublication::SP_SUBSERIES.include?(first_str)
+              first_str
+            elsif (m = first_str.match(/\A(\d+GB)\b/)) &&
+                Identifiers::SpecialPublication::SP_SUBSERIES.include?(m[1])
+              # Parser emits "1190GB-12" as a single first_number token; strip
+              # the suffix to surface the bare "1190GB" subseries code.
+              m[1]
+            end
+          if subseries_code
+            identifier.subseries =
+              Components::Code.new(value: subseries_code)
+          end
+        end
+
         # Series-specific post-processing (e.g., IR reverses the "84e2946"
         # form that preprocessing produced back to "84-2946").
         series.finalize_identifier(identifier, parsed_hash)
 
-        # publisher_was_parsed defaults to true (see Identifiers::Base), so only
+        # publisher_was_parsed defaults to true (see Identifier), so only
         # the prefix-less case needs recording: assign false when no publisher
         # was parsed/extracted, and leave it unset (default true, omitted from
         # to_hash) when one was. Keeps the common publisher-bearing id lean.
@@ -437,11 +455,13 @@ module Pubid
           component = Components::Supplement.new
           # Split the fused "Jun1925"/"Jun1926" strings into isolated start/end
           # month+year nodes (start reuses :month/:year, end uses *_end).
-          if range_start && (m = range_start.match(/\A([A-Za-z]{3,9})(\d{4})\z/))
+          # Each end is either a fused "Jun1925" (month+year) or a bare "1925"
+          # (year-only range, no month).
+          if range_start && (m = range_start.match(/\A([A-Za-z]{3,9})?(\d{4})\z/))
             component.month = m[1]
             component.year = m[2]
           end
-          if range_end && (m = range_end.match(/\A([A-Za-z]{3,9})(\d{4})\z/))
+          if range_end && (m = range_end.match(/\A([A-Za-z]{3,9})?(\d{4})\z/))
             component.month_end = m[1]
             component.year_end = m[2]
           end