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

data/lib/pubid/iso.rb

@@ -4,12 +4,6 @@ require "lutaml/model"
 
 module Pubid
   module Iso
-    extend Pubid::PrefixesSupport
-
-    # Sole ISO publisher token. Joint / co-publication forms (ISO/IEC, IEC/ISO,
-    # ISO/IEC/IEEE) are contributed symmetrically via Pubid::JOINT_PREFIXES.
-    PREFIXES = ["ISO"].freeze
-
     autoload :Builder, "#{__dir__}/iso/builder"
     autoload :BundledIdentifier, "#{__dir__}/iso/bundled_identifier"
     autoload :CombinedIdentifier, "#{__dir__}/iso/combined_identifier"
@@ -17,9 +11,9 @@ module Pubid
     autoload :FormatResolver, "#{__dir__}/iso/format_resolver"
     autoload :Identifier, "#{__dir__}/iso/identifier"
     autoload :Identifiers, "#{__dir__}/iso/identifiers"
-    autoload :Normalizer, "#{__dir__}/iso/normalizer"
     autoload :Parser, "#{__dir__}/iso/parser"
     autoload :RenderingStyle, "#{__dir__}/iso/rendering_style"
+    autoload :Scheme, "#{__dir__}/iso/scheme"
     autoload :SingleIdentifier, "#{__dir__}/iso/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/iso/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/iso/urn_generator"
@@ -31,15 +25,6 @@ module Pubid
     # @param format [Symbol] :auto, :human, :mr_string, or :urn
     # @return [Identifier] the parsed identifier
     def self.parse(identifier, format: :auto)
-      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
-
       format = Pubid::FormatDetector.detect(identifier) if format == :auto
 
       case format
@@ -48,77 +33,9 @@ module Pubid
       when :mr_string
         Pubid::Parsers::MrString.parse(identifier)
       else
-        Normalizer.apply(identifier)
-      end
-    end
-
-    # Build an ISO identifier from attributes.
-    #
-    # This is the public seam: callers in other flavors should never reach
-    # into `Pubid::Iso::Identifiers::*` or `Pubid::Iso::Components::*`
-    # directly — go through this method so the internal class registry can
-    # change without breaking callers.
-    #
-    # Accepts either raw values (Strings/Integers) or pre-built components.
-    # Raw values are wrapped in the appropriate ISO component internally.
-    #
-    # @param type [Symbol] the type key (e.g. :is, :tr, :ts, :guide)
-    # @param publisher [String, Pubid::Iso::Components::Publisher] primary publisher
-    # @param copublishers [Array<String>, Array<Pubid::Components::Publisher>]
-    # @param number [String, Integer, Pubid::Iso::Components::Code]
-    # @param year [String, Integer, Pubid::Components::Date, nil]
-    # @param attrs [Hash] additional identifier attributes
-    # @return [Pubid::Iso::Identifier]
-    def self.build(type:, publisher: nil, copublishers: nil, number: nil,
-                   year: nil, **attrs)
-      klass = locate_type(type) || raise(ArgumentError, "unknown ISO type: #{type.inspect}")
-
-      copub_list = Array(copublishers)
-      attrs[:publisher] = build_publisher(publisher, copub_list) if publisher || copub_list.any?
-      attrs[:copublishers] = build_copublishers(copub_list) if copub_list.any?
-      attrs[:number] = build_code(number) if number
-      attrs[:date] = build_date(year) if year
-
-      klass.new(attrs)
-    end
-
-    # @!visibility private
-    def self.build_publisher(value, copublishers = [])
-      return value if value.is_a?(Components::Publisher) && copublishers.empty?
-
-      copub_strings = copublishers.map { |cp| cp.is_a?(Components::Publisher) ? cp.publisher : cp.to_s }
-      Components::Publisher.new(
-        publisher: value.is_a?(Components::Publisher) ? value.publisher : value.to_s,
-        copublisher: copub_strings,
-      )
-    end
-    private_class_method :build_publisher
-
-    # @!visibility private
-    def self.build_copublishers(list)
-      Array(list).map do |cp|
-        next cp if cp.is_a?(Components::Publisher)
-
-        Components::Publisher.new(publisher: cp.to_s)
+        Scheme.parse(identifier)
       end
     end
