pubid 2.0.0.pre.alpha.9 → 2.0.0.pre.alpha.11

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

@@ -15,13 +15,42 @@ module Pubid
         # Type is stored in @type attribute from Identifier
         # All rendering handled by Identifier class
 
-        # Compact serialization (mirrors ISO/JCGM/OIML): the Code component
-        # collapses to a bare `number` scalar (plus a `parts` array and, rarely,
-        # a `minor` scalar); Version flattens to a scalar `version` string with
-        # an `is_edition` boolean flag (omitted when false); Date flattens to
-        # top-level year/month/day. The constant `publisher` ("ETSI") is
-        # intentionally NOT mapped — it is reconstructed on load from its
-        # attribute default, keeping the hash compact.
+        # --- Index columns -------------------------------------------------
+        #
+        # relaton-index sorts and bsearches every row on `id.root.number.to_s`,
+        # so the document number must be reachable as `number`. ETSI used to
+        # keep it inside an Etsi::Components::Code under a `code` attribute,
+        # leaving the inherited `number` nil and every index row keyed "".
+        #
+        # The three Code fields are now plain sibling attributes, which is the
+        # shape the serialized hash ALREADY had — the converters below merely
+        # read them directly instead of reaching through `code`, so the wire
+        # format is byte-identical and relaton-data-etsi's published index-v2
+        # needs no regeneration.
+        #
+        # `number` holds the BARE number ("300 175"), never the part, so all
+        # parts of a document share one index bucket and a part-less reference
+        # finds them all — the IEEE/ISO semantics documented in CLAUDE.md.
+        #
+        # LANDMINE: these redeclare attributes inherited from ::Pubid::Identifier
+        # (`number` is a Components::Code there, and Etsi::Components::Code is
+        # NOT a subclass of it). That resolves nondeterministically under
+        # multi-flavor load when declared on a class others inherit from, so it
+        # is confined to this LEAF — EtsiStandard has no subclasses, while the
+        # shared Pubid::Etsi::Identifier is also SupplementIdentifier's parent
+        # and must stay untouched. spec/pubid/etsi/root_number_spec.rb carries
+        # the tripwire and is only meaningful under the full `rake` suite.
+        attribute :number, :string
+        attribute :minor, :string
+        attribute :parts, :string, collection: true, default: -> { [] }
+
+        # Compact serialization (mirrors ISO/JCGM/OIML): the code fields are
+        # bare scalars (`number`, a `parts` array and, rarely, a `minor`);
+        # Version flattens to a scalar `version` string with an `is_edition`
+        # boolean flag (omitted when false); Date flattens to top-level
+        # year/month/day. The constant `publisher` ("ETSI") is intentionally
+        # NOT mapped — it is reconstructed on load from its attribute default,
+        # keeping the hash compact.
         #
         # This block lives on EtsiStandard (a leaf) rather than the shared Identifier:
         # SupplementIdentifier is a sibling that DELEGATES type/code/version and
@@ -30,9 +59,9 @@ module Pubid
         key_value do
           map "_type",      to: :_type
           map "type",       to: :type
-          map "number",     with: { to: :number_to_kv, from: :number_from_kv }
-          map "parts",      with: { to: :parts_to_kv,  from: :parts_from_kv }
-          map "minor",      with: { to: :minor_to_kv,  from: :minor_from_kv }
+          map "number",     to: :number
+          map "parts",      to: :parts
+          map "minor",      to: :minor
           map "version",    with: { to: :version_to_kv, from: :version_from_kv }
           map "is_edition", with: { to: :edition_to_kv, from: :edition_from_kv }
           map "year",       with: { to: :year_to_kv,  from: :year_from_kv }
@@ -40,36 +69,90 @@ module Pubid
           map "day",        with: { to: :day_to_kv,   from: :day_from_kv }
         end
 
