pubid 2.0.1 → 2.0.3

data/lib/pubid/ieee/builder.rb

@@ -146,7 +146,7 @@ module Pubid
               related =
                 begin
                   Identifier.parse(m[1])
-                rescue Parslet::ParseFailed
+                rescue Pubid::Errors::ParseError
                   Identifier.new(parenthetical_content: m[1])
                 end
               relationships = [Components::Relationship.new(
@@ -283,21 +283,90 @@ module Pubid
         # Parslet can return array of hashes - merge them
         parsed_hash = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
 
+        # The grammar binds the bare top-level draft clause as
+        # :draft_version_scalar (string) — the only cross-engine-stable
+        # scalar — and the composite draft rule as :draft_version_composite
+        # (raw). Surface the scalar under the top-level key the rest of the
+        # builder has always read, and the composite under the interior key
+        # the draft-element walks read.
+        if parsed_hash[:draft_version].nil? && parsed_hash[:draft_version_scalar]
+          parsed_hash[:draft_version] = parsed_hash.delete(:draft_version_scalar)
+        end
+        draft_elems = parsed_hash[:draft].is_a?(Array) ? parsed_hash[:draft] : [parsed_hash[:draft]]
+        draft_elems.each do |e|
+          next unless e.is_a?(Hash) && e[:draft_version].nil? && e[:draft_version_composite]
+
+          e[:draft_version] = e.delete(:draft_version_composite)
+        end
+        # The subpart run ("7.4-3-2" carries two) rides the raw
+        # part_subpart_year wrapper — the subparts[] array harvest emitted
+        # empty hashes for non-firing rep iterations on wasm
+        # (parsanol-ruby#399), so the run no longer binds top-level.
+        # Hoist the wrapper's part/year and deep-collect its interior
+        # subparts so every consumer — and every raw subtree built through
+        # here (the CSA dual's ieee_portion, the multi-numbered primary,
+        # the supplement bases) — sees the flat keys it has always read.
+        parsed_hash = unwrap_part_subpart_year(parsed_hash)
+
         # Grammar-captured dash dates (relaton's "/D-3-2017-07" and
         # "/R-x-2011-04" tails) land on the identifier's year/month exactly
         # like the number's own date clause. The revision-suffix form sits at
         # the top level; the draft tail nests under :draft — either as its
         # own element or wrapped in a draft_version hash.
+        # A revision element INSIDE the draft array is the draft rule's own
+        # split artifact (the version's trailing ".1" segment) — the spine
+        # captured the same value, and leaving it there makes the REV-date
+        # embed glue the draft date into the designator. A rev_inline
+        # capture never lands inside the draft array, so this only ever
+        # drops the artifact.
+        if parsed_hash[:draft].is_a?(Array) && parsed_hash[:revision]
+          artifact = parsed_hash[:draft].any? do |e|
+            e.is_a?(Hash) && e.key?(:revision) && e[:revision].to_s == parsed_hash[:revision].to_s
+          end
+          parsed_hash.delete(:revision) if artifact
+        end
+        # The edition-2 tree materializes a multi-segment draft version
+        # ("D2.1.1") as per-token nodes carrying no :draft_version key. The
+        # v1 tree degraded such a clause to a whole-clause LEAF string when
+        # no draft date follows (the designator survives through the
+        # Draft.parse inverse), and to a date-only hash when it does (the
+        # version is dropped, no draft built). Normalize to the v1 shape
+        # here — before the stage derivation and draft handling read it —
+        # so every consumer sees what v1 saw.
+        if parsed_hash[:draft].is_a?(Array)
+          draft_elems = parsed_hash[:draft].select { |e| e.is_a?(Hash) }
+          if !draft_elems.empty? && draft_elems.none? { |e| e.key?(:draft_version) }
+            has_date = draft_elems.any? { |e| e.key?(:draft_date_month) || e.key?(:draft_date_year) }
+            if has_date
+              date_elems = draft_elems.select do |e|
+                e.key?(:draft_date_month) || e.key?(:draft_date_year) || e.key?(:draft_date_day)
+              end
+              parsed_hash[:draft] = date_elems.inject({}, :merge)
+            else
+              parsed_hash[:draft] = draft_elems.flat_map { |e| e.values }.join
+            end
+          end
+        end
         drafts = parsed_hash[:draft].is_a?(Array) ? parsed_hash[:draft] : [parsed_hash[:draft]].compact
         drafts.each do |d|
           next unless d.is_a?(Hash) && d[:draft_version].is_a?(Hash)
           dv = d[:draft_version]
-          d[:dash_year] = dv[:dash_year] if dv[:dash_year]
-          d[:dash_month] = dv[:dash_month] if dv[:dash_month]
+          # The edition-2 grammar renames the nested draft-version dash
+          # captures (draft_version_dash_year/month) to keep them out of the
+          # flat bound map; the v1 tree spelling stays as the fallback.
+          d[:dash_year] = (dv[:draft_version_dash_year] || dv[:dash_year]) if
+            dv[:draft_version_dash_year] || dv[:dash_year]
+          d[:dash_month] = (dv[:draft_version_dash_month] || dv[:dash_month]) if
+            dv[:draft_version_dash_month] || dv[:dash_month]
           d.delete(:draft_version)
         end
         dash = parsed_hash[:dash_year] ? parsed_hash : nil
-        dash ||= drafts.find { |d| d.is_a?(Hash) && d[:dash_year] }
+        # The draft_date captures rename with the draft_date_ prefix on the
+        # edition-2 grammar (nested-only, kept off the identity keys); v1
+        # spelling stays as the fallback.
+        dash ||= drafts.find do |d|
+          d.is_a?(Hash) && (d[:draft_date_dash_year] || d[:dash_year])
+        end
         if dash.nil? && parsed_hash[:draft]
           # A numeric month trailing a draft is the draft's own date: it
           # embeds in the designator ("D09, 04 2011" -> "D09-2011-04")
@@ -323,25 +392,32 @@ module Pubid
         if dash
           joined = drafts.filter_map { |d| d.is_a?(Hash) ? d[:draft_version] : nil }
                          .map { |v| v.is_a?(Hash) ? v[:value] : v.to_s }.join
+          # dash is either the top-level spine (dash_year/dash_month) or the
+          # draft's own hash (draft_date_dash_year/month on the edition-2
+          # grammar, dash_year/month on v1) — read both spellings.
+          dash_y = dash[:dash_year] || dash[:draft_date_dash_year]
+          dash_m = dash[:dash_month] || dash[:draft_date_dash_month]
           bare_joint_draft = parsed_hash[:joint_publishers] &&
                              parsed_hash[:part].nil? &&
                              parsed_hash[:iso_stage].nil? &&
                              drafts.any? { |d| d.is_a?(Hash) && d[:draft_version] }
           dash_led = joined.start_with?("-")
           if bare_joint_draft && dash_led
-            parsed_hash[:part] = { value: dash[:dash_year] }
-          elsif dash[:dash_month] &&
+            parsed_hash[:part] = { value: dash_y }
+          elsif dash_m &&
                 (host = drafts.find { |d| d.is_a?(Hash) && d[:draft_version] })
             # The draft's own numeric date embeds in the designator
             # ("D2-2015-04") — the "D2, 04 2015" comma spelling
             # normalizes onto it (pubid ruling 2026-10-13).
             host[:draft_version] =
-              [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
+              [joined, dash_y, dash_m].compact.join("-")
             dash.delete(:dash_year)
             dash.delete(:dash_month)
-          elsif (dash[:dash_month] || dash_led) && parsed_hash[:year].nil?
-            parsed_hash[:year] = dash[:dash_year]
-            parsed_hash[:month] = dash[:dash_month]
+            dash.delete(:draft_date_dash_year)
+            dash.delete(:draft_date_dash_month)
+          elsif (dash_m || dash_led) && parsed_hash[:year].nil?
+            parsed_hash[:year] = dash_y
+            parsed_hash[:month] = dash_m
           else
             # Year-only tail embeds in the draft face ("D9-2006"), the model
             # the relaton-pinned renders use for corrupted update_codes
@@ -353,15 +429,17 @@ module Pubid
               # ("D9-2006", and with its month "D2-2015-04") — the
               # "D2, 04 2015" comma spelling normalizes onto it.
               host[:draft_version] =
-                [joined, dash[:dash_year], dash[:dash_month]].compact.join("-")
+                [joined, dash_y, dash_m].compact.join("-")
               dash.delete(:dash_year)
               dash.delete(:dash_month)
+              dash.delete(:draft_date_dash_year)
+              dash.delete(:draft_date_dash_month)
               # the hyphenated "/D-2-2007" spelling's year the spine
               # captured at top level is the draft's own — vacate it
-              parsed_hash.delete(:year) if parsed_hash[:year] == dash[:dash_year]
+              parsed_hash.delete(:year) if parsed_hash[:year] == dash_y
             else
-              parsed_hash[:year] = dash[:dash_year]
-              parsed_hash[:month] = dash[:dash_month]
+              parsed_hash[:year] = dash_y
+              parsed_hash[:month] = dash_m
             end
           end
         end
@@ -456,8 +534,11 @@ module Pubid
             # "IEEE P15026.2/D=FDIS-201008" (pubid#203 ruling). The
             # stage and date ride the designator; the ISO face is not
             # elected.
-            year = extract_value(fd[:year])
-            month = extract_value(fd[:month])
+            # fdraft's month/year rename with the fdraft_ prefix on the
+            # edition-2 grammar (nested-only); v1 spelling stays as the
+            # fallback.
+            year = extract_value(fd[:fdraft_year] || fd[:year])
+            month = extract_value(fd[:fdraft_month] || fd[:month])
             date = ""
             if year
               date = "-#{year}"
@@ -500,6 +581,11 @@ module Pubid
       def reconstruct_base_string(base_data)
         base_parts = []
 
+        # The part/subpart/year captures sit one level down, inside the
+        # raw part_subpart_year wrapper (parsanol-ruby#399) — hoist them
+        # before the flat reads below.
+        base_data = unwrap_part_subpart_year(base_data)
+
         # Extract publisher
         if base_data[:publishers]
           pub_data = base_data[:publishers]
@@ -536,11 +622,14 @@ module Pubid
           number_str += part_val if part_val
         end
 
-        # Add subpart if present
+        # Add subpart if present — the bound run arrives as subparts[]
+        # harvest hashes ({subpart: …}); v1's flat spelling stays as the
+        # fallback.
         if base_data[:subpart]
           subparts = base_data[:subpart]
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
+            sp = sp[:subpart] if sp.is_a?(Hash) && sp.key?(:subpart)
             subpart_val = extract_value(sp)
             number_str += subpart_val if subpart_val
           end
@@ -681,7 +770,7 @@ module Pubid
       def build_interpretation_supplement(parsed_hash)
         # Reconstruct base identifier string from parsed components (same logic as corrigendum)
         base_parts = []
-        base_data = parsed_hash[:base]
+        base_data = unwrap_part_subpart_year(parsed_hash[:base])
 
         # Extract publisher
         if base_data[:publishers]
@@ -714,11 +803,14 @@ module Pubid
           number_str += part_val if part_val
         end
 
-        # Add subpart if present
+        # Add subpart if present — the bound run arrives as subparts[]
+        # harvest hashes ({subpart: …}); v1's flat spelling stays as the
+        # fallback.
         if base_data[:subpart]
           subparts = base_data[:subpart]
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
+            sp = sp[:subpart] if sp.is_a?(Hash) && sp.key?(:subpart)
             subpart_val = extract_value(sp)
             number_str += subpart_val if subpart_val
           end
@@ -754,7 +846,7 @@ module Pubid
       def build_conformance_supplement(parsed_hash)
         # Reconstruct base identifier string from parsed components (same logic as corrigendum)
         base_parts = []
-        base_data = parsed_hash[:base]
+        base_data = unwrap_part_subpart_year(parsed_hash[:base])
 
         # Extract publisher
         if base_data[:publishers]
@@ -787,11 +879,14 @@ module Pubid
           number_str += part_val if part_val
         end
 
-        # Add subpart if present
+        # Add subpart if present — the bound run arrives as subparts[]
+        # harvest hashes ({subpart: …}); v1's flat spelling stays as the
+        # fallback.
         if base_data[:subpart]
           subparts = base_data[:subpart]
           subparts = [subparts] unless subparts.is_a?(Array)
           subparts.each do |sp|
+            sp = sp[:subpart] if sp.is_a?(Hash) && sp.key?(:subpart)
             subpart_val = extract_value(sp)
             number_str += subpart_val if subpart_val
           end
@@ -1320,9 +1415,12 @@ module Pubid
         # Extract SI type (SI or PSI)
         si_type = extract_value(parsed[:si_type])
 
-        # Extract publishers (should be "IEEE/ASTM")
-        if parsed[:publishers]
-          publishers_str = extract_value(parsed[:publishers])
+        # Extract publishers (should be "IEEE/ASTM") — the SI rule's bare
+        # publishers clause binds as publishers_scalar (string); the
+        # composite joint rows deliver :publishers (raw).
+        pub_src = parsed[:publishers] || parsed[:publishers_scalar]
+        if pub_src
+          publishers_str = extract_value(pub_src)
           # Split by slash to get individual publishers
           pubs = publishers_str.split("/")
           attributes[:publisher] = pubs.first
@@ -1334,6 +1432,10 @@ module Pubid
 
         # For PSI (draft), create proper Draft component object
         if si_type == "PSI"
+          # The bare top-level draft clause binds as :draft_version_scalar
+          # (string) — surface it under the key this builder reads.
+          parsed[:draft_version] = parsed.delete(:draft_version_scalar) if
+            parsed[:draft_version].nil? && parsed[:draft_version_scalar]
           if parsed[:draft_version]
             draft_version = extract_value(parsed[:draft_version])
             # Create Draft component (Lutaml::Model object)
@@ -1904,6 +2006,42 @@ module Pubid
         str_value.length.positive? ? str_value : nil
       end
 
+      # Deep-first collection of every :subpart node under a raw
+      # part_subpart_year wrapper (Hash or Array, any nesting).
+      def collect_subparts(node, out = [])
+        case node
+        when Hash
+          node.each do |key, value|
+            if key.to_sym == :subpart
+              out << value
+            else
+              collect_subparts(value, out)
+            end
+          end
+        when Array then node.each { |item| collect_subparts(item, out) }
+        end
+        out
+      end
+
+      # The part/subpart/year captures ride the raw part_subpart_year
+      # wrapper inside raw subtrees (parsanol-ruby#399: the subparts[]
+      # array harvest is not cross-engine stable, so the run does not
+      # bind top-level). Hoist the wrapper's part/year onto a copy of the
+      # subtree and surface the interior subpart run under :subpart, so
+      # the flat reads downstream see the shapes they always read.
+      def unwrap_part_subpart_year(node)
+        return node unless node.is_a?(Hash) && (run = node[:part_subpart_year])
+
+        nodes = run.is_a?(Array) ? run : [run]
+        flat = nodes.select { |item| item.is_a?(Hash) }.inject({}, :merge)
+        node = node.merge(flat.slice(:part, :year))
+        unless node[:subpart]
+          collected = collect_subparts(run)
+          node = node.merge(subpart: collected) unless collected.empty?
+        end
+        node
+      end
+
       # Extract optional attribute if present
       def extract_optional(parsed, attributes, key)
         value = extract_value(parsed[key])
@@ -2004,15 +2142,20 @@ module Pubid
           iso_stage ||= extract_value(draft_data[:draft_iso_stage]) if draft_data[:draft_iso_stage]
           iso_iteration = extract_value(draft_data[:draft_iso_iteration]) if draft_data[:draft_iso_iteration]
 
-          # Extract date information from draft data
-          month_slice = draft_data[:month]
+          # Extract date information from draft data. The edition-2 grammar
+          # renames draft_date's nested month/year/day captures with the
+          # draft_date_ prefix (kept off the identity keys); the v1
+          # spellings stay as the fallback.
+          month_slice = draft_data[:draft_date_month] || draft_data[:month]
           month = extract_value(month_slice) if month_slice
-          year = extract_value(draft_data[:year]) if draft_data[:year]
+          year = extract_value(draft_data[:draft_date_year] || draft_data[:year]) if
+            draft_data[:draft_date_year] || draft_data[:year]
           # The apostrophe-year catalogue convention ("P1484.20.1/D7,
           # May 07"): the 2-digit year expands with the <30 pivot so the
           # hash carries an unambiguous year.
           year = "#{year.to_i < 30 ? 20 : 19}#{year}" if year.to_s.match?(/\A\d{2}\z/)
-          day = extract_value(draft_data[:day]) if draft_data[:day]
+          day = extract_value(draft_data[:draft_date_day] || draft_data[:day]) if
+            draft_data[:draft_date_day] || draft_data[:day]
 
           # A REV-carrying draft embeds its print date into the designator
           # with the month canonicalized numeric (pubid ruling 2026-10-14):
@@ -2103,7 +2246,11 @@ module Pubid
       def handle_reaffirmed(parsed, attributes)
         if parsed[:reaffirmed].is_a?(Hash)
           reaf_data = parsed[:reaffirmed]
-          attributes[:reaffirmed] = extract_value(reaf_data[:year])
+          # The edition-2 grammar renames the nested year capture
+          # (reaffirmed_year) so the reaffirmation year cannot leak onto
+          # the identity year key; v1 spelling stays as the fallback.
+          attributes[:reaffirmed] =
+            extract_value(reaf_data[:reaffirmed_year] || reaf_data[:year])
         elsif parsed[:reaffirmed]
           attributes[:reaffirmed] = extract_value(parsed[:reaffirmed])
         end
@@ -2278,7 +2425,7 @@ module Pubid
         id_strings.map do |id_str|
           # Use Identifier.parse for recursive parsing
           Identifier.parse(id_str)
-        rescue Parslet::ParseFailed
+        rescue Pubid::Errors::ParseError
           # If parsing fails, create minimal identifier with just the string
           # This maintains graceful degradation
           Identifier.new(parenthetical_content: id_str)

data/lib/pubid/ieee/components/code.rb

@@ -23,13 +23,21 @@ module Pubid
         attribute :parts, :string, collection: true # Array of part strings
         attribute :original_separator, :string # Original separator (. or -) from parsing
 
+        # The separator BEFORE each part, when the source mixed them
+        # ("7.4-3-2" — dot after the number, dashes before the subparts).
+        # Runtime-only (a plain accessor, not a lutaml attribute): the
+        # serialized columns keep the single original_separator, and only
+        # a fresh parse knows the per-part spelling.
+        attr_accessor :original_separators
+
         def initialize(prefix: nil, number: nil, parts: nil,
-original_separator: nil)
+original_separator: nil, original_separators: nil)
           super()
           self.prefix = prefix
           self.number = number
           self.parts = parts || []
           self.original_separator = original_separator
+          self.original_separators = original_separators
         end
 
         # Parse code string into components
@@ -55,15 +63,45 @@ original_separator: nil)
           components = remainder.split(/[.-]/)
           number = components.shift
 
+          # The separators AS PRINTED, one per part boundary — a code may
+          # mix them ("7.4-3-2": dot after the number, dashes before the
+          # subparts), and to_s re-joins with these instead of the uniform
+          # original_separator when they were captured.
+          separators = remainder.scan(/[.-]/)
+          per_part = separators.length == components.length ? separators : nil
+
           new(
             prefix: prefix,
             number: number,
             parts: components.empty? ? nil : components,
             original_separator: separator,
+            original_separators: per_part,
           )
         end
 
+        # The printed face: keeps the separator each part was printed
+        # with ("7.4-3-2"), per Pubid::SubsetMatch. Spellings that differ
+        # only in part separators denote the same document, so faces that
+        # must be spelling-stable — the URN and the joint IEEE/ISO faces —
+        # render through #canonical_to_s instead.
         def to_s
+          render_code(per_part: true)
+        end
+
+        # The canonical face: one uniform separator across every part
+        # boundary (the first distinct one the source printed, the same
+        # face this class rendered before per-part separators were kept).
+        def canonical_to_s
+          render_code(per_part: false)
+        end
+
+        def render(context: nil)
+          to_s
+        end
+
+        private
+
+        def render_code(per_part:)
           result = ""
           result += prefix if prefix
           result += number if number # Guard against nil number (e.g., "ANSI X")
@@ -95,17 +133,18 @@ original_separator: nil)
               separator = "."
             end
 