-    private_class_method :build_copublishers
-
-    # @!visibility private
-    def self.build_code(value)
-      return value if value.is_a?(Components::Code)
-
-      Components::Code.new(value: value.to_s)
-    end
-    private_class_method :build_code
-
-    # @!visibility private
-    def self.build_date(value)
-      return value if value.is_a?(::Pubid::Components::Date)
-
-      ::Pubid::Components::Date.new(year: value.to_s)
-    end
-    private_class_method :build_date
 
     # Parse an ISO URN string
     # @param urn [String] the URN string to parse
@@ -127,109 +44,6 @@ module Pubid
     def self.parse_urn(urn)
       UrnParser.parse(urn)
     end
-
-    # Build an ISO identifier from a Parslet parse-tree hash (used by other
-    # flavors when parsing joint identifiers, e.g. IEC's `IEC … | ISO …` form).
-    #
-    # This is the public seam: callers should never reach into
-    # `Pubid::Iso::Builder` directly.
-    #
-    # @param hash [Hash] parse tree for an ISO identifier
-    # @return [Pubid::Iso::Identifier]
-    def self.build_from_parse(hash)
-      builder.build(hash)
-    end
-
-    # Return the named Parslet rule atom from the ISO parser, for embedding in
-    # another flavor's grammar (e.g. IEC joint identifiers).
-    #
-    # This is the public seam: callers should never instantiate
-    # `Pubid::Iso::Parser` directly.
-    #
-    # @param rule_name [Symbol] the parser rule to expose
-    # @return [Parslet::Atoms::Base]
-    def self.joint_grammar_atom(rule_name)
-      parser.public_send(rule_name)
-    end
-
-    # Auto-discover all identifier types from the Identifiers namespace
-    # @return [Array<Class>] identifier classes that define a self.type Hash
-    def self.identifier_types
-      @identifier_types ||= Identifiers.constants
-        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
-        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
-        .select { |c| c.type.is_a?(Hash) }
-    end
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>] all typed stages
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        if klass.const_defined?(:TYPED_STAGES)
-          klass.const_get(:TYPED_STAGES)
-        else
-          []
-        end
-      end
-    end
-
-    # Memoized builder instance used by Normalizer / URN parser
-    # @return [Pubid::Iso::Builder]
-    def self.builder
-      @builder ||= Builder.new
-    end
-
-    # Memoized parser instance used by Normalizer
-    # @return [Pubid::Iso::Parser]
-    def self.parser
-      @parser ||= Parser.new
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol] the type key to find
-    # @return [Class, nil] the matching identifier class
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    # Lookup: abbreviation -> typed stage
-    # @param abbr [String, Symbol] the abbreviation to find
-    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
-    def self.locate_stage(abbr)
-      abbr_str = abbr.to_s.upcase
-      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
-    end
-
-    # Lookup: stage code -> typed stage
-    # @param stage_code [String, Symbol]
-    # @return [Pubid::Components::TypedStage, nil]
-    def self.locate_stage_by_stage_code(stage_code)
-      stage_code_sym = stage_code.to_sym
-      all_typed_stages.find { |s| s.stage_code.to_sym == stage_code_sym }
-    end
-
-    # Lookup: per-typed-stage code -> typed stage
-    # @param code [String, Symbol]
-    # @return [Pubid::Components::TypedStage, nil]
-    def self.locate_stage_by_code(code)
-      code_sym = code.to_sym
-      all_typed_stages.find { |s| s.code&.to_sym == code_sym }
-    end
-
-    # Lookup: harmonized stage code -> typed stage
-    # @param harmonized_code [String]
-    # @return [Pubid::Components::TypedStage, nil]
-    def self.locate_stage_by_harmonized_code(harmonized_code)
-      harmonized_str = harmonized_code.to_s
-      all_typed_stages.find { |s| s.harmonized_stages&.include?(harmonized_str) }
-    end
-
-    # Default typed stage used when no type_with_stage is present
-    # (e.g., the bare International Standard published stage)
-    # @return [Pubid::Components::TypedStage]
-    def self.default_typed_stage
-      locate_stage("") || all_typed_stages.first
-    end
   end
 end
 

data/lib/pubid/itu/builder.rb

@@ -1,5 +1,17 @@
 # frozen_string_literal: true
 
