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

data/lib/pubid/ieee/renderer.rb

@@ -1,408 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ieee
-    # Human-readable renderer for IEEE identifiers.
-    #
-    # Produces strings like:
-    #   "IEEE Std 802.11-2020"
-    #   "IEEE Std 535-2013/Cor. 1-2017"
-    #   "ANSI C37.61-1973 and IEEE Std 321-1973"
-    #
-    # The renderer is registered as the +:human+ format in the IEEE format
-    # registry and invoked via +render(format: :human)+.
-    #
-    # For wrapper types (DualPublished, AdoptedStandard, etc.) the renderer
-    # composes child identifiers. For simple identifiers it delegates to the
-    # identifier's own publisher/code/relationship helpers.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        # IEEE attaches the trademark mark to the document number, before the
-        # year and every suffix ("IEEE Std 802.3®-2018"), so the mark is
-        # emitted by whichever method renders the number rather than appended
-        # to the finished string. A renderer instance is built per render call
-        # (Pubid::Identifier#render), so the flag is safe as instance state.
-        @trademark = opts[:trademark]
-
-        render_id(@id)
-      end
-
-      private
-
-      # Trademark mark for a document number, or "" when the flag is off.
-      # @param number [String, nil] bare document number
-      # @param prefix [String, nil] letter series of the code
-      # @param publishers [Array<String>] printed publisher tokens — the ®
-      #   series belongs to IEEE, not to another body numbering a document 802
-      def mark(number, prefix = nil, publishers: nil)
-        return "" unless @trademark
-
-        Pubid::Ieee.trademark_symbol_for(number, prefix, publishers: publishers)
-      end
-
-      # The publisher tokens an identifier prints, for the ® decision.
-      def publishers_of(id)
-        return id.publishers if id.respond_to?(:publishers) && id.publishers
-
-        copublishers = id.copublisher if id.respond_to?(:copublisher)
-        [id.publisher, *copublishers].compact
-      end
-
-      # Compose a child identifier, propagating the trademark flag only when it
-      # is safe. A foreign (non-IEEE) leaf may not accept the `trademark:`
-      # keyword at all — Pubid::Nist's `to_s(format = :short)` would silently
-      # swallow it as a positional Hash, and Pubid::Iso's would raise — and an
-      # adopted or parenthetical child is not the IEEE document being marked.
-      def child_to_s(child, **opts)
-        return child.to_s(**opts) unless @trademark &&
-          child.is_a?(Pubid::Ieee::Identifier)
-
-        child.to_s(**opts, trademark: true)
-      end
-
-      # Dispatch to the type-specific renderer, returning the composed string
-      # (each branch inserts the trademark mark at its own number boundary).
-      def render_id(id)
-        case id
-        when Identifiers::DualPublished
-          render_dual_published(id)
-        when Identifiers::DualIdentifier
-          render_dual_identifier(id)
-        when Identifiers::AdoptedStandard
-          render_adopted_standard(id)
-        when Identifiers::RedlinedStandard
-          render_redlined_standard(id)
-        when Identifiers::Amendment
-          render_amendment(id)
-        when Identifiers::Corrigendum
-          render_corrigendum(id)
-        when Identifiers::InterpretationIdentifier
-          render_interpretation(id)
-        when Identifiers::ConformanceIdentifier
-          render_conformance(id)
-        when Identifiers::MultiNumberedIdentifier
-          render_multi_numbered(id)
-        when Identifiers::ParentheticalIdentifier
-          render_parenthetical(id)
-        when Identifiers::CsaDualPublished
-          render_csa_dual_published(id)
-        when Identifiers::IecIeeeCopublished
-          render_iec_ieee_copublished(id)
-        when Identifiers::SiStandard
-          render_si_standard(id)
-        when Identifiers::JointDevelopment
-          child_to_s(id)
-        else
-          render_base(id)
-        end
-      end
-
-      # ------------------------------------------------------------------
-      # Base IEEE identifier rendering
-      # ------------------------------------------------------------------
-
-      def render_base(id)
-        parts = []
-
-        # Publisher(s) - handle copublisher array properly
-        if id.copublisher && !id.copublisher.empty?
-          parts << [id.publisher, *id.copublisher].join("/")
-        else
-          parts << id.publisher
-        end
-
-        # Draft status
-        parts << id.draft_status if id.draft_status
-
-        # Type - only render for IEEE/AIEE publishers, and only for non-projects.
-        # An unapproved draft is not yet a standard, so per IEEE guidance the
-        # "Std" token is dropped from the type when draft_status is "Unapproved"
-        # (e.g. "Draft Std" -> "Draft", "Std" -> "").
-        should_render_type = id.publisher&.match?(/^(IEEE|AIEE)/)
-
-        if should_render_type && !id.typed_stage&.project_status && id.type && !id.type.to_s.strip.empty? && id.type != "P"
-          type_str = id.type.dup
-          type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
-          if id.draft_status.to_s.match?(/unapproved/i)
-            type_str = type_str.gsub(/\bStd\b/i, "").squeeze(" ").strip
-          end
-          parts << type_str unless type_str.strip.empty?
-        end
-
-        # Code - with P prefix for projects (concatenated, not separated)
-        if id.code_obj
-          result = id.code_obj.to_s
-
-          # Prepend P if this is a project AND code doesn't already have P
-          if id.typed_stage&.project_status && should_render_type && !result.start_with?("P")
-            result = "P#{result}"
-          end
-
-          # Trademark mark — right after the number and its parts, before the
-          # year, the revision, the draft and every other suffix.
-          result += mark(id.code_obj.number, id.code_obj.prefix,
-                         publishers: publishers_of(id))
-
-          # Only attach year to code if there's no edition, no month, and no draft
-          result += "-#{id.year}" if id.year && !id.draft_obj && !id.edition && !id.month
-
-          # Append the numbered/lettered revision inline, in IEEE's native
-          # position — right after the code number and before the draft
-          # ("P802.16Rev2/D3"). Keeps a revision distinct from its base standard.
-          result += "Rev#{id.revision}" if id.revision
-
-          # Append draft to code - with or without space based on original format
-          if id.draft_obj
-            result += id.space_before_draft ? " #{id.draft_obj}" : id.draft_obj.to_s
-          end
-
-          # Append interpretation notation (/INT)
-          result += "/INT" if id.interpretation
-
-          # Conformance is always built as a ConformanceIdentifier wrapper
-          # (render_conformance), never inline on a base standard — the base no
-          # longer carries a conf_number attribute.
-
-          # Append ASHRAE joint publication (/ASHRAE Guideline NN-YYYY)
-          if id.ashrae_number
-            result += "/ASHRAE Guideline #{id.ashrae_number}"
-            result += "-#{id.ashrae_year}" if id.ashrae_year
-          end
-
-          # Append IEEE cross-reference (/C62.22.1-1996)
-          result += id.crossref if id.crossref
-
-          parts << result
-        elsif should_render_type && id.typed_stage&.project_status
-          # No code but is a project - add standalone P
-          parts << "P"
-        end
-
-        # Edition - with year if present (IEC style)
-        if id.edition
-          edition_str = "Edition #{id.edition}"
-          if id.year
-            edition_str += " #{id.year}"
-            edition_str += "-#{id.edition_month}" if id.edition_month
-          end
-          parts << edition_str
-        end
-
-        # Build the main identifier (without month yet)
-        result = parts.join(" ")
-
-        # Month/Day - append directly to avoid extra space before comma
-        if id.month
-          result += ", #{id.month}"
-          result += " #{id.day}" if id.day
-          if id.year && !id.edition
-            result += " #{id.year}"
-          end
-        end
-
-        # Bounded parenthetical markers only. The unbounded relationship/
-        # amendment narrative (relationships, revision_of, amendment_to,
-        # adoption, note) is deliberately NOT rendered here: an
-        # "as amended by …" list can run 300+ chars, and an identifier's to_s
-        # is used by consumers (relaton) as a document number and filename. The
-        # narrative is preserved on the runtime accessors (id.relationships
-        # etc.), just not embedded in the identifier string.
-        parentheticals = []
-
-        # Reaffirmation year — a bounded status marker.
-        reaff = id.reaffirmed
-        parentheticals << "(R#{reaff})" if reaff && !reaff.to_s.strip.empty?
-
-        # The catch-all parenthetical is a bounded, printed identity token, not
-        # relationship prose (e.g. the "S-135 (IPCEA P46-426)" co-designation).
-        # Long amendment narratives match the structural relationship grammar
-        # and land in `relationships`, never in this catch-all, so it stays
-        # bounded.
-        if id.parenthetical_content
-          parentheticals << "(#{id.parenthetical_content})"
-        end
-
-        result += " #{parentheticals.join(' ')}" unless parentheticals.empty?
-
-        # Book nickname - outside parentheses in square brackets
-        result += " [#{id.nickname}]" if id.nickname && !id.nickname.to_s.strip.empty?
-
-        # Redline suffix
-        result += " - Redline" if id.redline
-
-        result
-      end
-
-      # ------------------------------------------------------------------
-      # Wrapper types
-      # ------------------------------------------------------------------
-
-      def render_dual_published(id)
-        "#{child_to_s(id.first_identifier)} and " \
-          "#{child_to_s(id.second_identifier)}"
-      end
-
-      def render_dual_identifier(id)
-        "#{child_to_s(id.first_identifier)} and " \
-          "#{child_to_s(id.second_identifier)}"
-      end
-
-      def render_adopted_standard(id)
-        # Only the IEEE designation is marked; the adopted identifiers are
-        # other bodies' documents (and may be foreign pubid objects).
-        result = child_to_s(id.ieee_identifier)
-        if id.adopted_identifiers && !id.adopted_identifiers.empty?
-          adopted_strs = id.adopted_identifiers.map(&:to_s)
-          result += " (#{adopted_strs.join(' and ')})"
-        end
-        result
-      end
-
-      def render_redlined_standard(id)
-        result = child_to_s(id.base)
-        # NOTE: currently unreachable — a redline is built as a flat
-        # `redline: true` on a plain Standard (see the redline invariant in
-        # CLAUDE.md), so determine_identifier_class never routes here. Kept for
-        # completeness; if this path is ever revived, note `revision_of` is a
-        # bounded single-id reference, unlike the unbounded relationship
-        # narrative that render_base deliberately drops.
-        result += " (Revision of #{id.revision_of})" if id.revision_of
-        result += " - Redline" if id.redline
-        result
-      end
-
-      def render_corrigendum(id)
-        return render_base(id) unless id.base
-
-        result = child_to_s(id.base)
-        result += "/Cor"
-        result += ". " if id.number # Add period and space for formal format
-        result += id.number if id.number
-        result += "-#{id.year}" if id.year
-        result
-      end
-
-      def render_amendment(id)
-        return render_base(id) unless id.base
-
-        result = child_to_s(id.base)
-        result += "/Amd"
-        result += " #{id.number}" if id.number # canonical "/Amd 4-2020"
-        result += "-#{id.year}" if id.year
-        result
-      end
-
-      def render_interpretation(id)
-        return render_base(id) unless id.base
-
-        result = child_to_s(id.base)
-        result += "/INT"
-        result += "-#{id.year}" if id.year
-        result
-      end
-
-      def render_conformance(id)
-        return render_base(id) unless id.base
-
-        result = child_to_s(id.base)
-        result += "/Conformance#{id.number}" if id.number
-        result += "-#{id.year}" if id.year
-        result
-      end
-
-      def render_multi_numbered(id)
-        return child_to_s(id.primary_identifier) unless id.secondary_identifier
-
-        # Co-equal designations: each carries its own mark, before its own
-        # suffixes, as IEEE prints them.
-        primary = child_to_s(id.primary_identifier)
-        secondary = child_to_s(id.secondary_identifier)
-
-        secondary_code = id.secondary_identifier.code.to_s
-        if secondary_code.start_with?("C") && secondary_code.match?(/^C\d+\./)
-          # A cross-reference prints the bare second designation after the
-          # slash — "IEEE Std 1299/C62.22.1-1996" — not a second full
-          # reference, so this branch must not reuse `secondary`, which
-          # carries its own "IEEE Std " prefix.
-          "#{primary}/#{secondary_code}"
-        else
-          "#{primary} and #{secondary}"
-        end
-      end
-
-      def render_parenthetical(id)
-        # The mark belongs on the base; the parenthetical is a separate token.
-        result = child_to_s(id.base)
-        result += " (#{id.parenthetical_identifier})" if id.parenthetical_identifier
-        result
-      end
-
-      def render_csa_dual_published(id)
-        # csa_identifier is a Pubid::Csa object — never marked.
-        csa_str = id.csa_identifier.to_s
-        csa_str = "CSA #{csa_str}" unless csa_str.start_with?("CSA", "CAN/")
-
-        "#{child_to_s(id.ieee_identifier)}/#{csa_str}"
-      end
-
-      def render_iec_ieee_copublished(id)
-        result = "IEC/IEEE"
-        # copublished_number glues the parts and the publication year onto the
-        # number, so the mark is spliced in by that single implementation
-        # rather than rebuilt here; with the flag off it is passed "".
-        if id.copublished_number
-          result += " #{id.copublished_number(mark(id.number,
-                                                   publishers: %w[IEC IEEE]))}"
-        end
-        result += id.draft_info if id.draft_info
-        result += " IEC:#{id.iec_year}" if id.iec_year
-        result += " #{id.date_info}" if id.date_info
-        result
-      end
-
-      def render_si_standard(id)
-        parts = []
-
-        # Publisher (IEEE/ASTM)
-        parts << "IEEE/ASTM"
-
-        # Type (SI or PSI based on typed_stage)
-        parts << if id.typed_stage&.abbr&.include?("PSI")
-                   "PSI"
-                 else
-                   "SI"
-                 end
-
-        # Code (number) with draft version for PSI — the mark goes after the
-        # code, before the draft and the date.
-        code_part = id.code.to_s
-        code_part += mark(id.code_obj&.number, id.code_obj&.prefix,
-                          publishers: publishers_of(id))
-        if id.draft_obj
-          code_part += "/D#{id.draft_obj.version}"
-        end
-        parts << code_part if id.code
-
-        # Date
-        if id.month && id.year
-          parts << ", #{id.month} #{id.year}"
-        elsif id.year
-          parts << "-#{id.year}"
-        end
-
-        # Join parts with spaces, but don't insert a space before parts
-        # that start with "-" or "," (e.g., "-2010", ", July 2014") so the
-        # SI form renders as "SI 10-2010" not "SI 10 -2010". The descriptive
-        # relationships narrative is deliberately kept out of to_s (see
-        # render_base); it stays reachable on id.relationships.
-        parts.each_with_object([]) do |part, acc|
-          if acc.empty? || part.to_s.start_with?("-", ",")
-            acc << part.to_s
-          else
-            acc << " " << part.to_s
-          end
-        end.join
-      end
-    end
-  end
-end

