pubid 2.0.0.pre.alpha.13 → 2.0.0.pre.alpha.14

data/lib/pubid/ccsds/identifier.rb

@@ -77,7 +77,7 @@ module Pubid
 
         # Apply legacy update_codes normalization first
         normalized = Core::UpdateCodes.apply(identifier, :ccsds)
-        parsed = Pubid::Ccsds::Parser.parse(normalized)
+        parsed = Pubid::Parg::Backend.parse(:ccsds, normalized)
         Pubid::Ccsds::Builder.build(parsed)
       end
 

data/lib/pubid/cen_cenelec/identifier.rb

@@ -102,7 +102,8 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        normalized = Parser.normalize_input(identifier)
+        parsed = Pubid::Parg::Backend.parse(:cen_cenelec, normalized)
         Builder.new.build(parsed)
       end
 

data/lib/pubid/cen_cenelec/parser.rb

@@ -131,7 +131,10 @@ module Pubid
 
       rule(:root) { identifier }
 
-      def self.parse(input)
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(input)
         # Normalize special dash characters
         normalized = input.gsub(/[\u2011\u00AD]/, "-")
 
@@ -145,7 +148,11 @@ module Pubid
         normalized = normalized.gsub("CEN-CLC", "CEN/CLC")
           .gsub("CLC-CEN", "CLC/CEN")
           .gsub("GUIDE", "Guide")
-        new.parse(normalized)
+        normalized
+      end
+
+      def self.parse(input)
+        new.parse(normalize_input(input))
       end
     end
   end

data/lib/pubid/cie/identifier.rb

@@ -24,7 +24,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(input)
+        parsed = Pubid::Parg::Backend.parse(:cie, Parser.normalize_input(input))
         builder = Builder.new
         builder.build(parsed, original_string: input)
       end

data/lib/pubid/cie/parser.rb

@@ -375,7 +375,10 @@ module Pubid
       end
 
       # Class method for parsing with preprocessing
-      def self.parse(string)
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(string)
         # Minimal preprocessing for data quality
         cleaned = string.strip
 
@@ -389,7 +392,11 @@ module Pubid
         # This is a data quality fix - correct format always has colon
         cleaned = cleaned.gsub(%r{/(E|F|G|DE|ES|CN|RU|FR)(\d{4})}, '/\1:\2')
 
-        new.parse(cleaned)
+        cleaned
+      end
+
+      def self.parse(string)
+        new.parse(normalize_input(string))
       end
     end
   end

data/lib/pubid/conformance/checks.rb

@@ -18,7 +18,7 @@ module Pubid
           mismatchers(identifier, test_case, flavor_module)
             .flat_map(&:call)
         rescue StandardError => e
-          ["#{test_case.id} raised #{e.class}"]
+          ["#{test_case.id} raised #{e.class}: #{e.message}"]
         end
 
         # Each checker returns the case's mismatch list for its concern.

data/lib/pubid/csa/identifier.rb

@@ -61,7 +61,9 @@ module Pubid
             normalized = normalized.gsub(/\s+/, " ").strip
 
             # Parse normally (will create Bundled or Combined identifier)
-            tree = Parser.new.parse(normalized)
+            tree = Pubid::Parg::Backend.parse(:csa, Parser.normalize_input(normalized))
+        prefix = Parser.publisher_prefix_for(normalized)
+        Parser.inject_publisher_prefix(tree, prefix) if prefix && tree.is_a?(Hash)
             result = build!(tree, input)
 
             # Apply CAN/CSA- prefix to the appropriate parts
@@ -419,7 +421,9 @@ module Pubid
         # Normalize CAN3- to CSA (historical prefix)
         normalized = normalized.gsub("CAN3-", "CSA ")
 
-        tree = Parser.new.parse(normalized)
+        tree = Pubid::Parg::Backend.parse(:csa, Parser.normalize_input(normalized))
+        prefix = Parser.publisher_prefix_for(normalized)
+        Parser.inject_publisher_prefix(tree, prefix) if prefix && tree.is_a?(Hash)
         result = build!(tree, input)
 
         # Set publisher prefix if detected

data/lib/pubid/csa/parser.rb

@@ -366,13 +366,28 @@ module Pubid
 
       # Preprocessing to normalize input
       def parse(input)
+        prefix = self.class.publisher_prefix_for(input)
+        result = super(self.class.normalize_input(input))
+        if prefix && result.is_a?(Hash)
+          self.class.inject_publisher_prefix(result, prefix)
+        end
+        result
+      end
+
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(input)
         # Skip comment lines
         if input.strip.start_with?("#")
           raise Pubid::Errors::ParseError.new(
             "Comment line", input: input, flavor: "csa"
           )
         end
