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

data/lib/pubid/ieee/builder.rb

@@ -8,7 +8,7 @@ module Pubid
       attr_accessor :original_input
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifiers::Base)
+      def initialize(identifier_class = Identifier)
         @identifier_class = identifier_class
       end
 
@@ -16,46 +16,58 @@ module Pubid
       # @param parsed [Hash, Array] the parsed identifier data
       # @return [identifier] the constructed identifier object
       def build(parsed)
+        # Parslet returns a top-level *array* of hashes when a repeated capture
+        # (e.g. the two subparts in "7.4-3-2") stops the sibling captures from
+        # hash-merging. The dispatch checks below need hash access, so read them
+        # off a merged view (`d`); build_single_identifier re-handles the array
+        # itself (preserving every subpart), so it still gets the original.
+        d = parsed.is_a?(Array) ? merge_parsed_array(parsed) : parsed
+
         # Handle CSA dual published patterns
-        if parsed[:ieee_portion] && parsed[:csa_portion]
+        if d[:ieee_portion] && d[:csa_portion]
           return build_csa_dual_published(parsed)
         end
 
+        # Handle the historical IEEE/IPCEA cable designation (S-135)
+        if d[:s_number]
+          return build_s_designation(parsed)
+        end
+
         # Handle combined AIEE identifiers (from "Nos X and Y" preprocessing)
-        if parsed[:first_aiee] && parsed[:second_aiee]
+        if d[:first_aiee] && d[:second_aiee]
           return build_combined_aiee(parsed)
         end
 
         # Handle dual published patterns
-        if parsed[:first] && parsed[:second]
+        if d[:first] && d[:second]
           return build_dual_published(parsed)
         end
 
         # Handle IEC/IEEE copublished patterns
-        if parsed[:content]
+        if d[:content]
           return build_iec_ieee_copublished(parsed)
         end
 
         # Handle NESC identifiers (National Electrical Safety Code)
-        if parsed[:nesc]
+        if d[:nesc]
           nesc_builder = Nesc::Builder.new
-          return nesc_builder.build(parsed[:nesc])
+          return nesc_builder.build(d[:nesc])
         end
 
         # Handle AIEE identifiers (American Institute of Electrical Engineers)
-        if parsed[:aiee]
+        if d[:aiee]
           aiee_builder = Aiee::Builder.new
-          return aiee_builder.build(parsed[:aiee])
+          return aiee_builder.build(d[:aiee])
         end
 
         # Handle IRE identifiers (Institute of Radio Engineers)
-        if parsed[:ire]
+        if d[:ire]
           ire_builder = Ire::Builder.new
-          return ire_builder.build(parsed[:ire])
+          return ire_builder.build(d[:ire])
         end
 
         # Handle IEEE/ASTM SI/PSI identifiers (Système International)
-        if parsed[:si_type]
+        if d[:si_type]
           return build_si_psi_identifier(parsed)
         end
 
@@ -112,13 +124,59 @@ module Pubid
         end
 
         Identifiers::IecIeeeCopublished.new(
-          copublished_number: copublished_number,
           draft_info: draft_info,
           iec_year: iec_year,
           date_info: date_info,
+          **copublished_structured(copublished_number),
         )
       end
 