data/lib/pubid/ieee/urn_parser.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ieee
-    # Parses IEEE URNs back into identifiers.
-    #
-    # UrnGenerator emits many fields; this parser handles the common
-    # published-standard shape:
-    #   urn:ieee:{publisher}:{code}:{year}
-    #
-    # publisher is the lowercase publisher (with optional copublishers
-    # joined by `-`). code is the alphanumeric designation (period is the
-    # part separator within the code). The year separator in human-readable
-    # form is `-`.
-    #
-    # Examples:
-    # - urn:ieee:ieee:802.3:2018 → IEEE Std 802.3-2018
-    # - urn:ieee:ieee:1018:2019  → IEEE Std 1018-2019
-    class UrnParser < Pubid::UrnParser::Base
-      PUBLISHER_LABEL = "IEEE"
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        _publisher, code, year = parts
-
-        text = "#{PUBLISHER_LABEL} Std #{code}"
-        text += "-#{year}" if year
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/ietf/builder.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ietf
-    # Turns the Parser's parse tree into a concrete identifier object, choosing
-    # the class from which fields are present.
-    class Builder
-      SUBSERIES_CLASSES = {
-        "BCP" => "Bcp",
-        "STD" => "Std",
-        "FYI" => "Fyi",
-      }.freeze
-
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        if data.key?(:draft_rest)
-          build_draft(data)
-        elsif data[:series]
-          build_subseries(data)
-        else
-          build_rfc(data)
-        end
-      end
-
-      private
-
-      def build_rfc(data)
-        Identifiers::Rfc.new(number: unpad(data[:number]))
-      end
-
-      # The series token only selects the class: it is derived back from the
-      # class (Identifiers::Std::SERIES) rather than stored, since `_type`
-      # already carries it.
-      def build_subseries(data)
-        klass = Identifiers.const_get(
-          SUBSERIES_CLASSES.fetch(data[:series].to_s),
-        )
-        klass.new(number: unpad(data[:number]))
-      end
-
-      # Strip the zero-padding the RFC editor's rfc-index.xml writes ("STD0066",
-      # "RFC0001") so the canonical printed form is the unpadded one. The
-      # look-ahead keeps the last digit, so an all-zero number stays "0" rather
-      # than becoming empty.
-      def unpad(number)
-        number.to_s.sub(/\A0+(?=\d)/, "")
-      end
-
-      def build_draft(data)
-        full = "draft-#{data[:draft_rest]}"
-        slug, version = split_draft_version(full)
-        Identifiers::InternetDraft.new(number: slug, version: version)
-      end
-
-      # An Internet-Draft version is a trailing "-NN" of *exactly* two digits at
-      # the very end of the slug. A three-digit topic tail (e.g. "...-256") is
-      # NOT a version: there the char before the last two digits is itself a
-      # digit, not "-", so the guard below leaves it in the slug. This also
-      # means a (non-existent in practice) revision >= 100 would be read as part
-      # of the slug — IETF drafts are always two-digit-versioned, so that case
-      # never arises. Either way the printed string round-trips exactly.
-      #
-      # Dotted slugs need no special handling here: only the final three
-      # characters are inspected, so "draft-ietf-pilc-2.5g3g-12" splits into
-      # ("draft-ietf-pilc-2.5g3g", "12").
-      def split_draft_version(full)
-        if full.length > 3 && full[-3] == "-" && full[-2..].match?(/\A\d\d\z/)
-          [full[0...-3], full[-2..]]
-        else
-          [full, nil]
-        end
-      end
-    end
-  end
-end

