pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/parsers/mr_string.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parsers
+    # Parses a machine-readable (MR) identifier string back into an Identifier.
+    #
+    # The MR format produced by `Renderers::MrString` mirrors the human form,
+    # lowercased and filename-safe:
+    #
+    #   iso.9001.2015                              → ISO 9001:2015
+    #   iso-iec.17031-1.2020                       → ISO/IEC 17031-1:2020
+    #   iso.1234-1-2-3.2020                        → ISO 1234-1-2-3:2020
+    #   iso.tr.14627.2017                          → ISO/TR 14627:2017
+    #   iso.16634.--                               → ISO 16634:--
+    #   iso.9001.2015_amd.1.2020                   → ISO 9001:2015/Amd 1:2020
+    #   iso-iec.13818-1.2015_amd.3.2016_cor.1.2017 → ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
+    #
+    # Copublishers join with `-` (`iso-iec`), supplements append with `_`
+    # (`iso.9001.2015_amd.1.2020`). Both round-trip back to `/` here. The
+    # flavor's own parser is case-insensitive on the type/publisher tokens
+    # we emit, so the lowercased slug re-parses cleanly.
+    #
+    # Note: NIST, CSA, IEEE, JIS, and SAE emit their own MR shapes that this
+    # parser does not attempt to reverse (their `to_s` already round-trips
+    # through the flavor's own parser, so callers should use that path for
+    # those flavors).
+    class MrString < Base
+      FLAVOR_MAP = {
+        "ISO" => :iso,
+        "IEC" => :iec,
+        "IEEE" => :ieee,
+        "NIST" => :nist,
+        "NBS" => :nist,
+        "BS" => :bsi,
+        "CEN" => :cen_cenelec,
+        "JIS" => :jis,
+        "ETSI" => :etsi,
+        "ITU" => :itu,
+        "ANSI" => :ansi,
+        "OIML" => :oiml,
+        "CIE" => :cie,
+        "ASHRAE" => :ashrae,
+        "AMCA" => :amca,
+        "IDF" => :idf,
+        "IHO" => :iho,
+        "JCGM" => :jcgm,
+        "SAE" => :sae,
+        "ASME" => :asme,
+        "CSA" => :csa,
+        "API" => :api,
+        "ASTM" => :astm,
+        "PLATEAU" => :plateau,
+        "CCSDS" => :ccsds,
+      }.freeze
+
+      # Map flavor symbols to Pubid autoload constants
+      FLAVOR_CONSTANT_MAP = {
+        iso: :Iso,
+        iec: :Iec,
+        ieee: :Ieee,
+        nist: :Nist,
+        bsi: :Bsi,
+        cen_cenelec: :CenCenelec,
+        jis: :Jis,
+        etsi: :Etsi,
+        itu: :Itu,
+        ansi: :Ansi,
+        oiml: :Oiml,
+        cie: :Cie,
+        ashrae: :Ashrae,
+        amca: :Amca,
+        idf: :Idf,
+        iho: :Iho,
+        jcgm: :Jcgm,
+        sae: :Sae,
+        asme: :Asme,
+        csa: :Csa,
+        api: :Api,
+        astm: :Astm,
+        plateau: :Plateau,
+        ccsds: :Ccsds,
+      }.freeze
+
+      # Lower-case type codes the renderer emits as a separate MR segment
+      # (e.g. `iso.tr.14627`). When the parser sees one of these in the
+      # second position, it splits it back out as `/TYPE`.
+      TYPE_CODES = %w[
+        tr ts pas is amd cor suppl add ext guide spec
+        standard corrigendum amendment
+      ].freeze
+
+      def self.parse(mr_string)
+        flavor = detect_flavor(mr_string)
+
+        # Trigger autoload to register the flavor
+        if (const_name = FLAVOR_CONSTANT_MAP[flavor])
+          Pubid.const_get(const_name)
+        end
+
+        flavor_module = Pubid::Registry.get(flavor)
+        raise ArgumentError, "Unknown flavor: #{flavor}" unless flavor_module
+
+        identifier_string = convert_to_human_readable(mr_string)
+
+        # Refuse to hand the flavor a string this parser did not change.
+        #
+        # `detect_flavor` falls back to `:iso` for any publisher it does not
+        # know, and `Pubid::Iso.parse` sends an MR-shaped string straight back
+        # here — so a string that survives conversion unchanged recurses
+        # forever. `ECMA-426 ed1` is the standing example: "ECMA" is absent
+        # from FLAVOR_MAP, the string matches the MR shape heuristic
+        # (`/\A[A-Z]{2,}[.-]/`), and conversion is a fixed point.
+        # `Pubid::Iso.parse("ECMA-426 ed1")` raised SystemStackError.
+        #
+        # A fixed point means "this was never an MR string", which is a parse
+        # failure — the class the cross-flavor contract requires, and the one
+        # `Pubid.parse` treats as "try the next flavor".
+        if identifier_string == mr_string && flavor_module == Pubid::Iso
+          raise Parslet::ParseFailed,
+                "#{mr_string.inspect} is not an MR string"
+        end
+
+        flavor_module.parse(identifier_string)
+      end
+
+      def self.detect_flavor(mr_string)
+        publisher = mr_string.split(/[._-]/).first.to_s.upcase
+        FLAVOR_MAP[publisher] || :iso
+      end
+
+      # Convert the MR slug back to a human-readable identifier string the
+      # flavor's own parser will accept. Splits on `_` first so each segment
+      # (head + each supplement) is converted independently, then re-joined
+      # with `/`. Within the head, the copublisher separator `-` (first
+      # segment only) is restored to `/`.
+      def self.convert_to_human_readable(mr_string)
+        head, *supplements = mr_string.split("_")
+        human = convert_head(head)
+        return human if supplements.empty?
+
+        supplements.inject(human) do |acc, supp|
+          "#{acc}/#{convert_supplement(supp)}"
+        end
+      end
+
+      # Converts a head segment like `iso-iec.13818-1.2015` to
+      # `ISO/IEC 13818-1:2015`.
+      def self.convert_head(head)
+        parts = head.split(".")
+        return parts.join(" ").upcase if parts.length <= 1
+
+        publisher, *rest = parts
+
+        # Optional type code segment (iso.tr.14627.2017 → ISO/TR 14627:2017).
+        type_segment = nil
+        if rest.first && TYPE_CODES.include?(rest.first.downcase)
+          type_segment = rest.shift.upcase
+        end
+
+        # Trailing language segment — bare language code(s) with no parens.
+        # Detect by length <= 5 and all-alpha (en, fr, en-fr, ru).
+        language_segment = nil
+        if rest.last&.match?(/\A[a-z]{2}(-[a-z]{2})*\z/)
+          language_segment = rest.pop
+        end
+
+        # Trailing year segment (may be `--` for undated, or YYYY[-MM[-DD]]).
+        year_segment = nil
+        if rest.any? && rest.last.match?(/\A(?:\d{4}(?:-\d{2}){0,2}|--)\z/)
+          year_segment = rest.pop
+        end
+
+        # Copublishers in the first segment: `iso-iec` → `ISO/IEC`. Multi-word
+        # publisher bodies (e.g. `cen-cenelec`) round-trip the same way.
+        publisher_part = publisher.split("-").map(&:upcase).join("/")
+        publisher_part = "#{publisher_part}/#{type_segment}" if type_segment
+
+        number_part = rest.join(" ")
+        result = publisher_part
+        result += " #{number_part}" unless number_part.empty?
+        result += ":#{year_segment}" if year_segment
+        if language_segment
+          langs = language_segment.split("-").join(",")
+          result += "(#{langs})"
+        end
+        result
+      end
+
+      # Converts a supplement segment like `amd.1.2020` to `Amd 1:2020`.
+      # The first token is the lowercase type code; remaining tokens are
+      # number and optional year.
+      def self.convert_supplement(supp)
+        tokens = supp.split(".")
+        type = tokens.shift&.upcase
+        year = tokens.last&.match?(/\A\d{4}\z/) ? tokens.pop : nil
+        number = tokens.join(" ")
+
+        result = type.to_s
+        result += " #{number}" unless number.empty?
+        result += ":#{year}" if year
+        result
+      end
+    end
+  end
+end
+