+      # Decompose an IEC/IEEE `copublished_number` into the split index columns
+      # that reconstruct it losslessly (IecIeeeCopublished#copublished_number is
+      # the inverse). First peel a trailing *publication year* (19xx/20xx with
+      # its `-`/`:` separator) into `year`/`year_sep` — a bare 4-digit strip
+      # would wrongly eat a part like "60076.57-1202" (1202 is a part, not a
+      # year). Then tokenise the remainder on `.`/`-`, keeping each part's
+      # leading separator (a single code mixes them). So `number` narrows to the
+      # bucket, `parts` matches within it, and `separators` renders it back.
+      # `year_sep` is omitted when the default `-`. Returns empty for no number.
+      def copublished_structured(copublished_number)
+        return {} if copublished_number.nil? || copublished_number.empty?
+
+        remainder, year, year_sep = peel_copublished_year(copublished_number)
+        tokens = remainder.scan(/\A[^.\-]+|[.\-][^.\-]+/)
+        { number: tokens.shift }
+          .merge(copublished_parts(tokens))
+          .merge(copublished_year(year, year_sep))
+      end
+
+      # The `parts`/`separators` columns from the tokens after the number.
+      def copublished_parts(tokens)
+        return {} if tokens.empty?
+
+        { parts: tokens.map { |t| t[1..] }, separators: tokens.map { |t| t[0] } }
+      end
+
+      # The `year`/`year_sep` columns; `year_sep` is omitted when the default `-`.
+      def copublished_year(year, year_sep)
+        return {} unless year
+
+        year_sep == "-" ? { year: year } : { year: year, year_sep: year_sep }
+      end
+
+      # Peel a trailing publication year (19xx/20xx with its `-`/`:` separator)
+      # off a copublished number, returning [remainder, year, year_sep].
+      def peel_copublished_year(copublished_number)
+        return [copublished_number, nil, nil] unless
+          copublished_number =~ /([-:])((?:19|20)\d\d)\z/
+
+        year_sep = Regexp.last_match(1)
+        year = Regexp.last_match(2)
+        trimmed = copublished_number[0...(copublished_number.length -
+          year_sep.length - year.length)]
+        [trimmed, year, year_sep]
+      end
+
       # Build dual published identifier
       def build_dual_published(parsed)
         first_id = build_single_identifier(parsed[:first])
@@ -153,6 +211,33 @@ module Pubid
         )
       end
 
+      # Build the historical IEEE/IPCEA cable designation (e.g. S-135).
+      #
+      # The "S-135" designation is modelled as a plain Standard whose code holds
+      # the whole "S-135" string as `number` (prefix nil). It is passed as the
+      # `number:` split column directly — NOT as `code:` — so it bypasses
+      # Components::Code.parse, which would peel "S" as a prefix and leave an
+      # empty number (breaking the relaton index key and the round-trip). This
+      # keeps `root.number` == "S-135" and renders the dash back verbatim.
+      #
+      # The "/IPCEA …" slash co-designation is stored verbatim in `crossref`
+      # (rendered as-is); the "(IPCEA …)" parenthetical variant flows through
+      # the normal `parenthetical_content` path.
+      def build_s_designation(parsed)
+        attributes = {
+          number: extract_value(parsed[:s_number]),
+          publisher: extract_value(parsed[:publisher]) || "IEEE",
+          typed_stage: Pubid::Ieee.locate_stage("Std"),
+        }
+
+        if parsed[:ipcea_copub]
+          attributes[:crossref] = extract_value(parsed[:ipcea_copub])
+        end
+        handle_parameters(parsed, attributes)
+
+        Identifiers::Standard.new(**attributes)
+      end
+
       # Build single identifier
       def build_single_identifier(parsed, building_secondary: false)
         # Parslet can return array of hashes - merge them
@@ -164,19 +249,59 @@ module Pubid
           return build_multi_numbered_identifier(parsed_hash)
         end
 
-        # Handle corrigendum supplements (check for base_identifier + cor_number)
+        # Handle corrigendum supplements (check for base + cor_number)
         # This enables recursive base identifier parsing like ISO/IEC Amendment
-        if parsed_hash[:base_identifier] && parsed_hash[:cor_number]
+        if parsed_hash[:base] && parsed_hash[:cor_number]
           return build_corrigendum_supplement(parsed_hash)
         end
 
