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

data/lib/pubid/oiml/identifiers/code_number.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oiml
-    module Identifiers
-      # Installs the flat, index-friendly code columns and their serialization
-      # on the seven concrete OIML document leaves (Recommendation, Document,
-      # Vocabulary, Guide, BasicPublication, ExpertReport, SeminarReport).
-      #
-      # Why the leaves and not Pubid::Oiml::SingleIdentifier, which they all
-      # inherit from: `number` redefines the parent ::Pubid::Identifier's
-      # `attribute :number, Components::Code` as a plain :string (and `part` /
-      # `subpart` likewise). Declaring that on a class the concrete types
-      # INHERIT from resolves against the parent definition nondeterministically
-      # under multi-flavor load — it passes an OIML-only run and can flip
-      # `root.number` to "" under the full suite (the IEEE lesson; see
-      # lib/pubid/ieee/identifiers/code_number.rb and CLAUDE.md). Declaring on
-      # each leaf removes the ambiguity at the point of use.
-      #
-      # This matters because relaton-index sorts and bsearches every row on
-      # `id.root.number.to_s`. OIML kept the code in an Oiml::Components::Code
-      # under a `code` attribute and never set `number`, so all 12,226 lines of
-      # the published relaton-data-oiml index-v2 keyed "".
-      #
-      # The serialized hash ALREADY had these as bare top-level scalars — the
-      # old converters merely read them through `code` — so the wire format is
-      # byte-identical and that index needs no regeneration.
-      #
-      # Bulletin deliberately does NOT include this module. It carries no code
-      # at all (its locator is the year/issue/sequence tuple), so it would only
-      # gain a permanently-nil `number` and a `number` key that never appears.
-      # It derives its index key from the year instead; see bulletin.rb.
-      module CodeNumber
-        def self.included(base)
-          install_attributes(base)
-          install_mappings(base)
-        end
-
-        def self.install_attributes(base)
-          # Bare document number ("144"), the relaton index key. The part is a
-          # sibling column, never folded in, so every part of a document shares
-          # one bucket and a part-less reference finds them all.
-          base.attribute :number, :string
-          base.attribute :part, :string
-          base.attribute :subpart, :string
-          # Free-form trailing suffix glued to the code, e.g. "sup", "A",
-          # "erratum", "GUM 1", "ISO3930". Preserved verbatim for round-trip.
-          base.attribute :suffix, :string
-          # When true the suffix is space-separated ("D 1 Brochure") rather
-          # than the default dash ("R 60-sup"). Named for the RARE case with a
-          # false default, so the canonical to_hash drops it from every
-          # ordinary row.
-          base.attribute :space_suffix, :boolean, default: -> { false }
-        end
-
-        # Merged by lutaml with the block SingleIdentifier declares, which
-        # carries publisher/year/edition/stage/iteration.
-        def self.install_mappings(base)
-          base.key_value do
-            map "number", to: :number
-            map "part", to: :part
-            map "subpart", to: :subpart
-            map "suffix", to: :suffix
-            map "space_suffix", to: :space_suffix
-          end
-        end
-
-        # The composed document code, rebuilt on demand from the split columns
-        # so the renderer and the URN generator keep one place to ask for the
-        # printed form ("144-1", "60-sup"). Deliberately NOT an attribute and
-        # NOT memoised: the columns are writable (the base #exclude rebuilds
-        # through them), so a cached Code would go stale.
-        #
-        # nil when there is no number, preserving the old nil-`code` semantics
-        # the URN generator branches on.
-        def code
-          return nil if number.nil?
-
-          Components::Code.new(
-            number: number,
-            part: part,
-            subpart: subpart,
-            suffix: suffix,
-            space_suffix: space_suffix,
-          )
-        end
-      end
-    end
-  end
-end

data/lib/pubid/oiml/identifiers/errata.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oiml
-    module Identifiers
-      # Errata supplement, used by the trailing-word shorthand
-      # "OIML R 126:2015 Errata" (the publication year lives on the base).
-      class Errata < SupplementIdentifier
-        def supplement_type
-          "Errata"
-        end
-      end
-    end
-  end
-end

