pubid 2.0.1 → 2.0.2

data/lib/pubid/cie/parser.rb

@@ -1,383 +1,12 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Cie
     # Parser for CIE identifiers
     # Handles dual-style system (legacy vs current)
-    class Parser < ::Pubid::Parser::Grammar
-      # Basic building blocks
-      rule(:space) { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:dash) { str("-") }
-      rule(:colon) { str(":") }
-      rule(:dot) { str(".") }
-      rule(:slash) { str("/") }
-      rule(:comma) { str(",") }
-      rule(:digit) { match("[0-9]") }
-      rule(:digits) { digit.repeat(1) }
-      rule(:upper) { match("[A-Z]") }
-      rule(:lower) { match("[a-z]") }
-
-      # Year (4 digits: 1900-2099)
-      rule(:year_digits) do
-        (str("19") | str("20")) >> digit.repeat(2, 2)
-      end
-
-      # Date with separator detection (CRITICAL for style)
-      # Legacy: dash "-" (pre-2001)
-      # Current: colon ":" (2001+)
-      rule(:legacy_date) do
-        (dash >> year_digits.as(:year)).as(:legacy_date)
-      end
-
-      rule(:current_date) do
-        (colon >> year_digits.as(:year)).as(:current_date)
-      end
-
-      rule(:date) do
-        current_date | legacy_date
-      end
-
-      # Legacy format: NUMBER-YEAR (e.g., 001-1980)
-      # This is BEFORE 2001, using dash as year separator (NOT part)
-      # Can optionally have trailing language like "(RU-2020)"
-      rule(:legacy_code_with_year) do
-        str("CIE") >> space >> digits.as(:number) >> dash >> year_digits.as(:year) >>
-          (language_paren_year | str("")).as(:trailing_lang)
-      end
-
-      # Code patterns
-      # Pattern 1: "006.1" - iteration (leading zero + dot)
-      rule(:code_with_iteration) do
-        digits.as(:number) >> dot >> digits.as(:iteration)
-      end
-
-      # Pattern 1b: "19/2.1" - part with slash THEN iteration with dot (complex)
-      rule(:code_with_part_and_iteration_slash) do
-        digits.as(:number) >> slash >> digits.as(:part) >> dot >> digits.as(:iteration)
-      end
-
-      # Pattern 1c: "19-2.1" - part with dash THEN iteration with dot (complex)
-      rule(:code_with_part_and_iteration_dash) do
-        digits.as(:number) >> dash >> digits.as(:part) >> dot >> digits.as(:iteration) >>
-          dash.absent? # Don't consume date dash
-      end
-
-      # Pattern 2: "170-1" - part with dash (current style)
-      # NOTE: Part must be 1-3 digits, and NOT followed by a 4-digit year
-      rule(:code_with_part_dash) do
-        digits.as(:number) >> dash >> match("[0-9]").repeat(1, 3).as(:part) >>
-          str("").as(:dash_sep) >> # Marker for dash separator
-          # Negative lookahead: don't consume if followed by 4-digit year
-          (str("19") | str("20")).absent? >>
-          (dot | dash).absent? # Don't consume dot or date dash
-      end
-
-      # Pattern 3: "170/1" - part with slash (legacy style)
-      rule(:code_with_part_slash) do
-        digits.as(:number) >> slash >> digits.as(:part) >>
-          str("").as(:slash_sep) >> # Marker for slash separator
-          dot.absent? # Don't consume iteration dot
-      end
-
-      # Pattern 4: Simple number
-      rule(:code_simple) do
-        digits.as(:number)
-      end
-
-      # Code rule (longest match first - complex patterns before simple)
-      rule(:code) do
-        code_with_part_and_iteration_slash |
-          code_with_part_and_iteration_dash |
-          code_with_iteration |
-          code_with_part_slash |
-          code_with_part_dash |
-          code_simple
-      end
-
-      # Language patterns
-      # Format 1: /E, /F, /G (slash-prefix, legacy)
-      rule(:language_slash) do
-        (slash >> upper.as(:lang_code)).as(:language_slash)
-      end
-
-      # Format 2: (DE), (ES), (CN), (en), (E), (F), (G)
-      rule(:language_paren) do
-        (str("(") >> match("[A-Za-z]").repeat(1,
-                                              3).as(:lang_code) >> str(")")).as(:language_paren)
-      end
-
-      # Format 3: (RU-2021) - with translation year
-      # NOTE: The space before parenthesis is OPTIONAL (e.g., "2003 (RU-2021)" or "2003(RU-2021)")
-      rule(:language_paren_year) do
-        (space.maybe >> str("(") >> upper.repeat(2).as(:lang_code) >>
-        dash >> year_digits.as(:trans_year) >> str(")")).as(:language_paren_year)
-      end
-
-      rule(:language) do
-        language_paren_year | language_paren | language_slash
-      end
-
-      # S prefix (optional "Standard" marker)
-      rule(:s_prefix) do
-        str("S") >> space
-      end
-
-      # Conference x-prefix
-      rule(:x_prefix) do
-        str("x")
-      end
-
-      # Stage codes (DIS, DS, FDIS, etc.)
-      rule(:stage_code) do
-        (str("FDIS") | str("DIS") | str("DS")) >> space
-      end
-
-      # Document type (TR for Technical Report, TS for Technical Specification)
-      rule(:doc_type) do
-        (str("TR") | str("TS")) # Don't consume trailing space
-      end
-
-      # Proceedings paper code: 1+ uppercase letters (OP, PO, PP, WP, IP, P, ...)
-      # Deliberately generic (open set); greedy letters then digits.
-      rule(:paper_code) do
-        match("[A-Z]").repeat(1).as(:paper_code)
-      end
-
-      # Techstreet opaque conference variant: /<lowercase-alnum slug>
-      # Charset kept lowercase-alnum so it can't collide with the uppercase
-      # /E, /Cor, /IEC tails or the self.parse language gsub.
-      rule(:variant_slug) do
-        slash >> match("[0-9a-z]").repeat(1).as(:variant)
-      end
-
-      # Conference proceedings paper (x-prefixed): CIE x043-OP01
-      rule(:conf_proceedings) do
-        str("CIE") >> space >> str("x") >> digits.as(:conf_number) >>
-          dash >> paper_code >> digits.as(:paper_number)
-      end
-
-      # Standalone proceedings paper: CIE OP02 1-5
-      rule(:standalone_proceedings) do
-        str("CIE") >> space >> paper_code >> digits.as(:paper_number) >>
-          space >> (digits >> dash >> digits).as(:page_range)
-      end
-
-      # D-series: CIE D001-2006 / CIE D002:2004
-      rule(:d_series_identifier) do
-        str("CIE") >> space >> str("D").as(:d_prefix) >> digits.as(:number) >> date
-      end
-
-      # Standard with bare slash-year (no language letter): CIE S 007/1998
-      # Uses a narrow number(+iteration) pattern rather than the full code rule
-      # so code_with_part_slash doesn't greedily consume the /year.
-      rule(:standard_with_slash_year) do
-        str("CIE") >> space >>
-          stage_code.maybe.as(:stage) >>
-          s_prefix.maybe.as(:s_prefix) >>
-          (digits.as(:number) >> (dot >> digits.as(:iteration)).maybe) >>
-          slash >> year_digits.as(:slash_year)
-      end
-
-      # DIS stage with supplement pattern (e.g., DIS 025-SP1/E:2019)
-      rule(:dis_with_supplement) do
-        str("CIE") >> space >>
-          stage_code.as(:stage) >>
-          s_prefix.maybe.as(:s_prefix) >>
-          digits.as(:base_number) >>
-          dash >> str("SP") >> digits.as(:supplement_number) >>
-          (dot >> digits.as(:supplement_part)).maybe >>
-          slash >> upper.as(:lang_code) >> colon.as(:lang_colon) >> year_digits.as(:year)
-      end
-
-      # Standard identifier (most common) - language can come AFTER date
-      rule(:standard_identifier) do
-        str("CIE") >> space >>
-          stage_code.maybe.as(:stage) >>
-          s_prefix.maybe.as(:s_prefix) >>
-          code >>
-          # Language can come BEFORE date, AFTER date, or both.
-          # The whole date group is optional so a bare "CIE 015" (no year)
-          # parses with year left nil (partial reference for relaton matching).
-          (
-            (language >> date).as(:lang_before) |
-            (date >> language.maybe).as(:date_then_lang) |
-            date
-          ).maybe
-      end
-
-      # Standard identifier without ISO reference but with language-year (CIE S 014-4/E:2007)
-      rule(:standard_with_language_year) do
-        str("CIE") >> space >>
-          stage_code.maybe.as(:stage) >>
-          s_prefix.maybe.as(:s_prefix) >>
-          code >>
-          slash >> upper.as(:lang_code) >> colon.as(:lang_colon) >> year_digits.as(:year)
-      end
-
-      # Conference identifier (x-prefix)
-      rule(:conference_identifier) do
-        str("CIE") >> space >>
-          x_prefix.as(:conference) >>
-          digits.as(:conf_number) >>
-          date >>
-          # Optional amendment
-          (space >> str("Amendment") >> space >> digits.as(:amd_number)).maybe >>
-          # Optional techstreet opaque /slug variant
-          variant_slug.maybe
-      end
-
-      # Joint published with ISO
-      rule(:joint_with_iso) do
-        str("CIE") >> space >>
-          str("ISO").as(:copublisher) >> # Match and mark once
-          (slash >> str("CIE")).absent? >> # Make sure it's not "ISO/CIE"
-          space >>
-          (doc_type >> space).maybe.as(:doc_type) >> # Consume space here
-          stage_code.maybe.as(:stage) >>
-          digits.as(:number) >>
-          (dash >> digits.as(:part)).maybe >>
-          ((colon >> year_digits.as(:year)) | (dash >> year_digits.as(:year))).maybe >>
-          language.maybe
-      end
-
-      # Joint with ISO/CIE (special case)
-      rule(:joint_with_iso_cie) do
-        str("CIE") >> space >>
-          str("ISO/CIE").as(:copublisher) >> # Match and mark once
-          space >>
-          (doc_type >> space).maybe.as(:doc_type) >> # Consume space here
-          digits.as(:number) >>
-          (colon >> year_digits.as(:year)).maybe >>
-          language.maybe
-      end
-
-      # Joint published with IEC
-      rule(:joint_with_iec) do
-        str("CIE") >> space >>
-          str("IEC").as(:copublisher) >> # Match and mark once
-          space >>
-          digits.as(:number) >>
-          dot >> digits.as(:part) >> # IEC always uses dot
-          dash >> year_digits.as(:year)
-      end
-
-      # Identical with ISO (parenthetical reference)
-      # Patterns:
-      # "CIE S 006.1/1998 (ISO 16508:1999)" - iteration with dot
-      # "CIE S 014-4/E2007" - part with dash + language without colon (needs colon insertion)
-      # "CIE S 008/E:2001 (ISO 8995-1:2002(E))" - language with colon year
-      rule(:identical_with_iso) do
-        str("CIE") >> space >>
-          s_prefix.maybe.as(:s_prefix) >>
-          digits.as(:number) >>
-          # Can have iteration (.1) OR part (-4)
-          (
-            (dot >> digits.as(:iteration)) |
-            (dash >> digits.as(:part))
-          ).maybe >>
-          # Slash handling - three mutually exclusive patterns:
-          (slash >>
-            (
-              # /E:2001 - language code WITH colon year
-              (upper.as(:lang_code) >> colon.as(:lang_colon) >> year_digits.as(:year)) |
-              # /E2007 - language code WITHOUT colon + year (needs colon insertion)
-              (upper.as(:lang_code) >> year_digits.as(:year)) |
-              # /1998 - just legacy slash-year (no language)
-              year_digits.as(:slash_year)
-            )
-          ).maybe >>
-          # ISO reference - handle nested parentheses for language codes
-          space >> str("(ISO") >> space >>
-          # Match ISO identifier: digits, colons, dashes, slashes, dots
-          # Plus optional language code in parentheses like (E), (F)
-          (
-            match("[0-9A-Z:/.\\-]").repeat(1) >> # Main ISO identifier
-            (str("(") >> match("[A-Z]").repeat(1) >> str(")")).maybe # Optional (E), (F), etc.
-          ).as(:iso_reference) >>
-          str(")")
-      end
-
-      # Dual published with IEC (slash separator between full identifiers)
-      # Pattern: "CIE S 009:2002/IEC 62471:2006"
-      rule(:dual_with_iec) do
-        str("CIE") >> space >>
-          s_prefix.maybe.as(:s_prefix) >>
-          digits.as(:number) >>
-          colon >> year_digits.as(:year) >>
-          slash >> str("IEC") >> space >>
-          match("[^)\\n]").repeat(1).as(:iec_identifier)
-      end
-
-      # Supplement identifier (-SPN notation)
-      rule(:supplement_identifier) do
-        str("CIE") >> space >>
-          digits.as(:base_number) >>
-          dash >> str("SP") >> digits.as(:supplement_number) >>
-          (dot >> digits.as(:supplement_part)).maybe >>
-          colon >> year_digits.as(:year)
-      end
-
-      # Corrigendum identifier (/CorN notation)
-      rule(:corrigendum_identifier) do
-        # Parse base identifier first (could be supplement or standard)
-        str("CIE") >> space >>
-          digits.as(:base_number) >>
-          # Could have supplement notation before corrigendum
-          (dash >> str("SP") >> digits.as(:base_supplement) >>
-           (dot >> digits.as(:base_supplement_part)).maybe).maybe >>
-          colon >> year_digits.as(:base_year) >>
-          # Corrigendum portion
-          slash >> str("Cor") >> digits.as(:cor_number) >>
-          colon >> year_digits.as(:cor_year)
-      end
-
-      # Bundle identifier (comma-separated list)
-      rule(:bundle_identifier) do
-        str("CIE") >> space >>
-          digits.as(:first_number) >>
-          dash >> str("SP") >> digits >> dot >> digits >>
-          colon >> year_digits >>
-          (comma >> digits.as(:next_number) >>
-           dash >> str("SP") >> digits >> dot >> digits >>
-           colon >> year_digits).repeat(1).as(:bundle_items)
-      end
-
-      # Tutorial Bundle
-      rule(:tutorial_bundle) do
-        str("CIE Tutorials Bundle") >> space >> digits.as(:bundle_number)
-      end
-
-      # Main identifier rule (longest/most specific first)
-      root(:identifier)
-
-      rule(:identifier) do
-        tutorial_bundle |
-          bundle_identifier |
-          joint_with_iso_cie |
-          joint_with_iso |
-          joint_with_iec |
-          identical_with_iso |
-          dis_with_supplement |
-          dual_with_iec |
-          corrigendum_identifier |
-          supplement_identifier |
-          standard_with_language_year |
-          standard_with_slash_year |
-          d_series_identifier |
-          conf_proceedings |
-          standalone_proceedings |
-          legacy_code_with_year | # Before standard to catch 001-1980 pattern
-          conference_identifier |
-          standard_identifier
-      end
-
-      # Class method for parsing with preprocessing
-      # Pre-parse ingestion normalizations (R2): every parse path —
-      # parslet and PG artifact alike — feeds the grammar the same
-      # normalized string.
+    class Parser
+      # Pre-parse ingestion normalizations (R2): every parse path feeds
+      # the grammar the same normalized string.
       def self.normalize_input(string)
         # Minimal preprocessing for data quality
         cleaned = string.strip
