pubid 2.0.1 → 2.0.3

data/data/parg/tgpp.json

@@ -1 +1 @@
-{"bindings":null,"version":"0.1.0","grammar":"PubidTgpp","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"3GPP "}},{"Repetition":{"atom":0,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":6}},{"Str":{"pattern":"TR"}},{"Str":{"pattern":"TS"}},{"Alternative":{"atoms":[3,4]}},{"Named":{"name":"type","atom":5}},{"Entity":{"atom":8}},{"Str":{"pattern":" "}},{"Entity":{"atom":17}},{"Entity":{"atom":11}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":10,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Repetition":{"atom":14,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[12,13,15]}},{"Named":{"name":"number","atom":16}},{"Entity":{"atom":24}},{"Entity":{"atom":22}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Alternative":{"atoms":[20,21]}},{"Repetition":{"atom":19,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"suffix","atom":23}},{"Repetition":{"atom":18,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":34}},{"Entity":{"atom":32}},{"Str":{"pattern":"-"}},{"Entity":{"atom":11}},{"Repetition":{"atom":29,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"part","atom":30}},{"Sequence":{"atoms":[28,31]}},{"Repetition":{"atom":27,"min":0,"max":null,"tag":"Repetition"}},{"Named":{"name":"parts","atom":33}},{"Entity":{"atom":36}},{"Str":{"pattern":":"}},{"Entity":{"atom":60}},{"Entity":{"atom":47}},{"Entity":{"atom":11}},{"Repetition":{"atom":39,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Repetition":{"atom":42,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Repetition":{"atom":45,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[40,41,43,44,46]}},{"Entity":{"atom":49}},{"Re":{"pattern":"[\\x01-\\u{10ffff}]"}},{"Lookahead":{"atom":48,"positive":false}},{"Sequence":{"atoms":[38,50]}},{"Lookahead":{"atom":51,"positive":false}},{"Entity":{"atom":57}},{"Re":{"pattern":"[\\x01-\\x2e]"}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Re":{"pattern":"[\\x3b-\\u{10ffff}]"}},{"Alternative":{"atoms":[54,55,56]}},{"Repetition":{"atom":53,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"release","atom":58}},{"Sequence":{"atoms":[52,59]}},{"Sequence":{"atoms":[35,37]}},{"Repetition":{"atom":61,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":64}},{"Str":{"pattern":"/"}},{"Entity":{"atom":67}},{"Entity":{"atom":47}},{"Named":{"name":"version","atom":66}},{"Sequence":{"atoms":[63,65]}},{"Repetition":{"atom":68,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[1,2,7,9,25,26,62,69]}}],"root":70},"bindings":[]}},"preprocess":{},"tables":{},"lint":{"order_warnings":["rule release_char: branches 1 and 3 are order-dependent (first set not statically known)","rule release_char: branches 2 and 3 are order-dependent (first set not statically known)"]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"3GPP TS 21.101","expect":{}},{"entry":"identifier","kind":"accept","input":"TS 25.999","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/tgpp/parser.rb:\n# [3GPP ]<TR|TS> <NN.NNN>[suffix][-part…][:<release>][/<version>]\n# The release excludes \"/\" and \":\" (match[\"^/:\"]), byte-wise here; the\n# mistyped-version guard (!version…!any) is ported literally.\n\ngrammar PubidTgpp version \"0.1.0\" mode \"v1\" {\n  release_char = %x01-2E / %x30-39 / %x3B-10FFFF\n  any_char = %x01-10FFFF\n  type = (\"TR\" / \"TS\") as type\n  number = (1*digit \".\" 1*digit) as number\n  suffix = (1*letter) as suffix\n  part = \"-\" (1*digit) as part\n  parts = (*part) as parts\n  version_core = 1*digit \".\" 1*digit \".\" 1*digit\n  release = !(version_core !any_char) (1*release_char) as release\n  version = version_core as version\n  identifier = [\"3GPP \"] type space number [suffix] parts [(colon release)] [(slash version)]\n  letter = %x41-5A / %x61-7A\n  digit = %x30-39\n  space = \" \"\n  colon = \":\"\n  slash = \"/\"\n  entry identifier: identifier\n\n  test {\n    accept \"3GPP TS 21.101\"\n    accept \"TS 25.999\"\n    reject \"nonsense\"\n  }\n}\n","source_hash":"3f3bba714488dcad3057d1a3d86f1d02b854ff34d8e2173bd0ce5b92238d034c","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.114","edition":1,"checksum":"sha256:b60ab478f1cb8cb5e5bb1d5a72f709d2de8d6bbb21d24c6cc1bc609dc45dc2e0"}
+{"bindings":null,"version":"0.1.0","grammar":"PubidTgpp","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"3GPP "}},{"Repetition":{"atom":0,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":6}},{"Str":{"pattern":"TR"}},{"Str":{"pattern":"TS"}},{"Alternative":{"atoms":[3,4]}},{"Named":{"name":"type","atom":5}},{"Entity":{"atom":8}},{"Str":{"pattern":" "}},{"Entity":{"atom":17}},{"Entity":{"atom":11}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Repetition":{"atom":10,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Repetition":{"atom":14,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[12,13,15]}},{"Named":{"name":"number","atom":16}},{"Entity":{"atom":24}},{"Entity":{"atom":22}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x61-\\x7a]"}},{"Alternative":{"atoms":[20,21]}},{"Repetition":{"atom":19,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"suffix","atom":23}},{"Repetition":{"atom":18,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":34}},{"Entity":{"atom":32}},{"Str":{"pattern":"-"}},{"Entity":{"atom":11}},{"Repetition":{"atom":29,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"part","atom":30}},{"Sequence":{"atoms":[28,31]}},{"Repetition":{"atom":27,"min":0,"max":null,"tag":"Repetition"}},{"Named":{"name":"parts","atom":33}},{"Entity":{"atom":36}},{"Str":{"pattern":":"}},{"Named":{"name":"colon","atom":35}},{"Entity":{"atom":64}},{"Entity":{"atom":51}},{"Entity":{"atom":11}},{"Named":{"name":"digit","atom":40}},{"Repetition":{"atom":41,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Named":{"name":"digit","atom":44}},{"Repetition":{"atom":45,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Named":{"name":"digit","atom":48}},{"Repetition":{"atom":49,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[42,43,46,47,50]}},{"Entity":{"atom":53}},{"Re":{"pattern":"[\\x01-\\u{10ffff}]"}},{"Lookahead":{"atom":52,"positive":false}},{"Sequence":{"atoms":[39,54]}},{"Lookahead":{"atom":55,"positive":false}},{"Entity":{"atom":61}},{"Re":{"pattern":"[\\x01-\\x2e]"}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Re":{"pattern":"[\\x3b-\\u{10ffff}]"}},{"Alternative":{"atoms":[58,59,60]}},{"Repetition":{"atom":57,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"release","atom":62}},{"Sequence":{"atoms":[56,63]}},{"Sequence":{"atoms":[37,38]}},{"Repetition":{"atom":65,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":68}},{"Str":{"pattern":"/"}},{"Named":{"name":"slash","atom":67}},{"Entity":{"atom":80}},{"Entity":{"atom":11}},{"Repetition":{"atom":71,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Repetition":{"atom":74,"min":1,"max":null,"tag":"Repetition"}},{"Str":{"pattern":"."}},{"Entity":{"atom":11}},{"Repetition":{"atom":77,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[72,73,75,76,78]}},{"Named":{"name":"version","atom":79}},{"Sequence":{"atoms":[69,70]}},{"Repetition":{"atom":81,"min":0,"max":1,"tag":"Maybe"}},{"Sequence":{"atoms":[1,2,7,9,25,26,66,82]}}],"root":83},"bindings":[{"capture":"type","path":"type","type":"string","card":null,"preprocess":null},{"capture":"number","path":"number","type":"string","card":null,"preprocess":null},{"capture":"suffix","path":"suffix","type":"string","card":null,"preprocess":null},{"capture":"part","path":"parts[].part","type":"string","card":null,"preprocess":null},{"capture":"release","path":"release","type":"string","card":null,"preprocess":null},{"capture":"version","path":"version","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":["rule release_char: branches 1 and 3 are order-dependent (first set not statically known)","rule release_char: branches 2 and 3 are order-dependent (first set not statically known)"]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"3GPP TS 21.101","expect":{}},{"entry":"identifier","kind":"accept","input":"TS 25.999","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/tgpp/parser.rb:\n# [3GPP ]<TR|TS> <NN.NNN>[suffix][-part…][:<release>][/<version>]\n# The release excludes \"/\" and \":\" (match[\"^/:\"]), byte-wise here; the\n# mistyped-version guard (!version…!any) is ported literally.\n\ngrammar PubidTgpp version \"0.1.0\" edition 2 {\n  release_char = %x01-2E / %x30-39 / %x3B-10FFFF\n  any_char = %x01-10FFFF\n  type = (\"TR\" / \"TS\") as type\n  number = (1*digit \".\" 1*digit) as number\n  suffix = (1*letter) as suffix\n  part = \"-\" (1*digit) as part\n  parts = (*part) as parts\n  version_core = 1*digit \".\" 1*digit \".\" 1*digit\n  release = !(version_core !any_char) (1*release_char) as release\n  version = (1*digit \".\" 1*digit \".\" 1*digit) as version\n  identifier = [\"3GPP \"] type space number [suffix] parts [(colon release)] [(slash version)]\n  letter = %x41-5A / %x61-7A\n  digit = %x30-39\n  space = \" \"\n  colon = \":\"\n  slash = \"/\"\n  entry identifier: identifier\n\n  bindings identifier {\n    type -> type (string)\n    number -> number (string)\n    suffix -> suffix (string)\n    part -> parts[].part (string)\n    release -> release (string)\n    version -> version (string)\n  }\n\n\n  test {\n    accept \"3GPP TS 21.101\"\n    accept \"TS 25.999\"\n    reject \"nonsense\"\n  }\n}\n","source_hash":"8208f08be56685a980b7c3adeb2a58d64b962c148028fe676b3e00eede72f13a","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.114","edition":2,"checksum":"sha256:9bdb1d70089ba09ad10fcf091475fb938c7570282c26a20652df304e7f9693af"}

data/data/parg/un.json

@@ -1 +1 @@
-{"bindings":null,"version":"0.1.0","grammar":"PubidUn","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"UN "}},{"Repetition":{"atom":0,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":9}},{"Entity":{"atom":7}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Re":{"pattern":"[.]"}},{"Alternative":{"atoms":[4,5,6]}},{"Repetition":{"atom":3,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"token","atom":8}},{"Entity":{"atom":11}},{"Str":{"pattern":"/"}},{"Entity":{"atom":9}},{"Sequence":{"atoms":[10,12]}},{"Repetition":{"atom":13,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[1,2,14]}}],"root":15},"bindings":[]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"UN/CEFACT/TBG14","expect":{}},{"entry":"identifier","kind":"accept","input":"CEFACT/TBG14","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/un/parser.rb. `token` matches [A-Z0-9.] runs.\n\ngrammar PubidUn version \"0.1.0\" mode \"v1\" {\n  token_char = %x41-5A / %x30-39 / %x2E\n  token = (1*token_char) as token\n  identifier = [\"UN \"] token 1*(slash token)\n  slash = \"/\"\n  entry identifier: identifier\n\n  test {\n    accept \"UN/CEFACT/TBG14\"\n    accept \"CEFACT/TBG14\"\n    reject \"nonsense\"\n  }\n}\n","source_hash":"8af25923f5616b2ebe0443dc994d305d8f4390efe46bb685d8aebf89c68c66e2","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.114","edition":1,"checksum":"sha256:634305272bf558b8cb9193a1af8e75b9cc799d75386dd4d4a53e42d4d66cce1b"}
+{"bindings":null,"version":"0.1.0","grammar":"PubidUn","shape":"parsanol-tree/v2","binding_version":1,"entries":{"identifier":{"root":"identifier","grammar":{"atoms":[{"Str":{"pattern":"UN "}},{"Repetition":{"atom":0,"min":0,"max":1,"tag":"Maybe"}},{"Entity":{"atom":8}},{"Re":{"pattern":"[\\x41-\\x5a]"}},{"Re":{"pattern":"[\\x30-\\x39]"}},{"Re":{"pattern":"[.]"}},{"Alternative":{"atoms":[3,4,5]}},{"Repetition":{"atom":6,"min":1,"max":null,"tag":"Repetition"}},{"Named":{"name":"token","atom":7}},{"Str":{"pattern":"/"}},{"Entity":{"atom":8}},{"Sequence":{"atoms":[9,10]}},{"Repetition":{"atom":11,"min":1,"max":null,"tag":"Repetition"}},{"Sequence":{"atoms":[1,2,12]}}],"root":13},"bindings":[{"capture":"token","path":"token[].token","type":"string","card":null,"preprocess":null}]}},"preprocess":{},"tables":{},"lint":{"order_warnings":[]},"default_entry":"identifier","render":{},"derive":{},"tests":[{"entry":"identifier","kind":"accept","input":"UN/CEFACT/TBG14","expect":{}},{"entry":"identifier","kind":"accept","input":"CEFACT/TBG14","expect":{}},{"entry":"identifier","kind":"reject","input":"nonsense","expect":{}}],"docs":{},"source":"# Port of lib/pubid/un/parser.rb. `token` matches [A-Z0-9.] runs.\n#\n# Edition-2 typed bindings: `token` repeats (one per slash-separated\n# segment) and the builder walks every occurrence as a path element, so\n# the repeats collect under token[].token — a scalar binding would keep\n# only the first segment. The separator stays a raw \"/\" literal: a\n# parenthesized slash ref materializes a {slash:} node whose presence\n# the token-walking builder would read as an empty token.\n\ngrammar PubidUn version \"0.1.0\" edition 2 {\n  token_char = %x41-5A / %x30-39 / %x2E\n  token = ( 1*(%x41-5A / %x30-39 / %x2E) ) as token\n  identifier = [\"UN \"] token 1*( \"/\" token )\n  slash = \"/\"\n\n  entry identifier: identifier\n\n  bindings identifier {\n    token -> token[].token (string)\n  }\n\n  test {\n    accept \"UN/CEFACT/TBG14\"\n    accept \"CEFACT/TBG14\"\n    reject \"nonsense\"\n  }\n}\n","source_hash":"ba53a065d999fb151e5b557dafbf245bcb4d8a6948017b198444242eee47fcfb","unicode_tables":"onigmo (Ruby 3.4.8)","compiler_version":"1.3.114","edition":2,"checksum":"sha256:a71b6cfba806bd0802198e7cacb532cbb06136a375bf937f37823f7531f0e327"}

data/lib/pubid/adobe/identifier.rb

@@ -28,7 +28,7 @@ module Pubid
         end
 
         # R1 parser swap: the baked PG artifact is the parser of record.
-        parsed = Pubid::Parg::Backend.parse(:adobe, identifier.strip)
+        parsed = Pubid::Parg::Model.bound(:adobe, identifier.strip)
         Builder.build(parsed)
       end
 

data/lib/pubid/adobe/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Adobe
-    # Parslet grammar for Adobe identifiers.
+    # Grammar for Adobe identifiers.
     #
     # Canonical citation forms (what the renderer produces):
     #
@@ -21,116 +19,7 @@ module Pubid
     #   ATN5014                        (short alias)
     #   5014                           (bare number; data-repo context)
     #   adobe-glyph-list               (bare slug)
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-
-      root :identifier
-
-      rule(:space)  { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:hash)   { str("#") }
-      rule(:dot)    { str(".") }
-      rule(:dash)   { str("-") }
-
-      # Canonical short prefix: "Adobe TN" with optional trailing space.
-      # Matches both "Adobe TN 5014" and "Adobe TN5014".
-      rule(:tech_note_tn_prefix) do
-        str("Adobe") >> space >> str("TN") >> space?.maybe
-      end
-
-      # Legacy long prefix: "Adobe Technical Note" with optional "#".
-      rule(:tech_note_long_prefix) do
-        str("Adobe") >> space >> str("Technical") >> space >> str("Note") >>
-          (space? >> hash.maybe >> space?).maybe
-      end
-
-      # Legacy short alias: "ATN" with optional trailing space.
-      rule(:tech_note_atn_prefix) do
-        str("ATN") >> space?.maybe
-      end
-
-      rule(:tech_note_prefix) do
-        tech_note_tn_prefix | tech_note_long_prefix | tech_note_atn_prefix
-      end
-
-      rule(:digits) do
-        match("[0-9]").repeat(1)
-      end
-
-      # 4-digit tech note number, optionally followed by ".<Slug>" from
-      # the filename form. The slug is captured but not required.
-      rule(:slug_chars) do
-        match("[A-Za-z0-9_]").repeat(1)
-      end
-
-      rule(:tech_note) do
-        (tech_note_prefix >>
-          digits.as(:number) >>
-          (dot >> slug_chars.as(:slug)).maybe).as(:tech_note)
-      end
-
-      # Bare number form (e.g. when the data repo passes just "5014"
-      # extracted from a filename). Not advertised in user docs; used
-      # internally by AdobeFetcher::Docid.
-      rule(:bare_number) do
-        digits.as(:number).as(:tech_note_bare)
-      end
-
-      # "Adobe Publication " prefix. Matched literally then discarded —
-      # the publication slug/version is parsed by the inner rule.
-      rule(:publication_prefix) do
-        str("Adobe") >> space >> str("Publication") >> space
-      end
-
-      # Publication slug. Lowercase ASCII letters and digits joined by `-`.
-      # Each segment starts with a letter (so a trailing `-<digits>` is
-      # unambiguously a version suffix, not part of the slug).
-      rule(:slug_segment) do
-        match("[a-z]") >> match("[a-z0-9]").repeat
-      end
-
-      rule(:slug_inner) do
-        slug_segment >> (dash >> slug_segment).repeat
-      end
-
-      rule(:publication_with_version) do
-        (slug_inner.as(:slug) >> dash >> digits.as(:version)).as(:publication_version)
-      end
-
-      rule(:publication_slug_or_version) do
-        # Try with-version first so `adobe-japan1-7` doesn't get captured
-        # as slug `adobe-japan1-7` with no version. The flat `:slug` form
-        # is the fallback for unversioned slugs.
-        publication_with_version | slug_inner.as(:slug)
-      end
-
-      rule(:publication) do
-        # Optional "Adobe Publication " prefix. The prefix is consumed
-        # but not captured — the inner rule produces :slug or
-        # :publication_version as before.
-        publication_prefix.maybe >> publication_slug_or_version
-      end
-
-      rule(:identifier) do
-        tech_note | bare_number | publication
-      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/amca/identifiers/base.rb

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

data/lib/pubid/amca/parser.rb

@@ -4,151 +4,7 @@ module Pubid
   module Amca
     # Parser class for ACMA identifiers
     # Single Responsibility: Parsing ACMA identifier syntax
-    class Parser < ::Pubid::Parser::Grammar
-      # Basic building blocks
-      rule(:space) { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:dash) { str("-") }
-      rule(:slash) { str("/") }
-      rule(:lparen) { str("(") }
-      rule(:rparen) { str(")") }
-      rule(:dot) { str(".") }
-
-      rule(:digit) { match("[0-9]") }
-      rule(:digits) { digit.repeat(1) }
-      rule(:letter) { match("[A-Za-z]") }
-
-      # Year pattern (2 digits starting with 0-1, or 4 digits starting with 19 or 20)
-      rule(:year_digits) do
-        ((str("19") | str("20")) >> digit.repeat(2, 2)) |
-          digit.repeat(2, 2)
-      end
-
-      # Copublisher (ANSI/AMCA or AMCA)
-      rule(:copublisher) do
-        (str("ANSI") >> slash >> str("AMCA")) |
-          str("AMCA")
-      end
-
-      # Additional copublisher after year (e.g., /ASHRAE 51-16)
-      rule(:additional_copublisher) do
-        slash >> letter.repeat(2,
-                               10) >> space >> digits >> (dash >> digits).maybe
-      end
-
-      # Code pattern (e.g., 210, 500-D, 99, 204)
-      rule(:code) do
-        (
-          digits >> # Main number
-          (dash >> letter).maybe >> # Optional letter suffix (500-D)
-          (dot >> digits).maybe # Optional decimal (not in fixtures but possible)
-        ).as(:code)
-      end
-
-      # Type (Standard or Publication)
-      rule(:type) do
-        str("Standard") | str("Publication")
-      end
-
-      # Reaffirmation year (R2008, R2010, etc.)
-      rule(:reaffirmation) do
-        lparen >> str("R") >> digits.as(:reaffirmed) >> rparen
-      end
-
-      # Suffix
-      rule(:suffix) do
-        str("R") | str("P")
-      end
-
-      # Publication revision (Rev. 01-23)
-      rule(:revision) do
-        lparen >> str("Rev") >> dot.maybe >> space >>
-          (digits >> dash >> digits).as(:revision) >> rparen
-      end
-
-      # Interpretation code (JW, KB, RG, AW, AH, or just a number)
-      rule(:interpretation_code) do
-        letter.repeat(2).as(:interpretation_code) | # Two-letter code
-          digits.as(:interpretation_code) # Number
-      end
-
-      # Interpretation keyword
-      rule(:interp_keyword) do
-        space >> str("Interp")
-      end
-
-      # Main identifier rule
-      rule(:identifier) do
-        # Interpretation patterns (must come first as they're more specific)
-        interpretation_identifier |
-          # Publication patterns
-          publication_identifier |
-          # Standard patterns (must come last as they're the most general)
-          standard_identifier
-      end
-
-      # Interpretation pattern (e.g., AMCA 99 JW Interp, AMCA 204 – 1)
-      rule(:interpretation_identifier) do
-        (
-          copublisher.as(:copublisher).maybe >> space >>
-          code >>
-          space >>
-          # Either a letter code (JW, KB, etc.) or a dash-number pattern
-          (
-            (interpretation_code >> interp_keyword) |
-            ((str("–") | str("-")) >> digits.as(:interpretation_year) >> interp_keyword.maybe)
-          )
-        ).as(:interpretation) |
-          # Simple interpretation: AMCA 511 Interp
-          (
-            copublisher.as(:copublisher).maybe >> space >>
-            code >>
-            interp_keyword
-          ).as(:interpretation)
-      end
-
-      # Publication pattern (e.g., AMCA Publication 211-22 (Rev. 01-23))
-      rule(:publication_identifier) do
-        (
-          copublisher.as(:copublisher).maybe >> space >>
-          str("Publication").as(:publication_keyword) >> space >>
-          code >>
-          (dash >> year_digits.as(:year)).maybe >>
-          (space >> revision).maybe >>
-          (space >> reaffirmation).maybe
-        ).as(:publication)
-      end
-
-      # Standard pattern (e.g., ANSI/AMCA 210-16, ANSI/AMCA Standard 99-25)
-      rule(:standard_identifier) do
-        (
-          copublisher.as(:copublisher).maybe >> space >>
-          type.as(:type).maybe >> space.maybe >>
-          code >>
-          (dash >> year_digits.as(:year)).maybe >>
-          (space >> additional_copublisher).maybe >>
-          suffix.maybe >>
-          (space >> reaffirmation).maybe
-        ).as(:standard)
-      end
-
-      root(:identifier)
-
-      def self.parse(string)
-        # Strip leading/trailing whitespace
-        cleaned = string.strip
-
-        # Normalize multiple spaces to single space
-        cleaned = cleaned.gsub(/\s+/, " ")
-
-        # Normalize en dash to regular dash
-        cleaned = cleaned.gsub("–", "-")
-
-        # Remove trailing periods and commas
-        cleaned = cleaned.gsub(/[,.]$/, "")
-
-        new.parse(cleaned)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ansi/identifier.rb

@@ -23,7 +23,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:ansi, string)
+        parsed = Pubid::Parg::Model.bound(:ansi, string)
         Pubid::Ansi::Builder.new.build(parsed)
       end
     end

