pubid 2.0.1 → 2.0.3

data/lib/pubid/iala/builder.rb

@@ -2,20 +2,20 @@
 
 module Pubid
   module Iala
-    # Builds an IALA identifier object from the Parslet parse tree.
+    # Builds an IALA identifier object from the artifact's bound map —
+    # the flat attribute hash the grammar's bindings block declares
+    # (typed at the engine, one key per capture).
     class Builder
       def build(parsed)
-        hash = parsed
+        return build_annex(parsed) if parsed[:annex_marker]
 
-        return build_annex(hash) if hash[:annex_marker]
-
-        type_letter = stringify(hash[:type_letter])&.upcase
+        type_letter = stringify(parsed[:type_letter])&.upcase
         klass = Iala.identifier_klass_for_type_letter(type_letter)
 
         attrs = {
-          number:   build_number(hash, klass),
-          edition:  stringify(hash.dig(:edition, :edition_value)),
-          language: stringify(hash.dig(:language_group, :language))&.upcase,
+          number: build_number(parsed, klass),
+          edition: stringify(parsed[:edition_value]),
+          language: stringify(parsed[:language])&.upcase,
         }.compact
 
         klass.new(**attrs)
@@ -27,31 +27,34 @@ module Pubid
 
       private
 
-      # Build the Annex wrapper from the parse tree. The base sub-tree
-      # (captured under :base) is recursively built via the same logic as
-      # a flat identifier, then wrapped.
+      # Build the Annex wrapper from the bound map. The base composite in
+      # the grammar stays unbound: its captures (type_letter, doc_number,
+      # …) are the only occurrence of each name on the annex path, so the
+      # harvest hoists them to the top level and this branch reads the
+      # same flat keys as the plain identifier.
       def build_annex(hash)
-        base_hash = hash[:base]
-        base_type = stringify(base_hash[:type_letter])&.upcase
+        base_type = stringify(hash[:type_letter])&.upcase
         base_klass = Iala.identifier_klass_for_type_letter(base_type)
-        base = base_klass.new(number: build_number(base_hash, base_klass))
+        base = base_klass.new(number: build_number(hash, base_klass))
 
         attrs = {
           base: base,
-          annex_form:      stringify(hash[:annex_marker]),
-          letter:          stringify(hash[:annex_letter]),
-          edition:         stringify(hash.dig(:edition, :edition_value)),
-          language:        stringify(hash.dig(:language_group, :language))&.upcase,
+          annex_form: stringify(hash[:annex_marker]),
+          letter: stringify(hash[:annex_letter]),
+          edition: stringify(hash[:edition_value]),
+          language: stringify(hash[:language])&.upcase,
         }.compact
 
         Identifiers::Annex.new(**attrs)
       end
 
-      # Compose the full number string from the leading doc_number plus any
-      # dotted continuation (GA01.13 → "01.13", L2.1.11 → "2.1.11") plus
-      # the optional dash-separated subpart (C0103-1 → "0103-1", L2.7.1-2
-      # → "2.7.1-2"). Padding is class-driven: the resolved identifier
-      # class declares its canonical IALA cover-page widths via
+      # Compose the full number string from the bound map's three number
+      # columns: the leading doc_number, the dotted continuation segments
+      # (doc_number_dots, each `{dotted_segment: "01"}`) and the dash
+      # subpart runs (subpart, each `{subpart_number: "1"}`). GA01.13 →
+      # "01.13", L2.1.11 → "2.1.11", C0103-1 → "0103-1", L2.7.1-2 →
+      # "2.7.1-2". Padding is class-driven: the resolved identifier class
+      # declares its canonical IALA cover-page widths via
       # `canonical_number_width` / `canonical_dotted_segment_width`, so a
       # new type declares its padding on its own class instead of editing
       # this builder's case statement.
@@ -61,34 +64,40 @@ module Pubid
 
         base = canonical_base(base, klass)
 