-            parts.each do |part|
-              result += separator + part
+            parts.each_with_index do |part, idx|
+              # A fresh parse of mixed-separator codes ("7.4-3-2") carries
+              # the separator each part was printed with; the canonical
+              # face (and an unknown per-part spelling) falls back to the
+              # uniform original separator (the serialized shape).
+              sep = (per_part && original_separators&.at(idx)) || separator
+              result += sep + part
             end
           end
 
           result
         end
-
-        def render(context: nil)
-          to_s
-        end
       end
     end
   end

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

@@ -312,7 +312,7 @@ module Pubid
         else
           parse_single(result.input)
         end
-      rescue Parslet::ParseFailed
+      rescue Pubid::Errors::ParseError
         parse_single(input)
       end
 
@@ -403,7 +403,10 @@ module Pubid
           return build_dual(result.parts) if result.dispatch == :dual_semicolon
         end
         parser_input = Parser.normalize_input(normalized)
-        parsed = Pubid::Parg::Backend.parse(:ieee, parser_input)
+        # The edition-2 artifact's bindings block produces the builder-ready
+        # hash at the engine (typed scalars + raw wrappers); the tree
+        # backend's normalization it replaces read the edition-1 shapes.
+        parsed = Pubid::Parg::Model.bound(:ieee, parser_input)
         builder = Builder.new(Identifier)
         # Pass the original input string to builder for context
         builder.original_input = input

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