-        # --- Code component flattened to bare number / parts / minor ---
-        def number_to_kv(model, doc)
-          emit_kv(doc, "number", model.code&.number)
-        end
-
-        def number_from_kv(model, value)
-          code_for(model).number = value.to_s
-        end
-
-        def minor_to_kv(model, doc)
-          emit_kv(doc, "minor", model.code&.minor)
-        end
-
-        def minor_from_kv(model, value)
-          code_for(model).minor = value.to_s
-        end
-
-        def parts_to_kv(model, doc)
-          parts = model.code&.parts
-          return if parts.nil? || parts.empty?
-
-          doc.add_child(
-            Lutaml::KeyValue::DataModel::Element.new(
-              "parts", parts.map(&:to_s)
-            ),
+        # The composed document code, rebuilt on demand from the split columns
+        # so the renderer, the URN generator and #== keep one place to ask for
+        # the printed form ("300 175-1"). Deliberately NOT an attribute and NOT
+        # memoised: `number`/`parts` are writable (the base #exclude rebuilds
+        # through them), so a cached Code would go stale.
+        #
+        # nil when there is no number, preserving the old nil-`code` semantics
+        # the URN generator branches on.
+        def code
+          return nil if number.nil?
+
+          Pubid::Etsi::Components::Code.new(
+            number: number,
+            minor: minor,
+            parts: parts || [],
           )
         end
 
-        def parts_from_kv(model, value)
-          code_for(model).parts = Array(value).map(&:to_s)
+        # MR slug number segment.
+        #
+        # The base hook reads the inherited `number` and `part`; ETSI kept
+        # neither, so before the index columns landed every ETSI slug was just
+        # `etsi.<date>` — 454 distinct slugs for 24,724 documents, and
+        # `to_slug` is what consumers use as an output FILENAME.
+        #
+        # Two things the base hook cannot do for ETSI:
+        #   * the parts live in the `parts` collection, not the inherited
+        #     scalar `part`, so they must be appended here or every part of a
+        #     document collapses onto one slug;
+        #   * an ETSI number legitimately contains a SPACE ("300 175", "GSM
+        #     02.01"), which is outside the [a-z0-9.-] charset Renderers::MrString
+        #     documents and guarantees. Sanitize BY CHARSET rather than by an
+        #     enumerated escape list (the BIPM `mr_slug` precedent in
+        #     CLAUDE.md), so a character added later cannot reach a filename.
+        # `minor` is included because it is identity-bearing everywhere else —
+        # Code#== compares it, Code#to_s renders it and the URN carries it — so
+        # omitting it here would let two distinct documents share one filename.
+        # No fixture populates it today; it is in the grammar, so it is here.
+        def mr_number_with_part
+          return nil if number.nil?
+
+          mr_sanitize([number, minor, *Array(parts)].compact.join("-"))
+        end
+
+        # ETSI's identity is type + code + version + date (see
+        # Pubid::Etsi::Identifier#==), so all four must reach the slug —
+        # CLAUDE.md's rule that an identity-bearing marker has to appear on
+        # every identity surface, not just in `==`. The base hooks find
+        # neither: `mr_type` reads `typed_stage` (ETSI has none) and
+        # `mr_edition` reads `edition.number` (ETSI models the edition as
+        # `version`). Without these, "ETSI EN 300 729 V6.1.1 (2000-04)",
+        # "…V7.1.1 (2000-04)" and "ETSI ETS 300 729 ed.2 (2000-04)" all share
+        # one slug — i.e. one output filename.
+        def mr_type
+          type&.to_s&.downcase
+        end
+
+        def mr_edition
+          mr_sanitize(version&.version)
+        end
+
+        # Segment sanitizer. Renderers::MrString joins SEGMENTS with ".", so a
+        # dot inside one would break that structure — hence "." is replaced
+        # here even though it is inside the renderer's overall charset (the
+        # BIPM `bipm.si-brochure.9e-v3-01.e` precedent in CLAUDE.md). Filtering
+        # by charset rather than by an enumerated escape list keeps a character
+        # introduced later from leaking into a filename.
+        #
+        # Public purely to keep this file's surface flat, next to the
+        # lutaml-invoked converters below — it has no external callers and
+        # would work as well private.
+        #
+        # The emptiness check is on the OUTPUT, not just the input: a value
+        # made entirely of characters outside the charset collapses to "-" and
+        # then to "", and an empty string is truthy in Ruby, so it would reach
+        # Renderers::MrString as a blank segment and produce a double dot in
+        # the joined slug. Unreachable from today's grammar, which only feeds
+        # digit/alnum captures here — but not structurally prevented.
+        def mr_sanitize(value)
+          return nil if value.nil? || value.to_s.empty?
+
+          sanitized = value.to_s.downcase
+            .gsub(/[^a-z0-9-]+/, "-").gsub(/\A-+|-+\z/, "")
+          sanitized.empty? ? nil : sanitized
         end
 
         # --- Version flattened to scalar version + is_edition flag ---
@@ -126,10 +209,6 @@ module Pubid
           )
         end
 