data/lib/pubid/plateau/builder.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class Builder
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      def build(parsed)
+        # Check for annex supplement first
+        if parsed[:base] && parsed[:annex_letter]
+          return build_annex(parsed)
+        end
+
+        # Determine which class to use based on type
+        klass = case parsed[:type].to_s
+                when "Handbook"
+                  Identifiers::Handbook
+                when "Technical Report"
+                  Identifiers::TechnicalReport
+                else
+                  raise "Unknown PLATEAU type: #{parsed[:type]}"
+                end
+
+        # Build parameters common to all types
+        params = {
+          number: parsed[:number].to_s.to_i,
+        }
+
+        params[:annex] = parsed[:annex].to_s.to_i if parsed[:annex]
+        # Only Handbook carries an edition; a legacy Latin TR captures the
+        # edition slice via the shared handbook rule, so drop it here.
+        if parsed[:edition] && klass == Identifiers::Handbook
+          params[:edition] = parsed[:edition].to_s
+        end
+
+        klass.new(**params)
+      end
+
+      private
+
+      def build_annex(parsed)
+        # Recursively parse base identifier
+        base = build(parsed[:base])
+
+        Identifiers::Annex.new(
+          base: base,
+          letter: parsed[:annex_letter].to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/plateau/identifier.rb

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

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # PLATEAU Annex supplement
+      # Format: {BASE} Annex {letter}
+      # Example: PLATEAU Handbook #00 第1.0版 Annex A
+      class Annex < SupplementIdentifier
+        def supplement_string
+          "Annex #{letter}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Base class for all PLATEAU identifiers. Canonical name
+    # Pubid::Plateau::Identifier.
+    class Identifier < ::Pubid::Identifier
+      # Delegate to the flavor module so callers can use
+      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
+      def self.parse(identifier)
+        Pubid::Plateau.parse(identifier)
+      end
+
+      attribute :number, :integer
+      attribute :annex, :integer, default: -> {}
+
+      # Stored as a plain string (always "PLATEAU") so it round-trips through
+      # to_hash/from_hash. Was a `def publisher` method, which made lutaml
+      # serialize a String against the Components::Publisher attribute.
+      attribute :publisher, :string, default: -> { "PLATEAU" }
+
+      # Subclasses must implement type_string
+      def type_string
+        raise NotImplementedError, "Subclasses must implement type_string"
+      end
+
+      def formatted_number
+        "#%02d" % number
+      end
+
+      def formatted_annex
+        annex ? "-#{annex}" : ""
+      end
+
+      def ==(other)
+        return false unless other.class == self.class
+
+        number == other.number &&
+          annex == other.annex
+      end
+
+      # Include type_string and annex in serialization for round-trip compatibility
+      def base_hash
+        hash = super
+        if self.class.attributes.key?(:type_string) && type_string
+          hash[:type] =
+            type_string
+        end
+        hash[:annex] = annex if annex
+        hash
+      end
+    end
+
+  end
+end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # PLATEAU Handbook
+      # Format: PLATEAU Handbook #NN[-annex] [第X.Y版]
+      # Example: PLATEAU Handbook #00 第1.0版
+      class Handbook < Identifier
+        attribute :edition, :string, default: -> {}
+
+        def type_string
+          "Handbook"
+        end
+
+        def formatted_edition
+          "第#{edition}版"
+        end
+
+        def ==(other)
+          return false unless other.is_a?(Handbook)
+
+          super && edition == other.edition
+        end
+      end
+    end
+  end
+end

data/lib/pubid/plateau/identifiers/technical_report.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      # PLATEAU Technical Report
+      # Format: PLATEAU Technical Report #NN[-annex]
+      # Example: PLATEAU Technical Report #01
+      class TechnicalReport < Identifier
+        def type_string
+          "Technical Report"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/plateau/identifiers.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    module Identifiers
+      autoload :Annex, "#{__dir__}/identifiers/annex"
+      autoload :Handbook, "#{__dir__}/identifiers/handbook"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+    end
+  end
+end

data/lib/pubid/plateau/parser.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:hash) { str("#") }
+
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # PLATEAU
+      rule(:publisher) { str("PLATEAU") }
+
+      # Handbook or Technical Report
+      rule(:doc_type) do
+        (str("Handbook") | str("Technical Report")).as(:type)
+      end
+
+      # Number: #00, #01, #46, etc.
+      rule(:number) { hash >> digits.as(:number) }
+
+      # Annex: -1, -2, etc. Legacy Latin references use "_" as the sub-number
+      # separator (e.g. "#46_1"); both render as the canonical dash.
+      rule(:annex) { (dash | str("_")) >> digits.as(:annex) }
+
+      # Edition (Handbook only). Canonical form is 第X.Y版; legacy Latin
+      # references write the bare X.Y (e.g. "PLATEAU Handbook #00 1.0"). Both
+      # capture the same numeric :edition slice, so they build the same object
+      # and render to the canonical 第X.Y版.
+      rule(:edition_part) do
+        str("第") >>
+          (digits >> str(".") >> digits).as(:edition) >>
+          str("版")
+      end
+
+      rule(:edition_latin) { (digits >> str(".") >> digits).as(:edition) }
+
+      rule(:edition) { space >> (edition_part | edition_latin) }
+
+      # Annex supplement: "Annex A", "Annex B", etc.
+      rule(:annex_letter) { match["A-Z"].as(:annex_letter) }
+      rule(:annex_supplement) do
+        space >> str("Annex") >> space >> annex_letter
+      end
+
+      # Full identifier patterns
+      rule(:handbook) do
+        publisher >> space >> doc_type >> space >>
+          number >> annex.maybe >> edition.maybe
+      end
+
+      # Technical Report has no edition. A legacy Latin TR reference carrying a
+      # trailing edition (e.g. "#00 1.0") is matched by the `handbook` rule
+      # (doc_type matches either keyword, tried first); the builder dispatches
+      # on :type and drops the captured edition for Technical Report.
+      rule(:technical_report) do
+        publisher >> space >> doc_type >> space >>
+          number >> annex.maybe
+      end
+
+      # Annex identifier (supplement)
+      rule(:annex_identifier) do
+        (handbook | technical_report).as(:base) >> annex_supplement
+      end
+
+      rule(:identifier) { annex_identifier | handbook | technical_report }
+
+      rule(:root) { identifier }
+    end
+  end
+end