+require_relative "../components/date"
+require_relative "components/sector"
+require_relative "components/series"
+require_relative "components/code"
+require_relative "identifiers/recommendation"
+require_relative "identifiers/combined_identifier"
+require_relative "identifiers/supplement"
+require_relative "identifiers/amendment"
+require_relative "identifiers/corrigendum"
+require_relative "identifiers/special_publication"
+require_relative "identifiers/annex"
+
 module Pubid
   module Itu
     class Builder
@@ -13,59 +25,15 @@ module Pubid
           return build_annex(data[:annex_to])
         end
 
-        # Common-text twin ("| ISO/IEC ..." suffix) — extract before building
-        # the base ITU identifier, then attach to whichever class the base
-        # resolves to.
-        twin = parse_common_text_twin(data.delete(:common_text_twin))
-
-        # Labelled annex of a Recommendation — "ITU-T A.23 Annex A (06/2014)".
-        # The annexed document is the :base subtree; :year/:month at this level
-        # are the annex's own date, not the base's.
-        if data[:annex_number]
-          annex = build_annex_of_recommendation(data)
-          annex.common_text_twin = twin if twin
-          return annex
-        end
-
-        # Labelled appendix of a Recommendation — "ITU-T G.101 App. I
-        # (05/2000)". Same shape as the annex above.
-        if data[:appendix_number]
-          appendix = build_appendix_of_recommendation(data)
-          appendix.common_text_twin = twin if twin
-          return appendix
-        end
-
         # Operational Bulletin (Special Publication) — series == "OB" or
         # legacy long form ("Operational Bulletin No. ...").
-        # The series_dash guard keeps a series-code "ITU-T OB-1" out of this
-        # branch, which would drop the dash and render it "ITU OB No. 1".
-        # Belt-and-braces: `series_code_body` already refuses "OB" + dash, so
-        # nothing reaches here with both set — the guard documents that coupling
-        # so removing the parser's `absent?` fails loudly rather than silently
-        # rerouting.
-        if (data[:series].to_s == "OB" && data[:series_dash].nil?) ||
-            data[:_op_bull]
-          sp = build_special_publication(data)
-          sp.common_text_twin = twin if twin && sp
-          return sp
+        if data[:series].to_s == "OB" || data[:_op_bull]
+          return build_special_publication(data)
         end
 
         # Check if this is a supplement identifier
         if data[:supplement_type]
-          supp = build_supplement(data)
-          supp.common_text_twin = twin if twin && supp
-          return supp
-        end
-
-        # Handbook — "ITU-R 42.HDB"
-        if data[:handbook_marker]
-          return build_handbook(data)
-        end
-
-        # Question — numeric ("ITU-R 234-1/7:") or letter-series
-        # ("ITU-R P.3/BL/7"). Both carry a :study_group marker.
-        if data[:study_group]
-          return build_question(data)
+          return build_supplement(data)
         end
 
         # Build basic recommendation or combined identifier
@@ -74,77 +42,44 @@ module Pubid
         code = build_code(data) if data[:number]
         date = build_date(data) if data[:year]
 
-        # Combined (joint) recommendation — one or more additional
-        # "/SERIES.CODE" designations after the primary (e.g. "G.780/Y.1351",
-        # "G.780/Y.1351/Z.1362"). The primary stays on the base series/code.
-        if data[:combined]
+        # Check if this is a combined identifier (has combined_series and combined_number)
+        if data[:combined_series] || data[:combined_number]
+          if data[:combined_series]
+            combined_series = Components::Series.new(
+              series: data[:combined_series][:series].to_s,
+            )
+          end
+
+          if data[:combined_number]
+            combined_code = Components::Code.new(
+              number: data[:combined_number].to_s,
+              subseries: data[:combined_subseries]&.to_s,
+              parts: extract_parts(data[:combined_parts]),
+            )
+          end
+
           return Identifiers::CombinedIdentifier.new(
             sector: sector,
             series: series,
             code: code,
-            combined: build_designations(data[:combined]),
+            combined_series: combined_series,
+            combined_code: combined_code,
             date: date,
-            version: data[:version]&.to_s,
-            # with_series offers these slots on either side of
-            # combined_suffixes, so a joint id can carry them too; not
-            # forwarding them let "ITU-T H.350/X.1 attachment" compare equal to
-            # the un-attached document.
-            series_word: !data[:series_word].nil?,
-            series_dash: !data[:series_dash].nil?,
-            attachment: !data[:attachment].nil?,
-            range_end: data[:range_end]&.to_s,
             language: data[:language]&.to_s,
-            common_text_twin: twin,
           )
         end
 