-        # Handle interpretation supplements (check for base_identifier + int_year)
-        if parsed_hash[:base_identifier] && (parsed_hash[:int_year] || parsed_hash[:interpretation])
+        # Handle the flat draft + corrigendum form (relaton's `…/D-N/CorM-YYYY`,
+        # normalized to `…/Cor M-YYYY/D N`): the parser emits a top-level
+        # `corrigendum` hash alongside `draft`/number with NO `:base` subtree, so
+        # the supplement path above is skipped. Rebuild a real base standard
+        # (carrying the draft) and wrap it, so `to_s` renders correctly from a
+        # fresh parse and after a from_hash round-trip. The `!parsed_hash[:base]`
+        # guard keeps this disjoint from the nested-base branch above; a
+        # `:base` + nested-`corrigendum`-hash shape is not produced by the
+        # grammar, so it would fall through to `extract_attributes` (as before).
+        if parsed_hash[:corrigendum].is_a?(Hash) && !parsed_hash[:base]
+          return build_flat_corrigendum(parsed_hash)
+        end
+
+        # Handle amendment supplements — mirrors the corrigendum path above.
+        # Every amendment the grammar produces is FLAT (a top-level `amendment`
+        # hash, no `:base`): the `amendment` rule only ever appears inline via
+        # `amendment.maybe`, so `build_flat_amendment` carries all real traffic
+        # (`IEEE Std …/Amd N-YYYY` and `ISO/IEC/IEEE 8802.x/AmdN-YYYY`). The
+        # recursive-base branch below is kept for structural parity with
+        # corrigendum (which has a dedicated `corrigendum_identifier` rule
+        # emitting a `:base` + top-level `:amd_number`-style shape); no amendment
+        # grammar rule emits it today, so it would only fire if one were added.
+        if parsed_hash[:base] && parsed_hash[:amd_number]
+          return build_amendment_supplement(parsed_hash)
+        end
+
+        if parsed_hash[:amendment].is_a?(Hash) && !parsed_hash[:base]
+          return build_flat_amendment(parsed_hash)
+        end
+
+        # Handle interpretation supplements (check for base + int_year)
+        if parsed_hash[:base] && (parsed_hash[:int_year] || parsed_hash[:interpretation])
           return build_interpretation_supplement(parsed_hash)
         end
 
-        # Handle conformance supplements (check for base_identifier + conf_number)
-        if parsed_hash[:base_identifier] && parsed_hash[:conf_number]
+        # The same document with a TRAILING DATE parses FLAT — no :base subtree,
+        # just an :interpretation marker beside the number — so the branch above
+        # skipped it and determine_identifier_class built a base-less
+        # InterpretationIdentifier that dropped the number, the part and the
+        # publisher: "IEEE Std 1003.2-1992/INT, Dec. 1994 Ed." rendered as
+        # " 1003.2-1992/INT". Mirrors build_flat_corrigendum / build_flat_amendment.
+        if parsed_hash[:interpretation] && !parsed_hash[:base]
+          return build_flat_interpretation(parsed_hash)
+        end
+
+        # Handle conformance supplements (check for base + conf_number)
+        if parsed_hash[:base] && parsed_hash[:conf_number]
           return build_conformance_supplement(parsed_hash)
         end
 
@@ -194,16 +319,32 @@ module Pubid
 
         # Route to appropriate identifier class based on content
         identifier_class = determine_identifier_class(attributes)
+        rename_supplement_keys(attributes)
         identifier_class.new(**attributes)
       end
 
-      # Build corrigendum supplement with recursive base parsing
-      # @param parsed_hash [Hash] parsed data with base and supplement info
-      # @return [Identifiers::Corrigendum] corrigendum identifier
-      def build_corrigendum_supplement(parsed_hash)
-        # Reconstruct base identifier string from parsed components
+      # Supplement wrappers (Corrigendum/Amendment/Conformance/Interpretation)
+      # store their ordinal/year under the uniform `number`/`year`, but the parse
+      # tree and class-routing above key on the distinct
+      # `cor_*`/`amd_*`/`conf_*`/`int_year` names. Translate them **after**
+      # routing, just before construction. Guards ensure a plain standard's own
+      # `number`/`year` are never overwritten (it carries none of these keys).
+      def rename_supplement_keys(attributes)
+        ordinal = attributes.delete(:cor_number) ||
+          attributes.delete(:amd_number) || attributes.delete(:conf_number)
+        attributes[:number] = ordinal if ordinal
+        year = attributes.delete(:cor_year) || attributes.delete(:amd_year) ||
+          attributes.delete(:conf_year) || attributes.delete(:int_year)
+        attributes[:year] = year if year
+      end
+
+      # Reconstruct the base identifier string from a parsed `:base` subtree
+      # (publisher/copublishers + type + number/part/subpart/year), so it can be
+      # recursively re-parsed by the supplement builders (corrigendum/amendment).
+      # @param base_data [Hash] the `:base` subtree
+      # @return [String] e.g. "IEEE Std 802.1AC-2016" or "535-2013"
+      def reconstruct_base_string(base_data)
         base_parts = []
-        base_data = parsed_hash[:base_identifier]
 
         # Extract publisher
         if base_data[:publishers]
