pubid 2.0.1 → 2.0.2

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