-        dots = hash[:doc_number_dots]
-        dots_str = dots.is_a?(Array) ? "" : canonical_dots(stringify(dots).to_s, klass)
+        dots = canonical_dots(
+          number_segments(hash[:doc_number_dots], :dotted_segment), klass
+        )
+        dots_str = dots.empty? ? "" : ".#{dots}"
+
+        subparts = number_segments(hash[:subpart], :subpart_number)
+        subpart_str = subparts.empty? ? "" : "-#{subparts.join('-')}"
 
-        subpart_str = hash[:subpart] ? "-#{subpart_to_s(hash[:subpart])}" : ""
-        subpart_str = "" if subpart_str == "-"
         "#{base}#{dots_str}#{subpart_str}"
       end
 
+      # The string values of a bound repetition column: doc_number_dots
+      # carries `{dotted_segment: …}` elements, subpart carries
+      # `{subpart_number: …}` elements.
+      def number_segments(column, key)
+        Array(column).filter_map do |element|
+          stringify(element[key]) if element.is_a?(Hash)
+        end
+      end
+
       def canonical_base(base, klass)
         width = klass&.canonical_number_width
         width ? base.rjust(width, "0") : base
       end
 
-      def canonical_dots(str, klass)
-        return "" if str.empty?
+      # Pad each dotted continuation segment to the class's canonical
+      # width; nil width preserves the segments verbatim (the L series).
+      def canonical_dots(segments, klass)
+        return "" if segments.empty?
 
         width = klass&.canonical_dotted_segment_width
-        return str unless width
-
-        str.split(".", -1).map { |seg| seg.empty? ? seg : seg.rjust(width, "0") }.join(".")
-      end
-
-      # The subpart capture may be an array of {subpart_number: "1"},
-      # {subpart_number: "9"}, … (repeated matches). Join with "-".
-      def subpart_to_s(subpart)
-        return stringify(subpart).to_s unless subpart.is_a?(Array)
+        return segments.join(".") unless width
 
-        subpart.filter_map { |h| h.is_a?(Hash) ? stringify(h[:subpart_number]) : nil }.join("-")
+        segments.map { |segment| segment.rjust(width, "0") }.join(".")
       end
 
       def stringify(value)

data/lib/pubid/iala/identifier.rb

@@ -33,7 +33,7 @@ module Pubid
         if FormatDetector.detect(identifier) == :urn
           UrnParser.parse(identifier)
         else
-          parsed = Pubid::Parg::Backend.parse(:iala, identifier)
+          parsed = Pubid::Parg::Model.bound(:iala, identifier)
           Builder.build(parsed)
         end
       end

data/lib/pubid/iala/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Iala
-    # Parslet grammar for IALA identifiers.
+    # Grammar for IALA identifiers.
     #
     # Accepts every shape that appears on the IALA website or cover page:
     #