@@ -256,22 +397,118 @@ module Pubid
         end
 
         base_parts << number_str
+        base_parts.join(" ")
+      end
 
-        # Build base string and recursively parse it
-        base_string = base_parts.join(" ")
-
-        # Recursively parse base identifier using Base.parse
-        base_identifier = Identifiers::Base.parse(base_string)
+      # Build corrigendum supplement with recursive base parsing
+      # @param parsed_hash [Hash] parsed data with base and supplement info
+      # @return [Identifiers::Corrigendum] corrigendum identifier
+      def build_corrigendum_supplement(parsed_hash)
+        # Recursively parse the base identifier reconstructed from the subtree.
+        base = Identifier.parse(reconstruct_base_string(parsed_hash[:base]))
 
-        # Extract corrigendum attributes
+        # Extract corrigendum attributes (parse-tree keys are cor_*; the
+        # identifier stores them as the uniform `number`/`year`).
         cor_number = extract_value(parsed_hash[:cor_number])
         cor_year = extract_value(parsed_hash[:cor_year])
 
         # Create Corrigendum with parsed base
         Identifiers::Corrigendum.new(
-          base_identifier: base_identifier,
-          cor_number: cor_number,
-          cor_year: cor_year,
+          base: base,
+          number: cor_number,
+          year: cor_year,
+        )
+      end
+
+      # Build a Corrigendum from the flat parse tree produced by the combined
+      # `…/Cor M-YYYY/D N` form, where the corrigendum lives in a top-level
+      # `corrigendum` hash and there is no `:base` subtree. Peel the corrigendum
+      # off, build the remaining attributes into the base standard (with its
+      # draft) via the normal single-identifier path, then wrap.
+      # @param parsed_hash [Hash] flat parsed data with a :corrigendum hash
+      # @return [Identifiers::Corrigendum]
+      def build_flat_corrigendum(parsed_hash)
+        cor_data = parsed_hash[:corrigendum]
+        cor_number = extract_value(cor_data[:cor_number])
+        cor_year = extract_value(cor_data[:cor_year]) if cor_data[:cor_year]
+
+        base_hash = parsed_hash.reject { |key, _| key == :corrigendum }
+        base = build_single_identifier(base_hash)
+
+        Identifiers::Corrigendum.new(
+          base: base,
+          number: cor_number,
+          year: cor_year,
+        )
+      end
+
+      # Build an interpretation from a FLAT parse tree — the trailing-date form,
+      # where the :interpretation marker sits beside the base's own keys instead
+      # of over a :base subtree.
+      #
+      # The trailing date is the INTERPRETATION's date (an interpretation of the
+      # 1992 edition of 1003.2, issued in Dec 1994), so it goes on the wrapper;
+      # the base keeps its own `year`. That matches the nested form, whose
+      # `int_year` also lands on the wrapper.
+      # @param parsed_hash [Hash] flat parsed data carrying :interpretation
+      # @return [Identifiers::InterpretationIdentifier]
+      def build_flat_interpretation(parsed_hash)
+        int_year = extract_value(parsed_hash[:trailing_year]) if parsed_hash[:trailing_year]
+
+        base_hash = parsed_hash.reject do |key, _|
+          %i[interpretation trailing_month trailing_year].include?(key)
+        end
+        base = build_single_identifier(base_hash)
+
+        # The trailing MONTH is deliberately dropped, matching the nested form
+        # (whose `int_year` carries no month either). It was not preserved
+        # before this change, so nothing is lost; and setting it fed the URN's
+        # month_day_component, which put "Dec." — a word with a dot — into a
+        # URN segment.
+        Identifiers::InterpretationIdentifier.new(
+          base: base,
+          year: int_year,
+        )
+      end
+
+      # Build amendment supplement with recursive base parsing. Mirrors
+      # {#build_corrigendum_supplement} — reconstructs the base identifier
+      # string, recursively parses it, and wraps it in an Amendment.
+      # @param parsed_hash [Hash] parsed data with base and amendment info
+      # @return [Identifiers::Amendment] amendment identifier
+      def build_amendment_supplement(parsed_hash)
+        base = Identifier.parse(reconstruct_base_string(parsed_hash[:base]))
+
+        amd_number = extract_value(parsed_hash[:amd_number])
+        amd_year = extract_value(parsed_hash[:amd_year])
+
+        Identifiers::Amendment.new(
+          base: base,
+          number: amd_number,
+          year: amd_year,
+        )
+      end
+
+      # Build an Amendment from the flat parse tree produced by the common
+      # `…/Amd N-YYYY` form, where the amendment lives in a top-level
+      # `amendment` hash and there is no `:base` subtree. Peel the amendment
+      # off, build the remaining attributes into the base standard via the
+      # normal single-identifier path, then wrap. Mirrors
+      # {#build_flat_corrigendum}.
+      # @param parsed_hash [Hash] flat parsed data with an :amendment hash
+      # @return [Identifiers::Amendment]
+      def build_flat_amendment(parsed_hash)
+        amd_data = parsed_hash[:amendment]
+        amd_number = extract_value(amd_data[:amd_number])
+        amd_year = extract_value(amd_data[:amd_year]) if amd_data[:amd_year]
+
+        base_hash = parsed_hash.reject { |key, _| key == :amendment }
+        base = build_single_identifier(base_hash)
+
+        Identifiers::Amendment.new(
+          base: base,
+          number: amd_number,
+          year: amd_year,
         )
       end
 