@@ -394,10 +23,6 @@ module Pubid
 
         cleaned
       end
-
-      def self.parse(string)
-        new.parse(normalize_input(string))
-      end
     end
   end
 end

data/lib/pubid/conformance.rb

@@ -20,7 +20,7 @@ module Pubid
     # Neutral error vocabulary. Each implementation maps its native
     # exceptions onto these codes; the corpus never records Ruby classes.
     ERROR_CODES = {
-      "Parslet::ParseFailed" => "parse_failed",
+      "Pubid::Errors::ParseError" => "parse_failed",
       "ArgumentError" => "invalid_argument",
     }.freeze
 

data/lib/pubid/csa/builder.rb

@@ -33,12 +33,12 @@ module Pubid
         end
 
         # Handle bundled identifiers (with + notation)
-        if parsed_hash.key?(:bundled_first)
+        if parsed_hash[:plus_separator]
           return build_bundled(parsed_hash)
         end
 
         # Handle combined identifiers (with / notation)
-        if parsed_hash[:first] && parsed_hash[:second]
+        if parsed_hash[:csa_code_part] && !parsed_hash[:plus_separator]
           return build_combined(parsed_hash)
         end
 
@@ -101,7 +101,7 @@ module Pubid
           else
             begin
               Pubid::Iso.parse(base_str)
