pubid 2.0.1 → 2.0.3

data/lib/pubid/ecma/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Ecma
-    # Parslet grammar for ECMA identifiers.
+    # Grammar for ECMA identifiers.
     #
     # Four printed forms:
     #   ECMA-411          standard
@@ -20,57 +18,7 @@ module Pubid
     # Each branch captures its number under a distinct key so the builder can
     # pick the identifier class without a separate type token. Numbers are kept
     # as strings to preserve any leading zeros.
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digits) { match["0-9"].repeat(1) }
-
-      rule(:prefix) { str("ECMA") }
-
-      rule(:tr) { str(" TR/") >> digits.as(:tr_number) }
-
-      rule(:mem) { str(" MEM/") >> digits.as(:mem_number) }
-
-      # Standards print with a hyphen ("ECMA-6"), but references are commonly
-      # written with a space ("ECMA 6"). Both parse; the renderer normalises to
-      # the hyphen, so the space form round-trips as "ECMA-6" by design and must
-      # never enter the byte-exact `pass` fixtures.
-      rule(:standard_separator) { str("-") | str(" ") }
-
-      rule(:standard) do
-        standard_separator >> digits.as(:number) >>
-          (str("-") >> digits.as(:part)).maybe
-      end
-
-      # Editions are not all integers: ECMA-402 ed5.1 is a real document. The
-      # value is stored verbatim so it renders and serializes unchanged.
-      rule(:edition_number) { digits >> (str(".") >> digits).repeat(0) }
-
-      rule(:edition) { str(" ed") >> edition_number.as(:edition) }
-
-      rule(:volume) { str(" vol") >> digits.as(:volume) }
-
-      # The suffixes attach AFTER the type alternation, so a technical report
-      # and a memento carry them exactly as a standard does.
-      #
-      # Two PEG facts this arrangement depends on:
-      #
-      # 1. `standard` cannot shadow " TR/" or " MEM/", because after the space
-      #    it demands a digit and "T"/"M" are not digits. Keeping tr|mem first
-      #    is belt-and-braces; the DISJOINT FIRST CHARACTER is the load-bearing
-      #    invariant.
-      # 2. Appending a sequence moves the alternation out of tail position, so
-      #    Parslet no longer threads consume_all into it and will not backtrack
-      #    into an alternative that already succeeded. A future branch that
-      #    could match a proper prefix of another branch's input would now fail
-      #    the whole parse instead of being rescued by the next alternative.
-      rule(:identifier) do
-        prefix >> (tr | mem | standard) >> edition.maybe >> volume.maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ecma/renderer.rb

@@ -11,8 +11,8 @@ module Pubid
     #   "ECMA MEM/1970"      memento
     #   "ECMA-269 ed3 vol2"  with the edition and volume suffixes
     #
-    # With `with_publisher: false` the leading ECMA token is dropped, yielding
-    # "-411" / "TR/101" / "MEM/1970".
+    # The ECMA token is part of the designation and is always rendered; see
+    # `Pubid::Ecma::Identifier#publisher_prefixes`.
     class Renderer < ::Pubid::Renderers::Base
       PUBLISHER = "ECMA"
 
@@ -32,7 +32,7 @@ module Pubid
         # with a space ("ECMA TR/101"). type_prefix is nil only for standards.
         sep = id.type_prefix.nil? ? "" : " "
         core = id.type_prefix.nil? ? standard_core(id) : typed_core(id)
-        result = with_publisher?(id) ? "#{PUBLISHER}#{sep}#{core}" : core
+        result = "#{PUBLISHER}#{sep}#{core}"
         result + suffixes(id, with_edition, with_volume)
       end
 
@@ -58,10 +58,6 @@ module Pubid
       def typed_core(id)
         "#{id.type_prefix}/#{id.number}"
       end
-
-      def with_publisher?(id)
-        id.with_publisher != false
-      end
     end
   end
 end

data/lib/pubid/errors.rb

@@ -3,14 +3,12 @@
 # no `require "pubid"` here: errors.rb loads from pubid.rb itself, and
 # the umbrella self-require is a circular load whose failure order is
 # platform-dependent (windows raises mid-cycle where linux tolerates it)
