pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iso.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+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"
+    autoload :Components, "#{__dir__}/iso/components"
+    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 :SingleIdentifier, "#{__dir__}/iso/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/iso/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/iso/urn_generator"
+    autoload :UrnParser, "#{__dir__}/iso/urn_parser"
+    autoload :Utilities, "#{__dir__}/iso/utilities"
+
+    # Parse an ISO identifier string
+    # @param identifier [String] the identifier string to parse
+    # @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
+      when :urn
+        UrnParser.parse(identifier)
+      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)
+      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
+    # @return [Identifier] the parsed identifier
+    # @raise [Errors::ParseError] if URN is invalid
+    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
+
+Pubid::Registry.register(:iso, Pubid::Iso)

data/lib/pubid/itu/builder.rb

@@ -0,0 +1,360 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        # "Annex to ..." identifier — wraps a Special Publication base
+        if data[:annex_to]
+          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
+        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)
+        end
+
+        # Build basic recommendation or combined identifier
+        sector = Components::Sector.new(sector: data[:sector].to_s)
+        series = Components::Series.new(series: data[:series].to_s) if data[:series]
+        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]
+          return Identifiers::CombinedIdentifier.new(
+            sector: sector,
+            series: series,
+            code: code,
+            combined: build_designations(data[:combined]),
+            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(
+          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
+      # in its constructor.
+      def build_special_publication(data)
+        Identifiers::SpecialPublication.new(
+          series: Components::Series.new(series: "OB"),
+          code: data[:number] ? build_code(data) : nil,
+          date: data[:year] ? build_date(data) : nil,
+          language: data[:language]&.to_s,
+        )
+      end
+
+      # Build "Annex to ..." identifier. The inner data is the Special
+      # Publication; the annex inherits its language.
+      def build_annex(inner_data)
+        base = build_special_publication(inner_data)
+        Identifiers::Annex.new(
+          base: base,
+          language: inner_data[:language]&.to_s,
+        )
+      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]
+
+        # Determine supplement type
+        supplement_type = data[:supplement_type].to_s.gsub(".", "")
+        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)
+        supplement_date = if data[:supplement_year]
+                            Pubid::Components::Date.new(
+                              year: data[:supplement_year].to_s,
+                              month: data[:supplement_month]&.to_s,
+                            )
+                          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,
+          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
+
+      def build_date(data)
+        Pubid::Components::Date.new(
+          year: data[:year].to_s,
+          month: data[:month]&.to_s,
+        )
+      end
+
+      def extract_parts(parts_data)
+        return [] unless parts_data
+
+        parts = []
+        if parts_data.is_a?(Array)
+          parts_data.each do |part_hash|
+            parts << part_hash[:part].to_s if part_hash[:part]
+          end
+        elsif parts_data.is_a?(Hash) && parts_data[:part]
+          parts << parts_data[:part].to_s
+        end
+
+        parts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+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).
+      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 }
+
+        # 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 += ".#{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 &&
+            subseries == other.subseries &&
+            parts == other.parts &&
+            qualifier == other.qualifier
+        end
+      end
+    end
+  end
+end