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

data/lib/pubid/plateau/renderer.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Plateau
-    # Human-readable renderer for PLATEAU identifiers.
-    #
-    # Produces strings like:
-    #   "PLATEAU Technical Report #01"
-    #   "PLATEAU Handbook #00 第1.0版"
-    #   "PLATEAU Handbook #01-1 Annex A"
-    #
-    # The renderer is registered as the `:human` format in the PLATEAU 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)
-        when Identifiers::Handbook
-          render_handbook(id)
-        when Identifiers::TechnicalReport
-          render_technical_report(id)
-        else
-          render_base(id)
-        end
-      end
-
-      private
-
-      def render_base(id)
-        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
-      end
-
-      def render_technical_report(id)
-        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
-      end
-
-      def render_handbook(id)
-        result = "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
-        result += " #{id.formatted_edition}" if id.edition
-        result
-      end
-
-      def render_supplement(id)
-        "#{id.base} #{id.supplement_string}"
-      end
-    end
-  end
-end

data/lib/pubid/plateau/urn_parser.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Plateau
-    # Parses Plateau URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:plateau:{type}:{number}[:{annex}]
-    #
-    # type is one of: handbook, tr (technical report), an (annex), or another
-    # lowercase type string. Annex is a zero-padded 2-digit string when present.
-    #
-    # Examples:
-    # - urn:plateau:handbook:00        → PLATEAU Handbook #00
-    # - urn:plateau:tr:01              → PLATEAU Technical Report #01
-    class UrnParser < Pubid::UrnParser::Base
-      TYPE_MAP = {
-        "handbook" => "Handbook",
-        "tr" => "Technical Report",
-        "an" => "Annex",
-      }.freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        type_token = parts.fetch(0)
-        number = parts.fetch(1)
-        annex = parts[2]
-
-        text = "PLATEAU #{display_type(type_token)} ##{number}"
-        text += "-#{annex}" if annex
-        flavor_parse(text)
-      end
-
-      private
-
-      def display_type(token)
-        TYPE_MAP.fetch(token) { token.capitalize }
-      end
-    end
-  end
-end

data/lib/pubid/prefixes_support.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  # Mixin providing the uniform, static +prefixes+ class method that every
-  # registered flavor exposes. relaton uses this to build a global prefix
-  # register that routes a printed reference string (e.g. +"DD 1234"+,
-  # +"ISO/IEC 8802"+) to the flavor(s) that own it.
-  #
-  # A flavor +extend+s this module and defines a frozen +PREFIXES+ array holding
-  # only *its own* leading tokens. Joint / co-publication tokens are injected
-  # centrally from {Pubid::JOINT_PREFIXES} so that a co-published prefix
-  # (e.g. +"ISO/IEC"+) is listed symmetrically by every co-publisher without
-  # being duplicated by hand in two files.
-  #
-  # == Inclusion policy
-  # +prefixes+ returns the set of *leading identifier prefix tokens* — the
-  # tokens a printed identifier can start with such that the string belongs to
-  # this SDO. Concretely it INCLUDES:
-  # * publisher prefixes (e.g. +ISO+, +IEC+, +NIST+, +NBS+, +BS+, +BSI+);
-  # * leading series/type tokens that can *begin* a printed reference on their
-  #   own (e.g. BSI +DD+/+PD+, NIST +FIPS+/+SP+);
-  # * joint / co-publication forms (e.g. +ISO/IEC+, +ISO/IEC/IEEE+).
-  # It EXCLUDES:
-  # * pure sub-series that never appear without a publisher prefix;
-  # * dangerously-ambiguous single letters (e.g. BSI aerospace +A+/+B+/+C+),
-  #   which would cause false routing.
-  module PrefixesSupport
-    # The static set of leading prefix tokens this flavor recognizes.
-    #
-    # Static: callable without parsing any identifier string. Strings are
-    # returned in canonical case exactly as printed (e.g. +"BS EN ISO"+,
-    # +"ISO/IEC"+); consumers fold case themselves.
-    #
-    # @return [Array<String>] frozen, de-duplicated list of prefix tokens
-    def prefixes
-      own = const_defined?(:PREFIXES) ? const_get(:PREFIXES) : []
-      joint = Pubid::JOINT_PREFIXES.fetch(prefix_flavor_key, [])
-      (own + joint).uniq.freeze
-    end
-
-    # The registry key for this flavor, derived from the module name
-    # (e.g. +Pubid::CenCenelec+ => +:cen_cenelec+). Used to look this flavor up
-    # in {Pubid::JOINT_PREFIXES} and to label it in {Pubid.prefix_flavors}.
-    #
-    # @return [Symbol]
-    def prefix_flavor_key
-      name.split("::").last
-        .gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase.to_sym
-    end
-  end
-end