@@ -281,7 +518,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_identifier]
+        base_data = parsed_hash[:base]
 
         # Extract publisher
         if base_data[:publishers]
@@ -337,15 +574,15 @@ module Pubid
         base_string = base_parts.join(" ")
 
         # Recursively parse base identifier using Base.parse
-        base_identifier = Identifiers::Base.parse(base_string)
+        base = Identifier.parse(base_string)
 
         # Extract interpretation attributes
         int_year = extract_value(parsed_hash[:int_year])
 
-        # Create InterpretationIdentifier with parsed base
+        # Create InterpretationIdentifier with parsed base (int_year -> year)
         Identifiers::InterpretationIdentifier.new(
-          base_identifier: base_identifier,
-          int_year: int_year,
+          base: base,
+          year: int_year,
         )
       end
 
@@ -355,7 +592,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_identifier]
+        base_data = parsed_hash[:base]
 
         # Extract publisher
         if base_data[:publishers]
@@ -411,17 +648,17 @@ module Pubid
         base_string = base_parts.join(" ")
 
         # Recursively parse base identifier using Base.parse
-        base_identifier = Identifiers::Base.parse(base_string)
+        base = Identifier.parse(base_string)
 
         # Extract conformance attributes
         conf_number = extract_value(parsed_hash[:conf_number])
         conf_year = extract_value(parsed_hash[:conf_year])
 
-        # Create ConformanceIdentifier with parsed base
+        # Create ConformanceIdentifier with parsed base (conf_* -> number/year)
         Identifiers::ConformanceIdentifier.new(
-          base_identifier: base_identifier,
-          conf_number: conf_number,
-          conf_year: conf_year,
+          base: base,
+          number: conf_number,
+          year: conf_year,
         )
       end
 
@@ -445,8 +682,33 @@ module Pubid
         end
         attributes[:code] = code_str
 
-        # Extract year
-        attributes[:year] = extract_value(parsed[:year]) if parsed[:year]
+        # Extract year (and optional numeric month, e.g. the -MM of a historical
+        # "…-2018-05" ISO-stage date). The joint ISO/IEC rules also use the
+        # `edition` rule, whose year is captured as :edition_year (parser.rb);
+        # it is promoted to the identity only when no base :year was captured.
+        if parsed[:year]
+          attributes[:year] = extract_value(parsed[:year])
+        elsif parsed[:edition_year]
+          attributes[:year] = extract_value(parsed[:edition_year])
+        end
+        attributes[:month] = extract_value(parsed[:month]) if parsed[:month]
+
+        # Extract edition, from relaton's "/E-<n>" suffix (normalized to
+        # "Edition <n>.0"). nil-residue hand-off item 1.
+        attributes[:edition] = extract_value(parsed[:edition]) if parsed[:edition]
+        if parsed[:edition_month]
+          attributes[:edition_month] = extract_value(parsed[:edition_month])
+        end
+
+        # Extract draft version if present (e.g., D8 from /D8). This applies to
+        # both the ISO-led (bucket 5: "…FDIS P15289/D-3-2017") and IEEE-led
+        # forms, so it lives before the lead-party split.
+        if parsed[:draft_version]
+          draft_ver = extract_value(parsed[:draft_version])
+          # Remove leading 'D' if present since draft_version already has it
+          draft_ver = draft_ver.sub(/^D/, "") if draft_ver
+          attributes[:ieee_draft] = "D#{draft_ver}" if draft_ver
+        end
 
         # Detect lead party based on pattern
         if parsed[:iso_stage]