@@ -15,124 +13,7 @@ module Pubid
     #   R1016:ed2.0(F)
     #   C0103-1
     #   C0103-1 Ed 3.0
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-
-      root :identifier
-
-      rule(:space)  { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:dash)   { str("-") }
-      rule(:colon)  { str(":") }
-      rule(:dot)    { str(".") }
-      rule(:lparen) { str("(") }
-      rule(:rparen) { str(")") }
-
-      # Type prefix — IALA document classes. GA must be tried before G so it
-      # isn't left with a dangling "A". Captured to route to the right
-      # Identifiers::* subclass.
-      rule(:type_letter) do
-        (str("GA") | str("S") | str("R") | str("G") | str("M") |
-         str("C") | str("A") | str("L") | str("X") | str("P")).as(:type_letter)
-      end
-
-      # Document number — one or more decimal digits. The dataset historically
-      # zero-pads to 4 (S1070, R0126, M0001) but the canonical form going
-      # forward is unpadded (M1, GA1.1). Accept any length so both shapes
-      # round-trip; the number attribute preserves whatever was parsed.
-      rule(:doc_number) do
-        match("[0-9]").repeat(1).as(:doc_number)
-      end
-
-      # Dotted continuation that some prefixes use as part of the number:
-      # GA01.01 (series.index), L2.1.11 (series.sub.item). Captured into the
-      # same :doc_number atom so the number attribute stays a single string
-      # (e.g. "01.01", "2.1.11") and the existing builder needs no changes.
-      rule(:dotted_number) do
-        dot >> match("[0-9]").repeat(1)
-      end
-
-      rule(:number_with_dots) do
-        doc_number >> dotted_number.repeat.as(:doc_number_dots)
-      end
-
-      # Numeric sub-part suffix(es): "-1", "-9-10", "-11". The catalogue
-      # uses ranges like R0124-9-10 & 11 — that compound is captured
-      # verbatim and resolved by the caller, not here.
-      rule(:subpart) do
-        (dash >> digits.as(:subpart_number)).repeat(1).as(:subpart)
-      end
-
-      rule(:code) do
-        type_letter >> number_with_dots >> subpart.maybe
-      end
-
-      # Edition forms observed on covers and listing pages:
-      #   " Ed 2.0"      — cover-page human form
-      #   ":ed2.0"       — listing-page compact form
-      rule(:edition_human) do
-        (space >> str("Ed") >> space >> edition_value).as(:edition)
-      end
-
-      rule(:edition_compact) do
-        (colon >> str("ed") >> edition_value).as(:edition)
-      end
-
-      rule(:edition_value) do
-        (digits >> (dot >> digits).repeat).as(:edition_value)
-      end
-
-      rule(:edition) do
-        edition_human | edition_compact
-      end
-
-      # Language is a single uppercase letter inside parens: (E), (F), …
-      rule(:language) do
-        (space? >> lparen >>
-          (str("E") | str("F") | str("S") | str("C") | str("A") | str("R")).as(:language) >>
-          rparen).as(:language_group)
-      end
-
-      # Optional "IALA " prefix.
-      rule(:publisher) do
-        (str("IALA") >> space).maybe
-      end
-
-      rule(:identifier) do
-        annex_identifier | (publisher >> code >> edition.maybe >> language.maybe)
-      end
-
-      # Annex to a base publication. Wraps the base code and adds an
-      # "Annex" / "ANNEX" marker (case preserved verbatim), an optional
-      # single-letter suffix (A/B/C/D), then the usual edition + language.
-      # Tried before the flat `identifier` so the annex marker isn't left
-      # dangling after a successful base-code match.
-      #
-      # The letter suffix uses a negative lookahead for a following lowercase
-      # letter so the "E" in "Ed 1" isn't mis-captured as annex letter "E".
-      rule(:annex_identifier) do
-        (publisher >> type_letter >> number_with_dots >> subpart.maybe).as(:base) >>
-          space >> (str("Annex") | str("ANNEX")).as(:annex_marker) >>
-          (space >> match("[A-Z]").as(:annex_letter) >> match("[a-z]").absent?).maybe >>
-          edition.maybe >> language.maybe
-      end
-
-      # Parse a string and return the raw parslet tree.
-      # @param string [String]
-      # @return [Hash]
-      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(string.strip)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/iana/identifier.rb

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

data/lib/pubid/iana/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Iana
-    # Parslet grammar for IANA registry identifiers.
+    # Grammar for IANA registry identifiers.
     #
     # Accepts the authoritative printed form "IANA <slug>[/<sub-slug>]" as well
     # as a bare index-key slug (no "IANA " prefix). The optional prefix is
@@ -12,27 +10,7 @@ module Pubid
     #
     # Slugs use only [a-zA-Z0-9._-] and contain at most one "/", so a plain
     # character-class repeat parses them; there is no ReDoS surface.
-    class Parser < ::Pubid::Parser::Grammar
-      # A single registry slug: letters, digits, dot, underscore, hyphen.
-      rule(:slug) { match['a-zA-Z0-9._\-'].repeat(1) }
-
-      # Optional publisher prefix. The trailing space is required, so a
-      # space-free slug never triggers it; PEG `.maybe` backtracks the whole
-      # sequence if the space is absent (e.g. a slug that happens to start
-      # "IANA...").
-      rule(:iana_prefix) { (str("IANA") >> str(" ")).maybe }
-
-      rule(:identifier) do
-        iana_prefix >>
-          slug.as(:registry) >>
-          (str("/") >> slug.as(:sub_registry)).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/identifier.rb