data/lib/pubid/renderers/annotator.rb

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Renderers
-    # Adds semantic <span class="..."> markers to an already-rendered
-    # identifier string.
-    #
-    # In pubid 1.x annotation was applied in ONE place — `prerender_params`
-    # wrapped every value in the param hash — so all 40-odd flavors got it for
-    # free. pubid 2 replaced that hash with typed components and per-flavor
-    # renderers, and the annotation went with it: `Renderers::Base#annotate`
-    # exists, but only the HumanReadable family calls it. All 39 flavor
-    # renderers receive `context.annotated` and ignore it, so
-    # `to_s(annotated: true)` returned plain text for every flavor but ISO.
-    #
-    # Re-annotating inside 39 renderers would mean 39 chances to drift. This
-    # class recovers the markup from the OUTSIDE instead: it asks the
-    # identifier for its own component values and wraps each one where it
-    # appears in the rendered string. That is one implementation, and a flavor
-    # added tomorrow is covered without touching its renderer.
-    #
-    # It is a fallback, not a replacement. `Identifier#render` uses it only
-    # when the renderer produced no span of its own, so ISO's exact,
-    # render-time placement still wins.
-    #
-    # Deliberate limits:
-    #
-    # * A token that does not appear verbatim in the output is skipped. A
-    #   renderer may transform a value (abbreviate it, change its case), and a
-    #   missing span is a far better outcome than a wrong one or a crash.
-    # * Matching walks left to right behind a cursor, so a later token can
-    #   never match text an earlier one already claimed — that is what stops
-    #   the part "1" of `ISO 1234-1` from matching inside "1234".
-    class Annotator
-      # Semantic class for each token, in the order tokens appear in a printed
-      # identifier. Order matters: it is the sequence the cursor walks.
-      TOKENS = [
-        [:publisher, "publisher"],
-        [:copublishers, "publisher"],
-        %i[typed_stage typed_stage_css],
-        [:type, "doctype"],
-        [:stage, "stage"],
-        [:number, "docnumber"],
-        [:part, "part"],
-        [:subpart, "part"],
-        [:stage_iteration, "iteration"],
-        [:year, "year"],
-        [:edition, "edition"],
-        [:languages, "language"],
-      ].freeze
-
-      # Characters that may not sit directly against a match, so a token never
-      # binds to the middle of a longer run of the same character class.
-      WORD_CHAR = /[A-Za-z0-9]/
-
-      # How deep to follow nested identifiers. A wrapper around a wrapper is
-      # real (BSI adopts a CEN prestandard that adopts an ISO standard); four
-      # levels is past anything the corpus holds, and the cap is here so a
-      # cyclic `base` cannot hang a rendering call.
-      MAX_NESTING = 4
-
-      def initialize(identifier, context = nil)
-        @id = identifier
-        @context = context
-      end
-
-      # @param rendered [String] the plain rendering of {@id}
-      # @return [String] the same string with semantic spans inserted
-      def annotate(rendered)
-        return rendered unless rendered.is_a?(String) && !rendered.empty?
-
-        cursor = 0
-        result = +""
-
-        ordered_tokens(rendered).each do |text, css_class|
-          index = find_token(rendered, text, cursor)
-          next if index.nil?
-
-          result << rendered[cursor...index]
-          result << %(<span class="#{css_class}">#{text}</span>)
-          cursor = index + text.length
-        end
-
-        result << rendered[cursor..]
-        result
-      end
-
-      private
-
-      # Tokens sorted by where they actually appear, not by the order
-      # {TOKENS} lists them.
-      #
-      # Flavors disagree about layout: ISO prints the number before the type
-      # ("ISO/IEC TR 2131"), CCSDS prints it after ("CCSDS 121.0-B-2"). Walking
-      # in declaration order pushed the cursor past the number for CCSDS, so
-      # "121" was never annotated. Sorting by first occurrence makes the walk
-      # follow the printed identifier instead of a fixed idea of one.
-      def ordered_tokens(rendered)
-        tokens = []
-        each_token { |text, css_class| tokens << [text, css_class] }
-
-        decorated = tokens.each_with_index.map do |token, i|
-          position = find_token(rendered, token.first, 0) || rendered.length
-          [position, i, token]
-        end
-
-        decorated.sort_by { |position, i, _| [position, i] }.map(&:last)
-      end
-
-      # Yields [text, css_class] for every annotatable token this identifier
-      # actually carries, then every one its nested identifiers carry.
-      def each_token(&)
-        emit_tokens(@id, 0, &)
-      end
-
-      # A wrapper — an adoption, a supplement, a bundle — carries no number of
-      # its own and prints the document it wraps, so the annotatable tokens in
-      # its string belong to `base`. Reading only the wrapper's own attributes
-      # is why every CSA container and CIE's supplement rendered plain while
-      # accepting the flag.
-      #
-      # Order does not matter here: `ordered_tokens` sorts by first occurrence,
-      # so a nested token lands where it actually appears in the string.
-      def emit_tokens(id, depth, &)
-        return if depth > MAX_NESTING
-
-        tokens_for(id).each do |attr_name, css_class|
-          Array(token_values(id, attr_name)).each do |value|
-            text = token_text(value)
-            next if text.nil? || text.empty?
-
-            yield text, resolve_class(css_class, value)
-          end
-        end
-
-        nested_identifiers(id).each { |nested| emit_tokens(nested, depth + 1, &) }
-      end
-
-      # {TOKENS} unless the identifier names more of its own — see
-      # `Pubid::Identifier#annotation_tokens`.
-      def tokens_for(id)
-        id.respond_to?(:annotation_tokens) ? id.annotation_tokens : TOKENS
-      end
-
-      # The identifiers this one wraps, under any of the four names the gem
-      # uses: `base` (the uniform parent accessor), the `ids` / `identifiers`
-      # collections that bundles and consolidated identifiers hold instead, and
-      # CSA `Bundled`'s `bundled_with` — which holds the amendments a
-      # consolidation prints, and whose values it composes into the string from
-      # their components rather than from their own `to_s`.
-      def nested_identifiers(id)
-        %i[base ids identifiers bundled_with].flat_map do |name|
-          next [] unless id.respond_to?(name)
-
-          begin
-            Array(id.public_send(name))
-          rescue StandardError
-            []
-          end
-        end.grep(::Pubid::Identifier)
-      end
-
-      def token_values(id, attr_name)
-        return nil unless id.respond_to?(attr_name)
-
-        id.public_send(attr_name)
-      rescue StandardError
-        # A derived reader may assume state a partial identifier lacks. A
-        # missing span is not worth an exception on a rendering path.
-        nil
-      end
-
-      # The printed form of one component. Components render themselves through
-      # the context; a bare scalar is already its own text.
-      def token_text(value)
-        return nil if value.nil?
-
-        text = if value.respond_to?(:render)
-                 value.render(context: @context)
-               else
-                 value
-               end
-        text.to_s.strip
-      rescue StandardError
-        nil
-      end
-
-      def resolve_class(css_class, value)
-        return css_class unless css_class == :typed_stage_css
-
-        TypedStageClass.for(value)
-      end
-
-      # First occurrence of +text+ at or after +cursor+ that is not embedded in
-      # a longer word — so "1" matches the part in "ISO 1234-1", never the "1"
-      # inside "1234".
-      def find_token(rendered, text, cursor)
-        at = cursor
-        while (index = rendered.index(text, at))
-          return index if standalone?(rendered, index, text.length)
-
-          at = index + 1
-        end
-        nil
-      end
-
-      def standalone?(rendered, index, length)
-        before = index.zero? ? nil : rendered[index - 1]
-        after = rendered[index + length]
-
-        !WORD_CHAR.match?(before.to_s) && !WORD_CHAR.match?(after.to_s)
-      end
-
-      # The typed-stage class depends on the stage's type code, the same
-      # mapping `Renderers::Base#typed_stage_css` applies. Kept here rather
-      # than reached for through a private method on another object.
-      module TypedStageClass
-        MAP = {
-          "amd" => "amendment",
-          "cor" => "corrigendum",
-          "add" => "addendum",
-        }.freeze
-
-        def self.for(typed_stage)
-          code = typed_stage.respond_to?(:type_code) ? typed_stage.type_code.to_s : ""
-          return "stage" if code.empty? || code == "is"
-
-          MAP[code] || "doctype"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/sae/renderer.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Sae
-    # Human-readable renderer for SAE identifiers.
-    #
-    # Produces strings like:
-    #   "SAE AS5553"
-    #   "SAE ARP4754A"
-    #   "SAE AMS2475:2023"
-    #
-    # The renderer is registered as the +:human+ format in the SAE format
-    # registry and invoked via +render(format: :human)+.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
-        id = @id
-
-        parts = []
-
-        # Publisher and type
-        parts << id.publisher if id.publisher
-        parts << id.type.to_s if id.type
-
-        # Number
-        parts << id.number.to_s if id.number
-
-        result = parts.join(" ")
-
-        # Date
-        result += ":#{id.date.render(context:)}" if id.date
-
-        result
-      end
-    end
-  end
-end

data/lib/pubid/sae/urn_parser.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Sae
-    # Parses SAE URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:sae:{type|std}:{number}:{year}
-    # where slot[1] is overwritten with the publisher string when a publisher
-    # is set. The common single-publisher case keeps slot[1] = "sae".
-    #
-    # Examples:
-    # - urn:sae:j:300:2019     → SAE J300:2019
-    # - urn:sae:air:500        → SAE AIR500
-    # - urn:sae:ams:5000:2020  → SAE AMS5000:2020
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        type_token, number, year = parts
-        text = build_text(type_token, number, year)
-        flavor_parse(text)
-      end
-
-      private
-
-      def build_text(type_token, number, year)
-        head = type_token == "std" ? "" : type_token.upcase
-        text = "SAE #{head}#{number}"
-        text += ":#{year}" if year
-        text
-      end
-    end
-  end
-end

data/lib/pubid/tgpp/builder.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Tgpp
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        identifier_class(data[:type]).new(
-          number: data[:number].to_s,
-          suffix: data[:suffix]&.to_s,
-          parts: extract_part_strings(data[:parts]),
-          release: data[:release]&.to_s,
-          version: data[:version]&.to_s,
-        )
-      end
-
-      private
-
-      def identifier_class(type)
-        if type.to_s == "TR"
-          Identifiers::TechnicalReport
-        else
-          Identifiers::TechnicalSpecification
-        end
-      end
-
-      # parts_data is an array of `{ part: "1" }` hashes (or a single hash for a
-      # one-level part); return the part numbers as strings.
-      def extract_part_strings(parts_data)
-        case parts_data
-        when Array then parts_data.filter_map { |h| h[:part]&.to_s }
-        when Hash then [parts_data[:part]&.to_s].compact
-        else []
-        end
-      end
-    end
-  end
-end

data/lib/pubid/tgpp/identifier.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Tgpp
-    # Base class for every 3GPP identifier AND the flavor's parse entry point —
-    # mirrors Pubid::Jis::Identifier. Concrete identifiers under
-    # Pubid::Tgpp::Identifiers descend from this class, so a parsed 3GPP id is
-    # an instance of Pubid::Tgpp::Identifier.
-    class Identifier < ::Pubid::Identifier
-      # The dotted core (e.g. "23.207") kept as a string to preserve leading
-      # zeros. `number` overrides the base Components::Code attribute.
-      attribute :number, :string
-      # Optional letter suffix directly after the number: "U", "dcs", "ext"…
-      attribute :suffix, :string
-      # 1–2 hyphen parts (e.g. "26.171-1", "29.198-04-1"); strings preserve any
-      # zero-padding.
-      # `initialize_empty` makes a part-less identifier hold `[]` on BOTH
-      # construction paths: Builder always passes an array, but the serialized
-      # hash carries no `parts` key, so from_hash used to leave it nil and the
-      # two compared unequal — which silently broke `#matches?` (and so every
-      # part-less relaton index lookup). It does not change the serialized
-      # shape: lutaml omits an empty collection either way. See CLAUDE.md.
-      attribute :parts, :string, collection: true, initialize_empty: true
-      # Raw release token, stored verbatim: "REL-4", "Ph1", "UMTS",
-      # "Release 2000".
-      attribute :release, :string
-      # Three-part version string, e.g. "2.0.0".
-      attribute :version, :string
-
-      # Polymorphic type map for lutaml::Model key_value (de)serialization.
-      # Keys are the `pubid:3gpp:…` names produced by polymorphic_name (below).
-      TGPP_TYPE_MAP = {
-        "pubid:3gpp:technical-report" =>
-          "Pubid::Tgpp::Identifiers::TechnicalReport",
-        "pubid:3gpp:technical-specification" =>
-          "Pubid::Tgpp::Identifiers::TechnicalSpecification",
-      }.freeze
-
-      key_value do
-        map "_type", to: :_type, polymorphic_map: TGPP_TYPE_MAP
-        map "number", to: :number
-        map "suffix", to: :suffix
-        map "parts", to: :parts
-        map "release", to: :release
-        map "version", to: :version
-      end
-
-      # Publisher token. A plain constant (not a `publisher` method) so it does
-      # not shadow the inherited lutaml `publisher` attribute.
-      PUBLISHER = "3GPP"
-
-      # The auto-derived polymorphic name would be "pubid:tgpp:…" (from the
-      # module constant). Force the "3gpp" segment so the `_type` tag matches
-      # the relaton flavor name and TGPP_TYPE_MAP.
-      def self.polymorphic_name
-        super&.sub(/\Apubid:tgpp:/, "pubid:3gpp:")
-      end
-
-      # Rendering flag: whether to prefix the string with "3GPP ". Transient
-      # (not serialized). #to_s sets it, renders, then resets it to false in an
-      # ensure block, so a subsequent bare #render defaults to no publisher and
-      # the flag never leaks past the to_s call that set it.
-      attr_reader :with_publisher
-
-      # The rendered document code, e.g. "29.198-04-1" (number+suffix+parts).
-      def code
-        result = "#{number}#{suffix}"
-        result += parts.map { |p| "-#{p}" }.join if parts&.any?
-        result
-      end
-
-      # Basic string representation. Delegates to the :human renderer. Default
-      # omits the "3GPP " publisher token (matches the relaton index id);
-      # `to_s(with_publisher: true)` emits the printed "3GPP TS …" form.
-      def to_s(with_publisher: false, **opts)
-        @with_publisher = with_publisher
-        render(format: :human, **opts)
-      ensure
-        @with_publisher = false
-      end
-
-      # Parse a 3GPP identifier string into an identifier object.
-      #
-      # Let Parslet::ParseFailed propagate on a bad reference (matching ISO and
-      # ETSI), so relaton-cli's `rescue Parslet::ParseFailed` fetch handler
-      # catches it instead of a bare RuntimeError. The length guard keeps its
-      # ArgumentError — that is a different failure (input too long, not
-      # unparseable) and it is the ReDoS barrier.
-      #
-      # @param identifier [String] The 3GPP 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/tgpp/identifiers/technical_report.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Tgpp
-    module Identifiers
-      # Technical Report identifier type.
-      # Format: [3GPP ]TR NN.NNN[suffix][-part…][:<release>][/<version>]
-      # Example: TR 00.01U:UMTS/3.0.0, or the partial "TR 00.01U".
-      class TechnicalReport < Pubid::Tgpp::Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :tr,
-            stage_code: :published,
-            type_code: :tr,
-            abbr: ["TR"],
-            name: "Technical Report",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :tr,
-            web: :technical_report, title: "Technical Report", short: "TR" }
-        end
-
-        def type_prefix
-          "TR"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/tgpp/identifiers/technical_specification.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Tgpp
-    module Identifiers
-      # Technical Specification identifier type.
-      # Format: [3GPP ]TS NN.NNN[suffix][-part…][:<release>][/<version>]
-      # Example: TS 23.207:REL-4/2.0.0, or the partial "TS 23.207".
-      class TechnicalSpecification < Pubid::Tgpp::Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :ts,
-            stage_code: :published,
-            type_code: :ts,
-            abbr: ["TS"],
-            name: "Technical Specification",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :ts,
-            web: :technical_specification,
-            title: "Technical Specification", short: "TS" }
-        end
-
-        def type_prefix
-          "TS"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/tgpp/identifiers.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Tgpp
-    module Identifiers
-      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
-      autoload :TechnicalSpecification,
-               "#{__dir__}/identifiers/technical_specification"
-    end
-  end
-end