data/lib/pubid/oiml/renderer.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oiml
-    # Human-readable renderer for OIML identifiers.
-    #
-    # Produces strings like:
-    #   "OIML R 60:2000"
-    #   "OIML R 60 Edition 2013"
-    #   "OIML R 60 Annex A Edition 2013 (E)"
-    #   "OIML R 60 Annexes:2021 (E)"
-    #
-    # The renderer is registered as the `:human` format in the OIML format
-    # registry and invoked via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **opts)
-        id = @id
-        @context = context
-
-        case id
-        when Identifiers::Annex
-          render_annex(id)
-        when Identifiers::Bulletin
-          render_bulletin(id)
-        when SupplementIdentifier
-          render_supplement(id)
-        when SingleIdentifier
-          render_single(id)
-        else
-          id.to_s
-        end
-      end
-
-      private
-
-      # Render the Bulletin in the requested or parsed form. Default is the
-      # structured "YYYY-II-SS" form (the dataset's primary docid). The
-      # citation form ("LXVII(2) 20260211") is emitted when the user asks
-      # for it via `to_s(format: :citation)` or when the identifier was
-      # itself parsed from a citation string (parsed_format == "citation").
-      def render_bulletin(id)
-        if citation_form?(id)
-          render_bulletin_citation(id)
-        else
-          render_bulletin_structured(id)
-        end
-      end
-
-      # User's explicit format request takes precedence over the parsed
-      # form, so `parse("LXVII(2) 20260211").to_s(format: :short)` returns
-      # the structured form. With no explicit request, the parsed form is
-      # preserved for round-trip fidelity.
-      def citation_form?(id)
-        case id.requested_format
-        when :citation then true
-        when :short, :structured then false
-        else
-          id.parsed_format == "citation"
-        end
-      end
-
-      # "OIML Bulletin" / "OIML Bulletin 1960" / "OIML Bulletin 1960-03" /
-      # "OIML Bulletin 1960-03-01". No code; the locator is space-separated.
-      def render_bulletin_structured(id)
-        result = "#{id.publisher} Bulletin"
-        if id.date&.year
-          result += " #{id.date.year}"
-          result += "-#{id.issue}" if id.issue
-          result += "-#{id.sequence}" if id.sequence
-        end
-        result += " (#{id.language})" if id.language
-        result
-      end
-
-      # "OIML Bulletin LXVII(2) 20260211". Only emitted for full articles
-      # (year + issue + sequence all present); lower tiers fall back to
-      # structured since OIML's citation format doesn't define volume-only
-      # or issue-only variants.
-      def render_bulletin_citation(id)
-        return render_bulletin_structured(id) unless id.date&.year && id.issue && id.sequence
-
-        "#{id.publisher} Bulletin #{id.volume_roman}(#{id.issue.to_i}) #{id.article_id}"
-      end
-
-      def effective_format(id)
-        id.requested_format ||
-          (id.parsed_format == "long" ? :long : :short)
-      end
-
-      # Strip a trailing language group "(...)" from a rendered base string so
-      # the supplement can re-attach its own language at the end.
-      def strip_language(str)
-        str.sub(/\s*\([^)]+\)\s*$/, "").strip
-      end
-
-      def render_single(id)
-        format = effective_format(id)
-
-        result = "#{id.publisher} #{id.type_string} #{id.code}"
-
-        using_edition_format = false
-
-        if id.edition && id.date
-          result += " #{id.edition} Edition #{id.date.render(context: @context)}"
-          using_edition_format = true
-        elsif id.edition
-          result += " #{id.edition}"
-          using_edition_format = true
-        elsif id.date
-          if format == :long
-            result += " Edition #{id.date.render(context: @context)}"
-            using_edition_format = true
-          else
-            result += ":#{id.date.render(context: @context)}"
-          end
-        end
-
-        if id.stage || id.iteration
-          result += " "
-          result += id.iteration.to_s if id.iteration
-          result += id.stage.to_s if id.stage
-        end
-
-        if id.language
-          result += if using_edition_format || id.parsed_format == "short_with_space"
-                      " (#{id.language})"
-                    else
-                      "(#{id.language})"
-                    end
-        end
-
-        result
-      end
-
-      def render_supplement(id)
-        format = effective_format(id)
-
-        # Plus-joined: "BASE+Amendment:YEAR" / "BASE+Errata:YEAR" with both
-        # the base and the supplement carrying their own year.
-        if id.joined
-          base_str = strip_language(id.base.to_s)
-          result = "#{base_str}+#{id.supplement_type}"
-          result += ":#{id.year}" if id.year
-          result += " (#{id.language})" if id.language
-          return result
-        end
-
-        # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
-        # publication year kept on the base identifier. The word comes from the
-        # concrete supplement class.
-        if id.trailing
-          base_str = strip_language(id.base.to_s)
-          result = "#{base_str} #{id.supplement_type}"
-          result += " (#{id.language})" if id.language
-          return result
-        end
-
-        base_format = if format && format != :short
-                        format
-                      elsif id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
-                        :long
-                      else
-                        :short
-                      end
-
-        base_str = if id.base.is_a?(SingleIdentifier)
-                     id.base.to_s(format: base_format)
-                   else
-                     id.base.to_s
-                   end
-        base_str = strip_language(base_str)
-
-        result = "#{id.supplement_type} (#{id.year}) to #{base_str}"
-        result += " (#{id.language})" if id.language
-
-        result
-      end
-
-      def render_annex(id)
-        format = effective_format(id)
-
-        # "BASE:YYYY Annex(es)" — the year is glued to the base, the marker
-        # carries none. Keep the base date instead of stripping it.
-        if id.year_on_base
-          base_str = strip_language(id.base.to_s)
-          marker = id.letter ? "Annex #{id.letter}" : "Annexes"
-          result = "#{base_str} #{marker}"
-          result += " (#{id.language})" if id.language
-          return result
-        end
-
-        base_format = if id.base.class.attributes.key?(:parsed_format) && id.base.parsed_format == "long"
-                        :long
-                      else
-                        :short
-                      end
-
-        annex_format = if format
-                         format
-                       elsif id.class.attributes.key?(:parsed_format) && id.parsed_format == "long"
-                         :long
-                       else
-                         :short
-                       end
-
-        base_str = if id.base.is_a?(SingleIdentifier)
-                     id.base.to_s(format: base_format)
-                   else
-                     id.base.to_s
-                   end
-        result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
-          /\(.*\)/, ""
-        ).strip
-
-        if id.letter
-          result += " Annex #{id.letter}"
-          result += " Edition #{id.year}" if id.year
-        else
-          result += " Annexes"
-          if id.year
-            result += annex_format == :long ? " Edition #{id.year}" : ":#{id.year}"
-          elsif id.base.date
-            result += annex_format == :long ? " Edition #{id.base.date.render(context: @context)}" : ":#{id.base.date.render(context: @context)}"
-          end
-        end
-
-        result += " (#{id.language})" if id.language
-        result
-      end
-    end
-  end
-end