+        __normalize_input(input)
+      end
 
+      def self.__normalize_input(input)
         # Remove CONSOLIDATED notation FIRST (before other processing)
         normalized = input.gsub(/\s*\(\s*CONSOLIDATED\s*\)\s*/, " ")
         normalized = normalized.gsub(/\s*\bCONSOLIDATED\b\s*/, " ")
@@ -404,20 +419,22 @@ module Pubid
         # Clean up extra spaces
         normalized = normalized.gsub(/\s+/, " ").strip
 
-        # Parse and inject publisher_prefix into result
-        result = super(normalized)
+        normalized
+      end
 
-        # Inject publisher_prefix if we have one
-        if publisher_prefix && result.is_a?(Hash)
-          inject_publisher_prefix(result, publisher_prefix)
+      def self.publisher_prefix_for(input)
+        if input.start_with?("CAN/CSA-")
+          "CAN/CSA-"
+        elsif input.start_with?("CAN3-")
+          "CAN3-"
+        elsif input.start_with?("CSA ")
+          "CSA"
         end
-
-        result
       end
 
       private
 
-      def inject_publisher_prefix(hash, prefix)
+      def self.inject_publisher_prefix(hash, prefix)
         # For combined identifiers
         if hash[:first]
           hash[:first][:publisher_prefix] = prefix

data/lib/pubid/doi/identifier.rb

@@ -41,7 +41,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:doi, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/easc/identifier.rb

@@ -28,7 +28,16 @@ module Pubid
     #   РМГ 29-2013
     class Identifier < ::Pubid::Identifier
       def self.parse(identifier)
-        parsed = Parser.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 = Pubid::Parg::Backend.parse(:easc, identifier)
         Builder.build(parsed)
       end
 

data/lib/pubid/ecma/identifier.rb

@@ -129,7 +129,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:ecma, identifier)
         Builder.build(parsed)
       end
 

data/lib/pubid/etsi/identifiers/base.rb

@@ -18,7 +18,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:etsi, identifier)
         Builder.build(parsed)
       end
 

data/lib/pubid/evs.rb

@@ -33,7 +33,7 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
-      parsed = Parser.new.parse(identifier)
+      parsed = Pubid::Parg::Backend.parse(:evs, identifier)
       Builder.new.build(parsed)
     end
 

data/lib/pubid/gb/identifier.rb

@@ -80,7 +80,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:gb, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/gost/identifier.rb

@@ -13,7 +13,17 @@ module Pubid
     # Harmonized). A bare InterstateStandard/NationalStandard has neither.
     class Identifier < ::Pubid::Identifier
       def self.parse(identifier)
-        parsed = Parser.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 = Pubid::Parg::Backend.parse(:gost, Parser.normalize_input(identifier))
         Builder.build(parsed)
       end
 

data/lib/pubid/gost/parser.rb

@@ -87,6 +87,13 @@ module Pubid
           adopted_part.maybe >> adopted_reference_part.maybe
       end
 
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(string)
+        string.strip
+      end
+
       def self.parse(string)
         unless string.is_a?(String)
           raise ::Pubid::Errors::InvalidInputError,
@@ -98,7 +105,7 @@ module Pubid
                 ::Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        new.parse(string.strip)
+        new.parse(normalize_input(string))
       end
     end
   end

data/lib/pubid/iala/identifier.rb

@@ -21,10 +21,19 @@ module Pubid
       # @return [Pubid::Iala::Identifier]
       # @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
+
         if FormatDetector.detect(identifier) == :urn
           UrnParser.parse(identifier)
         else
-          parsed = Parser.parse(identifier)
+          parsed = Pubid::Parg::Backend.parse(:iala, identifier)
           Builder.build(parsed)
         end
       end

data/lib/pubid/iana/identifier.rb

@@ -132,7 +132,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:iana, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/idf/builder.rb

@@ -22,6 +22,11 @@ module Pubid
         end
 
         assign_attributes(identifier, parsed_hash)
+        # The locate-stage pass above selects the class; the typed_stage
+        # attribute itself is set by the :type_with_stage key. Subtrees
+        # built without that key (e.g. a joint identifier from a PG
+        # artifact shape) would render with a nil typed_stage otherwise.
+        identifier.typed_stage ||= typed_stage if typed_stage
         # "(all parts)" names every part of the document, so it wraps the
         # document, which holds no mark itself.
         all_parts ? identifier.to_all_parts : identifier

