pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/oiml/supplement_identifier.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class SupplementIdentifier < Identifier
+      # Base class for OIML supplements (amendments, annexes)
+      # These wrap a base identifier like ISO amendments
+      attribute :base, Oiml::Identifier, polymorphic: true
+      attribute :year, :string
+      attribute :language, :string
+
+      # Delegate the document code to the wrapped standard, mirroring
+      # Pubid::Etsi::Identifiers::SupplementIdentifier#code.
+      #
+      # PRE-EXISTING BUG this closes: `UrnGenerator#urn_number` calls
+      # `identifier.code` for every non-Bulletin type, but a supplement
+      # descends from Oiml::Identifier directly — it is a SIBLING of
+      # SingleIdentifier, which is where `code` used to live — so it inherited
+      # no `code` at all and `to_urn` raised NoMethodError for every Amendment,
+      # Errata and Annex. Verified against a baseline captured on main: all
+      # five supplement fixtures already raised there, so this is a fix, not a
+      # regression introduced by the move to split index columns.
+      #
+      # It stayed hidden because spec/pubid/oiml/urn_spec.rb only exercises a
+      # bare Recommendation and spec/pubid/oiml/fixtures_spec.rb globs a bad
+      # path and runs 0 examples (hand-off: ten-dead-fixture-specs).
+      # `iteration` is the same story: declared on SingleIdentifier, read
+      # unconditionally by UrnGenerator#urn_iteration, absent from the
+      # supplement branch of the hierarchy. (`stage` escapes because
+      # ::Pubid::Identifier declares one, so it merely returns nil.)
+      def code
+        base&.code
+      end
+
+      def iteration
+        base&.iteration
+      end
+      # True for the trailing-word shorthand ("OIML R 138:2009 Amendment"),
+      # where the supplement word is appended after a dated base instead of the
+      # "Amendment (YYYY) to BASE" prose form. The word itself comes from the
+      # concrete class (#supplement_type), so only this flag is stored.
+      attribute :trailing, :boolean, default: false
+      # True for the plus-joined form ("OIML B 10:2011+Amendment:2012") where
+      # both the base and the supplement carry their own year, joined by "+".
+      attribute :joined, :boolean, default: false
+      attribute :parsed_format, :string, default: -> {
+        "short"
+      } # Track supplement's parsed format
+
+      # Serialization delta on top of Oiml::Identifier's shared block. The
+      # nested base is (de)serialized recursively through the
+      # polymorphic router so its own `_type` selects the right subclass.
+      key_value do
+        map "base",
+            with: { to: :base_to_kv, from: :base_from_kv }
+        map "year", to: :year
+        map "trailing", to: :trailing
+        map "joined", to: :joined
+      end
+
+      def base_to_kv(model, doc)
+        base = model.base
+        return unless base
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new("base",
+                                                   base.to_hash),
+        )
+      end
+
+      def base_from_kv(model, value)
+        model.base = ::Pubid::Oiml::Identifier.from_hash(value) if value
+      end
+
+      attr_reader :requested_format
+
+      def to_s(format: nil, **opts)
+        @requested_format = format
+        render(format: :human, **opts)
+      end
+
+      # Subclasses override this
+      def supplement_type
+        raise NotImplementedError, "Subclasses must implement supplement_type"
+      end
+    end
+  end
+end

data/lib/pubid/oiml/urn_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        return "r" unless identifier.type
+
+        identifier.type.to_s.downcase
+      end
+
+      def urn_number
+        return nil unless identifier.code
+
+        identifier.code.to_s
+      end
+
+      def urn_stage
+        identifier.stage&.to_s&.downcase
+      end
+
+      def urn_iteration
+        identifier.iteration&.to_s
+      end
+
+      def urn_language
+        identifier.language&.to_s&.downcase
+      end
+
+      def generate
+        # Bulletin issues carry no code; the (year, issue, sequence) tuple
+        # is the locator. URNs are canonical regardless of how the input was
+        # formatted, so we always emit the structured YYYY-II-SS form even
+        # when the identifier was parsed from a citation string.
+        if identifier.is_a?(Identifiers::Bulletin)
+          parts = ["urn", "oiml", "bulletin"]
+          parts << bulletin_locator if identifier.date&.present?
+          parts << urn_language if urn_language
+          return parts.join(":")
+        end
+
+        parts = ["urn", "oiml"]
+        parts << urn_type
+        parts << urn_number if urn_number
+        parts << urn_year if urn_year
+        parts << urn_stage if urn_stage
+        parts << urn_iteration if urn_iteration
+        parts << urn_language if urn_language
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        if identifier.is_a?(SupplementIdentifier)
+          if identifier.typed_stage
+            supp_type = identifier.typed_stage.type_code.to_s
+            parts << supp_type if supp_type
+          end
+
+          if identifier.number
+            parts << identifier.number.to_s
+          end
+        end
+
+        parts.join(":")
+      end
+
+      # Structured locator "YYYY-II-SS" (or "YYYY-II" / "YYYY") for a Bulletin.
+      # Built directly from the date year and the issue/sequence attributes so
+      # the URN is identical regardless of whether the input was the structured
+      # or citation form.
+      def bulletin_locator
+        locator = identifier.date.year.to_s
+        locator += "-#{identifier.issue}" if identifier.issue
+        locator += "-#{identifier.sequence}" if identifier.sequence
+        locator
+      end
+    end
+  end
+end