-            rescue Parslet::ParseFailed
+            rescue Pubid::Errors::ParseError
               Pubid::Iec.parse(base_str)
             end
           end
@@ -135,7 +135,7 @@ module Pubid
                  else
                    begin
                      Pubid::Iso.parse(amendment_str)
-                   rescue Parslet::ParseFailed
+                   rescue Pubid::Errors::ParseError
                      Pubid::Iec.parse(amendment_str)
                    end
                  end
@@ -155,7 +155,7 @@ module Pubid
                  else
                    begin
                      Pubid::Iso.parse(wrapped_id_str)
-                   rescue Parslet::ParseFailed
+                   rescue Pubid::Errors::ParseError
                      Pubid::Iec.parse(wrapped_id_str)
                    end
                  end
@@ -417,17 +417,11 @@ module Pubid
         bundled = Identifiers::Bundled.new
 
         # Build base identifier
-        bundled.base = build_single(parsed_hash[:base])
+        parts = parsed_hash[:csa_code_part]
+        bundled.base = build_single(strip_part_prefix(parts.first))
 
-        # Build bundled portions (amendments/supplements)
-        # Combine bundled_first with bundled_rest array
-        bundled_portions = [parsed_hash[:bundled_first]]
-        if parsed_hash[:bundled_rest] && !parsed_hash[:bundled_rest].empty?
-          bundled_portions += parsed_hash[:bundled_rest]
-        end
-
-        bundled.bundled_with = bundled_portions.map do |portion|
-          build_single(portion)
+        bundled.bundled_with = parts[1..].map do |portion|
+          build_single(strip_part_prefix(portion))
         end
 
         # Reaffirmation - supports both 2-digit and 4-digit years