data/lib/pubid/iec/identifier.rb

@@ -323,7 +323,7 @@ module Pubid
 
         # Apply legacy update_codes normalization first, before any other preprocessing
         normalized = Core::UpdateCodes.apply(string, :iec)
-        parsed = Pubid::Iec::Parser.new.parse(normalized)
+        parsed = Pubid::Parg::Backend.parse(:iec, Pubid::Iec::Parser.normalize_input(normalized))
         Pubid::Iec::Builder.new.build(parsed)
       end
 

data/lib/pubid/iec/parser.rb

@@ -428,15 +428,20 @@ module Pubid
 
       IEV_SHORTHAND = /\AIEV(?=\z|[\s-])/
 
-      # Preprocess input to normalize tab-separated editions and other formats
-      def parse(input)
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(input)
         # Normalize tab-separated editions: "IECEE AD-001\tED1.6" -> "IECEE AD-001 ED1.6"
         normalized = input.gsub("\t", " ")
         # Normalize comma-separated editions: "IEC CAB-G01:2025-02, Ed. 2.1" -> "IEC CAB-G01:2025-02 Ed. 2.1"
         normalized = normalized.gsub(/,\s+Ed\./, " Ed.")
         # Expand IEV shorthand: "IEV" / "IEV-351" -> "IEC 60050" / "IEC 60050-351"
-        normalized = normalized.sub(IEV_SHORTHAND, "IEC 60050")
-        super(normalized)
+        normalized.sub(IEV_SHORTHAND, "IEC 60050")
+      end
+
+      def parse(input)
+        super(self.class.normalize_input(input))
       end
     end
   end

data/lib/pubid/ieee/builder.rb

@@ -88,6 +88,14 @@ module Pubid
         date_info = nil
 
         if content
+          # A bare (unparenthesised) revision narrative printed after the
+          # code is the same relationship prose as the parenthetical form
+          # (C3 ruling) — peel it before the number tokenisation so both
+          # spellings collapse onto one canonical.
+          if (m = content.match(/\A(.+?) (Revis(?:ion|on) (?:of|to) IEEE Std .+)\z/))
+            content = "#{m[1]} (#{m[2]})"
+          end
+
           # Extract copublished number (everything before IEC: or comma or parenthesis)
           copublished_number = if content.include?("IEC:")
                                  content.split(" IEC:").first.strip
@@ -114,21 +122,42 @@ module Pubid
             end
           end
 
-          # Extract date info if present
+          # The parenthetical tail is classified, not swallowed (C3 ruling:
+          # a "(Revision of IEEE Std …)" narrative is a relationship, not
+          # identity — it lands in `relationships` so the URN carries it as
+          # the `rel.` segment and the canonical human drops it, exactly the
+          # joint ISO route's model; an "(MM/DD)" print date is non-identity
+          # and dropped; anything else keeps the historical date_info
+          # rendering).
           if content.include?(" (")
-            date_part = content.split(" (")[1]
-            if date_part&.include?(")")
-              date_info = date_part.split(")")[0]
+            tail = content.split(" (")[1].to_s.split(")")[0]
+            if (m = tail.match(/\ARevis(?:ion|on) (?:of|to) IEEE Std (.+)\z/))
+              related =
+                begin
+                  Identifier.parse(m[1])
+                rescue Parslet::ParseFailed
+                  Identifier.new(parenthetical_content: m[1])
+                end
+              relationships = [Components::Relationship.new(
+                relationship_type: Components::Relationship::REVISION_OF,
+                related_identifiers: [related],
+              )]
+            elsif tail.match?(/\A\d{2}\/\d{2}\z/)
+              # print date — non-identity, dropped
+            else
+              date_info = tail
             end
           end
         end
 
-        Identifiers::IecIeeeCopublished.new(
+        kwargs = {
           draft_info: draft_info,
           iec_year: iec_year,
           date_info: date_info,
           **copublished_structured(copublished_number),
-        )
+        }
+        kwargs[:relationships] = relationships if relationships
+        Identifiers::IecIeeeCopublished.new(**kwargs)
       end
 
       # Decompose an IEC/IEEE `copublished_number` into the split index columns
@@ -372,12 +401,14 @@ module Pubid
         # Build the complete code string: "802.1AC-2016" or "535-2013" or "C37.41-2016"
         number_str = extract_value(base_data[:number])
 
