pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/api/identifiers/mpms.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class Mpms < Base
+        # The MPMS chapter IS the document number — "API MPMS CH 12.2" is
+        # chapter 12, section 2 — so it lives in the `number` inherited from
+        # ::Pubid::Identifier, which every other API type already sets. It used
+        # to sit in a separate `chapter` :string, leaving `number` nil, so all
+        # 30 MPMS ids keyed "" for relaton-index.
+        #
+        # `section`/`subsection` stay as sibling part columns, which is what
+        # gives the bucket semantics a part-less reference needs: every section
+        # of chapter 12 shares the key "12". `CH` is a literal marker in the
+        # renderer and was never part of the value.
+        attribute :section, :string
+        attribute :subsection, :string
+
+        def type_string
+          "MPMS"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/publication.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class Publication < Base
+        def type_string
+          "PUBL"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/recommended_practice.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class RecommendedPractice < Base
+        def type_string
+          "RP"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/specification.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class Specification < Base
+        def type_string
+          "SPEC"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class Standard < Base
+        def type_string
+          "STD"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class TechnicalReport < Base
+        def type_string
+          "TR"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers/typeless_standard.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      class TypelessStandard < Base
+        # No type_string method - renders without type
+      end
+    end
+  end
+end

data/lib/pubid/api/identifiers.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    module Identifiers
+      autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Bulletin, "#{__dir__}/identifiers/bulletin"
+      autoload :ContinuousOperationsStandard, "#{__dir__}/identifiers/continuous_operations_standard"
+      autoload :Mpms, "#{__dir__}/identifiers/mpms"
+      autoload :Publication, "#{__dir__}/identifiers/publication"
+      autoload :RecommendedPractice, "#{__dir__}/identifiers/recommended_practice"
+      autoload :Specification, "#{__dir__}/identifiers/specification"
+      autoload :Standard, "#{__dir__}/identifiers/standard"
+      autoload :TechnicalReport, "#{__dir__}/identifiers/technical_report"
+      autoload :TypelessStandard, "#{__dir__}/identifiers/typeless_standard"
+    end
+  end
+end

