pubid 2.0.0 → 2.0.2

data/lib/pubid/parg/model.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parg
+    # Typed model binding for one artifact entry point. The grammar declares
+    # which captures bind to which attributes (its `bindings` block); this
+    # module parses through those bindings — either straight into the
+    # flavor's model class (`parse`) or into the builder-ready hash its
+    # Builder consumes (`bound`) — so consumers never see the wire tree.
+    module Model
+      ALL_PARTS_SUFFIX = "(all parts)"
+      ALL_PARTS_PATTERN = /\s*\(all parts\)\s*\z/
+
+      @registered = {}
+      @mutex = Mutex.new
+
+      class << self
+        # Parse +input+ through the artifact's declared bindings into the
+        # builder-ready attribute hash, without materializing a model. For
+        # flavors whose Builder still owns type dispatch and component
+        # construction: the bindings replace tree normalization, not the
+        # builder. The "(all parts)" suffix keeps its contract — stripped
+        # before parsing, marked on the hash for the builder's AllPartsWrap.
+        def bound(flavor, input, entry: "identifier")
+          ensure_bindings!(flavor, entry)
+          all_parts = input.end_with?(ALL_PARTS_SUFFIX)
+          source = all_parts ? input.sub(ALL_PARTS_PATTERN, "") : input
+          hash = Artifact.for(flavor).parse_and_bind(entry, source)
+          all_parts ? Backend.mark_all_parts(hash) : hash
+        rescue Parsanol::ParseFailed => e
+          parse_error(e, input, flavor)
+        end
+
+        # Parse +input+ into +model_class+ through the artifact's declared
+        # bindings. The "(all parts)" suffix is stripped before parsing and
+        # re-applied to the model, exactly as the tree backend does.
+        def parse(flavor, model_class, input, entry: "identifier")
+          register(flavor, model_class, entry)
+          model, all_parts = materialize(flavor, model_class, input)
+          all_parts ? model.to_all_parts : model
+        rescue Parsanol::ParseFailed => e
+          parse_error(e, input, flavor)
+        end
+
+        private
+
+        def parse_error(error, input, flavor)
+          raise Pubid::Errors::ParseError.new(
+            error.message,
+            nil,
+            input: input,
+            flavor: Backend.registered_name(flavor),
+          )
+        end
+
+        def materialize(flavor, model_class, input)
+          all_parts = input.end_with?(ALL_PARTS_SUFFIX)
+          source = all_parts ? input.sub(ALL_PARTS_PATTERN, "") : input
+          [model_class.public_send(:"from_#{format_for(flavor)}", source),
+           all_parts]
+        end
+
+        def register(flavor, model_class, entry)
+          format = format_for(flavor)
+          @mutex.synchronize do
+            return if @registered[format] == model_class
+
+            ensure_bindings!(flavor, entry)
+            bind!(flavor, model_class, format, entry)
+            @registered[format] = model_class
+          end
+        end
+
+        def bind!(flavor, model_class, format, entry)
+          Parsanol::PARG::Lutaml.register(
+            model_class,
+            format_name: format,
+            artifact: Artifact.path_for(flavor),
+            entry: entry,
+            tables_dir: Artifact::TABLES_DIR,
+          )
+        end
+
+        def ensure_bindings!(flavor, entry)
+          return unless Artifact.for(flavor).bindings(entry).empty?
+
+          raise Pubid::Errors::ParseError,
+                "PG artifact for #{flavor} declares no bindings " \
+                "for entry #{entry}"
+        end
+
+        def format_for(flavor)
+          :"pg_#{flavor}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/parg.rb

@@ -4,5 +4,6 @@ module Pubid
   module Parg
     autoload :Artifact, "pubid/parg/artifact"
     autoload :Backend, "pubid/parg/backend"
+    autoload :Model, "pubid/parg/model"
   end
 end

data/lib/pubid/parser.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
-require "pubid"
 module Pubid
   module Parser
-    autoload :Grammar, "pubid/parser/grammar"
-    autoload :CommonParseMethods, "pubid/parser/common_parse_methods"
-    autoload :CommonParseRules, "pubid/parser/common_parse_rules"
+    # A trailing "(all parts)" marks the reference as the whole document.
+    # NIST's parse path strips it before preprocessing and carries the
+    # marker into the tree (:all_parts) for the builder to wrap; the
+    # shared Builder::Base reads the same marker for every other flavor.
+    ALL_PARTS_SUFFIX = "(all parts)".freeze
   end
 end

data/lib/pubid/parsers/mr_string.rb

@@ -116,7 +116,7 @@ module Pubid
         # 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,