-        def code_for(model)
-          model.code ||= Pubid::Etsi::Components::Code.new
-        end
-
         def version_for(model)
           model.version ||= Pubid::Etsi::Components::Version.new
         end

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

@@ -88,6 +88,16 @@ module Pubid
           raise NotImplementedError
         end
 
+        # Make Renderers::MrString recurse into `base` instead of slugging the
+        # supplement flat. Without this the flat path reads the supplement's own
+        # `number` — its ordinal, 1 — and the base document is dropped entirely,
+        # so every "/C1" corrigendum published in one month shared the slug
+        # `etsi.1.<date>`. `to_slug` is an output FILENAME, so that is an
+        # overwrite. Same fix as ITU's AnnexOfRecommendation (see CLAUDE.md).
+        def mr_supplement_suffix
+          [supplement_notation.to_s.downcase, number].compact.join(".")
+        end
+
         def ==(other)
           return false unless other.is_a?(SupplementIdentifier)
           return false unless other.class == self.class

data/lib/pubid/etsi/parser.rb

@@ -4,7 +4,7 @@ require "parslet"
 
 module Pubid
   module Etsi
-    class Parser < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       # Basic elements
       rule(:digit) { match["0-9"] }
       rule(:digits) { digit.repeat(1) }

data/lib/pubid/etsi.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 require "lutaml/model"
 
 module Pubid