-require "parslet"
 
 module Pubid
   # Every failure pubid raises.
   #
-  # The three classes below have three different superclasses, chosen so that
-  # code written against the old contract keeps working: relaton-cli rescues
-  # `Parslet::ParseFailed`, and the input guards have always raised
+  # The three classes below have three different superclasses: a parse
+  # failure is a `StandardError`, and the input guards have always raised
   # `ArgumentError`. What unifies them is the marker module
   # {Pubid::Errors::Error}, which every one of them includes, so a caller that
   # wants "pubid could not do this" writes one rescue:
@@ -21,8 +19,8 @@ module Pubid
   #     warn e.message
   #   end
   #
-  # A URN failure deliberately does not inherit `Parslet::ParseFailed`: no
-  # grammar runs, so there is no parse failure to report.
+  # A URN failure deliberately does not share the parse failure's
+  # superclass: no grammar runs, so there is no parse failure to report.
   module Errors
     # Marker module included by every pubid error. Rescue this to catch all
     # of them, whatever their superclass.
@@ -32,13 +30,14 @@ module Pubid
     #
     # Raised for a grammar rejection, and also for the few flavors that reject
     # an input before the grammar runs (a CSA comment line, a bad ISBN check
-    # digit). Those synthetic failures carry no parslet cause, so
-    # {#parse_failure_cause} is nillable — check it before calling
-    # `ascii_tree` on it.
+    # digit). Those synthetic failures carry no cause, so
+    # {#parse_failure_cause} is nillable — check it before using it.
     #
     # v1's `Pubid::Core::Errors::ParseError` flattened the cause into the
-    # message and threw the object away. This one keeps it.
-    class ParseError < ::Parslet::ParseFailed
+    # message and threw the object away. This one keeps it. The superclass
+    # was `Parslet::ParseFailed` while the grammars ran on parslet; the parg
+    # artifacts retired that engine, and the class stands on its own now.
+    class ParseError < ::StandardError
       include Error
 
       # The string that could not be parsed, when it is known.
@@ -54,16 +53,22 @@ module Pubid
       attr_reader :flavor
 
       # @param message [String]
-      # @param parse_failure_cause [Parslet::Cause, nil] parslet's structured
+      # @param parse_failure_cause [Object, nil] the engine's structured
       #   cause, nil for a failure raised without running a grammar
       # @param input [String, nil]
       # @param flavor [String, nil]
       def initialize(message, parse_failure_cause = nil, input: nil,
                      flavor: nil)
-        super(message, parse_failure_cause)
+        super(message)
+        @parse_failure_cause = parse_failure_cause
         @input = input
         @flavor = flavor
       end
+
+      # @return [Object, nil]
+      def parse_failure_cause
+        @parse_failure_cause
+      end
     end
 
     # A URN could not be turned into an identifier object.

data/lib/pubid/etsi/builder.rb

@@ -28,17 +28,20 @@ module Pubid
         supplements_array = data[:supplements]
         supplements_array = [supplements_array] unless supplements_array.is_a?(Array)
 
-        # Build supplements recursively - each wraps the previous
+        # Build supplements recursively - each wraps the previous. The
+        # bindings pair each supplement's kind ("/A", "/C") with its number
+        # by occurrence index.
         supplements_array.reduce(base) do |current_base, supp|
-          if supp[:amendment]
+          case supp[:supplement_kind]
+          when "/A"
             Identifiers::Amendment.new(
               base: current_base,
-              number: supp[:amendment][:number].to_i,
+              number: supp[:supplement_number].to_i,
             )
-          elsif supp[:corrigendum]
+          when "/C"
             Identifiers::Corrigendum.new(
               base: current_base,
-              number: supp[:corrigendum][:number].to_i,
+              number: supp[:supplement_number].to_i,
             )
           else
             current_base # Skip unknown supplement types

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

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

data/lib/pubid/etsi/parser.rb