-        # A Report ("Report ITU-R BT.2020-1") is shaped exactly like a
-        # Recommendation — only the leading word, captured as :report_marker,
-        # tells the two apart, and it has to, because the two series number
-        # independently and the same series/number is two real documents.
-        klass = data[:report_marker] ? Identifiers::Report : Identifiers::Recommendation
-
-        klass.new(
+        Identifiers::Recommendation.new(
           sector: sector,
           series: series,
           code: code,
           date: date,
-          version: data[:version]&.to_s,
-          series_word: !data[:series_word].nil?,
-          series_dash: !data[:series_dash].nil?,
-          attachment: !data[:attachment].nil?,
-          range_end: data[:range_end]&.to_s,
           language: data[:language]&.to_s,
-          common_text_twin: twin,
         )
       end
 
-      # Parse the common-text twin string ("| ISO/IEC 13818-1:2022") into
-      # the appropriate flavor's identifier object. Returns nil if the twin
-      # is empty or unparseable.
-      def parse_common_text_twin(twin_raw)
-        return nil if twin_raw.nil?
-
-        twin_str = twin_raw.to_s.strip
-        # Strip a leading pipe if the parser captured it
-        twin_str = twin_str.sub(/\A\s*\|\s*/, "")
-        return nil if twin_str.empty?
-
-        case twin_str
-        when /\AISO\/IEC\b/, /\AISO\b/
-          Pubid::Iso.parse(twin_str)
-        when /\AIEC\b/
-          Pubid::Iec.parse(twin_str)
-        end
-      rescue StandardError
-        # If the twin doesn't parse as a known flavor, leave it as nil
-        # rather than blowing up the whole parse — the ITU half is still
-        # usable on its own.
-        nil
-      end
-
       # Build Special Publication (OB). Sector is silently dropped — OB is a
-      # cross-bureau publication and `Identifier` rejects sector+OB
+      # cross-bureau publication and `Identifiers::Base` rejects sector+OB
       # in its constructor.
       def build_special_publication(data)
         Identifiers::SpecialPublication.new(
@@ -165,59 +100,6 @@ module Pubid
         )
       end
 
-      # Build a labelled annex of a Recommendation. sector/series/code are
-      # deliberately NOT copied from the base: they are not serialized on the
-      # wrapper, so copies would make a from_hash-rebuilt annex differ from the
-      # parsed one.
-      def build_annex_of_recommendation(data)
-        Identifiers::AnnexOfRecommendation.new(
-          base: build(data[:base]),
-          number: data[:annex_number].to_s,
-          date: data[:year] ? build_date(data) : nil,
-          language: data[:language]&.to_s,
-        )
-      end
-
-      # Build a labelled appendix of a Recommendation. Like the annex above,
-      # sector/series/code are deliberately NOT copied from the base — they are
-      # not serialized on the wrapper, so copies would make a from_hash-rebuilt
-      # appendix differ from the parsed one.
-      def build_appendix_of_recommendation(data)
-        Identifiers::AppendixOfRecommendation.new(
-          base: build(data[:base]),
-          number: data[:appendix_number].to_s,
-          material: data[:appendix_material]&.to_s,
-          date: data[:year] ? build_date(data) : nil,
-          language: data[:language]&.to_s,
-        )
-      end
-
-      # Build Handbook ("ITU-R 42.HDB").
-      def build_handbook(data)
-        Identifiers::Handbook.new(
-          sector: Components::Sector.new(sector: data[:sector].to_s),
-          code: build_code(data),
-          date: data[:year] ? build_date(data) : nil,
-        )
-      end
-
-      # Build Question (numeric or letter-series).
-      def build_question(data)
-        series = if data[:series]
-                   Components::Series.new(series: data[:series].to_s)
-                 end
-
-        Identifiers::Question.new(
-          sector: Components::Sector.new(sector: data[:sector].to_s),
-          series: series,
-          code: build_code(data),
-          study_group: data[:study_group].to_s,
-          has_bl: !data[:has_bl].nil?,
-          bracketed: !data[:bracketed].nil?,
-          has_colon: !data[:question_colon].nil?,
-        )
-      end
-
       def build_supplement(data)
         # Build the base identifier first
         base = build(data[:base]) if data[:base]
@@ -227,22 +109,10 @@ module Pubid
         klass = case supplement_type
                 when "Amd"
                   Identifiers::Amendment
-                when "Add"
-                  Identifiers::Addendum
                 when "Cor"
                   Identifiers::Corrigendum
-                when "Err"
-                  Identifiers::Errata
                 when "Suppl"
                   Identifiers::Supplement
-                else
-                  # Previously fell through to a nil class and died with
-                  # "undefined method 'new' for nil" one frame later. Any token
-                  # added to Parser#supplement_type without a class here should
-                  # say so.
-                  raise ArgumentError,
-                        "Unknown ITU supplement type: " \
-                        "#{data[:supplement_type].inspect}"
                 end
 
         # Build supplement date (separate from base date)
@@ -253,84 +123,25 @@ module Pubid
                             )
                           end
 