@@ -817,14 +817,86 @@ module Pubid
       # consumed by the renderer, not the rendering context — and some flavors
       # override build_rendering_context with a strict signature, so strip them
       # here rather than widening that signature.
-      ctx_opts = opts.except(:trademark, :with_volume)
+      # `:with_publisher` is a render-time flag too. It reaches the renderer
+      # only for the human format and only when given, so a renderer that
+      # reads it (BIPM, NIST) sees it and the default call is unchanged.
+      with_publisher = opts[:with_publisher]
+      ctx_opts = opts.except(:trademark, :with_volume, :with_publisher)
       context = build_rendering_context(renderer, format:, **ctx_opts)
       render_opts = opts.slice(:with_edition, :trademark, :with_volume)
+      if format == :human && !with_publisher.nil?
+        render_opts[:with_publisher] = with_publisher
+      end
       result = renderer.new(self).render(context:, **render_opts)
+      result = apply_with_publisher(result, format, with_publisher)
 
       annotate_rendered(result, format, ctx_opts[:annotated], context)
     end
 
+    # The publisher tokens this identifier's human rendering can start with,
+    # for `to_s(with_publisher: false)` ({Renderers::PublisherStripper}).
+    #
+    # The default is the rendered publisher, and the publisher joined by `/`
+    # to its copublishers in either order, so a co-published `ISO/IEC 27001`
+    # or `ANSI/AMCA 210-16` drops the whole group. Copublishers come from the
+    # shared `copublishers` collection or from a flavor's own `copublisher`
+    # (a String or an Array of them: AMCA, ASHRAE, IEEE). A wrapper with no
+    # publisher of its own prints the document it wraps, so it asks `base`.
+    #
+    # A flavor overrides this where the generic answer is wrong: where the
+    # leading token is a series that belongs to the designation (`BS 8611`,
+    # `GB/T 20223`, `ECMA-262`), the answer is `[]`; where the publisher is
+    # welded to another token (`ITU-T`), the answer is the welded group.
+    #
+    # @return [Array<String>]
+    def publisher_prefixes
+      pubs = publisher_texts(:publisher)
+      copubs = publisher_texts(:copublishers) + publisher_texts(:copublisher)
+      # A supplement can name its own publisher while the co-published group
+      # lives on the document it supplements, so `base` is always asked too.
+      # The stripper tries the longest prefix first, so order does not matter.
+      publisher_groups(pubs, copubs) + base_publisher_prefixes
+    end
+
+    # Each publisher alone, and the `/`-joined group in either order.
+    def publisher_groups(pubs, copubs)
+      return pubs + copubs if pubs.empty? || copubs.empty?
+
+      [[*pubs, *copubs].join("/"), [*copubs, *pubs].join("/"), *pubs, *copubs]
+    end
+    private :publisher_groups
+
+    # The printed form of a publisher-like attribute: a component, a String,
+    # or an Array of either (IEEE `DualPublished` returns an Array).
+    def publisher_texts(name)
+      return [] unless respond_to?(name)
+
+      value = public_send(name)
+      values = value.is_a?(Array) ? value : [value]
+      values.compact.map { |v| v.to_s.strip }.reject(&:empty?)
+    end
+    private :publisher_texts
+
+    def base_publisher_prefixes
+      nested = respond_to?(:base) ? base : nil
+      return [] unless nested.is_a?(::Pubid::Identifier) && !nested.equal?(self)
+
+      nested.publisher_prefixes
+    end
+    private :base_publisher_prefixes
+
+    # `with_publisher: false` on the human format drops the leading publisher
+    # token. Every other value, and every other format, leaves the string as
+    # the renderer produced it — `true` is the default rendering for every
+    # flavor whose default carries the prefix, and a flavor whose default
+    # omits it (3GPP, OGC, IETF) handles `true` itself.
+    def apply_with_publisher(result, format, with_publisher)
+      return result unless with_publisher == false && format == :human
+
+      Renderers::PublisherStripper.new(self).strip(result)
+    end
+    private :apply_with_publisher
+
     # Apply semantic spans when the renderer did not.
     #
     # `context.annotated` reaches all 39 flavor renderers and all 39 ignore it,