data/lib/pubid/oiml/urn_parser.rb

@@ -0,0 +1,39 @@
+# 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/oiml.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    extend Pubid::PrefixesSupport
+
+    # Sole OIML publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["OIML"].freeze
+
+    autoload :Builder, "#{__dir__}/oiml/builder"
+    autoload :Components, "#{__dir__}/oiml/components"
+    autoload :Identifier, "#{__dir__}/oiml/identifier"
+    autoload :Identifiers, "#{__dir__}/oiml/identifiers"
+    autoload :Parser, "#{__dir__}/oiml/parser"
+    autoload :Renderer, "#{__dir__}/oiml/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/oiml/single_identifier"
+    autoload :SupplementIdentifier, "#{__dir__}/oiml/supplement_identifier"
+    autoload :UrnGenerator, "#{__dir__}/oiml/urn_generator"
+    autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
+
+    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
+
+      parser = Parser.new
+      builder = Builder.new
+
+      parsed = parser.parse(identifier)
+      builder.build(parsed)
+    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: Oiml::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 Uoiml flavor with the registry
+Pubid::Registry.register(:oiml, Pubid::Oiml)

data/lib/pubid/omg/builder.rb

@@ -0,0 +1,19 @@
+# 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

@@ -0,0 +1,47 @@
+# 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

@@ -0,0 +1,32 @@
+# 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

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

data/lib/pubid/omg/parser.rb

@@ -0,0 +1,40 @@
+# 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

@@ -0,0 +1,19 @@
+# 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

@@ -0,0 +1,51 @@
+# 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/common_parse_methods.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    module CommonParseMethods
+      def array_to_str(array)
+        array.reduce(str(array.first)) do |acc, value|
+          acc | str(value)
+        end
+      end
+    end
+  end
+end

data/lib/pubid/parser/common_parse_rules.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    module CommonParseRules
+      def self.included(base)
+        base.class_eval do
+          rule(:space) { str(" ") }
+          rule(:space?) { space.maybe }
+
+          rule(:digits) do
+            match('\d').repeat(1)
+          end
+
+          rule(:year) do
+            match('\d').repeat(4, 4).as(:year)
+          end
+
+          rule(:comma) { str(", ") }
+          rule(:comma?) { comma.maybe }
+          rule(:comma_space) { comma | space }
+          rule(:dash) { str("-") }
+          rule(:dot) { str(".") }
+          rule(:words_digits) { match('[\dA-Za-z]').repeat(1) }
+          rule(:words) { match("[A-Za-z]").repeat(1) }
+          rule(:words?) { words.maybe }
+          rule(:year_digits) do
+            (str("19") | str("20")) >> match('\d').repeat(2,
+                                                          2) >> digits.absent?
+          end
+
+          rule(:month_digits) do
+            match('\d').repeat(2, 2)
+          end
+
+          rule(:day_digits) do
+            match('\d').repeat(2, 2)
+          end
+
+          rule(:originator) do
+            organization.as(:publisher) >>
+              (space? >> str("/") >> organization.as(:copublisher)).repeat
+          end
+
+          rule(:comma_month_year) do
+            comma >> words.as(:month) >> space >> year_digits.as(:year)
+          end
+
+          rule(:year_month) do
+            year_digits >> dash >> month_digits
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/parser/grammar.rb

@@ -0,0 +1,74 @@
+# 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/parser.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parser
+    autoload :Grammar, "pubid/parser/grammar"
+    autoload :CommonParseMethods, "pubid/parser/common_parse_methods"
+    autoload :CommonParseRules, "pubid/parser/common_parse_rules"
+  end
+end

data/lib/pubid/parsers/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parsers
+    class Base
+      def self.parse(string)
+        raise NotImplementedError, "#{self.class}.parse not implemented"
+      end
+    end
+  end
+end