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

data/lib/pubid/iala.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iala
-    extend Pubid::PrefixesSupport
-
-    # Sole IALA publisher token (see the parser's `publisher` rule).
-    PREFIXES = ["IALA"].freeze
-
-    autoload :Builder,      "#{__dir__}/iala/builder"
-    autoload :Identifier,   "#{__dir__}/iala/identifier"
-    autoload :Identifiers,  "#{__dir__}/iala/identifiers"
-    autoload :Parser,       "#{__dir__}/iala/parser"
-    autoload :Renderer,     "#{__dir__}/iala/renderer"
-    autoload :UrnGenerator, "#{__dir__}/iala/urn_generator"
-    autoload :UrnParser,    "#{__dir__}/iala/urn_parser"
-
-    # Parse an IALA identifier string into an identifier object.
-    # @param identifier [String] The IALA identifier string to parse
-    # @return [Pubid::Iala::Identifier]
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Iala::Renderer)
-
-    # Auto-discover all identifier types from the Identifiers namespace.
-    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
-    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 < Pubid::Identifier }
-        .reject { |c| c == Identifier }
-    end
-
-    # Build typed stage index from identifier types
-    # @return [Array<Pubid::Components::TypedStage>]
-    def self.all_typed_stages
-      @all_typed_stages ||= identifier_types.flat_map do |klass|
-        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
-      end
-    end
-
-    # Lookup: type code -> identifier class
-    # @param code [String, Symbol]
-    # @return [Class, nil]
-    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]
-    # @return [Pubid::Components::TypedStage, nil]
-    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
-
-    # Look up an identifier class by its IALA type letter (S, R, G, M, C, X, P).
-    # @param letter [String]
-    # @return [Class<Identifier>]
-    def self.identifier_klass_for_type_letter(letter)
-      @by_letter ||= identifier_types.to_h { |klass| [klass.type[:short], klass] }
-      @by_letter.fetch(letter.to_s.upcase)
-    end
-  end
-end
-
-Pubid::Registry.register(:iala, Pubid::Iala)

data/lib/pubid/iana/builder.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    # Builds an IANA identifier object from a parse tree. There is a single
-    # concrete type (Registry), so the builder just extracts the slug fields.
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        # The top-level slug is stored as `number` — it is the relaton-index
-        # key; `Identifier#registry` reads it back.
-        Identifiers::Registry.new(
-          number: data[:registry].to_s,
-          sub_registry: data[:sub_registry]&.to_s,
-        )
-      end
-    end
-  end
-end

data/lib/pubid/iana/identifier.rb