@@ -867,7 +939,12 @@ module Pubid
     # @param rendered [String] the plain rendering this method produced
     # @param opts [Hash] the render options it was called with
     # @return [String] annotated when `annotated:` was asked for, else as-is
+    #
+    # `with_publisher: false` is applied here too, before the annotation, so a
+    # hand-composed `to_s` drops its publisher token the same way {#render}
+    # does.
     def annotate_plain_render(rendered, **opts)
+      rendered = apply_with_publisher(rendered, :human, opts[:with_publisher])
       annotate_rendered(rendered, :human, opts[:annotated], nil)
     end
     protected :annotate_plain_render

data/lib/pubid/idf/builder.rb

@@ -13,6 +13,12 @@ module Pubid
       }.freeze
 
       def build(parsed_hash)
+        parsed_hash = split_supplement_base(parsed_hash)
+        # The Parslet tree carried a zero-width type_with_stage (an empty
+        # capture when no type is spelled) whose cast drove the default
+        # stage; the artifact tree omits the key entirely — restore the
+        # default input.
+        parsed_hash[:type_with_stage] ||= ""
         all_parts = parsed_hash.delete(:all_parts)
         typed_stage = Pubid::Idf.locate_stage(parsed_hash[:type_with_stage])
         identifier = Pubid::Idf.locate_type(typed_stage.type_code).new
@@ -32,8 +38,44 @@ module Pubid
         all_parts ? identifier.to_all_parts : identifier
       end
 
+      # The bound grammar flattens the supplement's base wrapper (the
+      # bindings cannot nest): the supplement layer keeps the canonical
+      # number_with_part/date/type_with_stage captures and the base
+      # portion captures under base_* names. Rebuild the nested shape
+      # the builder has always consumed — the base_* keys rename onto
+      # their canonical counterparts and the shared publisher capture
+      # belongs to the base (the tree backend captured it inside the
+      # base subtree, so the supplement itself carries no publisher).
+      BASE_KEY_MAP = {
+        base_number_with_part: :number_with_part,
+        base_date: :date,
+        base_type_with_stage: :type_with_stage,
+        base_stage_iteration: :stage_iteration,
+      }.freeze
+
       private
 
+      def split_supplement_base(parsed_hash)
+        unless BASE_KEY_MAP.keys.any? { |k| parsed_hash.key?(k) }
+          return parsed_hash
+        end
+
+        base_hash = {}
+        BASE_KEY_MAP.each do |bound_key, tree_key|
+          next unless parsed_hash.key?(bound_key)
+
+          base_hash[tree_key] = parsed_hash.delete(bound_key)
+        end
+        if parsed_hash[:publisher]
+          base_hash[:publisher] = parsed_hash.delete(:publisher)
+        end
+        # Keep the base as a raw hash: the shared assign_attributes loop
+        # routes :base through cast, which recursively builds it — the
+        # same path the tree backend's nested subtree took.
+        parsed_hash[:base] = base_hash
+        parsed_hash
+      end
+
       def default_identifier_class
         Identifiers::InternationalStandard
       end

data/lib/pubid/idf/identifier.rb

@@ -83,7 +83,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Idf::Parser.new.parse(string)
+        parsed = Pubid::Parg::Model.bound(:idf, string)
         Pubid::Idf::Builder.new.build(parsed)
       end
     end

data/lib/pubid/idf/parser.rb

