pubid 2.0.0 → 2.0.2

data/lib/pubid/bsi/single_identifier.rb

@@ -28,10 +28,47 @@ module Pubid
           return Pubid::Iec.parse(string)
         end
 
-        parsed = Pubid::Parg::Backend.parse(:bsi, string)
+        parsed = Pubid::Parg::Model.bound(:bsi, strip_bsi_prefix(string))
         Builder.build(parsed)
       end
 
+      # The document series that BSI cites with its `BSI` publisher prefix
+      # in front (`BSI PAS 2031:2019`). `BS` is the British Standard series
+      # itself and is never preceded by it.
+      BSI_PREFIXED_SERIES = %w[PAS PD DD BIP].freeze
+
+      BSI_PREFIX = /\ABSI\s+(?=(?:#{BSI_PREFIXED_SERIES.join('|')})\b)/
+
+      # `BSI PAS 2031:2019` is the external spelling of `PAS 2031:2019`. The
+      # prefix is not part of the identity, so it is dropped before the baked
+      # grammar runs, and `to_s(with_publisher: true)` puts it back.
+      def self.strip_bsi_prefix(string)
+        string.sub(BSI_PREFIX, "")
+      end
+
+      # `with_publisher: false` drops only a real `BSI` prefix
+      # (`BSI Flex 1888` -> `Flex 1888`). `BS` in `BS 8611:2016` is the
+      # British Standard series, part of the designation, and stays.
+      def publisher_prefixes
+        ["BSI"]
+      end
+
+      # `with_publisher: true` renders the external form of a PAS / PD / DD /
+      # BIP document, with the `BSI` prefix in front. Every other form already
+      # starts with its publisher (`BS`, `BSI Flex`), or with a token that
+      # BSI does not prefix, and is left as it is.
+      def to_s(**opts)
+        rendered = super
+        return rendered unless opts[:with_publisher] == true
+
+        plain = rendered.gsub(%r{</?span[^>]*>}, "")
+        return rendered unless BSI_PREFIXED_SERIES.include?(plain[/\A\S+/])
+
+        prefix = "BSI"
+        prefix = %(<span class="publisher">#{prefix}</span>) if opts[:annotated]
+        "#{prefix} #{rendered}"
+      end
+
       attribute :publisher, Bsi::Components::Publisher, default: -> {
         Bsi::Components::Publisher.new(body: "BS")
       }

data/lib/pubid/calconnect/identifier.rb

@@ -118,7 +118,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        Builder.build(Pubid::Parg::Backend.parse(:calconnect, identifier))
+        Pubid::Parg::Model.parse(:calconnect, Identifiers::Standard, identifier)
       end
     end
   end

data/lib/pubid/calconnect/parser.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Calconnect
-    # Parslet grammar for CalConnect identifiers.
+    # Grammar for CalConnect identifiers.
     #
     # Shape: CC[/<series>] <number>:<date>
     #   CC 18011:2018
@@ -12,43 +10,7 @@ module Pubid
     #   CC/Adv 0707.1:2007        (dot sub-part)
     #   CC/A 0812-1:2008          (dash sub-part)
     #   CC/WD 51017:2024-07-23    (full ISO date)
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-
-      # Publisher token
-      rule(:publisher) { str("CC") }
-
-      # Series token — an open [A-Za-z]+ set (A, WD, R, S, CD, DIR, Adv, FDS, …)
-      rule(:series) { match["A-Za-z"].repeat(1).as(:series) }
-
-      # Number — digits, preserving leading zeros, with at most one dot- or
-      # dash-delimited sub-part ("0707.1", "0812-1"). Kept as a string.
-      rule(:number) do
-        (digits >> ((str(".") | str("-")) >> digits).maybe).as(:number)
-      end
-
-      # Date after the colon: a year, optionally a full "YYYY-MM-DD". The colon
-      # hard-delimits number from date, and month+day only appear together, so
-      # the split is unambiguous.
-      rule(:date) do
-        digits.as(:year) >>
-          (str("-") >> digits.as(:month) >> str("-") >> digits.as(:day)).maybe
-      end
-
-      rule(:identifier) do
-        publisher >>
-          (str("/") >> series).maybe >>
-          str(" ") >>
-          number >>
-          (str(":") >> date).maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/ccsds/identifier.rb

@@ -77,7 +77,7 @@ module Pubid
 
         # Apply legacy update_codes normalization first
         normalized = Core::UpdateCodes.apply(identifier, :ccsds)
-        parsed = Pubid::Parg::Backend.parse(:ccsds, normalized)
+        parsed = Pubid::Parg::Model.bound(:ccsds, normalized)
         Pubid::Ccsds::Builder.build(parsed)
       end
 

data/lib/pubid/ccsds/parser.rb

@@ -1,73 +1,8 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module Ccsds
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:alnum) { match["A-Za-z0-9"] }
-      rule(:alnums) { alnum.repeat(1) }
-      rule(:space) { str(" ") }
-      rule(:dash) { str("-") }
-      rule(:dot) { str(".") }
-
-      # CCSDS prefix
-      rule(:ccsds_prefix) { str("CCSDS") >> space }
-
-      # Number (can be alphanumeric like A02)
-      rule(:number) { alnums.as(:number) }
-
-      # Part (can be multi-digit like .21 or alphanumeric like .1)
-      rule(:part) { dot >> alnums.as(:part) }
-
-      # Type (all possible type letters)
-      rule(:type) { dash >> match["A-Z"].as(:type) }
-
-      # Edition (can have dots like 4.1, and a trailing draft letter like 1.99h)
-      rule(:edition) do
-        dash >> (match["0-9."].repeat(1) >> match["A-Za-z"].maybe).as(:edition)
-      end
-
-      # Suffix (like -S)
-      rule(:suffix) { dash >> match["A-Z"].as(:suffix) }
-
-      # Corrigendum
-      rule(:corrigendum) do
-        space >> str("Cor.") >> space >> digits.as(:cor_number)
-      end
-
-      rule(:corrigenda) { corrigendum.repeat(0).as(:corrigenda) }
-
-      # Language metadata (e.g., " - French Translated", " - Russian Translated")
-      rule(:language_metadata) do
-        space >> dash >> space >>
-          (
-            (str("French") | str("Russian") | str("English") |
-             str("German") | str("Spanish") | str("Italian") |
-             str("Portuguese") | str("Chinese") | str("Japanese")).as(:language) >>
-            (space >> str("Translated")).maybe
-          )
-      end
-
-      # Main identifier
-      rule(:identifier) do
-        ccsds_prefix >>
-          number >>
-          part.maybe >>
-          type.maybe >>
-          edition.maybe >>
-          suffix.maybe >>
-          corrigenda >>
-          language_metadata.maybe
-      end
-
-      rule(:root) { identifier }
-
-      def self.parse(input)
-        new.parse(input)
-      end
+    class Parser
     end
   end
 end

data/lib/pubid/cen_cenelec/identifier.rb

@@ -28,6 +28,21 @@ module Pubid
       # repeat one entry of the stage registry, so they move together.
       subset_strict :type, :stage, :typed_stage
 
+      # The bodies that print as a publisher prefix (`CEN/TS 16931-3-1`,
+      # `CLC/TR 50600`, `CEN ISO/TS 12180-1`). The `publisher` attribute also
+      # holds the deliverable types `EN`, `HD`, `CR`, `CWA`, `ES` and `ENV`,
+      # which are the designation itself (`EN 13256:2000`): those stay under
+      # `with_publisher: false`, as `BS` does for BSI. The test reads the
+      # first token only, so a joint group drops whole
+      # (`CEN/CLC/ETSI/TR 101551` -> `TR 101551`).
+      PUBLISHER_PREFIXES = %w[CEN CLC CENELEC].freeze
+
+      def publisher_prefixes
+        super.select do |prefix|
+          PUBLISHER_PREFIXES.include?(prefix.split("/").first)
+        end
+      end
+
       # The publisher serializes as a bare string ("publisher" => "CEN"), and
       # the copublishers as a list of strings. The shared table does not do
       # this for every flavor, because IEEE has a published index whose rows
@@ -105,7 +120,7 @@ module Pubid
         end
 
         normalized = Parser.normalize_input(identifier)
-        parsed = Pubid::Parg::Backend.parse(:cen_cenelec, normalized)
+        parsed = Pubid::Parg::Model.bound(:cen_cenelec, normalized)
         Builder.new.build(parsed)
       end
 

data/lib/pubid/cen_cenelec/parser.rb

@@ -1,139 +1,10 @@
 # frozen_string_literal: true
 
-require "parslet"
-
 module Pubid
   module CenCenelec
-    class Parser < ::Pubid::Parser::Grammar
-      rule(:digit) { match["0-9"] }
-      rule(:digits) { digit.repeat(1) }
-      rule(:space) { str(" ") }
-      rule(:dash) { str("-") }
-      rule(:slash) { str("/") }
-      rule(:plus) { str("+") }
-      rule(:colon) { str(":") }
-
-      # Publishers
-      rule(:en) { str("EN") }
-      rule(:cen) { str("CEN") }
-      rule(:clc) { str("CLC") }
-      rule(:cwa) { str("CWA") }
-      rule(:hd) { str("HD") }
-      rule(:es) { str("ES") }
-      rule(:cr) { str("CR") }
-      rule(:env) { str("ENV") }
-
-      # Adopted organizations (ISO, IEC)
-      rule(:iso) { str("ISO") }
-      rule(:iec) { str("IEC") }
-      rule(:cispr) { str("CISPR") }
-
-      # Publisher (can be combined like EN/CLC or CEN/CLC)
-      rule(:publisher) do
-        (cwa | hd | es | cr | env).as(:publisher) |
-          (en.as(:publisher) >> (slash >> clc.as(:copublisher)).maybe) |
-          (cen.as(:publisher) >> (slash >> clc.as(:copublisher)).maybe) |
-          (clc.as(:publisher) >> (slash >> cen.as(:copublisher)).maybe) |
-          en.as(:publisher)
-      end
-
-      # Stage prefixes captured as type_with_stage for proper lookup
-      rule(:stage_prefix) { (str("FprEN") | str("prEN")).as(:type_with_stage) }
-
-      # Type
-      rule(:type) do
-        (str("Guide") | str("GUIDE") | str("TR") | str("TS")).as(:type)
-      end
-
-      # Number
-      rule(:number) { digits.as(:number) }
-
-      # Part (can be multi-level like 1-2 or 80-12)
-      rule(:part) { dash >> match["0-9-"].repeat(1).as(:part) }
-      rule(:parts) { part.repeat(0).as(:parts) }
-
-      # Year
-      rule(:year) { colon >> digit.repeat(4, 4).as(:year) }
-
-      # Month support for dates like 2016-11
-      rule(:month_digits) do
-        (
-          str("01") | str("02") | str("03") | str("04") |
-          str("05") | str("06") | str("07") | str("08") |
-          str("09") | str("10") | str("11") | str("12")
-        ).as(:month)
-      end
-
-      rule(:year_with_month) do
-        colon >> digit.repeat(4, 4).as(:year) >> dash >> month_digits
-      end
-
-      rule(:date) { year_with_month | year }
-
-      # Amendment (+A1:2008 or +A11:2020 or /A2:2019 or /A1 without year)
-      rule(:amendment) do
-        (plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
-          str("A") >> digits.as(:amd_number) >>
-          (colon >> digit.repeat(4, 4).as(:amd_year)).maybe
-      end
-
-      # Corrigendum (+AC:2009 or +AC1:2008 or +AC2:2009 or /AC1:2005 or /AC:2016-11 with month)
-      rule(:corrigendum) do
-        (plus.as(:amd_sep_plus) | slash.as(:amd_sep_slash)) >>
-          str("AC") >> digits.maybe.as(:cor_number) >>
-          (year_with_month | (colon >> digit.repeat(4, 4).as(:year))).maybe
-      end
-
-      # Supplements (amendments and corrigenda)
-      rule(:supplement) { (amendment | corrigendum).as(:supplement) }
-      rule(:supplements) { supplement.repeat(0).as(:supplements) }
-
-      # Edition (ED2, ED3, etc.)
-      rule(:edition) { space >> str("ED") >> digits.as(:edition) }
-
-      # Fragment identifier (EN 60038 AMD1 FRAG2, EN 60038/A1 FRAG2)
-      rule(:fragment_identifier) do
-        ((stage_prefix | publisher) >>
-          space >> number >> parts >>
-          space >> str("AMD") >> digits.as(:amendment_number) >>
-          space >> str("FRAG") >> digits.as(:fragment_number)) |
-          # Compact supplement notation: the base may carry a year, the
-          # amendment uses the /A1 or +A1 join (with an optional year of
-          # its own) instead of the spelled-out "AMD1" keyword.
-          ((stage_prefix | publisher) >>
-            space >> number >> parts >> year.maybe >>
-            (plus | slash) >> str("A") >> digits.as(:amendment_number) >>
-            (colon >> digit.repeat(4, 4).as(:amendment_year)).maybe >>
-            space >> str("FRAG") >> digits.as(:fragment_number))
-      end
-
-      # Adopted standard as opaque string - must start with org name
-      rule(:adopted_org_prefix) do
-        str("ISO") | str("IEC") | str("CISPR")
-      end
-
-      rule(:adopted_string) do
-        # Must start with organization name
-        (adopted_org_prefix >> (supplement.absent? >> edition.absent? >> match("[^\n]")).repeat(0)).as(:adopted_string)
-      end
-
-      # Identifier
-      rule(:identifier) do
-        fragment_identifier |
-          ((stage_prefix | publisher) >>
-            (space >> adopted_string).maybe >>
-            ((space >> type) | (slash >> type)).maybe >>
-            (space >> number >> parts >>
-            year.maybe).maybe >>
-            supplements >>
-            edition.maybe)
-      end
-
-      rule(:root) { identifier }
-
-      # 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(input)
         # Normalize special dash characters
         normalized = input.gsub(/[\u2011\u00AD]/, "-")
@@ -150,10 +21,6 @@ module Pubid
           .gsub("GUIDE", "Guide")
         normalized
       end
-
-      def self.parse(input)
-        new.parse(normalize_input(input))
-      end
     end
   end
 end

data/lib/pubid/cie/identifier.rb

@@ -24,7 +24,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Pubid::Parg::Backend.parse(:cie, Parser.normalize_input(input))
+        parsed = Pubid::Parg::Model.bound(:cie, Parser.normalize_input(input))
         builder = Builder.new
         builder.build(parsed, original_string: input)
       end