data/lib/pubid/oiml/urn_parser.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oiml
-    # Parses OIML URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:oiml:{type}:{locator}` where type is the
-    # lowercase document class — single letter for typed documents
-    # (r, d, b, g, …) or the word "bulletin" for Bulletin issues. The
-    # locator is the number-part-subpart for typed documents and the
-    # YYYY-II-SS tuple for Bulletins.
-    #
-    # Examples:
-    # - urn:oiml:r:111-1           → OIML R 111-1
-    # - urn:oiml:d:1               → OIML D 1
-    # - urn:oiml:bulletin:2026-02-11 → OIML Bulletin 2026-02-11
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-        type_token = parts.fetch(0)
-        number = parts[1]
-
-        text = "OIML #{display_type(type_token)}"
-        text += " #{number}" if number
-        flavor_parse(text)
-      end
-
-      private
-
-      # URN type tokens are lowercase. Typed documents use a single letter
-      # that maps cleanly via upcase; Bulletin is the multi-letter word
-      # that the human parser expects capitalized.
-      def display_type(token)
-        token.downcase == "bulletin" ? "Bulletin" : token.upcase
-      end
-    end
-  end
-end

data/lib/pubid/omg/builder.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Omg
-    # Builds a Pubid::Omg::Identifier from a parse tree.
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        Identifiers::Specification.new(
-          acronym: data[:acronym].to_s,
-          version: data[:version]&.to_s,
-        )
-      end
-    end
-  end
-end