@@ -1,140 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    # Base class for every IANA identifier AND the flavor's parse/create entry
-    # point. Concrete identifiers under Pubid::Iana::Identifiers descend from
-    # this class, so a parsed IANA id is an instance of Pubid::Iana::Identifier.
-    #
-    # IANA entries are protocol registries, not numbered standards: the value is
-    # a hierarchical registry slug (`registry` before the single "/", optional
-    # `sub_registry` after it). Both are kept verbatim.
-    #
-    # The top-level slug is stored as `number` on the concrete leaf
-    # (Identifiers::Registry) so it can serve as the relaton-index key; see the
-    # long comment there for why the attribute lives on the leaf. `registry` is
-    # a derived reader over it, so it is NOT a serialized key.
-    class Identifier < ::Pubid::Identifier
-      # The sub-registry slug (e.g. "lowpan_nhc"). nil for top registries; a nil
-      # default means it is dropped from the serialized hash when absent.
-      attribute :sub_registry, :string
-
-      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
-      # the single Registry subclass's polymorphic_name to its class name so a
-      # stored hash rebuilds the correct identifier type via from_hash.
-      IANA_TYPE_MAP = {
-        "pubid:iana:registry" => "Pubid::Iana::Identifiers::Registry",
-      }.freeze
-
-      # Identifiers::Registry merges its own block mapping `number` on top of
-      # this one. `number` is intentionally absent here: mapping it on the class
-      # the leaf inherits from would re-declare the parent's Components::Code
-      # attribute (see Identifiers::Registry).
-      key_value do
-        map "_type", to: :_type, polymorphic_map: IANA_TYPE_MAP
-        map "sub_registry", to: :sub_registry
-      end
-
-      # Publisher is always "IANA". A plain constant (not a `publisher` method)
-      # so it doesn't shadow the inherited lutaml `publisher` attribute, which
-      # would otherwise fail serialization type validation.
-      PUBLISHER = "IANA"
-
-      # Render-time flag stashed by #to_s; when false, the "IANA " token is
-      # dropped so callers can recover the bare index-key slug.
-      attr_reader :with_publisher
-
-      # The top-level registry slug. Derived from `number`, which is where it is
-      # stored — a plain method is safe because `registry` is no longer a lutaml
-      # attribute, so no generated accessor competes with it (the same shape as
-      # Pubid::Ietf::Identifiers::Bcp#series).
-      def registry
-        number
-      end
-
-      # The rendered registry code, e.g. "_6lowpan-parameters/lowpan_nhc".
-      def code
-        sub_registry ? "#{registry}/#{sub_registry}" : registry
-      end
-
-      # Basic string representation. Delegates to the renderer. Always emits the
-      # "IANA " token (the authoritative printed form) unless with_publisher is
-      # false, in which case the bare slug is rendered.
-      def to_s(with_publisher: true, **opts)
-        @with_publisher = with_publisher
-        render(format: :human, **opts)
-      end
-
-      # --- Machine-readable slug -------------------------------------------
-      # The shared MrString renderer composes publisher/type/number/... from the
-      # inherited attributes, none of which IANA populates: `publisher` is a
-      # constant rather than an attribute (see PUBLISHER above) and the builder
-      # sets no typed_stage. Without these two overrides every IANA identifier
-      # rendered the empty MR string, so all of them collided on `to_mr_string`
-      # and `to_slug` (issue #142) — and `to_slug` is used as a filename.
-      #
-      # Verified over the 3405 published relaton-data-iana rows: the resulting
-      # slugs are all distinct and stay inside the documented [a-z0-9._-] MR
-      # charset. Note that IANA slugs legitimately contain "_", which is MR's
-      # supplement separator, so an IANA MR is not re-parseable by
-      # Pubid::Parsers::MrString; uniqueness and filename-safety are what these
-      # buy, not MR round-tripping.
-      def mr_publisher
-        PUBLISHER.downcase
-      end
-
-      def mr_number_with_part
-        [number, sub_registry].compact.join(".").downcase
-      end
-
-      # The guard below has to cover this surface too: without it a nil number
-      # renders the bare publisher token "iana" for every affected row, i.e. one
-      # filename shared by all of them.
-      def to_mr_string
-        require_number!
-        super
-      end
-
-      # The top-level slug moved from a `registry` key into `number` with no
-      # alias, so a row serialized before that change deserializes with a nil
-      # number and NO error: lutaml ignores unknown keys, and relaton's
-      # Index::FileIO#id_supported? skips its round-trip check for concrete
-      # subclasses (every IANA id is an Identifiers::Registry). Failing loudly
-      # at render time is the only thing that surfaces a stale index.
-      #
-      # It is called from all three identity surfaces — to_s (via Renderer),
-      # to_urn (via UrnGenerator) and to_mr_string — because guarding only one
-      # still lets every stale row collide on the other two ("urn:iana:",
-      # "iana"), which is the silent overwrite this whole change exists to
-      # prevent.
-      def require_number!
-        return unless number.nil? || number.to_s.empty?
-
-        raise ArgumentError,
-              "Cannot render #{self.class} with an empty number " \
-              "(a pre-`number` index row stored the registry slug under " \
-              "`registry`; regenerate the index)"
-      end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
-      # IANA_TYPE_MAP remains as the key_value polymorphic_map.
-
-      # Parse an IANA identifier string into an identifier object
-      # @param identifier [String] The IANA identifier string to parse
-      # @return [Identifier] The appropriate identifier object
-      def self.parse(identifier)
-        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
-
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      end
-    end
-  end
-end