-        # Sector/series are copied from the base when it has them; the fallback
-        # to this level's own tokens is guarded because an annex base keeps
-        # sector/series/code on *its* base, leaving all three nil here while the
-        # supplement level carries no sector token of its own.
-        # An annex base keeps sector/series/code on *its* base, so reach through
-        # it via #root; otherwise a supplement of an annex would carry none of
-        # them and its MR string would collapse to a bare "itu.<date>".
-        base_identity = base&.sector ? base : base&.root
-        sector = base_identity&.sector ||
-          (Components::Sector.new(sector: data[:sector].to_s) if data[:sector])
-        series = base_identity&.series ||
-          (Components::Series.new(series: data[:series].to_s) if data[:series])
-
-        attrs = {
-          sector: sector,
-          series: series,
-          code: base_identity&.code,
+        # Build supplement with extracted components
+        klass.new(
+          sector: base&.sector || Components::Sector.new(sector: data[:sector].to_s),
+          series: base&.series || (data[:series] ? Components::Series.new(series: data[:series].to_s) : nil),
+          code: base&.code,
           base: base,
           number: data[:supplement_number].to_s,
-          # The marker is the captured space, so its ABSENCE is the flag.
-          number_glued: data[:supplement_space].nil?,
-          slash_joined: !data[:supplement_slash].nil?,
           date: supplement_date,
           language: data[:language]&.to_s,
-        }
-        # The "series" word rides on the supplement for the base-less,
-        # series-only form; with a base it is the base's, and renders from
-        # there. It is copied up anyway (like sector/series/code above) so the
-        # supplement's own MR slug stays distinct — `render_supplement` and the
-        # base-nil-guarded key_value/== only consult it when base is nil, so
-        # the copy is render- and serialization-neutral.
-        attrs[:series_word] = if base
-                                !!base_identity&.series_word
-                              else
-                                !data[:series_word].nil?
-                              end
-        attrs[:technical] = true if data[:technical] &&
-          klass == Identifiers::Corrigendum
-
-        klass.new(**attrs)
+        )
       end
 
       private
 
-      # Build the additional designations of a combined recommendation from the
-      # repeated parse subtrees (each `{ designation: { series:, number:, … } }`).
-      def build_designations(combined_data)
-        Array(combined_data).map do |element|
-          d = element[:designation] || element
-          Components::Designation.new(
-            series: Components::Series.new(series: d[:series].to_s),
-            code: Components::Code.new(
-              number: d[:number].to_s,
-              series_suffix: d[:series_suffix]&.to_s,
-              series_suffix_spaced: !d[:series_suffix_spaced].nil?,
-              subseries: d[:subseries]&.to_s,
-              parts: extract_parts(d[:parts]),
-              qualifier: d[:qualifier]&.to_s,
-              qualifier_glued: !d[:qualifier].nil? && d[:qualifier_spaced].nil?,
-            ),
-          )
-        end
-      end
-
       def build_code(data)
         Components::Code.new(
-          imp_marker: data[:imp_marker]&.to_s,
           number: data[:number].to_s,
-          series_suffix: data[:series_suffix]&.to_s,
-          # The marker is the captured separating space, so its presence is
-          # the flag for the edition word and its ABSENCE is the flag for the
-          # qualifier letter (whose majority spelling is spaced).
-          series_suffix_spaced: !data[:series_suffix_spaced].nil?,
           subseries: data[:subseries]&.to_s,
           parts: extract_parts(data[:parts]),
-          qualifier: data[:qualifier]&.to_s,
-          qualifier_glued: !data[:qualifier].nil? &&
-            data[:qualifier_spaced].nil?,
         )
       end
 

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