data/lib/pubid/ansi/parser.rb

@@ -4,88 +4,7 @@ module Pubid
   module Ansi
     # Parser for ANSI (American National Standards Institute) identifiers
     # Examples: ANSI X3.4-1986, ANSI C63.4-2014, ANSI/ISO 9899:1990
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-      include ::Pubid::Parser::CommonParseMethods
-
-      root :identifier
-
-      # ANSI as sole publisher
-      rule(:publisher) do
-        str("ANSI").as(:publisher)
-      end
-
-      # Copublishers: ISO, IEEE, IEC, etc.
-      ORGANIZATIONS = %w[ISO IEC IEEE SAE ASME ASTM].freeze
-      rule(:copublishers) do
-        (str("/") >> space? >> array_to_str(ORGANIZATIONS).as(:copublisher)).repeat(1).as(:copublishers)
-      end
-
-      # Optional "Std" keyword
-      rule(:std_keyword) do
-        (str("Std") >> space).maybe
-      end
-
-      # Number with optional parts and subparts
-      # Examples:
-      # - X3.4-1986 (letter prefix, one dot, year)
-      # - C63.4-2014 (letter prefix, one dot, year)
-      # - C37.06.1-2000 (letter prefix, two dots, year)
-      # - C57.12.10-1988 (letter prefix, three dots, year)
-      # - N323A-1997 (letter prefix, number, letter suffix, year)
-      # - N42.49A-2011 (letter prefix, dot, number, letter suffix, year)
-      # - 9899 (just digits)
-      # - 802.3-2012 (digits with dot and year)
-      # - 802.1b-1995 (digits, dot, digits, letter, year)
-      rule(:number_with_part) do
-        (
-          # Letter prefix with multiple dots and optional letter suffix
-          # C37.06.1, C57.12.10, C63.25.1, N323A, N42.49A
-          (match["A-Z"].repeat(1) >>
-           digits >>
-           (str(".") >> digits).repeat(0, 3) >> # Allow up to 3 additional dot-separated parts
-           match["A-Z"].maybe >>                  # Optional letter suffix (A, B, etc.)
-           (str("-") >> digits).maybe) |          # Optional dash-year part
-          # Just digits with optional dots and letter suffix: 9899, 802.3-2012, 802.1b-1995
-          (digits >>
-           (str(".") >> digits >> match["a-z"].maybe).repeat(0, 2) >> # Dots with optional lowercase letter
-           (str("-") >> digits).maybe)
-        ).as(:number_with_part)
-      end
-
-      # Date - year only
-      rule(:date) do
-        str(":") >> year_digits.as(:date)
-      end
-
-      # Language codes
-      rule(:language) do
-        str("(") >>
-          (match["a-z"].repeat(2) >> str(",").maybe).repeat.as(:languages) >>
-          str(")")
-      end
-
-      # Main identifier for ANSI with copublishers
-      # ANSI/ISO 9899:1990, ANSI/IEEE Std 1-1986
-      rule(:identifier_with_copublishers) do
-        publisher >> copublishers >>
-          space >> std_keyword >>
-          number_with_part >>
-          date.maybe >> language.maybe
-      end
-
-      # Main identifier for ANSI alone
-      # ANSI X3.4-1986, ANSI Std C63.4-1991
-      rule(:identifier_sole) do
-        publisher >> space >>
-          std_keyword >>
-          number_with_part >>
-          date.maybe >> language.maybe
-      end
-
-      rule(:identifier) do
-        identifier_with_copublishers | identifier_sole
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/api/builder.rb

