pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/ieee/builder.rb

@@ -3,71 +3,59 @@
 module Pubid
   module Ieee
     # Builder class for constructing IEEE identifier scheme from parsed data
-    # Single Responsibility: Transform parsed data into identifier objects
+    # Single Responsibility: Transform parsed data into Scheme objects
     class Builder
       attr_accessor :original_input
       attr_reader :identifier_class
 
-      def initialize(identifier_class = Identifier)
+      def initialize(identifier_class = Identifiers::Base)
         @identifier_class = identifier_class
       end
 
       # Build a scheme object from parsed data
       # @param parsed [Hash, Array] the parsed identifier data
-      # @return [identifier] the constructed identifier object
+      # @return [Scheme] the constructed scheme 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 d[:ieee_portion] && d[:csa_portion]
+        if parsed[:ieee_portion] && parsed[: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 d[:first_aiee] && d[:second_aiee]
+        if parsed[:first_aiee] && parsed[:second_aiee]
           return build_combined_aiee(parsed)
         end
 
         # Handle dual published patterns
-        if d[:first] && d[:second]
+        if parsed[:first] && parsed[:second]
           return build_dual_published(parsed)
         end
 
         # Handle IEC/IEEE copublished patterns
-        if d[:content]
+        if parsed[:content]
           return build_iec_ieee_copublished(parsed)
         end
 
         # Handle NESC identifiers (National Electrical Safety Code)
-        if d[:nesc]
+        if parsed[:nesc]
           nesc_builder = Nesc::Builder.new
-          return nesc_builder.build(d[:nesc])
+          return nesc_builder.build(parsed[:nesc])
         end
 
         # Handle AIEE identifiers (American Institute of Electrical Engineers)
-        if d[:aiee]
+        if parsed[:aiee]
           aiee_builder = Aiee::Builder.new
-          return aiee_builder.build(d[:aiee])
+          return aiee_builder.build(parsed[:aiee])
         end
 
         # Handle IRE identifiers (Institute of Radio Engineers)
-        if d[:ire]
+        if parsed[:ire]
           ire_builder = Ire::Builder.new
-          return ire_builder.build(d[:ire])
+          return ire_builder.build(parsed[:ire])
         end
 
         # Handle IEEE/ASTM SI/PSI identifiers (Système International)
-        if d[:si_type]
+        if parsed[:si_type]
           return build_si_psi_identifier(parsed)
         end
 
@@ -124,59 +112,13 @@ 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])
@@ -211,33 +153,6 @@ 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
@@ -249,59 +164,19 @@ module Pubid
           return build_multi_numbered_identifier(parsed_hash)
         end
 
-        # Handle corrigendum supplements (check for base + cor_number)
+        # Handle corrigendum supplements (check for base_identifier + cor_number)
         # This enables recursive base identifier parsing like ISO/IEC Amendment
-        if parsed_hash[:base] && parsed_hash[:cor_number]
+        if parsed_hash[:base_identifier] && parsed_hash[:cor_number]
           return build_corrigendum_supplement(parsed_hash)
         end
 
-        # 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])
+        # Handle interpretation supplements (check for base_identifier + int_year)
+        if parsed_hash[:base_identifier] && (parsed_hash[:int_year] || parsed_hash[:interpretation])
           return build_interpretation_supplement(parsed_hash)
         end
 
-        # 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]
+        # Handle conformance supplements (check for base_identifier + conf_number)
+        if parsed_hash[:base_identifier] && parsed_hash[:conf_number]
           return build_conformance_supplement(parsed_hash)
         end
 
@@ -319,32 +194,16 @@ 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
 
-      # 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)
+      # 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
         base_parts = []
+        base_data = parsed_hash[:base_identifier]
 
         # Extract publisher
         if base_data[:publishers]
@@ -397,118 +256,22 @@ module Pubid
         end
 
         base_parts << number_str
-        base_parts.join(" ")
-      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)
-        # Recursively parse the base identifier reconstructed from the subtree.
-        base = Identifier.parse(reconstruct_base_string(parsed_hash[:base]))
+        # 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)
 
-        # Extract corrigendum attributes (parse-tree keys are cor_*; the
-        # identifier stores them as the uniform `number`/`year`).
+        # Extract corrigendum attributes
         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: 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,
+          base_identifier: base_identifier,
+          cor_number: cor_number,
+          cor_year: cor_year,
         )
       end
 
@@ -518,7 +281,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 = parsed_hash[:base_identifier]
 
         # Extract publisher
         if base_data[:publishers]
@@ -574,15 +337,15 @@ module Pubid
         base_string = base_parts.join(" ")
 
         # Recursively parse base identifier using Base.parse
-        base = Identifier.parse(base_string)
+        base_identifier = Identifiers::Base.parse(base_string)
 
         # Extract interpretation attributes
         int_year = extract_value(parsed_hash[:int_year])
 
-        # Create InterpretationIdentifier with parsed base (int_year -> year)
+        # Create InterpretationIdentifier with parsed base
         Identifiers::InterpretationIdentifier.new(
-          base: base,
-          year: int_year,
+          base_identifier: base_identifier,
+          int_year: int_year,
         )
       end
 
@@ -592,7 +355,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 = parsed_hash[:base_identifier]
 
         # Extract publisher
         if base_data[:publishers]
@@ -648,17 +411,17 @@ module Pubid
         base_string = base_parts.join(" ")
 
         # Recursively parse base identifier using Base.parse