-        # Add part if present (e.g., ".1AC" or ".41")
+        # Part and subpart captures carry their own separator (".15",
+        # "-10417", ".4j" — the grammar mirrors the original parser's
+        # `((dot | dash) >> words_digits).as(:part)`), so they join the
+        # code string verbatim; re-adding a separator here would double
+        # it ("802..15").
         if base_data[:part]
           part_val = extract_value(base_data[:part])
-          # Determine separator: dot for most cases, dash for some
-          separator = number_str.match?(/^[A-Z]/) ? "." : "." # Letter prefix uses dot
-          number_str += separator + part_val
+          number_str += part_val if part_val
         end
 
         # Add subpart if present
@@ -386,7 +417,7 @@ module Pubid
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
             subpart_val = extract_value(sp)
-            number_str += ".#{subpart_val}" if subpart_val
+            number_str += subpart_val if subpart_val
           end
         end
 
@@ -545,11 +576,10 @@ module Pubid
         # Extract number with parts and year
         number_str = extract_value(base_data[:number])
 
-        # Add part if present
+        # Part/subpart captures carry their own separator — join verbatim.
         if base_data[:part]
           part_val = extract_value(base_data[:part])
-          separator = number_str.match?(/^[A-Z]/) ? "." : "."
-          number_str += separator + part_val
+          number_str += part_val if part_val
         end
 
         # Add subpart if present
@@ -558,7 +588,7 @@ module Pubid
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
             subpart_val = extract_value(sp)
-            number_str += ".#{subpart_val}" if subpart_val
+            number_str += subpart_val if subpart_val
           end
         end
 
@@ -619,11 +649,10 @@ module Pubid
         # Extract number with parts and year
         number_str = extract_value(base_data[:number])
 
-        # Add part if present
+        # Part/subpart captures carry their own separator — join verbatim.
         if base_data[:part]
           part_val = extract_value(base_data[:part])
-          separator = number_str.match?(/^[A-Z]/) ? "." : "."
-          number_str += separator + part_val
+          number_str += part_val if part_val
         end
 
         # Add subpart if present
@@ -632,7 +661,7 @@ module Pubid
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
             subpart_val = extract_value(sp)
-            number_str += ".#{subpart_val}" if subpart_val
+            number_str += subpart_val if subpart_val
           end
         end
 
@@ -754,8 +783,13 @@ module Pubid
                           "D=#{stage}"
                         end
           if parsed[:draft_iso_iteration]
-            joint_draft += ".#{extract_value(parsed[:draft_iso_iteration])}"
+            iter = extract_value(parsed[:draft_iso_iteration]).to_s.sub(/\A\./, "")
+            joint_draft += ".#{iter}" unless iter.empty?
           end
+          # The date rides inside the designator colon-joined
+          # ("D=CDV:2020" — the standing joint_stage_draft_spec contract;
+          # the dash spelling the grammar newly accepts is an alias that
+          # normalizes to the colon face).
           if parsed[:draft_stage_year]
             joint_draft += ":#{extract_value(parsed[:draft_stage_year])}"
           end
@@ -827,8 +861,11 @@ module Pubid
 
         # Detect lead party based on pattern
         if parsed[:iso_stage]
-          # ISO format - lead party is ISO
-          attributes[:lead_party] = "ISO"
+          # ISO stage word present. The lead party is the PRINTED first
+          # publisher (pubid#469: the arrangement is the organization's
+          # perspective, shown by the print) — "IEEE/ISO/IEC CD P42010"
+          # is IEEE-led even though the stage word is ISO's.
+          attributes[:lead_party] = attributes[:publishers]&.first || "ISO"
           attributes[:iso_stage] = extract_value(parsed[:iso_stage])
 
           # Create typed_stage for ISO stage
@@ -1157,7 +1194,8 @@ module Pubid
         end
 
         if code_str && !code_parts.empty?
-          code_str += ".#{code_parts.join('.')}"
+          # captures carry their own separator — join verbatim
+          code_str += code_parts.join
         end
 
         # Year detection: If code_str ends with year-like pattern (dash + 4 digits, 1884-2099)

data/lib/pubid/ieee/identifiers/base.rb

@@ -371,7 +371,7 @@ module Pubid
           result = PreParser.preprocess(normalized)
           return build_dual(result.parts) if result.dispatch == :dual_semicolon
         end
-        parsed = Parser.parse(normalized) # Use class method for preprocessing
+        parsed = Pubid::Parg::Backend.parse(:ieee, Parser.normalize_input(normalized))
         builder = Builder.new(Identifier)
         # Pass the original input string to builder for context
         builder.original_input = input