data/lib/pubid/iana/identifiers/registry.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    module Identifiers
-      # The sole IANA identifier type: a protocol registry (optionally with a
-      # sub-registry). Its class name yields the polymorphic `_type` tag
-      # "pubid:iana:registry".
-      #
-      # Examples:
-      #   IANA _6lowpan-parameters
-      #   IANA _6lowpan-parameters/lowpan_nhc
-      class Registry < Identifier
-        # The top-level registry slug ("_6lowpan-parameters"), and the index
-        # key: relaton-index bsearches on `id.root.number.to_s`, and every IANA
-        # identifier is its own root (the flavor has no wrapper or supplement
-        # types), so an empty key silently defeats the search for every row.
-        #
-        # An IANA identifier carries no numeric document number — digits only
-        # ever appear glued inside a slug token (`sip-parameters-13`,
-        # `idna-tables-11.0.0`), never as a separable component — so the slug
-        # itself is the key, exactly as an Internet-Draft's slug is
-        # (lib/pubid/ietf/identifiers/serialization.rb). Keying on the TOP-LEVEL
-        # slug rather than the full `registry/sub_registry` code means a
-        # registry and all of its sub-registries cluster into one bucket, the
-        # analogue of a draft clustering with its versions.
-        #
-        # WHY THIS IS DECLARED HERE AND NOT ON Pubid::Iana::Identifier:
-        # it redefines the parent ::Pubid::Identifier's
-        # `attribute :number, Components::Code` as a plain :string. Declaring
-        # that on a class the concrete type INHERITS from resolves against the
-        # parent definition nondeterministically under multi-flavor load — it
-        # passes an IANA-only run and can flip `root.number` to "" under the
-        # full suite (the IEEE/IETF lesson; see
-        # lib/pubid/ieee/identifiers/code_number.rb and CLAUDE.md). Declaring it
-        # directly on the leaf removes the ambiguity at the point of use.
-        # For the same reason, never define a `#number` *method* — it would
-        # collide with lutaml's generated accessor.
-        # spec/pubid/iana/root_number_spec.rb guards this and must run under the
-        # FULL suite to be meaningful.
-        attribute :number, :string
-
-        # Merged by lutaml with the base's key_value block, which maps `_type`
-        # and `sub_registry`. `registry` is deliberately NOT stored — it is the
-        # same string as `number`, and the base exposes it as a derived reader.
-        key_value do
-          map "number", to: :number
-        end
-
-        # IANA registries carry no revision/stage lifecycle; a single published
-        # typed stage keeps parity with the other flavors' type registries.
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :pubiana,
-            stage_code: :published,
-            type_code: :iana,
-            abbr: ["IANA"],
-            name: "IANA Registry",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :iana, web: :registry, title: "IANA Registry", short: "IANA" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/iana/identifiers.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    module Identifiers
-      autoload :Registry, "#{__dir__}/identifiers/registry"
-    end
-  end
-end