data/lib/pubid/evs/builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # Builds an EVS national adoption from the composed parse tree: the
+    # structured :adopted subtree (produced by the embedded CEN grammar) goes
+    # straight to the CEN/CENELEC builder as data — no string
+    # re-serialization anywhere.
+    class Builder < Pubid::Builder::Base
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        data = flatten_array(data) if data.is_a?(Array)
+
+        adopted = Pubid::CenCenelec::Builder.build(data[:adopted])
+
+        Identifiers::NationalAdoption.new(
+          adopted_identifier: adopted,
+          separator: data[:evs_separator] || "-",
+        )
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifier.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # An EVS national adoption wraps a CEN identifier the same way BSI's
+    # AdoptedEuropeanNorm does — polymorphic `adopted_identifier` so the
+    # wrapped object stays a real Pubid::CenCenelec identifier.
+    #
+    # Examples:
+    #   "EVS-EN 18216:2026"           (adopted_identifier: EN 18216:2026)
+    #   "EVS-EN ISO 14001:2026"       (adopted_identifier: EN ISO 14001:2026)
+    #   "EVS-EN ISO/IEC 27017:2026"   (adopted_identifier: EN ISO/IEC 27017:2026)
+    #   "EVS-EN ISO 9001:2015/A1:2024" (adopted_identifier: EN ISO 9001:2015/A1:2024)
+    class Identifier < ::Pubid::Identifier
+      attribute :adopted_identifier, ::Pubid::Identifier, polymorphic: true
+      # "-" or " " — preserves the printed separator ("EVS-EN" vs "EVS EN")
+      attribute :separator, :string, default: -> { "-" }
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      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
+
+        Pubid::Evs.parse(string)
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifiers/national_adoption.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    module Identifiers
+      # The EVS national adoption of a European Standard.
+      # Example: "EVS-EN 18216:2026"
+      class NationalAdoption < ::Pubid::Evs::Identifier
+        attribute :type, Components::Type, default: -> { self.class.type[:key] }
+
+        def self.type
+          { key: :evs_en, title: "EVS National Adoption of a European Standard" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/evs/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    module Identifiers
+      autoload :NationalAdoption, "#{__dir__}/identifiers/national_adoption"
+    end
+  end
+end

data/lib/pubid/evs/parser.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Evs
+    # Grammar for the printed EVS national-adoption reference, composed with
+    # the CEN/CENELEC parser as an embedded atom (the same pattern ISO uses
+    # for IDF joint identifiers, and IEEE for AIEE/IRE/NESC):
+    #
+    #   "EVS" ("-" | " ") <CEN identifier>
+    #
+    # The adopted portion is parsed by the real CEN grammar — publisher,
+    # adopted org, number, parts, year, supplements, edition — and captured
+    # as a structured :adopted subtree for the CEN builder.
+    #
+    #   "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
+    end
+  end
+end

data/lib/pubid/evs/renderer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # Human-readable renderer for EVS identifiers.
+    #
+    # Produces strings like:
+    #   "EVS-EN 18216:2026"
+    #   "EVS-EN ISO 14001:2026"
+    #   "EVS-EN ISO/IEC 27017:2026"
+    #   "EVS-EN ISO 9001:2015/A1:2024"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        # The adopted identifier renders with its own "EN …" prefix, so the
+        # national prefix composes as "EVS" + separator + adopted.
+        "EVS#{separator}#{adopted}"
+      end
+
+      private
+
+      def separator
+        @id.separator || "-"
+      end
+
+      def adopted
+        @id.adopted_identifier.to_s
+      end
+    end
+  end
+end

data/lib/pubid/evs/urn_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # URNs mirror the CEN adoption namespace with the national-body prefix:
+    #
+    #   "EVS-EN 18216:2026"            → urn:evs:en:18216:2026
+    #   "EVS-EN ISO 14001:2026"        → urn:evs:en:iso:14001:2026
+    #   "EVS-EN ISO/IEC 27017:2026"    → urn:evs:en:iso-iec:27017:2026
+    #   "EVS-EN ISO 9001:2015/A1:2024" → urn:evs:en:iso:9001:2015:amd:1:2024
+    #
+    # Generation delegates to the adopted CEN identifier's URN and swaps the
+    # `urn:cen:` namespace for `urn:evs:`, so the two stay consistent by
+    # construction.
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      CEN_NAMESPACE = "urn:cen:"
+      EVS_NAMESPACE = "urn:evs:"
+
+      def generate
+        adopted_urn = identifier.adopted_identifier.to_urn
+        unless adopted_urn.start_with?(CEN_NAMESPACE)
+          raise Errors::ParseError,
+                "expected adopted CEN URN, got #{adopted_urn.inspect}"
+        end
+
+        adopted_urn.sub(/\A#{Regexp.escape(CEN_NAMESPACE)}/o, EVS_NAMESPACE)
+      end
+    end
+  end
+end

data/lib/pubid/evs/urn_parser.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Evs
+    # Parses `urn:evs:…` URNs back into identifiers, following the same
+    # pattern as Pubid::CenCenelec::UrnParser: reassemble the adopted
+    # identifier's human text and delegate to the real grammar so every
+    # structural check happens in parsers, not in this class.
+    #
+    #   urn:evs:en:18216:2026                → EVS-EN 18216:2026
+    #   urn:evs:en:iso:14001:2026            → EVS-EN ISO 14001:2026
+    #   urn:evs:en:iso-iec:27017:2026        → EVS-EN ISO/IEC 27017:2026
+    #   urn:evs:en:iso:9001:2015:amd:1:2024  → EVS-EN ISO 9001:2015/A1:2024
+    class UrnParser < Pubid::UrnParser::Base
+      ORGS = {
+        "iso" => "ISO",
+        "iso-iec" => "ISO/IEC",
+        "iec" => "IEC",
+        "cispr" => "CISPR",
+      }.freeze
+
+      # UrnGenerator emits "urn:evs:" (national-body namespace).
+      def flavor_name
+        "evs"
+      end
+
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+
+        type = parts.shift
+        unless /\Aen\z/i.match?(type)
+          raise Errors::ParseError, "unsupported type in #{urn.inspect}"
+        end
+
+        text = +"EN"
+        org_parts = []
+        org_parts << parts.shift while parts.first&.match?(/\A[a-z][a-z-]*\z/)
+        if org_parts.any?
+          org = ORGS.fetch(org_parts.join("-")) do
+            raise Errors::ParseError, "unknown adopted org in #{urn.inspect}"
+          end
+          text << " #{org}"
+        end
+
+        number = parts.shift
+        year = parts.shift
+        unless number
+          raise Errors::ParseError, 
+                "missing number in #{urn.inspect}"
+        end
+
+        text << " #{number}"
+        text << ":#{year}" if year
+
+        append_supplement(text, parts, urn) unless parts.empty?
+
+        adopted = Pubid::CenCenelec.parse(text)
+        ::Pubid::Evs::Identifiers::NationalAdoption.new(
+          adopted_identifier: adopted,
+        )
+      end
+
+      private
+
+      # Appends the trailing `amd|cor : iteration [: year]` in human form.
+      def append_supplement(text, parts, urn)
+        year = parts.last&.match?(/\A\d{4}\z/) ? parts.pop : nil
+        kind = parts.shift
+        iteration = parts.shift
+        unless %w[amd cor].include?(kind) && iteration && parts.empty?
+          raise Errors::ParseError, "malformed supplement in #{urn.inspect}"
+        end
+
+        text << (kind == "amd" ? "/A#{iteration}" : "/AC#{iteration}")
+        text << ":#{year}" if year
+        text
+      end
+    end
+  end
+end

data/lib/pubid/evs.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "pubid"
+module Pubid
+  module Evs
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed EVS reference can start with, drawn from the
+    # reference PDFs in metanorma/mn-samples-evs-private. Longest first so
+    # prefix routing picks the most specific claim. Deliberately EXCLUDES the
+    # bare adopted forms ("EN …" alone routes to Pubid::CenCenelec).
+    PREFIXES = [
+      "EVS-EN ISO/IEC", "EVS-EN ISO", "EVS-EN",
+      "EVS EN ISO/IEC", "EVS EN ISO", "EVS EN",
+      "EVS"
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/evs/builder"
+    autoload :Identifier, "#{__dir__}/evs/identifier"
+    autoload :Identifiers, "#{__dir__}/evs/identifiers"
+    autoload :Parser, "#{__dir__}/evs/parser"
+    autoload :Renderer, "#{__dir__}/evs/renderer"
+    autoload :UrnGenerator, "#{__dir__}/evs/urn_generator"
+    autoload :UrnParser, "#{__dir__}/evs/urn_parser"
+
+    def self.parse(identifier)
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      parsed = Parser.new.parse(identifier)
+      Builder.new.build(parsed)
+    end
+
+    # Build an EVS identifier from a parse-tree hash.
+    # @param hash [Hash] parse tree
+    # @return [Pubid::Evs::Identifier]
+    def self.build_from_parse(hash)
+      Builder.new.build(hash)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human.
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Evs::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants.filter_map do |c|
+        begin
+          Identifiers.const_get(c)
+        rescue NameError
+          nil
+        end
+      end
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # EVS identifiers have no typed stages.
+    # @return [Array<Pubid::Components::TypedStage>]
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol]
+    # @return [Class, nil]
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param _abbr [String, Symbol]
+    # @return [nil] EVS identifiers have no typed stages
+    def self.locate_stage(_abbr)
+      nil
+    end
+  end
+end
+
+# Register EVS flavor with the registry
+Pubid::Registry.register(:evs, Pubid::Evs)

data/lib/pubid/export.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module Export
     autoload :IdentifierTypeResult, "#{__dir__}/export/result"

data/lib/pubid/format_detector.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   module FormatDetector
     URN_PATTERN = /\Aurn:/i

data/lib/pubid/gb/identifier.rb

@@ -50,14 +50,17 @@ module Pubid
       # @param identifier [String]
       # @return [Pubid::Gb::Identifier]
       def self.parse(identifier)
+        unless identifier.is_a?(String)
+          raise Pubid::Errors::InvalidInputError,
+                Pubid::INPUT_NOT_A_STRING_MESSAGE
+        end
+
         if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
         parsed = Parser.parse(identifier)
         Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse Chinese Standard identifier '#{identifier}': #{e.message}"
       end
     end
   end

data/lib/pubid/gb/parser.rb

@@ -14,7 +14,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 < Parslet::Parser
+    class Parser < ::Pubid::Parser::Grammar
       rule(:space)  { str(" ") }
       rule(:dot)    { str(".") }
       rule(:dash)   { str("-") | str("—") }

data/lib/pubid/gb.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pubid"
 module Pubid
   # Chinese Standard (GB) flavor.
   #