@@ -464,14 +726,6 @@ module Pubid
           # IEEE format - lead party is IEEE
           attributes[:lead_party] = "IEEE"
 
-          # Extract draft version if present (e.g., D8 from /D8)
-          if parsed[:draft_version]
-            draft_ver = extract_value(parsed[:draft_version])
-            # Remove leading 'D' if present since draft_version already has it
-            draft_ver = draft_ver.sub(/^D/, "") if draft_ver
-            attributes[:ieee_draft] = "D#{draft_ver}" if draft_ver
-          end
-
           # Mark as project (P prefix)
           attributes[:type] = "P"
 
@@ -555,9 +809,14 @@ module Pubid
           # Pattern: slash >> "C" >> digits >> dot >> digits >> dot >> digits >> dash >> year_digits
           # The parsed crossref is a string - extract the number part
           # Format: C62.22.1-1996 where C is part of the crossref notation
+          # The captured slice keeps the leading slash, which is a SEPARATOR in
+          # the printed reference, not part of the number. Storing it made the
+          # secondary's code "/C62.22.1-1996", which then failed the renderer's
+          # own cross-reference test (`/^C\d+\./`) and fell through to the
+          # " and " join. Strip it.
           secondary_id = Identifiers::Standard.new(
             publisher: "IEEE",
-            number: extract_value(crossref),
+            number: extract_value(crossref).to_s.sub(%r{\A/}, ""),
           )
         elsif parsed[:secondary_joint]
           # Joint standard format: ", Std 1177-1989"
@@ -616,6 +875,11 @@ module Pubid
           return Identifiers::Corrigendum
         end
 
+        # Check for amendment supplements (structural: has amd_number)
+        if attributes[:amd_number]
+          return Identifiers::Amendment
+        end
+
         # Check for multi-numbered standards (structural: has crossref or joint patterns)
         # These are handled at the build() method level, not here
         # (cross-reference patterns like /C62.22.1-1996 and joint standards)
@@ -625,13 +889,16 @@ module Pubid
           return Identifiers::AdoptedStandard
         end
 
-        # Check for redline standards (structural: has redline flag)
-        if attributes[:redline]
-          return Identifiers::RedlinedStandard
-        end
+        # A redline is a plain Standard carrying `redline: true` (a distinct
+        # document from its base) — NOT the RedlinedStandard wrapper, which
+        # expects a nested `base` the flat build path never sets. render_base
+        # restores the " - Redline" suffix from the flag.
 
-        # Default to base identifier
-        Identifiers::Base
+        # Default to the concrete Standard leaf (a plain published standard).
+        # Routing to a leaf — rather than instantiating the shared base
+        # Ieee::Identifier — is what lets `number` be a reliable :string index
+        # key (see Identifiers::Standard).
+        Identifiers::Standard
       end
 
       # Detect lead party for joint development identifiers
@@ -777,6 +1044,26 @@ module Pubid
         if parsed[:year]
           year_str = extract_value(parsed[:year])
           attributes[:year] = year_str
+        elsif parsed[:edition_year]
+          # The `edition` rule captures its own year under :edition_year (not
+          # :year) so it never collides with the base -YYYY (see parser.rb).
+          # With no base year the edition's year IS the document date and is
+          # promoted to the identity (e.g. "IEEE Std 802.11 Edition 3.0-2009"
+          # -> year 2009). When a base year exists it wins above and
+          # :edition_year is dropped — the edition ordinal is still kept.
+          attributes[:year] = extract_value(parsed[:edition_year])
+        elsif parsed[:trailing_year]
+          # No base -YYYY identity year: the trailing "Month YYYY" IS the
+          # document date (e.g. "IEEE Std 519, May 1993"), so promote it.
+          # When a base year exists it wins (the IEEE approval/identity year)
+          # and the trailing date is intentionally dropped rather than
+          # fabricating a wrong month/year pairing. The trailing captures use
+          # distinct keys (:trailing_month/:trailing_year) so they never collide
+          # with the base :year (Parslet no longer warns "Duplicate subtrees").
+          attributes[:year] = extract_value(parsed[:trailing_year])
+          if parsed[:trailing_month]
+            attributes[:month] = extract_value(parsed[:trailing_month])
+          end
         end
 
         # Extract edition_month if parsed separately