data/lib/pubid/plateau/renderer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Human-readable renderer for PLATEAU identifiers.
+    #
+    # Produces strings like:
+    #   "PLATEAU Technical Report #01"
+    #   "PLATEAU Handbook #00 第1.0版"
+    #   "PLATEAU Handbook #01-1 Annex A"
+    #
+    # The renderer is registered as the `:human` format in the PLATEAU format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when SupplementIdentifier
+          render_supplement(id)
+        when Identifiers::Handbook
+          render_handbook(id)
+        when Identifiers::TechnicalReport
+          render_technical_report(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+      end
+
+      def render_technical_report(id)
+        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+      end
+
+      def render_handbook(id)
+        result = "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+        result += " #{id.formatted_edition}" if id.edition
+        result
+      end
+
+      def render_supplement(id)
+        "#{id.base} #{id.supplement_string}"
+      end
+    end
+  end
+end

data/lib/pubid/plateau/supplement_identifier.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Pubid
+  module Plateau
+    # Base class for PLATEAU supplements (Annex)
+    # Supplements reference a base identifier
+    class SupplementIdentifier < Pubid::Identifier
+      attribute :base, Identifier
+      attribute :letter, :string, default: -> {}
+
+      def publisher
+        "PLATEAU"
+      end
+
+      # Subclasses must implement supplement_string
+      def supplement_string
+        raise NotImplementedError, "Subclasses must implement supplement_string"
+      end
+
+      # Override base_hash to extract edition, type, and annex from base
+      def base_hash
+        hash = super
+        # For Plateau supplements, edition comes from the base identifier
+        if base.class.attributes.key?(:edition) && base.edition
+          hash[:edition] = base.edition
+        end
+        # Include type from base
+        if base.class.attributes.key?(:type_string) && base.type_string
+          hash[:type] = base.type_string
+        end
+        # Include annex from base
+        if base.class.attributes.key?(:annex) && base.annex
+          hash[:annex] = base.annex
+        end
+        hash
+      end
+
+      # Override supplement_hash to include letter instead of number
+      def supplement_hash(supplement)
+        {
+          type: extract_supplement_type(supplement),
+          letter: supplement.letter,
+        }.compact
+      end
+
+      # Extract supplement type from class name
+      def extract_supplement_type(supplement)
+        return nil unless supplement.class
+
+        # Get class name without namespace
+        class_name = supplement.class.name.to_s
+        parts = class_name.split("::")
+        simple_name = parts.last
+        # Convert camel case to snake case (Annex -> annex)
+        simple_name&.gsub(/([a-z])([A-Z])/, '\1_\2')&.downcase
+      end
+
+      def ==(other)
+        return false unless other.class == self.class
+
+        base == other.base &&
+          letter == other.letter
+      end
+    end
+  end
+end

data/lib/pubid/plateau/urn_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def generate
+        parts = ["urn", "plateau"]
+
+        if identifier.type_string
+          type_str = identifier.type_string.to_s.downcase
+          parts << case type_str
+                   when "technical report"
+                     "tr"
+                   when "annex"
+                     "an"
+                   else
+                     type_str
+                   end
+        end
+
+        parts << format("%02d", identifier.number) if identifier.number
+
+        parts << format("%02d", identifier.annex) if identifier.annex
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/plateau/urn_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Parses Plateau URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:plateau:{type}:{number}[:{annex}]
+    #
+    # type is one of: handbook, tr (technical report), an (annex), or another
+    # lowercase type string. Annex is a zero-padded 2-digit string when present.
+    #
+    # Examples:
+    # - urn:plateau:handbook:00        → PLATEAU Handbook #00
+    # - urn:plateau:tr:01              → PLATEAU Technical Report #01
+    class UrnParser < Pubid::UrnParser::Base
+      TYPE_MAP = {
+        "handbook" => "Handbook",
+        "tr" => "Technical Report",
+        "an" => "Annex",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0)
+        number = parts.fetch(1)
+        annex = parts[2]
+
+        text = "PLATEAU #{display_type(type_token)} ##{number}"
+        text += "-#{annex}" if annex
+        flavor_parse(text)
+      end
+
+      private
+
+      def display_type(token)
+        TYPE_MAP.fetch(token) { token.capitalize }
+      end
+    end
+  end
+end