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

data/lib/pubid/oasis/urn_generator.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    # Emits `urn:oasis:<slug>`, echoing the verbatim `original` as a single URN
-    # segment (OASIS slugs never contain ":"). The only characters that occur in
-    # real records outside the URN-safe set are the space and a stray "]" (both
-    # only in a handful of malformed records); these are percent-encoded so the
-    # URN stays well-formed, and UrnParser reverses them exactly.
-    #
-    #   "OASIS amqp-core"          -> "urn:oasis:amqp-core"
-    #   "OASIS OSLC-CM-v1.0-CS01"  -> "urn:oasis:OSLC-CM-v1.0-CS01"
-    class UrnGenerator < Pubid::UrnGenerator::Base
-      # Character -> percent-encoding for the non-URN-safe characters that
-      # actually appear in OASIS slugs. Kept explicit (not a blanket URI escape)
-      # so clean slugs — dots, hyphens, mixed case — pass through unchanged.
-      ENCODE = { " " => "%20", "]" => "%5D" }.freeze
-
-      def generate
-        slug = identifier.original.to_s.gsub(/[ \]]/) { |c| ENCODE[c] }
-        "urn:oasis:#{slug}"
-      end
-    end
-  end
-end

data/lib/pubid/oasis/urn_parser.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    # Parses OASIS URNs back into identifiers by reconstructing the printed form
-    # and delegating to the flavor's text parser.
-    #
-    # UrnGenerator emits `urn:oasis:<slug>` (single segment) with the space and
-    # "]" characters percent-encoded; reverse exactly those two here.
-    #
-    #   urn:oasis:OSLC-CM-v1.0-CS01 -> OASIS OSLC-CM-v1.0-CS01
-    #   urn:oasis:amqp-core         -> OASIS amqp-core
-    class UrnParser < Pubid::UrnParser::Base
-      DECODE = { "%20" => " ", "%5D" => "]" }.freeze
-
-      def parse_urn(urn)
-        slug = strip_namespace(urn).gsub(/%20|%5D/, DECODE)
-        flavor_parse("OASIS #{slug}")
-      end
-    end
-  end
-end

data/lib/pubid/oasis.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oasis
-    extend Pubid::PrefixesSupport
-
-    # Sole OASIS publisher token (see the parser's `prefix` rule). Everything
-    # after "OASIS " is a free-form slug, so there are no leading type tokens to
-    # exclude.
-    PREFIXES = ["OASIS"].freeze
-
-    autoload :Builder, "#{__dir__}/oasis/builder"
-    autoload :Identifier, "#{__dir__}/oasis/identifier"
-    autoload :Identifiers, "#{__dir__}/oasis/identifiers"
-    autoload :Parser, "#{__dir__}/oasis/parser"
-    autoload :Renderer, "#{__dir__}/oasis/renderer"
-    autoload :UrnGenerator, "#{__dir__}/oasis/urn_generator"
-    autoload :UrnParser, "#{__dir__}/oasis/urn_parser"
-
-    # Parse an OASIS identifier string
-    def self.parse(identifier)
-      # Reject pathological inputs before they reach the parser
-      # (CodeQL rb/polynomial-redos barrier — inline .length by design).
-      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
-
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Oasis::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 OASIS flavor with the registry
-Pubid::Registry.register(:oasis, Pubid::Oasis)

data/lib/pubid/ogc/builder.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    # Turns the parse tree into an Ogc::Identifiers::Document. OGC has a single
-    # document type, so there is no type dispatch.
-    class Builder
-      def self.build(parsed_data)
-        new.build(parsed_data)
-      end
-
-      def build(data)
-        Identifiers::Document.new(
-          year: data[:year].to_s,
-          number: data[:number].to_s,
-          revision: normalize_revision(data[:revision]),
-        )
-      end
-
-      private
-
-      # Normalize the revision suffix to its canonical lowercased form (the
-      # shape the relaton index stores, e.g. "R1" -> "r1"). nil when there is
-      # no revision.
-      def normalize_revision(revision)
-        return nil if revision.nil?
-
-        normalized = revision.to_s.strip.downcase
-        normalized.empty? ? nil : normalized
-      end
-    end
-  end
-end