data/lib/pubid/iana/parser.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Iana
-    # Parslet grammar for IANA registry identifiers.
-    #
-    # Accepts the authoritative printed form "IANA <slug>[/<sub-slug>]" as well
-    # as a bare index-key slug (no "IANA " prefix). The optional prefix is
-    # consumed and discarded — the renderer always re-emits it.
-    #
-    # Slugs use only [a-zA-Z0-9._-] and contain at most one "/", so a plain
-    # character-class repeat parses them; there is no ReDoS surface.
-    class Parser < ::Pubid::Parser::Grammar
-      # A single registry slug: letters, digits, dot, underscore, hyphen.
-      rule(:slug) { match['a-zA-Z0-9._\-'].repeat(1) }
-
-      # Optional publisher prefix. The trailing space is required, so a
-      # space-free slug never triggers it; PEG `.maybe` backtracks the whole
-      # sequence if the space is absent (e.g. a slug that happens to start
-      # "IANA...").
-      rule(:iana_prefix) { (str("IANA") >> str(" ")).maybe }
-
-      rule(:identifier) do
-        iana_prefix >>
-          slug.as(:registry) >>
-          (str("/") >> slug.as(:sub_registry)).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/iana/renderer.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    # Human-readable renderer for IANA registry identifiers.
-    #
-    # Produces the authoritative printed form:
-    #   "IANA _6lowpan-parameters"
-    #   "IANA _6lowpan-parameters/lowpan_nhc"
-    #
-    # With `with_publisher: false` on the identifier it renders the bare
-    # index-key slug instead (no "IANA " token).
-    class Renderer < ::Pubid::Renderers::Base
-      PUBLISHER = "IANA"
-
-      def render(**_opts)
-        id = @id
-        # A stale (pre-`number`) row must not render as a bare "IANA " or
-        # "IANA /lowpan_nhc"; see Identifier#require_number!.
-        id.require_number!
-        code = id.code
-        with_publisher?(id) ? "#{PUBLISHER} #{code}" : code
-      end
-
-      private
-
-      def with_publisher?(id)
-        id.with_publisher != false
-      end
-    end
-  end
-end

data/lib/pubid/iana/urn_generator.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    # Emits `urn:iana:<registry>[:<sub_registry>]`. Slugs contain no ":"
-    # (charset is [a-zA-Z0-9._-]), so the two levels split unambiguously.
-    class UrnGenerator < Pubid::UrnGenerator::Base
-      def generate
-        # A stale (pre-`number`) row would otherwise emit the bare "urn:iana:"
-        # for every affected id; see Identifier#require_number!.
-        identifier.require_number!
-        # `number` holds the top-level registry slug (Identifiers::Registry).
-        parts = ["urn", "iana", identifier.number]
-        parts << identifier.sub_registry if identifier.sub_registry
-        parts.join(":")
-      end
-    end
-  end
-end

data/lib/pubid/iana/urn_parser.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    # Parses IANA URNs back into identifiers.
-    #
-    # UrnGenerator emits `urn:iana:<registry>[:<sub_registry>]`; this rebuilds
-    # the bare slug and delegates to the flavor's text parser (which normalizes
-    # it back to the "IANA "-prefixed printed form).
-    #
-    # Examples:
-    # - urn:iana:calipso -> IANA calipso
-    # - urn:iana:_6lowpan-parameters:lowpan_nhc
-    #     -> IANA _6lowpan-parameters/lowpan_nhc
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        registry, sub_registry = split_parts(body)
-        slug = sub_registry ? "#{registry}/#{sub_registry}" : registry
-        flavor_parse(slug)
-      end
-    end
-  end
-end

data/lib/pubid/iana.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iana
-    extend Pubid::PrefixesSupport
-
-    # Sole IANA publisher token (see the parser's optional `IANA ` prefix).
-    # IANA entries are protocol registries whose printed form always leads with
-    # the "IANA" token; routing relies on it since the raw slug carries no
-    # publisher.
-    PREFIXES = ["IANA"].freeze
-
-    autoload :Builder, "#{__dir__}/iana/builder"
-    autoload :Identifier, "#{__dir__}/iana/identifier"
-    autoload :Identifiers, "#{__dir__}/iana/identifiers"
-    autoload :Parser, "#{__dir__}/iana/parser"
-    autoload :Renderer, "#{__dir__}/iana/renderer"
-    autoload :UrnGenerator, "#{__dir__}/iana/urn_generator"
-    autoload :UrnParser, "#{__dir__}/iana/urn_parser"
-
-    # Parse an IANA identifier string
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Iana::Renderer)
-
-    # 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
-
-    # 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
-  end
-end
-
-# Register IANA flavor with the registry
-Pubid::Registry.register(:iana, Pubid::Iana)