@@ -450,13 +444,33 @@ module Pubid
         bundled
       end
 
+
+      # Strips the part_-prefix the combined/bundled array group carries,
+      # leaving the plain field names build_single reads.
+      def strip_part_prefix(part)
+        part.each_with_object({}) do |(key, value), acc|
+          acc[key.to_s.delete_prefix("part_").to_sym] = value
+        end
+      end
+
       def build_combined(parsed_hash)
         combined = Identifiers::Combined.new
 
+        parts = parsed_hash[:csa_code_part].map(&:dup)
+        # SERIES and series_prefix bind as top-level scalars: the capture
+        # only fires in the parts that carry the keyword, and array
+        # bindings pair occurrences by index, so a sparse capture would
+        # land on the wrong part. The keyword qualifies the designation it
+        # follows — the last part in every combined form.
+        if parsed_hash[:part_series]
+          parts.last[:part_series] = parsed_hash[:part_series]
+          parts.last[:part_series_prefix] = parsed_hash[:part_series_prefix] if
+            parsed_hash[:part_series_prefix]
+        end
+
         # Build each designation, in printed order, into one collection.
-        combined.identifiers = %i[first second third]
-          .filter_map { |key| parsed_hash[key] }
-          .map { |part| build_single(part) }
+        combined.identifiers = parts
+          .map { |part| build_single(strip_part_prefix(part)) }
 
         # Detect separator from parser marker
         combined.separator = if parsed_hash[:comma_separator]