data/lib/pubid/omg/identifier.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Omg
-    # Base class for every OMG identifier AND the flavor's parse/create
-    # entry point.
-    class Identifier < ::Pubid::Identifier
-      # The spec family acronym, e.g. "AMI4CCM", "UML", "CORBA".
-      attribute :acronym, :string
-
-      # Free-form version string. Stored verbatim because OMG versioning is
-      # loose ("1.0", "2.5.1", "5 beta 3", "1.1"). Use Version#to_s for
-      # rendering.
-      attribute :version, :string
-
-      OMG_TYPE_MAP = {
-        "pubid:omg:specification" => "Pubid::Omg::Identifiers::Specification",
-      }.freeze
-
-      key_value do
-        map "_type", to: :_type, polymorphic_map: OMG_TYPE_MAP
-        map "acronym", to: :acronym
-        map "version", to: :version
-      end
-
-      PUBLISHER = "OMG"
-
-      def to_s(**opts)
-        render(format: :human, **opts)
-      end
-
-      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/omg/identifiers/specification.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Omg
-    module Identifiers
-      # OMG specification identifier.
-      #
-      # Examples:
-      #   OMG AMI4CCM 1.0
-      #   OMG UML 2.5.1
-      #   OMG DDS 5 beta 3
-      #   OMG CORBA
-      class Specification < Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :pubomg,
-            stage_code: :published,
-            type_code: :omg,
-            abbr: ["OMG"],
-            name: "OMG Specification",
-            harmonized_stages: %w[60.00 60.60],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :omg, web: :specification, title: "OMG Specification",
-            short: "OMG" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/omg/identifiers.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Omg
-    module Identifiers
-      autoload :Specification, "#{__dir__}/identifiers/specification"
-    end
-  end
-end

data/lib/pubid/omg/parser.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Omg
-    # Parslet grammar for OMG specification identifiers.
-    #
-    # Accepts:
-    #   OMG {ACRONYM}[ {VERSION}]
-    #
-    # ACRONYM is uppercase letters/digits, at least 1 char.
-    # VERSION is digits/dots/spaces/beta+space+digit, e.g. "1.0", "2.5.1",
-    # "5 beta 3".
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { str(" ") }
-
-      # Acronym: starts with uppercase, may contain uppercase + lowercase +
-      # digits (covers "SysML", "AMI4CCM", "UML", "CORBA", "BMM", ...).
-      rule(:acronym) { (match("[A-Z]") >> match("[A-Za-z0-9]").repeat).as(:acronym) }
-
-      # Version: digits with optional dots, optionally followed by " beta N".
-      rule(:version) do
-        (match("[0-9]").repeat(1) >>
-          (str(".") >> match("[0-9]").repeat(1)).repeat >>
-          (str(" beta ") >> match("[0-9]").repeat(1)).maybe).as(:version)
-      end
-
-      rule(:identifier) do
-        str("OMG") >> space >> acronym >> (space >> version).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/omg/renderer.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Omg
-    # Human-readable renderer for OMG specification identifiers.
-    #
-    # Produces:
-    #   "OMG AMI4CCM 1.0"
-    #   "OMG UML 2.5.1"
-    #   "OMG CORBA"
-    class Renderer < ::Pubid::Renderers::Base
-      def render(**_opts)
-        result = "OMG #{@id.acronym}"
-        result += " #{@id.version}" if @id.version && !@id.version.empty?
-        result
-      end
-    end
-  end
-end