data/lib/pubid/ogc/identifier.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    # Base class for every OGC identifier AND the flavor's parse/create entry
-    # point. There is a single concrete type (Identifiers::Document), so this
-    # base mostly exists to hold the shared attributes and the polymorphic
-    # serialization mapping.
-    class Identifier < ::Pubid::Identifier
-      # OGC ids are digit-leading (`<yy>-<nnn>`) with no publisher token in the
-      # printed form. Everything is kept as a string to preserve zero-padding
-      # ("032", not 32) and the exact revision suffix.
-      attribute :year, :string   # the "<yy>" field, e.g. "24"
-      attribute :number, :string # the "<nnn>" field, e.g. "032"
-      # Optional revision suffix, stored as the full lowercased token including
-      # its separator letter: "r1", "c1", "a", "r3a", "r12a". nil when absent.
-      attribute :revision, :string
-
-      # Polymorphic type map for lutaml::Model key_value (de)serialization: maps
-      # the concrete class's polymorphic_name to its class name so a stored hash
-      # rebuilds the correct identifier type via from_hash.
-      OGC_TYPE_MAP = {
-        "pubid:ogc:document" => "Pubid::Ogc::Identifiers::Document",
-      }.freeze
-
-      key_value do
-        map "_type", to: :_type, polymorphic_map: OGC_TYPE_MAP
-        map "year", to: :year
-        map "number", to: :number
-        map "revision", to: :revision
-      end
-
-      # Publisher is always "OGC". 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 = "OGC"
-
-      attr_reader :with_publisher
-
-      # Basic string representation. Delegates to the human renderer. The
-      # printed OGC id carries no publisher token, so with_publisher defaults to
-      # false; pass with_publisher: true to prepend "OGC ".
-      def to_s(**opts)
-        render(format: :human, **opts)
-      end
-
-      # Capture the with_publisher flag on EVERY render call (default false), so
-      # it can never leak across calls: a bare render/to_s always renders
-      # without the publisher token regardless of a prior with_publisher: true.
-      # The base `render` only forwards `:with_edition` to the renderer, so the
-      # flag is threaded via this per-call instance write (the renderer reads
-      # `id.with_publisher`).
-      def render(format: :human, with_publisher: false, **opts)
-        @with_publisher = with_publisher
-        super(format: format, **opts)
-      end
-
-      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
-      # OGC_TYPE_MAP remains as the key_value polymorphic_map.
-
-      # Parse an OGC identifier string into an identifier object.
-      # @param identifier [String] The OGC identifier string to parse
-      # @return [Identifier] The document identifier object
-      # @raise [Pubid::Errors::InvalidInputError]
-      #   If the input exceeds the maximum length
-      # @raise [Pubid::Errors::ParseError] If parsing fails
-      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
-
-        Builder.build(Parser.parse(identifier))
-      end
-    end
-  end
-end