+          raise Pubid::Errors::ParseError,
                 "#{mr_string.inspect} is not an MR string"
         end
 

data/lib/pubid/plateau/parser.rb

@@ -2,72 +2,7 @@
 
 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 }
+    class Parser
     end
   end
 end

data/lib/pubid/plateau.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "pubid"
-require "parslet"
 
 module Pubid
   module Plateau
@@ -31,7 +30,7 @@ module Pubid
 
       # Apply legacy update_codes normalization first
       normalized = Core::UpdateCodes.apply(input, :plateau)
-      parsed = Pubid::Parg::Backend.parse(:plateau, normalized)
+      parsed = Pubid::Parg::Model.bound(:plateau, normalized)
       Builder.build(parsed)
     end
 

data/lib/pubid/renderers/directives_renderer.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Renderers
     class DirectivesRenderer < HumanReadable
-      def render(context:, with_edition: false)
+      def render(context:, with_edition: false, **_opts)
         parts = []
         parts << render_publisher_portion(context)
         num_port = render_number_portion(context)

data/lib/pubid/renderers/iwa_renderer.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Renderers
     class IwaRenderer < HumanReadable
-      def render(context:, with_edition: false)
+      def render(context:, with_edition: false, **_opts)
         parts = []
         if @id.typed_stage
           parts << annotate(@id.typed_stage.render(context:),

data/lib/pubid/renderers/publisher_stripper.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Renderers
+    # Removes the leading publisher token from an already-rendered identifier,
+    # for `to_s(with_publisher: false)`.
+    #
+    # relaton#49 asks for an internal form of every identifier: the form an SDO
+    # uses when it cites its own documents, with the publisher prefix dropped
+    # (`NIST SP 800-113` -> `SP 800-113`). Teaching 40-odd flavor renderers to
+    # omit the publisher would mean 40 chances to drift, and a flavor added
+    # tomorrow would get nothing. This class works from the OUTSIDE instead,
+    # the way {Annotator} does: the identifier names the prefixes its rendering
+    # can start with (`Pubid::Identifier#publisher_prefixes`), and the prefix
+    # is cut off together with the one separator that follows it.
+    #
+    # Deliberate limits:
+    #
+    # * A prefix must be followed by a separator (space, `-`, `/` or `.`), so
+    #   `ISO` never cuts into `ISOFIX`.
+    # * When no prefix matches, or cutting it would leave nothing, the input
+    #   comes back unchanged: the option is ignored rather than producing a
+    #   broken identifier.
+    class PublisherStripper
+      SEPARATOR = %r{\A(?:\s+|[-/.]\s*)}
+
+      def initialize(identifier)
+        @id = identifier
+      end
+
+      # A co-published group is not always joined by `/`: CIE prints
+      # `CIE ISO 10916:2024`. The cut therefore repeats while a publisher
+      # token still leads, so the group drops whole whatever its joiner.
+      # The cap only guards against a cycle; no corpus id has more than three.
+      MAX_CUTS = 4
+
+      # @param rendered [String] the default human rendering of the identifier
+      # @return [String] the rendering without its leading publisher token
+      def strip(rendered)
+        return rendered unless rendered.is_a?(String)
+
+        candidates = prefixes
+        MAX_CUTS.times do
+          stripped = cut_once(rendered, candidates)
+          break if stripped.equal?(rendered)
+
+          rendered = stripped
+        end
+        rendered
+      end
+
+      private
+
+      def cut_once(rendered, candidates)
+        candidates.each do |prefix|
+          next unless rendered.start_with?(prefix)
+
+          rest = rendered[prefix.length..]
+          next unless rest.match?(SEPARATOR)
+
+          stripped = rest.sub(SEPARATOR, "")
+          return stripped unless stripped.empty?
+        end
+
+        rendered
+      end
+
+      # Longest first, so `ISO/IEC` wins over `ISO`. Each prefix also comes in
+      # its annotated spelling: ISO annotates inside its own renderer, so its
+      # string already reads `<span class="publisher">ISO</span> …` when it
+      # reaches this class.
+      def prefixes
+        Array(@id.publisher_prefixes)
+          .map { |p| p.to_s.strip }
+          .reject(&:empty?)
+          .flat_map { |p| [%(<span class="publisher">#{p}</span>), p] }
+          .uniq
+          .sort_by { |p| -p.length }
+      end
+    end
+  end
+end

data/lib/pubid/renderers/supplement_renderer.rb

@@ -3,7 +3,7 @@
 module Pubid
   module Renderers
     class SupplementRenderer < HumanReadable
-      def render(context:, with_edition: false)
+      def render(context:, with_edition: false, **_opts)
         parts = []
 
         base_str = @id.base.to_s(

data/lib/pubid/renderers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Renderers
     autoload :Annotator, "pubid/renderers/annotator"
+    autoload :PublisherStripper, "pubid/renderers/publisher_stripper"
     autoload :Base, "pubid/renderers/base"
     autoload :DirectivesRenderer, "pubid/renderers/directives_renderer"
     autoload :GuideRenderer, "pubid/renderers/guide_renderer"

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

@@ -16,7 +16,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:sae, input)
+        parsed = Pubid::Parg::Model.bound(:sae, input)
         Builder.build(parsed)
       end
 

data/lib/pubid/sae/parser.rb

@@ -1,55 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Sae
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space) { str(" ") }
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:letter) { match["A-Z"] }
-      rule(:colon) { str(":") }
-
-      # Publisher
-      rule(:publisher) { str("SAE").as(:publisher) }
-
-      # Document types with optional number suffix (e.g., J300, J308A)
-      rule(:doc_type) do
-        (
-          str("AMS") |  # Aerospace Material Specification
-          str("AIR") |  # Aerospace Information Report
-          str("ARP") |  # Aerospace Recommended Practice
-          str("AS") |   # Aerospace Standard
-          str("J") |    # SAE Standard (e.g., J300)
-          str("MA")     # Material Advisory
-        ).as(:type)
-      end
-
-      # Number with optional letter prefix or suffix
-      rule(:number) do
-        ((letter.repeat(1,
-                        1) >> digits) | (digits >> letter.repeat(0,
-                                                                 1))).as(:number)
-      end
-
-      # Year
-      rule(:year) { digit.repeat(4, 4).as(:year) }
-
-      # Date
-      rule(:date) { colon >> year }
-
-      # Main identifier
-      rule(:identifier) do
-        publisher >> space >> doc_type >> space.maybe >>
-          number >> date.maybe
-      end
-
-      root(:identifier)
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/tgpp/identifier.rb

@@ -113,7 +113,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:tgpp, identifier)
+        parsed = Pubid::Parg::Model.bound(:tgpp, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/tgpp/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Tgpp
-    # Parslet grammar for 3GPP identifiers.
+    # Grammar for 3GPP identifiers.
     #
     # Form: `[3GPP ]<TR|TS> <NN.NNN>[suffix][-part…][:<release>][/<version>]`
     #   TS 23.207:REL-4/2.0.0
@@ -17,62 +15,7 @@ module Pubid
     # document alone ("3GPP TS 23.207"), and relaton parses that bare form to
     # search the index. Only the type and the dotted number core are required,
     # so "TS" and "TS foo" are still rejected.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:space) { str(" ") }
-
-      # Optional leading publisher token.
-      rule(:publisher_prefix) { str("3GPP") >> space }
-
-      # Document type.
-      rule(:type) { (str("TR") | str("TS")).as(:type) }
-
-      # Dotted number core, kept as a string (preserves leading zeros).
-      rule(:number_core) { (digits >> str(".") >> digits).as(:number) }
-
-      # Letter suffix directly after the number ("U"/"dcs"/"ext"…). Generic so
-      # future controlled-vocabulary values keep round-tripping.
-      rule(:suffix) { match["A-Za-z"].repeat(1).as(:suffix) }
-
-      # Hyphen parts.
-      rule(:part) { str("-") >> digits.as(:part) }
-      rule(:parts) { part.repeat(0).as(:parts) }
-
-      # Release token, stored verbatim: everything up to the version separator.
-      # Excludes ":" (as well as "/") so the ":"-delimited URN scheme can always
-      # encode it — every real release ("REL-4", "Ph1", "UMTS", "Release 2000")
-      # is colon-free.
-      #
-      # A trailing segment shaped exactly like a version is a mistyped "/"
-      # separator ("TS 23.207:2.0.0"), not a release: no release in the 88,464
-      # published index rows contains a dot at all. Reject it rather than
-      # silently misfiling the version as the release — which only became
-      # reachable once the version segment was made optional.
-      rule(:release) do
-        (version_core >> any.absent?).absent? >>
-          match["^/:"].repeat(1).as(:release)
-      end
-
-      # Three-part version, kept as a string.
-      rule(:version_core) do
-        digits >> str(".") >> digits >> str(".") >> digits
-      end
-      rule(:version) { version_core.as(:version) }
-
-      rule(:identifier) do
-        publisher_prefix.maybe >>
-          type >> space >>
-          number_core >> suffix.maybe >> parts >>
-          (str(":") >> release).maybe >>
-          (str("/") >> version).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/un/identifier.rb

@@ -32,7 +32,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:un, identifier, merge_top_sequence: false)
+        parsed = Pubid::Parg::Model.bound(:un, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/un/parser.rb

@@ -1,25 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Un
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:slash) { str("/") }
-      rule(:un_prefix) { (str("UN") >> str(" ")).maybe }
-      rule(:token) { match("[A-Z0-9.]").repeat(1) }
-
-      rule(:identifier) do
-        un_prefix >>
-          token.as(:token) >>
-          (slash >> token.as(:token)).repeat(1)
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0"
+  VERSION = "2.0.2"
 end

data/lib/pubid/w3c/identifier.rb

@@ -122,7 +122,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:w3c, identifier)
+        parsed = Pubid::Parg::Model.bound(:w3c, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/w3c/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module W3c
-    # Parslet grammar for printed W3C identifiers, e.g.
+    # Grammar for printed W3C identifiers, e.g.
     #   "W3C WD-charmod-19991129"   (type + code + date)
     #   "W3C NOTE-xml-names"        (type + code)
     #   "W3C 2dcontext"             (bare code)
@@ -14,30 +12,7 @@ module Pubid
     # greedily consume the trailing date and make a `.maybe` date rule
     # unreliable. This is safe: no real W3C code ends in a same-width (4/6/8)
     # digit run, so the Builder's fixed-width trailing-date test never collides.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:prefix) { str("W3C") >> str(" ") }
-
-      # Known W3C maturity tokens. Order matters for shared prefixes: CRD before
-      # CR, PER before PR, DNOTE before NOTE.
-      rule(:type_token) do
-        str("DNOTE") | str("NOTE") | str("WD") | str("CRD") | str("CR") |
-          str("REC") | str("PER") | str("PR") | str("SPSD") | str("OBSL")
-      end
-
-      # A leading token is only a type when immediately followed by "-".
-      rule(:type_part) { type_token.as(:type) >> str("-") }
-
-      # The remainder: code plus an optional trailing date. Captured whole and
-      # split in the Builder.
-      rule(:rest) { any.repeat(1).as(:rest) }
-
-      rule(:identifier) { prefix >> type_part.maybe >> rest }
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/xsf/identifier.rb

@@ -30,15 +30,19 @@ module Pubid
       # publisher name in an identifier — the leading token is "XEP".
       PUBLISHER = "XSF"
 
-      attr_reader :with_publisher
-
-      # Basic string representation. Delegates to renderer; `with_publisher:
-      # false` yields the bare number.
-      def to_s(with_publisher: true, **opts)
-        @with_publisher = with_publisher
+      # Basic string representation. Delegates to renderer.
+      #
+      # `with_publisher:` is accepted and has no effect: `XEP` names the
+      # series, and XSF itself cites `XEP 0001`, so the internal form is the
+      # external one (see {#publisher_prefixes}).
+      def to_s(**opts)
         render(format: :human, **opts)
       end
 
+      def publisher_prefixes
+        []
+      end
+
       # from_hash is the shared polymorphic dispatch on Pubid::Identifier;
       # XSF_TYPE_MAP remains as the key_value polymorphic_map.
 
@@ -58,7 +62,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:xsf, identifier)
+        parsed = Pubid::Parg::Model.bound(:xsf, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/xsf/parser.rb

@@ -1,38 +1,10 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Xsf
-    # Parslet grammar for XSF identifiers. Two shapes: "XEP NNNN", and the two
-    # named documents in SPECIAL_NUMBERS.
-    class Parser < ::Pubid::Parser::Grammar
-      # The XMPP extensions repository publishes two documents whose name is
-      # not a number: the editor README and the `xep-xxxx` template. Both reach
-      # pubid as real primary docids ("XEP README", "XEP xxxx"), so the number
-      # rule admits these two literals beside the digits. Exact case, and no
-      # other word: the flavor still rejects "XEP foo".
-      SPECIAL_NUMBERS = %w[README xxxx].freeze
-
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-
-      rule(:special_number) do
-        SPECIAL_NUMBERS.map { |name| str(name) }.reduce(:|)
-      end
-
-      # "XEP 0001" — publisher token, a single space, then the number kept as
-      # a string of digits (leading zeros preserved by the builder), or the
-      # name of one of the two named documents.
-      rule(:identifier) do
-        str("XEP") >> str(" ") >> (digits | special_number).as(:number)
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    # Grammar for XSF identifiers. Two shapes: "XEP NNNN", and the two
+    # named documents (README and the four-x placeholder).
+    class Parser
     end
   end
 end