@@ -1,139 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Etsi
-    class Parser < ::Pubid::Parser::Grammar
-      # Basic elements
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:letter) { match["A-Za-z"] }
-      rule(:alnum) { match["A-Za-z0-9"] }
-      rule(:letters) { letter.repeat(1) }
-      rule(:alnums) { alnum.repeat(1) }
-      rule(:space) { str(" ") }
-      rule(:dash) { str("-") }
-      rule(:dot) { str(".") }
-
-      # ETSI prefix
-      rule(:etsi_prefix) { str("ETSI") >> space }
-
-      # Type prefixes - all 15 types
-      rule(:type) do
-        (str("I-ETS") | str("TCRTR") | str("GTS") | str("ETR") |
-         str("ETS") | str("TBR") | str("NET") | str("EN") |
-         str("ES") | str("EG") | str("TS") | str("GR") |
-         str("GS") | str("SR") | str("TR")).as(:type)
-      end
-
-      # Number variants
-
-      # GSM with dotted number: "GSM 11.14", "GSM 02.01"
-      rule(:gsm_with_space_number) do
-        str("GSM").capture(:gsm_prefix) >> space >>
-          digits.capture(:main) >> dot >> digits.capture(:sub)
-      end
-
-      # Number with dot: 11.40, 02.01
-      rule(:dotted_number) do
-        digits.capture(:main) >> dot >> digits.capture(:sub)
-      end
-
-      # Complex format: ABC 123 or ABC-DEF 123 or IP6 031
-      rule(:complex_number) do
-        alnums.capture(:prefix1) >>
-          (dash >> alnums.capture(:prefix2)).maybe >>
-          space >>
-          digits.capture(:num)
-      end
-
-      # Simple format: just digits
-      rule(:simple_number) do
-        digits.capture(:num)
-      end
-
-      # Main number
-      rule(:number) do
-        (gsm_with_space_number | dotted_number | complex_number | simple_number).as(:number)
-      end
-
-      # Optional minor part
-      rule(:minor) do
-        space >> digits.as(:minor)
-      end
-
-      # Parts
-      rule(:part) do
-        dash >> alnums.as(:part)
-      end
-
-      rule(:parts) { part.repeat(0).as(:parts) }
-
-      # Version
-      rule(:version) do
-        str("V") >> match["0-9."].repeat(1).as(:version)
-      end
-
-      # Edition
-      rule(:edition) do
-        str("ed.") >> digits.as(:edition)
-      end
-
-      # Version or edition
-      rule(:version_or_edition) do
-        version | edition
-      end
-
-      # Published date
-      rule(:date_part) do
-        str("(") >>
-          digit.repeat(4, 4).as(:year) >>
-          dash >>
-          digit.repeat(2, 2).as(:month) >>
-          str(")")
-      end
-
-      # Individual supplements
-      rule(:amendment) do
-        str("/A") >> digits.as(:number)
-      end
-
-      rule(:corrigendum) do
-        str("/C") >> digits.as(:number)
-      end
-
-      # Single supplement (AMD or COR)
-      rule(:single_supplement) do
-        amendment.as(:amendment) | corrigendum.as(:corrigendum)
-      end
-
-      # Multiple supplements
-      rule(:supplements) do
-        single_supplement.repeat(1).as(:supplements)
-      end
-
-      # Main identifier
-      #
-      # The mandatory core is `etsi_prefix type number` (+ optional
-      # minor/parts/supplements), mirroring ISO. The version/edition and date
-      # suffixes are optional so a partial reference (e.g. "ETSI GS ZSM 012")
-      # parses with version/date left nil. Each `.maybe` guards its own leading
-      # space so no trailing space is demanded when the suffix is absent.
-      rule(:identifier) do
-        etsi_prefix >>
-          type >> space >>
-          number >> minor.maybe >> parts >>
-          supplements.maybe >>
-          (space >> version_or_edition).maybe >>
-          (space >> date_part).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/evs/identifier.rb

@@ -42,6 +42,13 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # Every EVS form starts with the `EVS` publisher, welded to an adopted
+      # designation by a dash (`EVS-EN 18216:2026`); `with_publisher: false`
+      # leaves the adopted designation (`EN 18216:2026`).
+      def publisher_prefixes
+        ["EVS"]
+      end
+
       def self.parse(string)
         unless string.is_a?(String)
           raise Pubid::Errors::InvalidInputError,