data/lib/pubid/ogc/identifiers/document.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    module Identifiers
-      # The sole OGC identifier type. An OGC document is numbered
-      # `<yy>-<nnn>[<revision>]` with no publisher token in the printed form.
-      class Document < Identifier
-        TYPED_STAGES = [
-          Pubid::Components::TypedStage.new(
-            code: :ogc,
-            stage_code: :published,
-            type_code: :ogc,
-            abbr: ["OGC"],
-            name: "OGC Document",
-            harmonized_stages: [],
-          ),
-        ].freeze
-
-        def self.type
-          { key: :ogc, web: :document, title: "OGC Document", short: "OGC" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/ogc/identifiers.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    # Namespace for concrete OGC identifier types.
-    module Identifiers
-      autoload :Document, "#{__dir__}/identifiers/document"
-    end
-  end
-end

data/lib/pubid/ogc/parser.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Ogc
-    # Parslet grammar for OGC identifiers.
-    #
-    # Recognizes `<yy>-<nnn>` optionally followed by a revision suffix that
-    # begins with a letter (r/c/a/R…) and may carry a trailing letter
-    # (e.g. "r3a"). An optional leading "OGC" publisher token is accepted for
-    # leniency, though the canonical printed form omits it.
-    #
-    # Examples: "25-023", "24-032r1", "01-009a", "04-095c1", "OGC 24-032r1".
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { match["\\s"].repeat(1) }
-      rule(:digits) { match["0-9"].repeat(1) }
-
-      # Optional leading publisher token, e.g. "OGC " — consumed, not captured.
-      rule(:publisher) { (str("OGC") >> space).maybe }
-
-      # Revision suffix: a run of letters/digits that starts after the numeric
-      # part (which greedily consumes all digits, so the suffix begins with a
-      # separator letter). Kept as a single token for the builder to normalize.
-      rule(:revision) { match["A-Za-z0-9"].repeat(1).as(:revision) }
-
-      rule(:identifier) do
-        publisher >>
-          digits.as(:year) >> str("-") >> digits.as(:number) >>
-          revision.maybe >> space.maybe
-      end
-
-      root(:identifier)
-
-      def self.parse(input)
-        new.parse(input)
-      end
-    end
-  end
-end

data/lib/pubid/ogc/renderer.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    # Human-readable renderer for OGC identifiers.
-    #
-    # Produces the canonical printed form, e.g.:
-    #   "24-032r1"
-    #   "01-009a"
-    #   "OGC 24-032r1"   (only when with_publisher: true)
-    #
-    # Registered as the `:human` format in the OGC format registry and invoked
-    # via `render(format: :human)`.
-    class Renderer < ::Pubid::Renderers::Base
-      PUBLISHER = "OGC"
-
-      def render(**_opts)
-        id = @id
-        result = +""
-        result << "#{PUBLISHER} " if with_publisher?(id)
-        result << "#{id.year}-#{id.number}"
-        result << id.revision.to_s if id.revision
-        result
-      end
-
-      private
-
-      def with_publisher?(id)
-        id.respond_to?(:with_publisher) && id.with_publisher == true
-      end
-    end
-  end
-end

data/lib/pubid/ogc/urn_generator.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    # Emits `urn:ogc:<year>:<number>[:<revision>]`, e.g. `urn:ogc:24:032:r1`.
-    class UrnGenerator < Pubid::UrnGenerator::Base
-      def generate
-        parts = ["urn", "ogc", identifier.year.to_s, identifier.number.to_s]
-        parts << identifier.revision.to_s if identifier.revision
-        parts.join(":")
-      end
-    end
-  end
-end

data/lib/pubid/ogc/urn_parser.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    # Parses OGC URNs back into identifiers.
-    #
-    # UrnGenerator emits: `urn:ogc:<year>:<number>[:<revision>]`.
-    #
-    # Examples:
-    # - urn:ogc:25:023    → 25-023
-    # - urn:ogc:24:032:r1 → 24-032r1
-    class UrnParser < Pubid::UrnParser::Base
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        year, number, revision = split_parts(body)
-        text = "#{year}-#{number}"
-        text += revision.to_s if revision
-        flavor_parse(text)
-      end
-    end
-  end
-end

data/lib/pubid/ogc.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Ogc
-    extend Pubid::PrefixesSupport
-
-    # OGC identifiers are digit-leading (`25-023`) and carry no publisher token
-    # in the printed form. Per the PREFIXES inclusion policy, bare numeric
-    # patterns are NOT listed (they would make cross-flavor routing ambiguous).
-    # Instead the sole entry is the publisher token "OGC", which relaton uses to
-    # route a reference to this flavor even though it is not literally present
-    # in the id string.
-    PREFIXES = ["OGC"].freeze
-
-    autoload :Builder, "#{__dir__}/ogc/builder"
-    autoload :Identifier, "#{__dir__}/ogc/identifier"
-    autoload :Identifiers, "#{__dir__}/ogc/identifiers"
-    autoload :Parser, "#{__dir__}/ogc/parser"
-    autoload :Renderer, "#{__dir__}/ogc/renderer"
-    autoload :UrnGenerator, "#{__dir__}/ogc/urn_generator"
-    autoload :UrnParser, "#{__dir__}/ogc/urn_parser"
-
-    # Parse an OGC identifier string
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry: inherits global formats, overrides :human
-    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Ogc::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 OGC flavor with the registry
-Pubid::Registry.register(:ogc, Pubid::Ogc)

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

@@ -1,137 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Oiml
-    module Identifiers
-      # OIML Bulletin issues and articles. Carries no code — the locator is
-      # the (year, issue, sequence) tuple drawn from the issue's place in the
-      # periodical hierarchy.
-      #
-      # Two input forms are accepted, both referring to the same article:
-      #
-      #   structured:  "OIML Bulletin 2026-02-11"
-      #   citation:    "OIML Bulletin LXVII(2) 20260211"
-      #
-      # The structured form is the dataset's primary docid (sortable,
-      # deterministic). The citation form is what OIML prints on the article
-      # page (`Citation: AUTHOR YEAR OIML Bulletin VOLUME(ISSUE) ARTID`).
-      #
-      # Volume tracks year deterministically: 1960 = I, year - 1959 = volume.
-      # The 8-digit article id is YYYYNNSS — the same three values concatenated,
-      # so the citation form is decoded entirely from the article id; the
-      # roman volume and parenthesised issue are redundant display.
-      #
-      # Shapes in relaton-data-oiml:
-      #   "OIML Bulletin"                       (periodical)
-      #   "OIML Bulletin 1960"                  (volume / year)
-      #   "OIML Bulletin 1960-03"               (issue)
-      #   "OIML Bulletin 1960-03-01"            (article, structured)
-      #   "OIML Bulletin LXVII(2) 20260211"     (article, citation)
-      class Bulletin < SingleIdentifier
-        # OIML Bulletin volume I was issued in 1960. Volume N corresponds to
-        # year (N + BASE_YEAR_OFFSET). Used to translate between the year
-        # carried in the structured form and the roman volume in citations.
-        BASE_YEAR_OFFSET = 1959
-
-        # Zero-padded issue number within the year ("01".."04", plus "07"/"10"
-        # for the online-bulletin series). Always 2 digits.
-        attribute :issue, :string
-        # Zero-padded sequence within the issue ("00" = editorial, "01"+ for
-        # articles). Always 2 digits.
-        attribute :sequence, :string
-
-        key_value do
-          map "issue", to: :issue
-          map "sequence", to: :sequence
-        end
-
-        # relaton-index keys on `id.root.number.to_s`. Bulletin is the one OIML
-        # leaf with no code (it does not include Identifiers::CodeNumber), so
-        # it derives the key from the year it already stores: every issue and
-        # article of a volume clusters into one bucket, with per-article
-        # distinctness coming from the MR slug instead. That is the BIPM
-        # Metrologia-volume precedent recorded in CLAUDE.md.
-        #
-        # A DERIVED READER, deliberately not an attribute: storing it would
-        # duplicate `year` in every row, and the key_value block above maps no
-        # "number", so nothing is added to the wire format. Safe as a plain
-        # method because Bulletin declares no `number` attribute of its own
-        # (the ITU itu/identifiers/base.rb precedent).
-        #
-        # nil for the bare periodical reference "OIML Bulletin", which names no
-        # year — a deliberate gap, pinned in spec/pubid/oiml/root_number_spec.rb.
-        def number
-          date&.year&.to_s
-        end
-
-        # The index key above is deliberately coarse — a whole volume in one
-        # bucket — which is only defensible because the MR slug stays
-        # per-article. The inherited hook reads through `code`, which Bulletin
-        # does not have, so it would return nil and collapse every article of a
-        # year onto `oiml.bulletin.<year>`; `to_slug` is an output FILENAME, so
-        # that is an overwrite. Emit the rest of the locator instead.
-        #
-        # The year is deliberately NOT included: Renderers::MrString already
-        # gives it its own segment (`mr_year`), so repeating it here would
-        # render `oiml.bulletin.1960-03-01.1960`.
-        def mr_number_with_part
-          segments = [issue, sequence].compact
-          return nil if segments.empty?
-
-          segments.join("-")
-        end
-
-        def type_string
-          "Bulletin"
-        end
-
-        # Volume as an arabic string ("67"), derived from the year. nil when
-        # the year is absent (bare periodical reference).
-        def volume_arabic
-          return nil unless date&.year
-
-          (date.year.to_i - BASE_YEAR_OFFSET).to_s
-        end
-
-        # Volume as a roman-numeral string ("LXVII"), derived from the year.
-        # nil when the year is absent.
-        def volume_roman
-          number = volume_arabic&.to_i
-          return nil unless number&.positive?
-
-          self.class.to_roman(number)
-        end
-
-        # 8-digit oiml.org article id ("20260211"). Composed by concatenating
-        # year + issue + sequence. nil unless all three are present.
-        def article_id
-          return nil unless date&.year && issue && sequence
-
-          "#{date.year}#{issue}#{sequence}"
-        end
-
-        class << self
-          # Convert a positive integer to its roman-numeral representation.
-          # Used to render the citation form. The dataset already stores the
-          # roman volume verbatim in `extent.locality`, so this conversion is
-          # only needed when rendering from the structured form.
-          def to_roman(number)
-            raise ArgumentError, "volume must be > 0" unless number.positive?
-
-            ROMAN_TABLE.each_with_object(+"") do |(value, sym), result|
-              quotient, number = number.divmod(value)
-              result << (sym * quotient)
-            end.freeze
-          end
-
-          ROMAN_TABLE = [
-            [1000, "M"], [900, "CM"], [500, "D"], [400, "CD"],
-            [100, "C"], [90, "XC"], [50, "L"], [40, "XL"],
-            [10, "X"], [9, "IX"], [5, "V"], [4, "IV"],
-            [1, "I"]
-          ].freeze
-        end
-      end
-    end
-  end
-end