data/lib/pubid/api/parser.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Api
+    class Parser < ::Pubid::Parser::Grammar
+      # Basic building blocks
+      rule(:space) { str(" ") }
+      rule(:dash) { str("-") }
+      rule(:slash) { str("/") }
+      rule(:colon) { str(":") }
+      rule(:dot) { str(".") }
+      rule(:digit) { match("[0-9]") }
+      rule(:digits) { digit.repeat(1) }
+      rule(:letter) { match("[A-Z]") }
+      rule(:letters) { letter.repeat(1) }
+
+      # Publisher
+      rule(:publisher) { str("API") >> space }
+
+      # Document types (longest first for proper matching)
+      rule(:doc_type) do
+        (
+          str("MPMS") |
+          str("BULL") |
+          str("SPEC") |
+          str("STD") |
+          str("RP") |
+          str("TR") |
+          str("COS") |
+          str("PUBL")
+        ).as(:type)
+      end
+
+      # Chapter notation for MPMS (e.g., "CH 10")
+      rule(:chapter_notation) do
+        space >> str("CH") >> space >> digits.as(:chapter)
+      end
+
+      # Number with optional part (e.g., "579-2", "1104", "6D", "D16", "17TR7")
+      # Allow any mix of digits and letters
+      rule(:number_with_part) do
+        match("[0-9A-Z]").repeat(1).as(:number) >>
+          (dash >> match("[0-9A-Z]").repeat(1).as(:part)).maybe
+      end
+
+      # Digits with optional letter suffix (for MPMS sections: 6.4A, 3.1A)
+      rule(:digits_with_letter) do
+        digits >> letter.maybe
+      end
+
+      # Year (4-digit)
+      rule(:year) { digit.repeat(4, 4).as(:year) }
+
+      # Date with dash (e.g., "-2023")
+      rule(:date_dash) { dash >> year }
+
+      # Date with colon (e.g., ":2023")
+      rule(:date_colon) { colon >> year }
+
+      # Reaffirmation notation (e.g., "(R2020)")
+      rule(:reaffirmation) do
+        space >> str("(R") >> year >> str(")")
+      end
+
+      # Part notation (e.g., ", Part 2")
+      rule(:part_notation) do
+        str(", Part ") >> digits.as(:part_number)
+      end
+
+      # Edition notation (e.g., ", 4th edition")
+      rule(:edition_notation) do
+        str(", ") >>
+          digits.as(:edition_number) >>
+          (str("st") | str("nd") | str("rd") | str("th")) >>
+          str(" edition")
+      end
+
+      # MPMS identifier (special format with CH)
+      rule(:mpms_identifier) do
+        publisher >>
+          str("MPMS").as(:type) >>
+          chapter_notation >>
+          (dot >> digits_with_letter.as(:section)).maybe >>
+          (dot >> digits_with_letter.as(:subsection)).maybe >>
+          (date_dash | date_colon).maybe
+      end
+
+      # Standard identifier with type
+      rule(:typed_identifier) do
+        publisher >>
+          doc_type >> space >>
+          number_with_part >>
+          part_notation.maybe >>
+          (date_dash | date_colon).maybe >>
+          reaffirmation.maybe
+      end
+
+      # Typeless identifier (just API + number)
+      rule(:typeless_identifier) do
+        publisher >>
+          number_with_part >>
+          part_notation.maybe >>
+          (date_dash | date_colon).maybe >>
+          reaffirmation.maybe
+      end
+
+      # Second identifier in combined (no API prefix, just type + number)
+      rule(:second_identifier) do
+        doc_type >> space >>
+          number_with_part >>
+          part_notation.maybe >>
+          (date_dash | date_colon).maybe
+      end
+
+      # Combined identifier (two identifiers separated by slash)
+      rule(:combined_identifier) do
+        (mpms_identifier | typed_identifier | typeless_identifier).as(:first) >>
+          slash >>
+          second_identifier.as(:second) >>
+          edition_notation.maybe
+      end
+
+      # Main identifier (try combined first, then MPMS, then typed, then typeless)
+      rule(:identifier) do
+        combined_identifier | mpms_identifier | typed_identifier | typeless_identifier
+      end
+
+      root(:identifier)
+
+      # Preprocessing to normalize common typos
+      def parse(input)
+        # Normalize MPMP typo to MPMS
+        normalized = input.gsub("API MPMP", "API MPMS")
+        super(normalized)
+      end
+    end
+  end
+end

data/lib/pubid/api/renderer.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    # Human-readable renderer for API identifiers.
+    #
+    # Produces strings like:
+    #   "API Std 650"
+    #   "API MPMS CH 4.1"
+    #   "API 5L-2018"
+    #
+    # The renderer is registered as the +:human+ format in the API format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::Mpms
+          render_mpms(id)
+        when Identifiers::TypelessStandard
+          render_typeless(id)
+        else
+          render_default(id)
+        end
+      end
+
+      private
+
+      def render_default(id)
+        parts = ["API"]
+
+        # Add the type token (RP, STD, BULL, PUBL, SPEC, TR ...) if the leaf
+        # defines one. `type_string` is a plain METHOD on each leaf, never a
+        # lutaml attribute, so the old `attributes.key?(:type_string)` guard
+        # was always false and the token was dropped from every rendering.
+        parts << id.type_string if id.respond_to?(:type_string) && id.type_string
+
+        # Add code/number with part as one token
+        parts << code_portion(id) if code_portion(id)
+
+        result = parts.join(" ")
+        result += "-#{id.year}" if id.year
+        result += " (R#{id.reaffirmation})" if id.reaffirmation
+        result
+      end
+
+      def render_mpms(id)
+        parts = ["API", "MPMS"]
+
+        # Add chapter
+        parts << "CH #{id.number}" if id.number
+
+        # Add section/subsection
+        if id.section
+          parts << ".#{id.section}"
+          parts << ".#{id.subsection}" if id.subsection
+        end
+
+        # Add year
+        parts << "-#{id.year}" if id.year
+
+        parts.join(" ").gsub(" .", ".")
+      end
+
+      def render_typeless(id)
+        parts = ["API"]
+
+        # Add code/number
+        parts << code_portion(id) if code_portion(id)
+
+        # Add year
+        parts << "-#{id.year}" if id.year
+
+        # Add reaffirmation
+        parts << " (R#{id.reaffirmation})" if id.reaffirmation
+
+        parts.join(" ")
+      end
+
+      # The document number plus its part, as one token.
+      #
+      # This used to read a `code` attribute that NOTHING ever assigned — the
+      # parser emits no `:code` key and the builder never sets one — so it
+      # always returned nil and 163 of API's 193 corpus identifiers rendered
+      # as the bare publisher "API". That string is both the document number
+      # and the output filename, so they all collapsed onto each other.
+      # `number` is what Builder#cast actually populates.
+      def code_portion(id)
+        return nil unless id.number
+
+        code_str = id.number.to_s
+        code_str += "-#{id.part}" if id.part
+        code_str
+      end
+    end
+  end
+end