data/lib/pubid/evs/parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Evs
     # Grammar for the printed EVS national-adoption reference, composed with
@@ -16,12 +14,7 @@ module Pubid
     #
     #   "EVS-EN 18216:2026"            → {evs_separator, adopted: {publisher, number, year}}
     #   "EVS-EN ISO 9001:2015/A1:2024" → {evs_separator, adopted: {publisher, adopted_string, supplements}}
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:root) do
-        str("EVS") >>
-          (str("-") | str(" ")).as(:evs_separator) >>
-          ::Pubid::CenCenelec::Parser.new.identifier.as(:adopted)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/evs.rb

@@ -39,7 +39,7 @@ module Pubid
       language = identifier[/ (et-en|et|en)\z/, 1]
       body = language ? identifier.sub(/ #{Regexp.escape(language)}\z/, "") : identifier
 
-      parsed = Pubid::Parg::Backend.parse(:evs, body)
+      parsed = Pubid::Parg::Model.bound(:evs, body)
       built = Builder.new.build(parsed)
       # An "(all parts)" parse wraps the identifier — the language belongs
       # to the inner EVS identifier, not the flavor-less wrapper.

data/lib/pubid/gb/identifier.rb

@@ -67,6 +67,12 @@ module Pubid
         render(format: :human, **opts)
       end
 
+      # `GB` is the standard code, welded to the mandate (`GB/T`), not a
+      # publisher prefix: `with_publisher: false` keeps it, as BSI keeps `BS`.
+      def publisher_prefixes
+        []
+      end
+
       # Parse a Chinese Standard identifier string.
       # @param identifier [String]
       # @return [Pubid::Gb::Identifier]

data/lib/pubid/gb/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Gb
-    # Parslet grammar for Chinese Standard identifiers.
+    # Grammar for Chinese Standard identifiers.
     #
     # Accepts the canonical printed form
     #
@@ -14,54 +12,7 @@ module Pubid
     # T/GZAEPI, ...). TYPE is T (recommended), Z (guideline), or omitted.
     # YEAR is 4 digits, separated by either ASCII dash or em-dash (Chinese
     # typography uses the em-dash form).
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:space)  { str(" ") }
-      rule(:dot)    { str(".") }
-      rule(:dash)   { str("-") | str("—") }
-      rule(:digits) { match("[0-9]").repeat(1) }
-
-      # Publisher token: national/industry codes (1-3 letters, optionally
-      # followed by /T or /Z) OR social-group form "T/{ACRONYM}".
-      rule(:publisher_code) do
-        # Social-group form: "T/" then 2+ uppercase letters/digits.
-        (str("T/") >> match("[A-Z0-9]").repeat(1)).as(:publisher_code) |
-          # Confidential national series. The lowercase "n" is part of the
-          # code, so it comes before the uppercase-only rule below: a PEG
-          # takes the first branch that matches and does not backtrack.
-          (str("GBn") >> (str("/T") | str("/Z")).maybe).as(:publisher_code) |
-          # Standard form: 1-3 letters, optional slash-T-or-Z.
-          (match("[A-Z]").repeat(1, 3) >>
-            (str("/T") | str("/Z")).maybe).as(:publisher_code)
-      end
-
-      # Mandate category captured separately when the publisher token didn't
-      # already include it. Allows "GB/T" (inline) and "GB" + " T" (separate)
-      # to both parse.
-      rule(:mandate_suffix) do
-        (str("/") >> (str("T") | str("Z")).as(:mandate)).maybe
-      end
-
-      rule(:number) { digits.as(:number) }
-      rule(:part)   { dot >> digits.as(:part) }
-      rule(:year)   { (dash >> match("[0-9]").repeat(4, 4).as(:year)).maybe }
-      rule(:all_parts_flag) do
-        (space >> str("(") >> str("all parts") >> str(")")).as(:all_parts)
-      end
-
-      rule(:identifier) do
-        publisher_code >>
-          space >>
-          number >>
-          part.maybe >>
-          year >>
-          all_parts_flag.maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/gost/identifier.rb

@@ -23,7 +23,7 @@ module Pubid
                 ::Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:gost, Parser.normalize_input(identifier))