@@ -164,7 +164,10 @@ module Pubid
           # P11073.10418", #216); a plain ISO/IEC number keeps the
           # printed separator ("IEC/IEEE FDIS 60079-30-2", "ISO/IEC
           # 8802-3").
-          code_str = code.to_s
+          # Canonical (uniform-separator) code: a joint document parses
+          # from both the dotted IEEE face and the dashed IEC face, and
+          # both spellings must render — and URN — identically.
+          code_str = code.canonical_to_s
           code_str = code_str.tr("-", ".") if code_str.start_with?("P")
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
@@ -213,8 +216,9 @@ module Pubid
           parts << draft_status if draft_status
 
           # Build code part — the P-state prints as spelled (P = project
-          # draft; no P = standard). Never added or stripped.
-          code_str = code.to_s
+          # draft; no P = standard). Never added or stripped. Canonical
+          # code for the same both-faces reason as the ISO face above.
+          code_str = code.canonical_to_s
 
           # Mark after the number, before the draft and the year
           code_str += mark unless code_str.empty?

data/lib/pubid/ieee/ire/identifier.rb

@@ -39,7 +39,8 @@ module Pubid
 
         # Parse IRE identifier string
         def self.parse(input)
-          parsed = Parser.new.parse(input)
+          parsed = Pubid::Parg::Model.bound(:ire, input,
+                                   entry: "ire_identifier")
           builder = Builder.new
           builder.build(parsed)
         end

data/lib/pubid/ieee/ire.rb

@@ -5,7 +5,6 @@ module Pubid
     module Ire
       autoload :Builder, "#{__dir__}/ire/builder"
       autoload :Identifier, "#{__dir__}/ire/identifier"
-      autoload :Parser, "#{__dir__}/ire/parser"
     end
   end
 end

data/lib/pubid/ieee/nesc/builder.rb

@@ -94,7 +94,7 @@ module Pubid
           return Identifiers::Nesc::Preprint if parsed_hash[:preprint]
 
           # Draft identifiers
-          return Identifiers::Nesc::Draft if parsed_hash[:draft]
+          return Identifiers::Nesc::Draft if parsed_hash[:draft] || parsed_hash[:nesc_draft_marker]
 
           # Variant-based identifiers
           if parsed_hash[:variant]

data/lib/pubid/ieee/nesc.rb

@@ -4,7 +4,6 @@ module Pubid
   module Ieee
     module Nesc
       autoload :Builder, "#{__dir__}/nesc/builder"
-      autoload :Parser, "#{__dir__}/nesc/parser"
     end
   end
 end