-        base = Identifier.parse(base_string)
+        base_identifier = Identifiers::Base.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 (conf_* -> number/year)
+        # Create ConformanceIdentifier with parsed base
         Identifiers::ConformanceIdentifier.new(
-          base: base,
-          number: conf_number,
-          year: conf_year,
+          base_identifier: base_identifier,
+          conf_number: conf_number,
+          conf_year: conf_year,
         )
       end
 
@@ -682,33 +445,8 @@ module Pubid
         end
         attributes[:code] = code_str
 
-        # 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
+        # Extract year
+        attributes[:year] = extract_value(parsed[:year]) if parsed[:year]
 
         # Detect lead party based on pattern
         if parsed[:iso_stage]
@@ -720,18 +458,26 @@ module Pubid
           stage_abbr = attributes[:iso_stage]
           if stage_abbr
             attributes[:typed_stage] =
-              Pubid::Ieee.locate_stage(stage_abbr)
+              Ieee::Scheme.locate_typed_stage_by_abbr(stage_abbr)
           end
         else
           # 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"
 
           # Create typed_stage for IEEE project
           attributes[:typed_stage] =
-            Pubid::Ieee.locate_stage("P")
+            Ieee::Scheme.locate_typed_stage_by_abbr("P")
         end
 
         Identifiers::JointDevelopment.new(**attributes)
@@ -809,14 +555,9 @@ 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).to_s.sub(%r{\A/}, ""),
+            number: extract_value(crossref),
           )
         elsif parsed[:secondary_joint]
           # Joint standard format: ", Std 1177-1989"
@@ -834,7 +575,7 @@ module Pubid
       end
 
       # Determine which identifier class to use based on attributes
-      # CRITICAL: Use flavor module for type-based decisions, NOT hardcoded logic here
+      # CRITICAL: Use Scheme for type-based decisions, NOT hardcoded logic here
       # Builder's job is ONLY to cast types, not make business decisions
       def determine_identifier_class(attributes)
         # Check for AIEE publisher FIRST (AIEE has its own identifier class)
@@ -843,12 +584,12 @@ module Pubid
           return Ieee::Aiee::Identifier
         end
 
-        # Get type from attributes and use flavor module to locate class
+        # Get type from attributes and use Scheme to locate class
         type_code = attributes[:type]
 
-        # Use flavor module for type-to-class mapping
+        # Use Scheme registry for type-to-class mapping
         if type_code
-          klass = Pubid::Ieee.locate_type(type_code)
+          klass = Ieee::Scheme.locate_identifier_klass_by_type_code(type_code)
           return klass if klass
         end
 
@@ -875,11 +616,6 @@ 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)
@@ -889,16 +625,13 @@ module Pubid
           return Identifiers::AdoptedStandard
         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.
+        # Check for redline standards (structural: has redline flag)
+        if attributes[:redline]
+          return Identifiers::RedlinedStandard
+        end
 
-        # 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
+        # Default to base identifier
+        Identifiers::Base
       end
 
       # Detect lead party for joint development identifiers
@@ -945,7 +678,7 @@ module Pubid
 
       # Extract and normalize attributes from parsed data
       # @param parsed [Hash] the parsed data
-      # @return [Hash] normalized attributes for identifier
+      # @return [Hash] normalized attributes for Scheme
       def extract_attributes(parsed)
         attributes = {}
 
@@ -1044,26 +777,6 @@ 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
@@ -1072,7 +785,7 @@ module Pubid
         end
 
         # Set type attribute for backward compatibility (after P extraction)
-        # NOTE: "P" IS a type code that maps to ProjectDraftIdentifier via flavor module
+        # NOTE: "P" IS a type code that maps to ProjectDraftIdentifier via Scheme
         # Type can be: "Std", "No", "P" (project draft), etc.
         attributes[:type] = type_value if type_value
 
@@ -1081,7 +794,7 @@ module Pubid
                                                 parsed)
         if typed_stage_abbr
           attributes[:typed_stage] =
-            Pubid::Ieee.locate_stage(typed_stage_abbr)
+            Ieee::Scheme.locate_typed_stage_by_abbr(typed_stage_abbr)
         end
 
         attributes[:draft_status] = draft_status_value
@@ -1100,12 +813,6 @@ 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)
 
@@ -1173,7 +880,7 @@ module Pubid
             if version
               draft_abbr = "D#{version}"
               # Check if this specific draft stage is in registry
-              stage = Pubid::Ieee.locate_stage(draft_abbr)
+              stage = Ieee::Scheme.locate_typed_stage_by_abbr(draft_abbr)
               return draft_abbr if stage&.abbr&.include?(draft_abbr)
             end
           end
@@ -1220,36 +927,15 @@ 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. 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.
+        # Draft can be an array of hash elements or a single hash
         if draft_data.is_a?(Array)
-          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?
+          # Merge all elements in the array
+          merged = draft_data.inject({}) { |result, elem| result.merge(elem) }
           draft_data = merged
         end
 
@@ -1269,9 +955,6 @@ 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]
@@ -1500,7 +1183,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<Identifier>] array of parsed identifier objects
+      # @return [Array<Identifiers::Base>] array of parsed identifier objects
       def parse_identifier_list(list_data)
         return [] unless list_data
 
@@ -1509,12 +1192,12 @@ module Pubid
 
         # Recursively parse each identifier string
         id_strings.map do |id_str|
-          # Use Identifier.parse for recursive parsing
-          Identifier.parse(id_str)
+          # Use Identifiers::Base.parse for recursive parsing
+          Identifiers::Base.parse(id_str)
         rescue Parslet::ParseFailed
           # If parsing fails, create minimal identifier with just the string
           # This maintains graceful degradation
-          Identifier.new(parenthetical_content: id_str)
+          Identifiers::Base.new(parenthetical_content: id_str)
         end
       end