data/lib/pubid/ietf/identifier.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-# Pubid::Ietf::Identifier is the IETF base class and the flavor's parse entry
-# point; its body lives in
-# identifiers/base.rb (mirrors the AMCA layout).

data/lib/pubid/ietf/identifiers/base.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ietf
-    # Base class for every IETF identifier AND the flavor's parse/create entry
-    # point (mirrors Pubid::Jis::Identifier). Concrete identifiers under
-    # Pubid::Ietf::Identifiers descend from this class, so a parsed IETF id is
-    # an instance of Pubid::Ietf::Identifier.
-    #
-    # All families are flat, supplement-free, and use plain string attributes.
-    # Those attributes are declared on the LEAVES by Identifiers::Serialization
-    # (see the determinism note there — never re-add `attribute :number` here):
-    #   * Rfc            -> number ("2119")
-    #   * Bcp/Std/Fyi    -> number ("3") + a derived `series` reader
-    #   * InternetDraft  -> number ("draft-giuliano-treedn") + optional version
-    class Identifier < ::Pubid::Identifier
-      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
-      # each subclass's polymorphic_name to its class name so a stored hash
-      # rebuilds the correct identifier type via the shared from_hash dispatch.
-      IETF_TYPE_MAP = {
-        "pubid:ietf:rfc" => "Pubid::Ietf::Identifiers::Rfc",
-        "pubid:ietf:bcp" => "Pubid::Ietf::Identifiers::Bcp",
-        "pubid:ietf:std" => "Pubid::Ietf::Identifiers::Std",
-        "pubid:ietf:fyi" => "Pubid::Ietf::Identifiers::Fyi",
-        "pubid:ietf:internet-draft" =>
-          "Pubid::Ietf::Identifiers::InternetDraft",
-      }.freeze
-
-      # NOTE: no `key_value` block here on purpose. The mapping lives on the
-      # leaves (Identifiers::Serialization); a block on this shared parent would
-      # be inherited-and-merged by every leaf and re-emit keys the leaf did not
-      # declare.
-
-      # Publisher is always "IETF". 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 = "IETF"
-
-      # Basic string representation. Delegates to the flavor renderer.
-      def to_s(**opts)
-        render(format: :human, **opts)
-      end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier; the
-      # IETF_TYPE_MAP above serves as its key_value polymorphic_map.
-
-      # Parse an IETF identifier string into the appropriate identifier object.
-      # @param identifier [String] the IETF identifier string to parse
-      # @return [Identifier] the concrete identifier object
-      # @raise [Pubid::Errors::InvalidInputError] if the input exceeds
-      #   Pubid::MAX_INPUT_LENGTH
-      # @raise [Pubid::Errors::ParseError] if parsing fails
-      def self.parse(identifier)
-        # Inline length guard (CodeQL rb/polynomial-redos barrier) — must be
-        # the first statement. This class-level funnel is what relaton reaches
-        # directly through `pubid_class: ::Pubid::Ietf::Identifier`, so it
-        # cannot rely on the guard in Pubid::Ietf.parse.
-        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/ietf/identifiers/bcp.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ietf
-    module Identifiers
-      # A BCP (Best Current Practice) sub-series id, e.g. "BCP 3".
-      class Bcp < Identifier
-        include Serialization
-
-        # The series token is derived from the class, not stored:
-        # `_type` already encodes it, so serializing `series` would
-        # duplicate the type in every index row.
-        SERIES = "BCP"
-
-        def series
-          SERIES
-        end
-
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :bcp,
-            stage_code: :published,
-            type_code: :bcp,
-            abbr: ["BCP"],
-            name: "Best Current Practice",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :bcp, web: :bcp, title: "Best Current Practice", short: "BCP" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/ietf/identifiers/fyi.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ietf
-    module Identifiers
-      # An FYI (For Your Information) sub-series id, e.g. "FYI 1".
-      class Fyi < Identifier
-        include Serialization
-
-        # The series token is derived from the class, not stored:
-        # `_type` already encodes it, so serializing `series` would
-        # duplicate the type in every index row.
-        SERIES = "FYI"
-
-        def series
-          SERIES
-        end
-
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :fyi,
-            stage_code: :published,
-            type_code: :fyi,
-            abbr: ["FYI"],
-            name: "For Your Information",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :fyi, web: :fyi, title: "For Your Information", short: "FYI" }
-        end
-      end
-    end
-  end
-end