@@ -1,144 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Idf
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-      include ::Pubid::Parser::CommonParseMethods
-
-      # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Idf.all_typed_stages
-        .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Idf.all_typed_stages
-        .select { |ts| %w[amd cor].include?(ts.type_code.to_s) }
-        .map(&:abbr).flatten.sort_by(&:length).reverse
-
-      root :identifier
-
-      rule(:identifier) do
-        supplement_identifier |
-          identifier_publisher
-      end
-
-      # IDF 125A:1988
-      rule(:prefix_sole_publisher) do
-        str("IDF").as(:publisher)
-      end
-
-      rule(:number_with_part) do
-        (number >> part_and_subpart.maybe).as(:number_with_part)
-      end
-
-      # IDF identifiers can contain alphanumeric characters
-      # IDF 125A:1988
-      rule(:number) do
-        match('\w').repeat(1, 5)
-      end
-
-      rule(:date) do
-        (year_digits >>
-          (dash >> month_digits).maybe >>
-          (dash >> day_digits).maybe
-        ).as(:date)
-      end
-
-      rule(:part_and_subpart) do
-        # IDF 80-1:2001
-        # the "space?" needed to handle "ISO/TS 10303- 1751:2014"
-        dash >> space? >>
-          # matches a part
-          match('\w').repeat >>
-          # matches a subpart, e.g. "A01" or "1-2" (yes we treat {5}-{1-1} as part and subpart)
-          (dash >> match('\w').repeat).repeat.maybe
-      end
-
-      rule(:all_parts) do
-        str("(all parts)").as(:all_parts)
-      end
-
-      rule(:type_with_stage) do
-        # IDF/RM 82:2004
-        # IDF/RM 254:2022
-        array_to_str(TYPED_STAGES).as(:type_with_stage) >>
-          (match('\d').as(:stage_iteration) >> space).maybe
-      end
-
-      rule(:language) do
-        # IDF/RM 82:2004(en,fr)
-        str("(") >>
-          (
-            # parse 2-char language codes: ru,en,fr,de,ar,es
-            (match["a-z"].repeat(1) >> str(",").maybe) |
-            # parse single language codes: R/E/F
-            (match["EFARDS"] >> str("/").maybe)
-          ).repeat.as(:languages) >>
-          str(")")
-      end
-
-      rule(:stage_iteration) do
-        # "ISO 11243.1"
-        str(".") >> match('\d').as(:stage_iteration)
-      end
-
-      rule(:second_part) do
-        number_with_part >>
-          stage_iteration.maybe >>
-          space? >> (
-            # :2005-02
-            str(":") >> date
-          ).maybe
-      end
-
-      rule(:third_part) do
-        # End of the identifier, we can have language, or all parts
-        space? >> language.maybe >> all_parts.maybe
-      end
-
-      # prefix sole publishers with type and stage
-      # IDF/RM 82:2004
-      rule(:identifier_publisher) do
-        identifier_publisher_no_third >> third_part
-      end
-
-      rule(:identifier_publisher_no_third) do
-        prefix_sole_publisher >> space? >> str("/").maybe >>
-          type_with_stage.maybe >>
-          space.maybe >>
-          second_part
-      end
-
-      rule(:supplement_type_with_stage) do
-        # "AMD" or "COR"
-        array_to_str(TYPED_STAGES_SUPPLEMENTS).as(:type_with_stage)
-      end
-
-      # IDF 148-1:2008 / COR 1:2009
-      # IDF 140-1:2007 / AMD1:2012 (no space between AMD and 1)
-      rule(:supplement_identifier_no_third) do
-        identifier_publisher_no_third.as(:base) >>
-          space? >> str("/") >> space? >>
-          supplement_type_with_stage >>
-          space.maybe >> second_part
-      end
-
-      rule(:supplement_identifier) do
-        supplement_identifier_no_third >> third_part
-      end
-
-      # # ISO/IEC 13818-1:2015/Amd 3:2016/Cor 1:2017
-      # # ISO/IEC 19794-7:2014/Amd 1:2015/CD Cor 1
-      # rule(:supplement_supplement_identifier) do
-      #   supplement_identifier_no_third.as(:base) >>
-      #     str("/") >> supplement_type_with_stage >>
-      #     # digits.as(:stage_iteration).maybe >>
-      #     space? >> second_part >> third_part
-      # end
-
-      rule(:dash) do
-        str("-") | str("‑") | str("‐")
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/idf.rb

@@ -28,10 +28,9 @@ module Pubid
         raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
       end
 
-      parser = Parser.new
       builder = Builder.new
 
-      parsed = parser.parse(identifier)
+      parsed = Pubid::Parg::Model.bound(:idf, identifier)
       builder.build(parsed)
     end