@@ -627,6 +641,15 @@ module Pubid
           identifier.package = data[:package_portion].to_s
         end
 
+        # Amendment riding on the identifier ("/A1:15" after the base)
+        if data[:amendment_number]
+          return Identifiers::Amendment.new(
+            base: identifier,
+            amendment_number: data[:amendment_number].to_s,
+            amendment_year: data[:amendment_year]&.to_s,
+          )
+        end
+
         identifier
       end
 

data/lib/pubid/csa/identifier.rb

@@ -61,7 +61,7 @@ module Pubid
             normalized = normalized.gsub(/\s+/, " ").strip
 
             # Parse normally (will create Bundled or Combined identifier)
-            tree = Pubid::Parg::Backend.parse(:csa, Parser.normalize_input(normalized))
+            tree = Pubid::Parg::Model.bound(:csa, Parser.normalize_input(normalized))
         prefix = Parser.publisher_prefix_for(normalized)
         Parser.inject_publisher_prefix(tree, prefix) if prefix && tree.is_a?(Hash)
             result = build!(tree, input)
@@ -421,7 +421,7 @@ module Pubid
         # Normalize CAN3- to CSA (historical prefix)
         normalized = normalized.gsub("CAN3-", "CSA ")
 
-        tree = Pubid::Parg::Backend.parse(:csa, Parser.normalize_input(normalized))
+        tree = Pubid::Parg::Model.bound(:csa, Parser.normalize_input(normalized))
         prefix = Parser.publisher_prefix_for(normalized)
         Parser.inject_publisher_prefix(tree, prefix) if prefix && tree.is_a?(Hash)
         result = build!(tree, input)
