pubid 2.0.0.pre.alpha.5 → 2.0.0.pre.alpha.7

data/lib/pubid/etsi.rb

@@ -4,6 +4,13 @@ require "lutaml/model"
 
 module Pubid
   module Etsi
+    extend Pubid::PrefixesSupport
+
+    # Sole ETSI publisher token (see the parser's `etsi_prefix` rule). The
+    # document-type tokens (EN, TS, TR, ...) are sub-types that follow the ETSI
+    # prefix, not standalone routing tokens, so they are excluded.
+    PREFIXES = ["ETSI"].freeze
+
     autoload :Builder, "#{__dir__}/etsi/builder"
     autoload :Components, "#{__dir__}/etsi/components"
     autoload :Identifier, "#{__dir__}/etsi/identifier"

data/lib/pubid/iala/builder.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Builds an IALA identifier object from the Parslet parse tree.
+    class Builder
+      def build(parsed)
+        hash = parsed
+
+        return build_annex(hash) if hash[:annex_marker]
+
+        type_letter = stringify(hash[:type_letter])&.upcase
+
+        attrs = {
+          number:   build_number(hash, type_letter),
+          edition:  stringify(hash.dig(:edition, :edition_value)),
+          language: stringify(hash.dig(:language_group, :language))&.upcase,
+        }.compact
+
+        Iala.identifier_klass_for_type_letter(type_letter).new(**attrs)
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      # Build the Annex wrapper from the parse tree. The base sub-tree
+      # (captured under :base) is recursively built via the same logic as
+      # a flat identifier, then wrapped.
+      def build_annex(hash)
+        base_hash = hash[:base]
+        base_type = stringify(base_hash[:type_letter])&.upcase
+        base_number = build_number(base_hash, base_type)
+        base = Iala.identifier_klass_for_type_letter(base_type).new(number: base_number)
+
+        attrs = {
+          base_identifier: base,
+          annex_form:      stringify(hash[:annex_marker]),
+          letter:          stringify(hash[:annex_letter]),
+          edition:         stringify(hash.dig(:edition, :edition_value)),
+          language:        stringify(hash.dig(:language_group, :language))&.upcase,
+        }.compact
+
+        Identifiers::Annex.new(**attrs)
+      end
+
+      # Compose the full number string from the leading doc_number plus any
+      # dotted continuation (GA01.13 → "01.13", L2.1.11 → "2.1.11") plus
+      # the optional dash-separated subpart (C0103-1 → "0103-1", L2.7.1-2
+      # → "2.7.1-2"). Padding is type-aware per IALA's canonical form:
+      # typed S/R/G/M/C zero-pad to 4 digits; GeneralAssembly (GA) zero-
+      # pads each segment to 2; Advices (A) and Letters (L) preserve input
+      # (their canonical form is already what the IALA site prints).
+      def build_number(hash, type_letter = nil)
+        base = stringify(hash[:doc_number])
+        return base unless base
+
+        base = canonical_base(base, type_letter)
+
+        dots = hash[:doc_number_dots]
+        dots_str = dots.is_a?(Array) ? "" : canonical_dots(stringify(dots).to_s, type_letter)
+
+        subpart_str = hash[:subpart] ? "-#{subpart_to_s(hash[:subpart])}" : ""
+        subpart_str = "" if subpart_str == "-"
+        "#{base}#{dots_str}#{subpart_str}"
+      end
+
+      # Per-type canonical width for the leading numeric run.
+      def canonical_base(base, type_letter)
+        case type_letter
+        when "S", "R", "G", "M", "C", "X", "P" then base.rjust(4, "0")
+        when "GA" then base.rjust(2, "0")
+        else base
+        end
+      end
+
+      # Per-type canonical width for each dotted continuation segment.
+      # `str` looks like ".13" or ".1.11" (leading dot, then digits).
+      def canonical_dots(str, type_letter)
+        return "" if str.empty?
+
+        if type_letter == "GA"
+          str.split(".", -1).map { |seg| seg.empty? ? seg : seg.rjust(2, "0") }.join(".")
+        else
+          str
+        end
+      end
+
+      # The subpart capture may be an array of {subpart_number: "1"},
+      # {subpart_number: "9"}, … (repeated matches). Join with "-".
+      def subpart_to_s(subpart)
+        return stringify(subpart).to_s unless subpart.is_a?(Array)
+
+        subpart.filter_map { |h| h.is_a?(Hash) ? stringify(h[:subpart_number]) : nil }.join("-")
+      end
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifier.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Base class for all IALA identifiers. Canonical name
+    # Pubid::Iala::Identifier; every concrete IALA identifier
+    # (Identifiers::*) descends from it, and Identifiers::Base — aliased
+    # at the foot of identifiers/base.rb — points back to it.
+    #
+    # IALA identifiers have the form:
+    #   [IALA ]{S|R|G|M|C|X|P}<4-digit number>[-<subpart>][ Ed <edition>][ (<LangLetter>)]
+    #
+    # Examples:
+    #   S1070
+    #   IALA S1070 Ed 2.0
+    #   R1016:ed2.0(F)
+    #   C0103-1 Ed 3.0
+    class Identifier < ::Pubid::Identifier
+      # Parse an IALA identifier string into an identifier object.
+      # @param identifier [String]
+      # @return [Pubid::Iala::Identifier]
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse IALA identifier '#{identifier}': #{e.message}"
+      end
+
+      attribute :publisher, :string, default: "IALA"
+      attribute :number,    :string    # "1070", "0126", "0103-1"
+      attribute :edition,   :string    # "2.0", "1.3", nil
+      attribute :language,  :string    # "E", "F", "S", "C", "A", "R", nil
+
+      IALA_TYPE_MAP = {
+        "pubid:iala:standard"          => "Pubid::Iala::Identifiers::Standard",
+        "pubid:iala:recommendation"    => "Pubid::Iala::Identifiers::Recommendation",
+        "pubid:iala:guideline"         => "Pubid::Iala::Identifiers::Guideline",
+        "pubid:iala:manual"            => "Pubid::Iala::Identifiers::Manual",
+        "pubid:iala:model-course"      => "Pubid::Iala::Identifiers::ModelCourse",
+        "pubid:iala:advice"            => "Pubid::Iala::Identifiers::Advice",
+        "pubid:iala:general-assembly"  => "Pubid::Iala::Identifiers::GeneralAssembly",
+        "pubid:iala:letter"            => "Pubid::Iala::Identifiers::Letter",
+        "pubid:iala:annex"             => "Pubid::Iala::Identifiers::Annex",
+        "pubid:iala:report"            => "Pubid::Iala::Identifiers::Report",
+        "pubid:iala:resolution"        => "Pubid::Iala::Identifiers::Resolution",
+      }.freeze
+
+      key_value do
+        map "_type",    to: :_type, polymorphic_map: IALA_TYPE_MAP
+        map "number",   to: :number
+        map "edition",  to: :edition
+        map "language", to: :language
+      end
+
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
+
+      # Single-letter type code (S, R, G, …) — convenience accessor used
+      # by Renderer and UrnGenerator.
+      def type_letter
+        self.class.type[:short]
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/advice.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Advices (A prefix). Numbering is dashed: A12-01, A13-04.
+      # Carries no edition in the corpus.
+      class Advice < Base
+        def self.type
+          { key: :advice, title: "Advice", short: "A" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/annex.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Annex to a base publication. Two surface forms appear in the
+      # corpus, both wrapping a Guideline:
+      #
+      #   "G1045 Annex Ed 1"           — bare Annex, no letter
+      #   "G1128 ANNEX A Ed 1.6"        — uppercase + letter (A/B/C/D)
+      #
+      # The case of the marker is preserved (Annex vs ANNEX) for round-trip
+      # fidelity. Edition and language apply to the Annex itself, not the base.
+      class Annex < Base
+        # The publication this annex supplements. Always present; carries the
+        # type letter and number (e.g. G1045).
+        attribute :base_identifier, ::Pubid::Iala::Identifier, polymorphic: true
+        # "Annex" or "ANNEX" — preserved verbatim for exact round-trip.
+        attribute :annex_form, :string
+        # "A", "B", "C", "D", or nil for the bare form.
+        attribute :letter, :string
+
+        key_value do
+          map "base_identifier",
+              with: { to: :base_identifier_to_kv, 
+                      from: :base_identifier_from_kv }
+          map "annex_form", to: :annex_form
+          map "letter",     to: :letter
+        end
+
+        def self.type
+          { key: :annex, title: "Annex", short: nil }
+        end
+
+        private
+
+        def base_identifier_to_kv(model, doc)
+          base = model.base_identifier
+          return unless base
+
+          doc.add_child(
+            Lutaml::KeyValue::DataModel::Element.new("base_identifier",
+                                                     base.to_hash),
+          )
+        end
+
+        def base_identifier_from_kv(model, value)
+          return unless value
+
+          model.base_identifier = ::Pubid::Iala::Identifier.from_hash(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Backward-compatible alias: IALA's base class used to be
+# Pubid::Iala::Identifiers::Base. It is now Pubid::Iala::Identifier
+# (defined in identifier.rb), which is loaded by the parent autoload.
+require_relative "../identifier" unless defined?(Pubid::Iala::Identifier)
+
+module Pubid
+  module Iala
+    module Identifiers
+      Base = Pubid::Iala::Identifier
+    end
+  end
+end

data/lib/pubid/iala/identifiers/general_assembly.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA General Assembly resolutions (GA prefix). Numbering is dotted
+      # with a series and an index: GA01.01, GA01.13. No edition.
+      class GeneralAssembly < Base
+        def self.type
+          { key: :"general-assembly", title: "General Assembly Resolution", 
+            short: "GA" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/guideline.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Guidelines (G series).
+      # Examples: G1015 Ed 2.2, G1078 Ed 2.1.
+      class Guideline < Base
+        def self.type
+          { key: :guideline, title: "Guideline", short: "G" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/letter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Letters (L prefix). Numbering is dotted with a series, sub-series,
+      # and item: L2.1.11, L2.7.1-2 (the trailing -2 is a sub-part on top of
+      # the dotted number).
+      class Letter < Base
+        def self.type
+          { key: :letter, title: "Letter", short: "L" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/manual.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Manuals (M prefix, planned).
+      # Today manuals carry no code (NAVGUIDE, VTS Manual, …); M is
+      # reserved for future numbered manuals.
+      class Manual < Base
+        def self.type
+          { key: :manual, title: "Manual", short: "M" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/model_course.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Model Courses (C series).
+      # Examples: C0103-1 Ed 3.0, C2001-1 Ed 1.0.
+      class ModelCourse < Base
+        def self.type
+          { key: :"model-course", title: "Model Course", short: "C" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/recommendation.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Recommendations (R series).
+      # Examples: R0103 Ed 3.1, R0126 Ed 2.0, R1024 Ed 1.0.
+      class Recommendation < Base
+        def self.type
+          { key: :recommendation, title: "Recommendation", short: "R" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/report.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Reports & Proceedings (X prefix, planned).
+      # Today reports carry no code; X is reserved for future numbered
+      # reports.
+      class Report < Base
+        def self.type
+          { key: :report, title: "Report", short: "X" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/resolution.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Resolutions and other Council publications (P prefix,
+      # planned). Today resolutions carry no code; P is reserved for
+      # future numbered resolutions.
+      class Resolution < Base
+        def self.type
+          { key: :resolution, title: "Resolution", short: "P" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers/standard.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      # IALA Standards (S series).
+      # Examples: S1010, S1020 Ed 2.0, S1070 Ed 2.0.
+      class Standard < Base
+        def self.type
+          { key: :standard, title: "Standard", short: "S" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/iala/identifiers.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    module Identifiers
+      autoload :Base,             "#{__dir__}/identifiers/base"
+      autoload :Advice,           "#{__dir__}/identifiers/advice"
+      autoload :Annex,            "#{__dir__}/identifiers/annex"
+      autoload :Standard,         "#{__dir__}/identifiers/standard"
+      autoload :Recommendation,   "#{__dir__}/identifiers/recommendation"
+      autoload :Guideline,        "#{__dir__}/identifiers/guideline"
+      autoload :Manual,           "#{__dir__}/identifiers/manual"
+      autoload :ModelCourse,      "#{__dir__}/identifiers/model_course"
+      autoload :GeneralAssembly,  "#{__dir__}/identifiers/general_assembly"
+      autoload :Letter,           "#{__dir__}/identifiers/letter"
+      autoload :Report,           "#{__dir__}/identifiers/report"
+      autoload :Resolution,       "#{__dir__}/identifiers/resolution"
+    end
+  end
+end

data/lib/pubid/iala/parser.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iala
+    # Parslet grammar for IALA identifiers.
+    #
+    # Accepts every shape that appears on the IALA website or cover page:
+    #
+    #   S1070
+    #   S1070 Ed 2.0
+    #   IALA S1070 Ed 2.0
+    #   S1070 Ed 2.0 (F)
+    #   R1016:ed2.0(F)
+    #   C0103-1
+    #   C0103-1 Ed 3.0
+    class Parser < Parslet::Parser
+      include ::Pubid::Parser::CommonParseRules
+
+      root :identifier
+
+      rule(:space)  { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:dash)   { str("-") }
+      rule(:colon)  { str(":") }
+      rule(:dot)    { str(".") }
+      rule(:lparen) { str("(") }
+      rule(:rparen) { str(")") }
+
+      # Type prefix — IALA document classes. GA must be tried before G so it
+      # isn't left with a dangling "A". Captured to route to the right
+      # Identifiers::* subclass.
+      rule(:type_letter) do
+        (str("GA") | str("S") | str("R") | str("G") | str("M") |
+         str("C") | str("A") | str("L") | str("X") | str("P")).as(:type_letter)
+      end
+
+      # Document number — one or more decimal digits. The dataset historically
+      # zero-pads to 4 (S1070, R0126, M0001) but the canonical form going
+      # forward is unpadded (M1, GA1.1). Accept any length so both shapes
+      # round-trip; the number attribute preserves whatever was parsed.
+      rule(:doc_number) do
+        match("[0-9]").repeat(1).as(:doc_number)
+      end
+
+      # Dotted continuation that some prefixes use as part of the number:
+      # GA01.01 (series.index), L2.1.11 (series.sub.item). Captured into the
+      # same :doc_number atom so the number attribute stays a single string
+      # (e.g. "01.01", "2.1.11") and the existing builder needs no changes.
+      rule(:dotted_number) do
+        dot >> match("[0-9]").repeat(1)
+      end
+
+      rule(:number_with_dots) do
+        doc_number >> dotted_number.repeat.as(:doc_number_dots)
+      end
+
+      # Numeric sub-part suffix(es): "-1", "-9-10", "-11". The catalogue
+      # uses ranges like R0124-9-10 & 11 — that compound is captured
+      # verbatim and resolved by the caller, not here.
+      rule(:subpart) do
+        (dash >> digits.as(:subpart_number)).repeat(1).as(:subpart)
+      end
+
+      rule(:code) do
+        type_letter >> number_with_dots >> subpart.maybe
+      end
+
+      # Edition forms observed on covers and listing pages:
+      #   " Ed 2.0"      — cover-page human form
+      #   ":ed2.0"       — listing-page compact form
+      rule(:edition_human) do
+        (space >> str("Ed") >> space >> edition_value).as(:edition)
+      end
+
+      rule(:edition_compact) do
+        (colon >> str("ed") >> edition_value).as(:edition)
+      end
+
+      rule(:edition_value) do
+        (digits >> (dot >> digits).repeat).as(:edition_value)
+      end
+
+      rule(:edition) do
+        edition_human | edition_compact
+      end
+
+      # Language is a single uppercase letter inside parens: (E), (F), …
+      rule(:language) do
+        (space? >> lparen >>
+          (str("E") | str("F") | str("S") | str("C") | str("A") | str("R")).as(:language) >>
+          rparen).as(:language_group)
+      end
+
+      # Optional "IALA " prefix.
+      rule(:publisher) do
+        (str("IALA") >> space).maybe
+      end
+
+      rule(:identifier) do
+        annex_identifier | (publisher >> code >> edition.maybe >> language.maybe)
+      end
+
+      # Annex to a base publication. Wraps the base code and adds an
+      # "Annex" / "ANNEX" marker (case preserved verbatim), an optional
+      # single-letter suffix (A/B/C/D), then the usual edition + language.
+      # Tried before the flat `identifier` so the annex marker isn't left
+      # dangling after a successful base-code match.
+      #
+      # The letter suffix uses a negative lookahead for a following lowercase
+      # letter so the "E" in "Ed 1" isn't mis-captured as annex letter "E".
+      rule(:annex_identifier) do
+        (publisher >> type_letter >> number_with_dots >> subpart.maybe).as(:base) >>
+          space >> (str("Annex") | str("ANNEX")).as(:annex_marker) >>
+          (space >> match("[A-Z]").as(:annex_letter) >> match("[a-z]").absent?).maybe >>
+          edition.maybe >> language.maybe
+      end
+
+      # Parse a string and return the raw parslet tree.
+      # @param string [String]
+      # @return [Hash]
+      def self.parse(string)
+        raise ArgumentError, "IALA identifier string exceeds maximum length" if string.length > ::Pubid::MAX_INPUT_LENGTH
+
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/iala/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Human-readable renderer for IALA identifiers.
+    #
+    # Produces strings like:
+    #   "IALA S1070"
+    #   "IALA S1070 Ed 2.0"
+    #   "IALA R1016 Ed 2.0 (F)"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        return render_annex(id) if id.is_a?(Identifiers::Annex)
+
+        rendered = "#{id.publisher} #{id.type_letter}#{id.number}"
+        rendered << " Ed #{id.edition}" if id.edition
+        rendered << " (#{id.language})" if id.language
+        rendered
+      end
+
+      # Render an Annex wrapper. The base identifier is rendered first, then
+      # the marker form is preserved verbatim ("Annex" vs "ANNEX"), then the
+      # optional letter, edition, and language.
+      def render_annex(id)
+        base_str = id.base_identifier.to_s
+        rendered = "#{base_str} #{id.annex_form}"
+        rendered << " #{id.letter}" if id.letter
+        rendered << " Ed #{id.edition}" if id.edition
+        rendered << " (#{id.language})" if id.language
+        rendered
+      end
+    end
+  end
+end

data/lib/pubid/iala/urn_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iala
+    # Generates URN strings for IALA identifiers using the Maritime Resource
+    # Name (MRN) namespace that IALA prints on its cover pages.
+    #
+    # Format: urn:mrn:iala:pub:<type-lower><number>[:ed<edition>][:<lang-lower>]
+    # Example: urn:mrn:iala:pub:s1070:ed2.0
+    #          urn:mrn:iala:pub:r1016:ed2.0:f
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        return generate_annex if identifier.is_a?(Identifiers::Annex)
+
+        parts = ["urn:mrn:iala:pub", code_segment]
+        parts << "ed#{identifier.edition}" if identifier.edition
+        parts << identifier.language.downcase if identifier.language
+        parts.join(":")
+      end
+
+      private
+
+      # URN for an Annex: embeds the base's code, then an "annex" segment
+      # (with optional letter suffix), then the annex's own edition/lang.
+      #   G1045 Annex Ed 1           → urn:mrn:iala:pub:g1045:annex:ed1
+      #   G1128 ANNEX A Ed 1.6 (E)    → urn:mrn:iala:pub:g1128:annex-a:ed1.6:e
+      def generate_annex
+        base = identifier.base_identifier
+        parts = ["urn:mrn:iala:pub",
+                 "#{base.type_letter.downcase}#{base.number}"]
+        annex_seg = identifier.letter ? "annex-#{identifier.letter.downcase}" : "annex"
+        parts << annex_seg
+        parts << "ed#{identifier.edition}" if identifier.edition
+        parts << identifier.language.downcase if identifier.language
+        parts.join(":")
+      end
+
+      def code_segment
+        "#{identifier.type_letter.downcase}#{identifier.number}"
+      end
+    end
+  end
+end