+        parsed = Pubid::Parg::Model.bound(:gost, Parser.normalize_input(identifier))
         Builder.build(parsed)
       end
 
@@ -38,6 +38,14 @@ module Pubid
       # document.
       subset_strict :copublisher
 
+      # `GOST` (and `GOST R`) is the national standard designation, as `GB`
+      # and `BS` are, not a publisher prefix: `GOST 26951-2025` without it is
+      # no designation, and `GOST IEC 62868` would read as the IEC document.
+      # `with_publisher: false` therefore keeps it.
+      def publisher_prefixes
+        []
+      end
+
       GOST_TYPE_MAP = {
         "pubid:gost:interstate-standard" => "Pubid::Gost::Identifiers::InterstateStandard",
         "pubid:gost:national-standard"   => "Pubid::Gost::Identifiers::NationalStandard",

data/lib/pubid/gost/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Gost
-    # Parslet grammar for GOST identifiers.
+    # Grammar for GOST identifiers.
     #
     # Accepts the Latin and Cyrillic surface forms observed in the wild:
     #
@@ -26,87 +24,12 @@ module Pubid
     #
     # The builder interprets prefix_text (splits copublisher vs subtype,
     # normalizes Cyrillic to Latin) and raw (splits number vs year).
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-
-      root :identifier
-
-      rule(:space)  { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:dot)    { str(".") }
-
-      rule(:year_sep) do
-        (str("-") | str("—") | str("–")) >> space?.maybe
-      end
-
-      rule(:gost_word) do
-        (str("GOST") | str("ГОСТ")).as(:gost_word) >> space
-      end
-
-      rule(:scope_r) do
-        (match("R") | match("Р")).as(:scope_r) >> space
-      end
-
-      # Everything between scope_r and the first digit: copublisher,
-      # subtype, or both. Captured as a raw string — the builder splits
-      # it into copublisher + subtype. Matches uppercase letters (Latin
-      # and Cyrillic), forward slashes, and spaces between words.
-      rule(:prefix_text) do
-        (match("[A-ZА-Яa-zа-я/]").repeat(1) >>
-          (space >> match("[A-ZА-Яa-zа-я/]").repeat(1)).repeat).as(:prefix_text) >> space
-      end
-
-      rule(:digits) do
-        match("[0-9]").repeat(1)
-      end
-
-      rule(:raw_body) do
-        (digits >> ((dot | year_sep) >> digits).repeat).as(:raw)
-      end
-
-      # IDT adoption suffix: "/<foreign-identifier>". The slash is
-      # consumed but NOT captured — only the foreign identifier text
-      # goes into :adopted_raw. Captures everything after the first
-      # slash, including subsequent slashes (the adopted identifier
-      # may itself contain slashes, e.g. "ISO/TR 25901-1:2016").
-      rule(:adopted_part) do
-        space?.maybe >> str("/") >> match(".").repeat(1).as(:adopted_raw)
-      end
-
-      # Adoption reference in parens: "(<foreign-id>)". The parens
-      # themselves are consumed but NOT captured. The content goes
-      # into :adopted_reference_raw. This form appears for MOD/NEQ
-      # adoptions where the foreign standard is referenced but not
-      # identical (IDT would use the slash form instead).
-      rule(:adopted_reference_part) do
-        space?.maybe >> str("(") >> match("[^)]").repeat(1).as(:adopted_reference_raw) >> str(")")
-      end
-
-      rule(:identifier) do
-        gost_word >> scope_r.maybe >> prefix_text.maybe >> raw_body >>
-          adopted_part.maybe >> adopted_reference_part.maybe
-      end
-
-      # Pre-parse ingestion normalizations (R2): every parse path —
-      # parslet and PG artifact alike — feeds the grammar the same
-      # normalized string.
+    class Parser
+      # Pre-parse ingestion normalizations (R2): every parse path feeds
+      # the grammar the same normalized string.
       def self.normalize_input(string)
         string.strip
       end
-
-      def self.parse(string)
-        unless string.is_a?(String)
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > ::Pubid::MAX_INPUT_LENGTH
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
-        new.parse(normalize_input(string))
-      end
     end
   end
 end