@@ -14,8 +14,35 @@ module Pubid
         "PUBL" => Identifiers::Publication,
       }.freeze
 
+      # The bound grammar flattens the combined form's first/second
+      # wrappers (the bindings cannot nest): the second identifier's
+      # fields capture under second_* names. The tree backend folded
+      # first and second into one hash in parse order, so the second
+      # side's assignments came last and its number/part/year overwrite
+      # the first's — and select_class saw no top-level :type, so a
+      # combined form always built the typeless class. Reproduce both.
+      SECOND_KEYS = %i[second_number second_part second_year second_type].freeze
+      SECOND_OVERWRITES = { number: :second_number,
+                            part: :second_part,
+                            year: :second_year }.freeze
+
+      def build(data)
+        super(unflatten_combined(data))
+      end
+
       private
 
+      def unflatten_combined(data)
+        return data unless SECOND_KEYS.any? { |k| data.key?(k) }
+
+        data = data.dup
+        data.delete(:type)
+        SECOND_OVERWRITES.each do |target, source|
+          data[target] = data.delete(source) if data.key?(source)
+        end
+        data
+      end
+
       def default_identifier_class
         Identifiers::TypelessStandard
       end
@@ -29,7 +56,11 @@ module Pubid
         # `:type` is consumed only by select_class for dispatch; it is not an
         # identifier attribute (the concrete class is pinned by `_type`). Drop it
         # so the raw Parslet::Slice never lands in the inherited :type attribute.
-        when :type then nil
+        # `:second_type` is the combined form's second type token, with
+        # the same dispatch-only role (unflatten_combined has already
+        # removed the first side's :type so the typeless class wins,
+        # exactly as the tree backend's wrapper nesting did).
+        when :type, :second_type then nil
         when :reaffirmation
           value.is_a?(Hash) ? (value[:year] || value).to_s : value.to_s
         # Every remaining key is a bare scalar. `:chapter` is a PARSE-TREE key

data/lib/pubid/api/identifier.rb

@@ -34,7 +34,7 @@ module Pubid
         # this was the one public parse in the gem that could return nil, which
         # a caller reading `id.to_s` sees as a NoMethodError far from the cause.
         # Both API fixture loaders already drop `#` lines themselves.
-        tree = Pubid::Parg::Backend.parse(:api, Api::Parser.normalize_input(input))
+        tree = Pubid::Parg::Model.bound(:api, Api::Parser.normalize_input(input))
         Builder.new.build(tree)
       end
     end

data/lib/pubid/api/parser.rb

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

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

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