@@ -813,6 +1100,12 @@ module Pubid
         # Handle draft (can be complex)
         handle_draft(parsed, attributes)
 
+        # Default draft version 1 when the type indicates a Draft but the
+        # parser found no explicit version (issue #205). Real-world IEEE
+        # drafts always have at least version 1; the missing suffix is a
+        # source-data omission, not an undrafted document.
+        apply_default_draft_version(attributes, type_value)
+
         # Handle corrigendum
         handle_corrigendum(parsed, attributes)
 
@@ -927,15 +1220,36 @@ module Pubid
         attributes[key] = value if value
       end
 
+      # Default draft version to "1" when the identifier type indicates a
+      # Draft but the parser found no explicit version (issue #205).
+      def apply_default_draft_version(attributes, type_value)
+        return if attributes[:draft] || attributes[:draft_obj]
+        return unless type_value.to_s == "Draft Std"
+
+        attributes[:draft] = "D1"
+        # Carry the identifier's year into the draft object so the renderer
+        # doesn't drop it (the renderer suppresses the `-YYYY` suffix when
+        # a draft is attached, expecting the year to live inside /D...).
+        attributes[:draft_obj] =
+          Components::Draft.new(version: "1", year: attributes[:year])
+      end
+
       # Handle draft information
       def handle_draft(parsed, attributes)
         draft_data = parsed[:draft] || parsed[:digit_draft]
         return unless draft_data
 
-        # Draft can be an array of hash elements or a single hash
+        # Draft can be an array of hash elements or a single hash. The grammar's
+        # `draft_version.repeat(1,2)` splits a dotted designator like "1.2.6"
+        # into ["1.2", ".6"], so DON'T let a plain merge overwrite it (that
+        # dropped every part but the last — "1.2.6" -> ".6"). Collect ALL the
+        # draft_version parts into an array (the version extraction below joins
+        # them back into one verbatim string) and merge the remaining keys.
         if draft_data.is_a?(Array)
-          # Merge all elements in the array
-          merged = draft_data.inject({}) { |result, elem| result.merge(elem) }
+          hashes = draft_data.select { |e| e.is_a?(Hash) }
+          versions = hashes.filter_map { |e| e[:draft_version] }
+          merged = hashes.inject({}) { |result, elem| result.merge(elem) }
+          merged[:draft_version] = versions unless versions.empty?
           draft_data = merged
         end
 
@@ -955,6 +1269,9 @@ module Pubid
                       else
                         extract_value(dv)
                       end
+            # Normalize a leading hyphen ("/D-3.0" -> "3.0"); the draft
+            # designator is otherwise held verbatim so no digit is lost.
+            version = version.sub(/\A-/, "") if version
           end
 
           revision = extract_value(draft_data[:revision]) if draft_data[:revision]
@@ -1183,7 +1500,7 @@ module Pubid
 
       # Parse a list of identifier strings into identifier objects
       # @param list_data [Hash, Array, nil] the parsed identifier list data
-      # @return [Array<Identifiers::Base>] array of parsed identifier objects
+      # @return [Array<Identifier>] array of parsed identifier objects
       def parse_identifier_list(list_data)
         return [] unless list_data
 
@@ -1192,12 +1509,12 @@ module Pubid
 
         # Recursively parse each identifier string
         id_strings.map do |id_str|
-          # Use Identifiers::Base.parse for recursive parsing
-          Identifiers::Base.parse(id_str)
+          # Use Identifier.parse for recursive parsing
+          Identifier.parse(id_str)
         rescue Parslet::ParseFailed
           # If parsing fails, create minimal identifier with just the string
           # This maintains graceful degradation
-          Identifiers::Base.new(parenthetical_content: id_str)
+          Identifier.new(parenthetical_content: id_str)
         end
       end