data/lib/pubid/api/single_identifier.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    class SingleIdentifier < Identifier
+      # Generate URN for this identifier
+      #
+      # @return [String] URN representation
+
+      # Stored as a plain string (always "API") 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: -> { "API" }
+
+      # `number` and `part` are inherited as :string from
+      # Pubid::Api::Identifier. There is deliberately no `code` attribute: one
+      # existed here typed Components::Code, but nothing ever assigned it
+      # (the parser emits no `:code` key), so it only misdirected
+      # Renderer#code_portion away from the `number` the builder populates.
+      attribute :year, :string
+      attribute :reaffirmation, :string
+    end
+  end
+end

data/lib/pubid/api/urn_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      def urn_type
+        "std"
+      end
+
+      def generate
+        parts = ["urn", "api"]
+        parts << urn_type
+        parts << urn_number if urn_number
+        parts << urn_part if urn_part
+        parts << urn_year if urn_year
+
+        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/api/urn_parser.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    # Parses API URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:api:{publisher}:{number}[-{part}]:{year}
+    # where slot[1] is the publisher (default "api"), slot[2] is the number
+    # with optional `-part` suffix, slot[3] is the optional year.
+    #
+    # Examples:
+    # - urn:api:api:1104              → API STD 1104
+    # - urn:api:api:1104-1:2020       → API STD 1104-1:2020
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        _type, number = parts
+        idx = 2
+        part = nil
+        if parts[idx]&.start_with?("-")
+          part = parts[idx]
+          idx += 1
+        end
+        year = parts[idx]
+
+        text = "API STD #{number}#{part}"
+        text += ":#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/api.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Api
+    extend Pubid::PrefixesSupport
+
+    # Sole API publisher token (see the parser's `publisher` rule).
+    PREFIXES = ["API"].freeze
+
+    autoload :Builder, "#{__dir__}/api/builder"
+    autoload :Identifier, "#{__dir__}/api/identifier"
+    autoload :Identifiers, "#{__dir__}/api/identifiers"
+    autoload :Parser, "#{__dir__}/api/parser"
+    autoload :Renderer, "#{__dir__}/api/renderer"
+    autoload :SingleIdentifier, "#{__dir__}/api/single_identifier"
+    autoload :UrnGenerator, "#{__dir__}/api/urn_generator"
+    autoload :UrnParser, "#{__dir__}/api/urn_parser"
+
+    def self.parse(input)
+      Identifier.parse(input)
+    end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    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 < Pubid::Identifier }
+        .reject { |c| c.name&.split("::")&.last == "Base" }
+    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 }
+    rescue NoMethodError
+      nil
+    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 Uapi flavor with the registry
+Pubid::Registry.register(:api, Pubid::Api)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Api::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Api::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Api::Renderer)