data/lib/pubid/idf/renderer.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Idf
-    # Human-readable renderer for IDF identifiers.
-    #
-    # Produces strings like:
-    #   "IDF 125:1988"
-    #   "IDF/AMD 1:2023"
-    #   "IDF 125:1988/AMD 1:2023"
-    #
-    # The renderer is registered as the `:human` format in the IDF format
-    # registry and invoked via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        id = @id
-
-        case id
-        when SupplementIdentifier
-          render_supplement(id, opts, context)
-        else
-          render_single(id, opts, context)
-        end
-      end
-
-      private
-
-      def render_single(id, opts, context)
-        [
-          publisher_portion(id, context),
-          number_portion(id, opts, context),
-        ].join
-      end
-
-      def publisher_portion(id, context)
-        [
-          id.publisher.render(context:),
-          (id.typed_stage.abbreviation.empty? ? "" : "/#{id.typed_stage.abbreviation}"),
-        ].join
-      end
-
-      def number_portion(id, opts, context)
-        lang_single = opts[:lang_single] || false
-
-        [
-          (id.number ? " #{id.number}" : ""),
-          (id.part ? "-#{id.part}" : ""),
-          (id.subpart ? "-#{id.subpart}" : ""),
-          (id.stage_iteration ? ".#{id.stage_iteration.render(context:)}" : ""),
-          (id.date ? ":#{id.date.render(context:)}" : ""),
-          language_portion(id, lang_single: lang_single),
-        ].join
-      end
-
-      def language_portion(id, lang_single: false)
-        return "" unless id.languages&.any?
-
-        [
-          "(",
-          id.languages.map do |lang|
-            lang.to_s(lang_single: lang_single)
-          end.join(lang_single ? "/" : ","),
-          ")",
-        ].join
-      end
-
-      def render_supplement(id, opts, context)
-        lang = opts[:lang] || :en
-        lang_single = opts[:lang_single] || false
-        with_edition = opts[:with_edition] || false
-
-        [
-          id.base.to_s(lang: lang, lang_single: lang_single,
-                                   with_edition: with_edition),
-          "/",
-          id.typed_stage.abbreviation,
-          " ",
-          id.number,
-          (id.date ? ":#{id.date.render(context:)}" : ""),
-        ].join
-      end
-    end
-  end
-end

data/lib/pubid/idf/urn_parser.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Idf
-    # Parses IDF URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:idf:{number}:{year}:` with a trailing empty
-    # field (a known quirk of the generator).
-    #
-    # Examples:
-    # - urn:idf:87:2019: → IDF 87:2019
-    # - urn:idf:100:     → IDF 100
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body).reject(&:empty?)
-
-        number, year = parts
-        text = "IDF #{number}"
-        text += ":#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/iec/components.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iec
-    module Components
-      autoload :Code, "#{__dir__}/components/code"
-      autoload :ConsolidatedAmendment, "#{__dir__}/components/consolidated_amendment"
-      autoload :Publisher, "#{__dir__}/components/publisher"
-      autoload :Sheet, "#{__dir__}/components/sheet"
-      autoload :TrfInfo, "#{__dir__}/components/trf_info"
-      autoload :VapSuffix, "#{__dir__}/components/vap_suffix"
-    end
-  end
-end

data/lib/pubid/iec/identifiers/technical_group.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iec
-    module Identifiers
-      # Technical Group identifier — identifies a committee rather than a
-      # publication. Covers:
-      #
-      #   IEC TC 1             (Technical Committee)
-      #   IEC PC 118           (Project Committee)
-      #   ISO/IEC JTC 1        (Joint Technical Committee)
-      #   ISO/IEC JPC 2        (Joint Project Committee)
-      #   ISO/IEC JTC 1/SC 7   (Joint TC with Subcommittee)
-      #   IEC SC 100A          (Subcommittee with letter suffix)
-      #   CIS/A                (CISPR Subcommittee, bare form)
-      #   CISPR                (CISPR Committee, bare form)
-      class TechnicalGroup < Base
-        attribute :technical_committee, :string
-        attribute :subcommittee, :string
-
-        TYPED_STAGES = [].freeze
-
-        def self.type
-          { key: :tg,
-            web: :technical_group, title: "Technical Group", short: "TG" }
-        end
-      end
-    end
-  end
-end