@@ -6,77 +6,32 @@ module Pubid
   module Itu
     module Components
       # ITU Code component
-      # Format: [Imp]NUMBER[SUFFIX][.SUBSERIES][-PART]
-      # Examples: 1234, 1234.5, 1234-1, 1234.5-2, 50bis, 8bis, Imp712, ImpOSI
-      #
-      # The optional "Imp" marker identifies an Implementers' Guide for the
-      # series (e.g. G.Imp712, X.ImpOSI); the NUMBER that follows may be
-      # digits or a short letter string.
-      #
-      # SUFFIX is the edition marker "bis" / "ter" / "quater" attached
-      # directly to the number (e.g. X.50bis, V.8bis).
-      #
-      # Stays independent of Pubid::Components::Code because ITU uses
-      # +subseries+ (dot-separated, flavor-specific) and +parts+
-      # (dash-separated).
+      # Format: NUMBER[.SUBSERIES][-PART]
+      # Examples: 1234, 1234.5, 1234-1, 1234.5-2
       class Code < Lutaml::Model::Serializable
-        attribute :imp_marker, :string
         attribute :number, :string
-        attribute :series_suffix, :string
-        # ITU prints the edition word both glued ("X.50bis") and space-
-        # separated ("E.250 bis"). The word itself is stored without the space,
-        # so `series_suffix` stays a clean, whitespace-free value to compare and
-        # index on; the spacing is this rendering-only flag. Named for the
-        # rarer-in-code form so the `false` default stays out of `to_hash`.
-        attribute :series_suffix_spaced, :boolean, default: -> { false }
         attribute :subseries, :string
-        attribute :parts, :string, collection: true, default: []
-        # A single trailing letter distinguishing variants of one
-        # Recommendation: "D.200 R" (old D-series tariff recommendations),
-        # "Q.2931 B", "R.38 A", the glued "D.502R" and the lowercase
-        # "I.256.2a". Spaced is the majority spelling, so the glued one is the
-        # flag.
-        attribute :qualifier, :string
-        attribute :qualifier_glued, :boolean, default: -> { false }
+        attribute :parts, :string, collection: true
+
+        def initialize(number:, subseries: nil, parts: nil)
+          @number = number
+          @subseries = subseries
+          @parts = parts || []
+        end
 
-        # Segment order mirrors the grammar exactly — a GLUED suffix is
-        # captured inside `standard_code` (the edition word before the
-        # subseries, the qualifier after the parts), while a SPACED one is
-        # captured afterwards by `code_suffixes`. Rendering the edition word
-        # unconditionally first would print "Q.11a bis" back as "Q.11 bisa".
         def to_s
-          result = "#{imp_marker}#{number}"
-          result += series_suffix.to_s if series_suffix && !series_suffix_spaced
+          result = number.to_s
           result += ".#{subseries}" if subseries
           result += parts.map { |p| "-#{p}" }.join if parts&.any?
-          result += qualifier.to_s if qualifier && qualifier_glued
-          result += " #{series_suffix}" if series_suffix && series_suffix_spaced
-          result += " #{qualifier}" if qualifier && !qualifier_glued
           result
         end
 
-        # Space-free rendering for URN and MR use: the print form may separate
-        # the edition word or the qualifier letter with a space ("E.250 bis",
-        # "D.200 R"), which is not admissible inside a URN segment. Removing
-        # the space keeps "D.200" and "D.200 R" on distinct URNs, which
-        # dropping the suffix would not.
-        def compact_s
-          to_s.delete(" ")
-        end
-
-        def render(context: nil)
-          to_s
-        end
-
         def ==(other)
           return false unless other.is_a?(Code)
 
-          imp_marker == other.imp_marker &&
-            number == other.number &&
-            series_suffix == other.series_suffix &&
+          number == other.number &&
             subseries == other.subseries &&
-            parts == other.parts &&
-            qualifier == other.qualifier
+            parts == other.parts
         end
       end
     end