@@ -433,7 +433,7 @@ module Pubid
         result.year_format = "dash" if has_dash_year && result.year_format.nil?
 
         result
-      rescue Parslet::ParseFailed => e
+      rescue Pubid::Errors::ParseError => e
         raise e
       end
 
@@ -459,7 +459,7 @@ module Pubid
       # it is the one caller that genuinely wants a nil rather than a raise.
       def self.try_parse(input)
         parse(input)
-      rescue Parslet::ParseFailed, ArgumentError
+      rescue Pubid::Errors::ParseError, ArgumentError
         nil
       end
 
@@ -523,6 +523,14 @@ module Pubid
         nil
       end
 
+      # The leading publisher prefixes a CSA rendering can carry
+      # (`publisher_prefix` records which one the input used). The national
+      # forms `CAN/CSA-` and `CAN3-` are dropped whole, so
+      # `with_publisher: false` gives `C22.2 NO. 60601-1:14`, not `CSA-C22.2…`.
+      def publisher_prefixes
+        ["CAN/CSA", "CAN3", "CSA"]
+      end
+
       # CSA stores the publication year in its own plain `year` string
       # attribute (not a `Components::Date`), so the base `#exclude`'s
       # `:year`->`:date` remap nils the unused inherited `date` and leaves

data/lib/pubid/csa/identifiers/amendment.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Csa
+    module Identifiers
+      # An amendment riding on a CSA identifier: "/A1:15" after the base
+      # designation. The grammar binds amendment_number and
+      # amendment_year; the builder wraps the base identifier in this
+      # class when they are present.
+      class Amendment < Identifier
+        attribute :base, ::Pubid::Identifier
+        attribute :amendment_number, :string
+        attribute :amendment_year, :string
+
+        def initialize(base:, amendment_number:, amendment_year: nil, **opts)
+          super(base: base, amendment_number: amendment_number,
+                amendment_year: amendment_year, **opts)
+        end
+
+        def to_s(**opts)
+          suffix = "/A#{amendment_number}"
+          suffix += ":#{amendment_year}" if amendment_year
+          "#{base.to_s(**opts)}#{suffix}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/csa/identifiers.rb

@@ -4,6 +4,7 @@ module Pubid
   module Csa
     module Identifiers
       autoload :Base, "#{__dir__}/identifiers/base"
+      autoload :Amendment, "#{__dir__}/identifiers/amendment"
       autoload :Bundled, "#{__dir__}/identifiers/bundled"
       autoload :CanadianAdopted, "#{__dir__}/identifiers/canadian_adopted"
       autoload :Cec, "#{__dir__}/identifiers/cec"