data/lib/pubid/omg.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  # OMG (Object Management Group) specification flavor.
-  #
-  # Covers formal OMG specifications identified by an acronym (UML, SysML,
-  # CORBA, AMI4CCM, ...) with optional version (`1.0`, `2.5.1`,
-  # `5 beta 3`).
-  module Omg
-    extend Pubid::PrefixesSupport
-
-    PREFIXES = ["OMG"].freeze
-
-    autoload :Builder, "#{__dir__}/omg/builder"
-    autoload :Identifier, "#{__dir__}/omg/identifier"
-    autoload :Identifiers, "#{__dir__}/omg/identifiers"
-    autoload :Parser, "#{__dir__}/omg/parser"
-    autoload :Renderer, "#{__dir__}/omg/renderer"
-
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Omg::Renderer)
-
-    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
-
-    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
-
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-
-    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
-
-Pubid::Registry.register(:omg, Pubid::Omg)

data/lib/pubid/parser/grammar.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-require_relative "../errors"
-
-module Pubid
-  module Parser
-    # The superclass of every flavor grammar.
-    #
-    # Its only job is to keep parslet out of pubid's public contract. Every
-    # grammar failure originates in `Parslet::Atoms::Base#parse`, which
-    # `Parslet::Parser` does not override, so one override here covers all 46
-    # grammars, both public entry points of every flavor, and the cross-flavor
-    # delegation routes (`Pubid::Iso.parse("ITU-T G.711")` runs ITU's grammar)
-    # — without touching the 131 `parse` methods.
-    #
-    # The name is `Grammar`, not `Base`, because {Pubid::Parsers::Base} already
-    # exists and means something unrelated (the MR-string parser).
-    #
-    # Known limit: a rule atom parsed directly, `Parser.new.<rule>.parse(str)`,
-    # bypasses this and raises a bare `Parslet::ParseFailed`. Nothing in the
-    # gem does that.
-    class Grammar < ::Parslet::Parser
-      # @param io [String, IO]
-      # @param options [Hash] passed through to parslet
-      # @raise [Pubid::Errors::ParseError]
-      def parse(io, options = {})
-        super
-      rescue ::Pubid::Errors::ParseError
-        # A nested grammar already wrapped it. Keep the inner flavor and input.
-        raise
-      rescue ::Parslet::ParseFailed => e
-        raise wrap_parse_failure(e, io)
-      end
-
-      private
-
-      # @param error [Parslet::ParseFailed]
-      # @param io [String, IO] what was handed to {#parse}
-      # @return [Pubid::Errors::ParseError]
-      def wrap_parse_failure(error, io)
-        ::Pubid::Errors::ParseError.new(
-          error.message,
-          error.parse_failure_cause,
-          input: io.is_a?(String) ? io : nil,
-          flavor: pubid_flavor_name,
-        )
-      end
-
-      # "Pubid::Iso::Parser" -> "iso"; "Pubid::Ieee::Aiee::Parser" -> "ieee".
-      #
-      # Resolved through {Pubid::Registry} rather than taken from the module
-      # name, because the two disagree: `Pubid::Tgpp` registers as `"3gpp"`,
-      # and `Pubid::CenCenelec` registers twice (`"cen_cenelec"` first, then
-      # the `"cen"` alias). Reporting the registered name is what lets a caller
-      # feed `error.flavor` straight back to `Pubid::Registry.get`.
-      # @return [String, nil]
-      def pubid_flavor_name
-        parts = self.class.name.to_s.split("::")
-        return nil unless parts[0] == "Pubid" && parts.length > 1
-
-        registered_flavor_name(parts[1]) || parts[1].downcase
-      end
-
-      # @param module_name [String] e.g. "Tgpp"
-      # @return [String, nil] the registered name, nil if not registered
-      def registered_flavor_name(module_name)
-        ::Pubid::Registry.flavors.key(::Pubid.const_get(module_name))
-      rescue ::NameError
-        nil
-      end
-    end
-  end
-end

data/lib/pubid/plateau/identifier.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-# Pubid::Plateau::Identifier is the PLATEAU base class (a real Pubid::Identifier
-# subclass); its body and `.parse` live in identifiers/base.rb. This file just ensures it is loaded.