relaton 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/ieee/rawbib_id_parser.rb

@@ -1,5 +1,3 @@
-require_relative "pub_id"
-
 module Relaton
   module Ieee
     module RawbibIdParser
@@ -8,15 +6,105 @@ module Relaton
       APPROV = '(?:\s(?:Unapproved|Approved))?'.freeze
       STD = "(?<std>\s(?i)Std.?(?-i))?".freeze
 
+      # Recurring OCR/spelling variants of month names seen in the raw IEEE
+      # dataset, mapped to a name Ruby's Date tables recognise.
+      MONTH_TYPOS = {
+        "sept" => "sep", "feburary" => "february", "novemer" => "november",
+        "octobor" => "october", "janurary" => "january"
+      }.freeze
+
+      #
+      # Parse a raw IEEE `normtitle` into a pubid identifier.
       #
-      # Parse normtitle
+      # pubid-first: most normtitles are canonical enough that
+      # `::Pubid::Ieee::Identifier.parse` handles them directly. The bespoke
+      # `#parse_fallback` regex pipeline only runs for the messy remainder — it
+      # normalizes the vendor string into a canonical form (via the private
+      # `Renderer`) that pubid can then parse. Either way the return value is a
+      # `::Pubid::Ieee::Identifier` (or nil when neither can make sense of it).
       #
       # @param [String] normtitle document element "normtitle"
       # @param [String] stdnumber document element "stdnumber"
       #
-      # @return [RelatonIeee::PubId, nil]
+      # @return [::Pubid::Ieee::Identifier, nil]
+      #
+      def parse(normtitle, stdnumber)
+        # Bespoke canonical string is the faithfulness reference: for the ~6% of
+        # normtitles pubid can't parse directly it's the recovery source, and for
+        # the rest it guards against pubid parsing but silently dropping a digit.
+        rendered = parse_fallback(normtitle, stdnumber)
+        ref = rendered&.to_id
+        [pubid_parse(normtitle), (ref && pubid_parse(ref))].compact.each do |pid|
+          return pid if ref.nil? || faithful?(pid.to_s, ref)
+        end
+        rendered # neither pubid parse kept every digit — keep the bespoke id
+      end
+
+      #
+      # True when `pid` is not a real IEEE designation but a leading fragment
+      # of the document's own title, coined by a generic {#parse_fallback}
+      # branch built for a genuine catalog number (e.g. "IEEE 802.3") that
+      # also happens to match a short title's opening words ("WEB 3.0: The
+      # Evolution of ..." -> `WEB 3.0`). Restricting this to the unvalidated
+      # `Renderer` fallback (never a pubid grammar match) is what keeps a
+      # genuine, correctly-resolved standard safe: measured over 9,091
+      # successfully-parsed records in the raw corpus, 7 real standards whose
+      # title happens to literally start with their own real designation
+      # (`IEEE Std 1636.99-2013, IEEE Standard for ...`) resolve to a real
+      # `::Pubid::Ieee::Identifier`, never a `Renderer`, so they are never
+      # flagged. `DataFetcher#no_standard_number?` catches most title-fragment
+      # records upfront by `publicationsubtype`, but that list can't cover
+      # every vendor subtype spelling, so this is a second, subtype-agnostic
+      # guard on the resolved id itself. Requiring a real ISBN keeps a
+      # genuine `Renderer` id (the ~1.3% that miss the faithfulness guard;
+      # see {#parse}) whose title coincidentally starts with it from being
+      # discarded.
+      #
+      # @param [::Pubid::Ieee::Identifier, Renderer, nil] pid
+      # @param [String, nil] title the document's own (non-normtitle) title
+      # @param [Boolean] isbn_present whether the document carries a real ISBN
       #
-      def parse(normtitle, stdnumber) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # @return [Boolean]
+      #
+      def fabricated_title_id?(pid, title, isbn_present)
+        return false unless pid.is_a?(Renderer)
+
+        !!(title && isbn_present && title.start_with?(pid.to_s))
+      end
+
+      # Parse a canonical id string into a pubid identifier, or nil on failure.
+      def pubid_parse(str)
+        ::Pubid::Ieee::Identifier.parse(str)
+      rescue StandardError
+        nil
+      end
+
+      MONTHS_RE = /\b(?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:t)?(?:ember)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\b/i # rubocop:disable Layout/LineLength
+
+      # Date-independent digit multiset of an id (strips month names, years, and a
+      # trailing numeric month), so date reformatting doesn't count as a change.
+      def id_digits(str)
+        t = str.gsub(MONTHS_RE, " ").gsub(/(?:19|20)\d{2}/, " ").gsub(/-\s*\d{1,2}(?=\D*\z)/, " ")
+        t.gsub(/\D/, "").chars
+      end
+
+      # True when the pubid rendering kept every (non-date) digit of the bespoke
+      # reference — i.e. pubid didn't drop a draft/part/number digit. Digit-level
+      # (not token-level) so a benign re-split like `P1476/D4` vs `P14764` counts
+      # as faithful (same digits) while a real loss (`/D3.0` -> `/D.0`) does not.
+      def faithful?(pubid_str, ref_str)
+        have = id_digits(pubid_str).tally
+        id_digits(ref_str).tally.all? { |d, c| have.fetch(d, 0) >= c }
+      end
+
+      #
+      # Fallback: map a messy normtitle to an internal {Renderer} whose `.to_id`
+      # is a canonical string pubid can parse. Only the ~12% of normtitles pubid
+      # can't parse directly reach here.
+      #
+      # @return [Renderer, nil]
+      #
+      def parse_fallback(normtitle, stdnumber) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         case normtitle.sub(/^ISO\s(?=\/)/, "ISO").sub(/^ANSI\/\s(?=IEEE)/, "ANSI/")
         # when "2012 NESC Handbook, Seventh Edition" then "NESC HBK ED7.2012"
         # when "2017 NESC(R) Handbook, Premier Edition" then "NESC HBK ED1.2017"
@@ -25,105 +113,105 @@ module Relaton
         # when /^(\d+HistoricalData)-(\d{4})/ then "IEEE #{$1}.#{$2}"
         # when /^(\d+)\.(\w+)\sBattery\sLife\sImprovement/ then "IEEE #{$1}-#{$2}"
         # when /^(\d+)\.(\w+)-(\d{4})\s\(Amendment/ then "IEEE #{$1}-#{$2}.#{$3}"
-        when "A.I.E.E. No. 15 May-1928" then PubId.new(publisher: "AIEE", number: "15", year: "1928", month: "05")
+        when "A.I.E.E. No. 15 May-1928" then Renderer.new(publisher: "AIEE", number: "15", year: "1928", month: "05")
         # when "AIEE Nos 72 and 73 - 1932" then "AIEE 72_73.1932"
-        when "IEEE Std P1073.1.3.4/D3.0" then PubId.new(publisher: "IEEE", std: true, number: "P11073", part: "00101") # "IEEE Std P11073-00101"
-        # when "P1073.1.3.4/D3.0" then PubId.new(publisher: "IEEE", number: "P1073", part: "1-3-4", draft: "3.0") # "IEEE P1073-1-3-4/D3.0"
-        when "IEEE P1073.2.1.1/D08" then PubId.new(publisher: "ISO/IEEE", number: "P1073", part: "2-1-1", draft: "08") # "ISO/IEEE P1073-2-1-1/D08"
+        when "IEEE Std P1073.1.3.4/D3.0" then Renderer.new(publisher: "IEEE", std: true, number: "P11073", part: "00101") # "IEEE Std P11073-00101"
+        # when "P1073.1.3.4/D3.0" then Renderer.new(publisher: "IEEE", number: "P1073", part: "1-3-4", draft: "3.0") # "IEEE P1073-1-3-4/D3.0"
+        when "IEEE P1073.2.1.1/D08" then Renderer.new(publisher: "ISO/IEEE", number: "P1073", part: "2-1-1", draft: "08") # "ISO/IEEE P1073-2-1-1/D08"
         when "IEEE P802.1Qbu/03.0, July 2015" # "IEEE P802.1Qbu/D3.0.2015"
-          PubId.new(publisher: "IEEE", number: "P802", part: "1Qbu", draft: "3.0", year: "2015")
+          Renderer.new(publisher: "IEEE", number: "P802", part: "1Qbu", draft: "3.0", year: "2015")
         when "IEEE P11073-10422/04, November 2015" # "IEEE P11073-10422/D04.2015"
-          PubId.new(publisher: "IEEE", number: "P11073", part: "10422", draft: "04", year: "2015")
+          Renderer.new(publisher: "IEEE", number: "P11073", part: "10422", draft: "04", year: "2015")
         when "IEEE P802.11aqTM/013.0 October 2017" # "IEEE P802-11aqTM/D13.0.2017"
-          PubId.new(publisher: "IEEE", number: "P802", part: "11aqTM", draft: "13.0", year: "2017")
+          Renderer.new(publisher: "IEEE", number: "P802", part: "11aqTM", draft: "13.0", year: "2017")
         when "IEEE P844.3/C22.2 293.3/D0, August 2018" # "IEEE P844-3/C22.2-293.3/D0.2018"
-          PubId.new([{ publisher: "IEEE", number: "P844", part: "3" },
+          Renderer.new([{ publisher: "IEEE", number: "P844", part: "3" },
                     { number: "C22.2", part: "293.3", dtaft: "0", year: "2018" }])
         when "IEEE P844.3/C22.2 293.3/D1, November 2018" # "IEEE P844.3/C22.2 293.3/D1.2018"
-          PubId.new([{ publisher: "IEEE", number: "P844", part: "3" },
+          Renderer.new([{ publisher: "IEEE", number: "P844", part: "3" },
                     { number: "C22.2", part: "293.3", draft: "1", year: "2018" }])
-        when "AIEE No 431 (105) -1958" then PubId.new(publisher: "AIEE", number: "431", year: "1958") # "AIEE 431.1958"
-        when "IEEE 1076-CONC-I99O" then PubId.new(publisher: "IEEE", number: "1076", year: "199O") # "IEEE 1076.199O"
+        when "AIEE No 431 (105) -1958" then Renderer.new(publisher: "AIEE", number: "431", year: "1958") # "AIEE 431.1958"
+        when "IEEE 1076-CONC-I99O" then Renderer.new(publisher: "IEEE", number: "1076", year: "199O") # "IEEE 1076.199O"
         when "IEEE Std 960-1993, IEEE Std 1177-1993" # "IEEE 960/1177.1993"
-          PubId.new([{ publisher: "IEEE", std: true, number: "960" }, { number: "1177", year: "1993" }])
+          Renderer.new([{ publisher: "IEEE", std: true, number: "960" }, { number: "1177", year: "1993" }])
         when "IEEE P802.11ajD8.0, August 2017" # "IEEE P802-11aj/D8.0.2017"
-          PubId.new(publisher: "IEEE", number: "P802", part: "11aj", draft: "8.0", year: "2017")
+          Renderer.new(publisher: "IEEE", number: "P802", part: "11aj", draft: "8.0", year: "2017")
         when "IEEE P802.11ajD9.0, November 2017" # "IEEE P802-11aj/D9.0.2017"
-          PubId.new(publisher: "IEEE", number: "P802", part: "11aj", draft: "9.0", year: "2017")
+          Renderer.new(publisher: "IEEE", number: "P802", part: "11aj", draft: "9.0", year: "2017")
         when "ISO/IEC/IEEE P29119-4-DISMay2013" # "ISO/IEC/IEEE DIS P29119-4.2013"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P29119", part: "4", year: "2013")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P29119", part: "4", year: "2013")
         when "IEEE-P15026-3-DIS-January 2015" # "IEEE DIS P15026-3.2015"
-          PubId.new(publisher: "IEEE", stage: "DIS", number: "P15026", year: "2015")
+          Renderer.new(publisher: "IEEE", stage: "DIS", number: "P15026", year: "2015")
         when "ANSI/IEEE PC63.7/D rev17, December 2014" # "ANSI/IEEE PC63-7/D/REV-17.2014"
-          PubId.new(publisher: "ANSI/IEEE", number: "PC63", part: "7", draft: "", rev: "17", year: "2014")
+          Renderer.new(publisher: "ANSI/IEEE", number: "PC63", part: "7", draft: "", rev: "17", year: "2014")
         when "IEC/IEEE P62271-37-013:2015 D13.4" # "IEC/IEEE P62271-37-013/D13.4.2015"
-          PubId.new(publisher: "IEC/IEEE", number: "P62271", part: "37-013", draft: "13.4", year: "2015")
+          Renderer.new(publisher: "IEC/IEEE", number: "P62271", part: "37-013", draft: "13.4", year: "2015")
         when "PC37.30.2/D043 Rev 18, May 2015" # "IEEE PC37-30-2/D043/REV-18.2015"
-          PubId.new(publisher: "IEEE", number: "PC37", part: "30-2", draft: "043", rev: "18", year: "2015")
+          Renderer.new(publisher: "IEEE", number: "PC37", part: "30-2", draft: "043", rev: "18", year: "2015")
         when "IEC/IEEE FDIS 62582-5 IEC/IEEE 2015" # "IEC/IEEE FDIS 62582-5.2015"
-          PubId.new(publisher: "IEC/IEEE", stage: "FDIS", number: "62582", part: "5", year: "2015")
+          Renderer.new(publisher: "IEC/IEEE", stage: "FDIS", number: "62582", part: "5", year: "2015")
         when "ISO/IEC/IEEE P15289:2016, 3rd Ed FDIS/D2" # "ISO/IEC/IEEE FDIS P15289/E3/D2.2016"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "FDIS", number: "P15289", part: "", edition: "3", draft: "2", year: "2016")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "FDIS", number: "P15289", part: "", edition: "3", draft: "2", year: "2016")
         when "IEEE P802.15.4REVi/D09, April 2011 (Revision of IEEE Std 802.15.4-2006)"
-          PubId.new(publisher: "IEEE", number: "P802", part: "15.4", rev: "i", draft: "09", year: "2013", month: "04", approval: "Approved")
+          Renderer.new(publisher: "IEEE", number: "P802", part: "15.4", rev: "i", draft: "09", year: "2013", month: "04", approval: "Approved")
         when "Draft IEEE P802.15.4REVi/D09, April 2011 (Revision of IEEE Std 802.15.4-2006)"
-          PubId.new(publisher: "IEEE", number: "P802", part: "15.4", rev: "i", draft: "09", year: "2011", month: "04")
+          Renderer.new(publisher: "IEEE", number: "P802", part: "15.4", rev: "i", draft: "09", year: "2011", month: "04")
         when "ISO/IEC/IEEE DIS P42020:201x(E), June 2017"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P42020", year: "2017", month: "06")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P42020", year: "2017", month: "06")
         when "IEEE/IEC P62582 CD2 proposal, May 2017"
-          PubId.new(publisher: "IEEE/IEC", number: "P62582", stage: "CD2", year: "2017", month: "05")
+          Renderer.new(publisher: "IEEE/IEC", number: "P62582", stage: "CD2", year: "2017", month: "05")
         when "ISO/IEC/IEEE P16326:201x WD.4a, July 2017"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "P16326", draft: "4a", year: "2017", month: "07")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "P16326", draft: "4a", year: "2017", month: "07")
         when "ISO/IEC/IEEE CD.1 P21839, October 2017"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "CD1", number: "P21839", year: "2017", month: "10")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "CD1", number: "P21839", year: "2017", month: "10")
         when "IEEE P3001.2/D5, August 2017"
-          PubId.new(publisher: "IEEE", number: "P3001", part: "2", draft: "5", year: "2017", month: "01")
+          Renderer.new(publisher: "IEEE", number: "P3001", part: "2", draft: "5", year: "2017", month: "01")
         when "P3001.2/D5, August 2017"
-          PubId.new(publisher: "IEEE", number: "P3001", part: "2", draft: "5", year: "2017", month: "12")
+          Renderer.new(publisher: "IEEE", number: "P3001", part: "2", draft: "5", year: "2017", month: "12")
         when "ISO/IEC/IEEE P16326:201x WD5, December 2017"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "P16326", draft: "5", year: "2017", month: "12")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "P16326", draft: "5", year: "2017", month: "12")
         when "ISO/IEC/IEEE DIS P16326/201x, December 2018"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P16326", year: "2018", month: "12")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P16326", year: "2018", month: "12")
         when "ISO/IEC/IEEE/P21839, 2019(E)"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "P21839", year: "2019")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "P21839", year: "2019")
         when "ISO/IEC/IEEE P42020/V1.9, August 2018"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "P42020", year: "2018", month: "08")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "P42020", year: "2018", month: "08")
         when "ISO/IEC/IEEE CD2 P12207-2: 201x(E), February 2019"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "CD2", number: "P12207", part: "2", year: "2019", month: "02")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "CD2", number: "P12207", part: "2", year: "2019", month: "02")
         when "ISO/IEC/IEEE P42010.WD4:2019(E)"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "P42010", draft: "4", year: "2019")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "P42010", draft: "4", year: "2019")
         when "IEC/IEEE P63195_CDV/V3, February 2020"
-          PubId.new(publisher: "IEC/IEEE", number: "P63195", stage: "CDV", year: "2020", month: "02")
+          Renderer.new(publisher: "IEC/IEEE", number: "P63195", stage: "CDV", year: "2020", month: "02")
         when "IEEE/ISO/IEC P42010.CD1-V1.0, April 2020"
-          PubId.new(publisher: "IEEE/ISO/IEC", number: "P42010", stage: "CD1", year: "2020", month: "04")
+          Renderer.new(publisher: "IEEE/ISO/IEC", number: "P42010", stage: "CD1", year: "2020", month: "04")
         when "ISO/IEC/IEEE/P16085_DIS, March 2020"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P16085", year: "2020", month: "03")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "DIS", number: "P16085", year: "2020", month: "03")
         when "ANSI/IEEE Std: Outdoor Apparatus Bushings"
-          PubId.new(publisher: "ANSI/IEEE", std: true, number: "21", year: "1976", month: "11")
+          Renderer.new(publisher: "ANSI/IEEE", std: true, number: "21", year: "1976", month: "11")
         when "Unapproved Draft Std ISO/IEC FDIS 15288:2007(E) IEEE P15288/D3,"
-          PubId.new(publisher: "ISO/IEC/IEEE", stage: "FDIS", std: true, number: "P15288", draft: "3", year: "2007")
+          Renderer.new(publisher: "ISO/IEC/IEEE", stage: "FDIS", std: true, number: "P15288", draft: "3", year: "2007")
         when "Draft National Electrical Safety Code, January 2016"
-          PubId.new(publisher: "IEEE", number: "PC2", year: "2016", month: "01")
-        when "ANSI/IEEE-ANS-7-4.3.2-1982" then PubId.new(publisher: "ANSI/IEEE/ANS", number: "7", part: "4-3-2", year: "1982")
+          Renderer.new(publisher: "IEEE", number: "PC2", year: "2016", month: "01")
+        when "ANSI/IEEE-ANS-7-4.3.2-1982" then Renderer.new(publisher: "ANSI/IEEE/ANS", number: "7", part: "4-3-2", year: "1982")
         when "IEEE Unapproved Draft Std P802.1AB/REVD2.2, Dec 2007" # "IEEE P802.1AB/REV/D2.2.2007"
-          PubId.new(publisher: "IEEE", std: true, number: "P802", part: "1AB", rev: "", draft: "2.2", year: "2007", month: "12")
+          Renderer.new(publisher: "IEEE", std: true, number: "P802", part: "1AB", rev: "", draft: "2.2", year: "2007", month: "12")
         when "International Standard ISO/IEC 8802-9: 1996(E) ANSI/IEEE Std 802.9, 1996 Edition"
-          PubId.new(publisher: "ISO/IEC/IEEE", std: true, number: "802", part: "9", year: "1996")
+          Renderer.new(publisher: "ISO/IEC/IEEE", std: true, number: "802", part: "9", year: "1996")
         when "ISO/IEC13210: 1994 (E) ANSI/IEEE Std 1003.3-1991"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "13210", year: "1994")
-        when "J-STD-016-1995" then PubId.new(publisher: "IEEE", number: "016", year: "1995")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "13210", year: "1994")
+        when "J-STD-016-1995" then Renderer.new(publisher: "IEEE", number: "016", year: "1995")
         when "Std 802.1ak-2007 (Amendment to IEEE Std 802.1QTM-2005)"
-          PubId.new(publisher: "IEEE", std: true, number: "802", part: "1ak", year: "2007")
+          Renderer.new(publisher: "IEEE", std: true, number: "802", part: "1ak", year: "2007")
         when "IS0/IEC/IEEE 8802-11:2012/Amd.5:2015(E) (Adoption of IEEE Std 802.11af-2014)"
-          PubId.new(publisher: "ISO/IEC/IEEE", number: "802", part: "11", year: "2012", amd: "5", year_amendment: "2015")
+          Renderer.new(publisher: "ISO/IEC/IEEE", number: "802", part: "11", year: "2012", amd: "5", year_amendment: "2015")
         when "National Electrical Safety Code, C2-2012 - Redline"
-          PubId.new(publisher: "IEEE", number: "C2", year: "2012", redline: "true")
-        when "National Electrical Safety Code, C2-2012" then PubId.new(publisher: "IEEE", number: "C2", year: "2012")
-        when "2012 NESC Handbook, Seventh Edition" then PubId.new(publisher: "NESC", number: "HBK", year: "2012")
+          Renderer.new(publisher: "IEEE", number: "C2", year: "2012", redline: "true")
+        when "National Electrical Safety Code, C2-2012" then Renderer.new(publisher: "IEEE", number: "C2", year: "2012")
+        when "2012 NESC Handbook, Seventh Edition" then Renderer.new(publisher: "NESC", number: "HBK", year: "2012")
         when /^Amendment to IEEE Std 802\.11-2007 as amended by IEEE Std 802\.11k-2008/
-          PubId.new(publisher: "IEEE", std: true, number: "802", part: "11u", year: "2007")
-        when "Std 11073-10417-2009" then PubId.new(publisher: "IEEE", std: true, number: "11073", part: "10417", year: "2009")
-        when "Nuclear EQ Sourcebook and Supplement" then PubId.new publisher: "IEEE", number: "7438946"
+          Renderer.new(publisher: "IEEE", std: true, number: "802", part: "11u", year: "2007")
+        when "Std 11073-10417-2009" then Renderer.new(publisher: "IEEE", std: true, number: "11073", part: "10417", year: "2009")
+        when "Nuclear EQ Sourcebook and Supplement" then Renderer.new publisher: "IEEE", number: "7438946"
 
         # drop all with <standard_id>0</standard_id>
         # when "IEEE Std P1671/D5, June 2006", "IEEE Std PC37.100.1/D8, Dec 2006",
@@ -137,12 +225,12 @@ module Relaton
 
         # publisher1, number1, part1, publisher2, number2, part2, draft, year
         when /^([A-Z\/]+)\s(\w+)[-.](\d+)\/(\w+)\s(\w+)[-.](\d+)_D([\d.]+),\s\w+\s(\d{4})/
-          PubId.new([{ publisher: $1, number: $2, part: $3 },
+          Renderer.new([{ publisher: $1, number: $2, part: $3 },
                     { publisher: $4, number: $5, part: $6, draft: dn($7), year: $8 }])
 
         # publisher1, number1, part1, number2, part2, draft, year, month
         when /^([A-Z\/]+)\s(\w+)[.-]([\w.-]+)\/(\w+)[.-]([[:alnum:].-]+)[\/_]D([\w.]+),\s(\w+)\s(\d{4})/
-          PubId.new([{ publisher: $1, number: $2, part: sp($3) }, { number: $4, part: sp($5), draft: dn($6), year: $8, month: mn($7) }])
+          Renderer.new([{ publisher: $1, number: $2, part: sp($3) }, { number: $4, part: sp($5), draft: dn($6), year: $8, month: mn($7) }])
 
         # publisher, approval, number, part, corrigendum, draft, year
         when /^(?<publisher>[A-Z\/]+)#{APPROVAL}(?:\sDraft)?\sStd\s(?<number>\w+)\.(?<part>\d+)-\d{4}[^\/]*\/Cor\s?(?<corr>\d)\/(?<draft>D[\d\.]+),\s(?:\w+\s)?(?<year>\d{4})/o
@@ -154,7 +242,7 @@ module Relaton
 
         # publidsher1, number1, year1 publisher2, number2, draft, year2
         when /^([A-Z\/]+)\s(\w+)-(\d{4})\/([A-Z]+)\s([[:alnum:]]+)_D([\w.]+),\s(\d{4})/
-          PubId.new([{ publisher: $1, number: $2, year: $3 }, { publisher: $4, number: $5, draft: dn($6), year: $7 }])
+          Renderer.new([{ publisher: $1, number: $2, year: $3 }, { publisher: $4, number: $5, draft: dn($6), year: $7 }])
 
         when /^(?<publisher>[A-Z\/]+)\s#{STAGE}\s(?<number>\w+)[.-](?<part>[[:alnum:].-]+)[\s\/_]ED(?<edition>[\w.]+),\s(?<month>\w+)\s(?<year>\d{4})/o
           create_pubid(Regexp.last_match)
@@ -163,20 +251,20 @@ module Relaton
         when /^(?<publisher1>[A-Z\/]+)#{APPROV}(?:\sDraft)?#{STD}\s(?<number1>\w+)\/(?<publisher2>[A-Z]+)\s(?<number2>[[:alnum:]]+)_D(?<draft>[\d\.]+),\s\w+\s(?<year>\d{4})/o,
             /^(?<publisher1>[A-Z\/]+)\s(?<number1>\w+)\sand\s(?<publisher2>[A-Z]+)(?:\sGuideline)?\s(?<number2>[[:alnum:]]+)\/D(?<draft>[\d\.]+),\s\w+\s(?<year>\d{4})/o
           nc = Regexp.last_match.named_captures
-          PubId.new([{ publisher: nc["publisher1"], std: !!nc["std"], number: nc["number1"] },
+          Renderer.new([{ publisher: nc["publisher1"], std: !!nc["std"], number: nc["number1"] },
                     { publisher: nc["publisher2"], number: nc["number2"], draft: dn(nc["draft"]), year: nc["year"] }])
 
         # publidsher1, number1, part, publisher2, number2, year
         when /^([A-Z\/]+)\s(\w+)\.(\d+)_(\w+)\s(\w+),\s(\d{4})/ # "#{$1} #{$2}-#{$3}/#{$4} #{$5}.#{$6}"
-          PubId.new([{ publisher: $1, number: $2, part: $3 }, { publisher: $4, number: $5, year: $6 }])
+          Renderer.new([{ publisher: $1, number: $2, part: $3 }, { publisher: $4, number: $5, year: $6 }])
 
         # publisher, number1, part1, number2, part2, draft
         when /^([A-Z\/]+)\s(\w+)[.-](\d+)\/(\w+)\.(\d+)[\/_]D([\d.]+)/ # "#{$1} #{$2}-#{$3}/#{$4}-#{$5}/D#{$6}"
-          PubId.new([{ publisher: $1, number: $2, part: $3 }, { number: $4, part: $5, draft: dn($6) }])
+          Renderer.new([{ publisher: $1, number: $2, part: $3 }, { number: $4, part: $5, draft: dn($6) }])
 
         # publidsher, number1, part1, number2, part2, year
         when /^([A-Z\/]+)\sStd\s(\w+)\.(\w+)\/(\w+)\.(\w+)\/INT\s\w+\s(\d{4})/
-          PubId.new([{ publisher: $1, number: $2, part: $3 }, { number: $4, part: $5, year: $6 }])
+          Renderer.new([{ publisher: $1, number: $2, part: $3 }, { number: $4, part: $5, year: $6 }])
 
         # publisher, number, part, corrigendum, draft, year
         when /^(?<publisher>[A-Z\/]+)#{APPROV}(?:\sDraft)?#{STD}\s(?<number>\w+)[.-](?<part>[\d-]+)\/Cor\s?(?<corr>\d)[\/_]D(?<draft>[\d\.]+),\s(?:\w+\s)?(?<year>\d{4})/o,
@@ -184,10 +272,12 @@ module Relaton
             /^(?<publisher>[A-Z\/]+)\s(?<number>\w+)\.(?<part>[[:alnum:].]+)[-_]Cor[\s-]?(?<corr>\d)\/D(?<draft>[\d.]+),?\s\w+\s(?<year>\d{4})/
           create_pubid(Regexp.last_match)
         when /^([A-Z\/]+)\s(\w+)\.(\d+)-\d{4}\/Cor(\d)-(\d{4})\/D([\d.]+)/ # "#{$1} #{$2}-#{$3}/Cor#{$4}/D#{$6}.#{$5}"
-          PubId.new(publisher: $1, number: $2, part: $3, corr: $4, draft: dn($6), year: $5)
+          Renderer.new(publisher: $1, number: $2, part: $3, corr: $4, draft: dn($6), year: $5)
 
-        # publisher, status, number, part, draft, year, month
-        when /^(?<publisher>[A-Z\/]+)(?<status>\sActive)#{APPROV}(?:\sDraft)?#{STD}\s(?<number>\w+)[.-](?<part>[[:alnum:]\.]+)\s?[\/_]D(?<draft>[\w\.]+),?\s(?<month>\w+)(?:\s\d{1,2},)?\s?(?<year>\d{2,4})/o
+        # publisher, number, part, draft, year, month. The bare "Active" status
+        # word is matched but NOT captured — folding it into the id rendered a
+        # stray token and a double space (`IEEE  Active Std ...`) pubid rejects.
+        when /^(?<publisher>[A-Z\/]+)(?:\sActive)#{APPROV}(?:\sDraft)?#{STD}\s(?<number>\w+)[.-](?<part>[[:alnum:]\.]+)\s?[\/_]D(?<draft>[\w\.]+),?\s(?<month>\w+)(?:\s\d{1,2},)?\s?(?<year>\d{2,4})/o
           create_pubid(Regexp.last_match)
 
         # publisher, approval, number, part, draft, year, month
@@ -246,11 +336,11 @@ module Relaton
 
         # number, part, draft, year, month
         when /(\w+)[.-]([[:alnum:].]+)[\/\s_]D([\d.]+)(?:,?\s|_)([[:alpha:]]+)[\s_]?(\d{4})/
-          PubId.new(publisher: "IEEE", number: $1, part: sp($2), draft: dn($3), year: $5, month: mn($4))
+          Renderer.new(publisher: "IEEE", number: $1, part: sp($2), draft: dn($3), year: $5, month: mn($4))
 
         # number, corrigendum, draft, year, month
         when /^(\w+)-\d{4}[\/_]Cor\s?(\d)[\/_]D([\w.]+),\s(\w+)\s(\d{4})/
-          PubId.new(publisher: "IEEE", number: $1, corr: $2, draft: dn($3), month: mn($4), year: $5)
+          Renderer.new(publisher: "IEEE", number: $1, corr: $2, draft: dn($3), month: mn($4), year: $5)
 
         # publisher, number, corrigendum, draft, year
         when /^(?<publisher>[A-Z\/]+)#{APPROV}(?:\sDraft)?\sStd\s(?<number>\w+)(?:-\d{4})?[\/_]Cor\s?(?<corr>\d)\/D(?<draft>[\d\.]+),\s\w+\s(?<year>\d{4})/o
@@ -258,7 +348,7 @@ module Relaton
 
         # publisher, number, part, rev, corrigendum, draft
         when /^([A-Z\/]+)\s(\w+)\.(\w+)-\d{4}-Rev\/Cor(\d)\/D([\d.]+)/
-          PubId.new(publisher: $1, number: $2, part: $3, rev: "", corr: $4, draft: dn($5))
+          Renderer.new(publisher: $1, number: $2, part: $3, rev: "", corr: $4, draft: dn($5))
 
         # publisher, number, part, corrigendum, draft
         when /^(?<publisher>[A-Z\/]+)#{APPROV}(?:\sDraft)?#{STD}\s(?<number>\w+)\.(?<part>[\w.]+)\/[Cc]or\s?(?<corr>\d)\/D(?<draft>[\w\.]+)/o,
@@ -362,7 +452,7 @@ module Relaton
         # publisher, number, edition, year
         when /^([A-Z\/]+)\s(\w+)\s(\w+)\sEdition,\s\w+\s(\d+)/,
             /^([A-Z\/]+)\s(\w+)[\/_]ED([\d.]+),\s(\d{4})/
-          PubId.new(publisher: $1, number: $2, edition: en($3), year: $4)
+          Renderer.new(publisher: $1, number: $2, edition: en($3), year: $4)
 
         # publisher, number, part, conformance, draft
         when /^(?<publisher>[A-Z\/]+)#{APPROV}(?:\sDraft)?#{STD}\s(?<number>\w+)\.(?<part>[[:alnum:].]+)[\/-]Conformance(?<conformance>\d+)[\/_]D(?<draft>[\w\.]+)/o
@@ -436,27 +526,35 @@ module Relaton
 
         # number, part, year
         when /^(\d{2})\sIRE\s(\w+)[\s.](\w+)/ # "IRE #{$2}-#{$3}.#{yn $1}"
-          PubId.new(publisher: "IRE", number: $2, part: $3, year: yn($1))
-        when /^(\w+)\.(\w+)-(|d{4})/ then PubId.new(publisher: "IEEE", number: $1, part: $2, year: $3)
+          Renderer.new(publisher: "IRE", number: $2, part: $3, year: yn($1))
+        when /^(\w+)\.(\w+)-(|d{4})/ then Renderer.new(publisher: "IEEE", number: $1, part: $2, year: $3)
 
         # number, year
-        when /^(\w+)-(\d{4})\D/ then PubId.new(publisher: "IEEE", number: $1, year: $2)
+        when /^(\w+)-(\d{4})\D/ then Renderer.new(publisher: "IEEE", number: $1, year: $2)
 
-        # publisher, number
-        when /^(?<publisher>[A-Z\/]+)#{APPROV}(?:\sDraft)?#{STD}(?:\sNo\.?)?\s(?<number>\w+)/o
+        # publisher, number. The number must have a digit: otherwise a title
+        # such as "A Call to Action ..." gives the id `A Call`.
+        when /^(?<publisher>[A-Z\/]+)#{APPROV}(?:\sDraft)?#{STD}(?:\sNo\.?)?\s(?<number>[[:alpha:]]*\d\w*)/o
           create_pubid(Regexp.last_match)
 
         else
-          Util.warn %{Use stdnumber "#{stdnumber}" for normtitle "#{normtitle}"}
-          PubId.new(publisher: "IEEE", srd: true, number: stdnumber)
+          # Last resort: fall back to the raw stdnumber. (#parse runs this for
+          # every doc as the faithfulness reference, so no warning here — an
+          # unparseable id surfaces downstream as a nil docnumber.) A record
+          # with no standard number (a white paper, a research document) has a
+          # category here, e.g. "White Paper". It gets no id, because all such
+          # records would otherwise share one id, and so one output file.
+          if stdnumber.to_s.match?(/\d/)
+            Renderer.new(publisher: "IEEE", number: stdnumber)
+          end
         end
-      rescue ArgumentError => e
-        e
+      rescue ArgumentError
+        nil
       end
 
       def create_pubid(regex_match)
         args = regex_match.named_captures
-        PubId.new(
+        Renderer.new(
           publisher: args["publisher"] || "IEEE",
           std: !!args["std"],
           number: args["number"],
@@ -517,10 +615,19 @@ module Relaton
       def mn(month)
         return if month.nil?
 
-        n = Date::ABBR_MONTHNAMES.index(month) || Date::MONTHNAMES.index(month)
-        return month unless n
+        s = month.to_s.strip
+        return s.rjust(2, "0") if s.match?(/\A\d{1,2}\z/) # already numeric
 
-        n.to_s.rjust 2, "0"
+        # Letters only — drops trailing day/garble digits (e.g. "Sep20" -> "sep").
+        key = s.downcase[/\A[a-z]+/]
+        return unless key
+
+        key = MONTH_TYPOS[key] || key
+        cap = key.capitalize
+        n = Date::ABBR_MONTHNAMES.index(cap) || Date::MONTHNAMES.index(cap)
+        # Genuine miss: omit the month (a date-less id parses; a name-suffixed
+        # one does not) rather than leak an unparseable name into the id.
+        n&.to_s&.rjust(2, "0")
       end
 
       #
@@ -542,6 +649,104 @@ module Relaton
         draftnum && draftnum.sub(/^\./, "").gsub("-", ".")
       end
 
+      # Internal fallback renderer. Turns the fields extracted by #parse_fallback
+      # into the canonical relaton id string that #parse hands to pubid — it is
+      # NOT a public identifier type (pubid's `::Pubid::Ieee::Identifier` is the
+      # identifier abstraction). Kept private because the fallback still needs to
+      # normalize the ~12% of normtitles pubid can't parse directly.
+      class Renderer
+        class Id
+          # Series IEEE registers as trademarks, so they take ® rather than ™.
+          # Mirrors pubid's rule (metanorma/pubid#322): the series is read off
+          # the *number*, with a leading project `P` stripped, so `P802.8` counts
+          # as 802 while a letter series like `C802.1` does not.
+          REGISTERED_SERIES = %w[802 8802 2030].freeze
+          # 8802 is the ISO-adopted form of 802 and carries ® on the number
+          # alone; every other registered series also needs IEEE as (co)publisher,
+          # so `AIEE Std No. 802` and `ANSI 802.1-1985` stay ™.
+          ISO_ADOPTED_SERIES = "8802".freeze
+
+          attr_reader :number, :publisher, :std, :stage, :part, :status, :approval,
+                      :edition, :draft, :rev, :corr, :amd, :redline, :year, :month
+
+          def initialize(number:, **args) # rubocop:disable Metrics/AbcSize
+            @number = number
+            @publisher = args[:publisher]
+            @std = args[:std]
+            @stage = args[:stage]
+            @part = args[:part]
+            @status = args[:status]
+            @approval = args[:approval]
+            @edition = args[:edition]
+            @draft = args[:draft]
+            @rev = args[:rev]
+            @corr = args[:corr]
+            @amd = args[:amd]
+            @year = args[:year]
+            @month = args[:month]
+            @redline = args[:redline]
+          end
+
+          def to_s(trademark: false) # rubocop:disable Metrics/AbcSize
+            out = number
+            out = "Std #{out}" if std
+            out = "#{stage} #{out}" if stage
+            out = "#{approval} #{out}" if approval
+            out = "#{status} #{out}" if status
+            out = "#{publisher} #{out}" if publisher
+            out += ".#{part}" if part
+            out += trademark_symbol if trademark
+            out += edition_to_s + draft_to_s + rev_to_s + corr_to_s + amd_to_s
+            out + year_to_s + month_to_s + redline_to_s
+          end
+
+          # ® for a registered series, ™ otherwise. See REGISTERED_SERIES.
+          def trademark_symbol
+            series = number.to_s.sub(/\AP/, "")[/\A\d+/]
+            return "™" unless REGISTERED_SERIES.include?(series)
+            return "®" if series == ISO_ADOPTED_SERIES
+
+            publisher.to_s.split("/").include?("IEEE") ? "®" : "™"
+          end
+
+          def edition_to_s = edition ? "/E-#{edition}" : ""
+          def draft_to_s   = draft ? "/D-#{draft}" : ""
+          def rev_to_s     = rev ? "/R-#{rev}" : ""
+          def corr_to_s    = corr ? "/Cor#{corr}" : ""
+          def amd_to_s     = amd ? "/Amd #{amd}" : ""
+          def year_to_s    = year ? "-#{year}" : ""
+          def month_to_s   = month ? "-#{month}" : ""
+          def redline_to_s = redline ? " Redline" : ""
+        end
+
+        def initialize(pubid)
+          @pubid = (pubid.is_a?(Array) ? pubid : [pubid]).map { |id| Id.new(**id) }
+        end
+
+        # Full id string (all numbers joined). Used when the faithfulness guard
+        # keeps the bespoke id because pubid dropped a digit.
+        def to_s(trademark: false)
+          @pubid.map { |id| id.to_s(trademark: trademark) }.join("/")
+        end
+
+        # Canonical id string. For a dual-numbered id, the second number
+        # contributes only the suffix components the first one lacks.
+        def to_id # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          out = @pubid[0].to_s
+          if @pubid.size > 1
+            out += @pubid[1].edition_to_s if @pubid[0].edition.nil?
+            out += @pubid[1].draft_to_s if @pubid[0].draft.nil?
+            out += @pubid[1].rev_to_s if @pubid[0].rev.nil?
+            out += @pubid[1].corr_to_s if @pubid[0].corr.nil?
+            out += @pubid[1].amd_to_s if @pubid[0].amd.nil?
+            out += @pubid[1].year_to_s if @pubid[0].year.nil?
+            out += @pubid[1].month_to_s if @pubid[0].month.nil?
+            out += @pubid[1].redline_to_s unless @pubid[0].redline
+          end
+          out
+        end
+      end
+
       extend RawbibIdParser
     end
   end

data/lib/relaton/ieee.rb

@@ -1,6 +1,7 @@
 require "digest/md5"
 require "faraday"
 require "yaml"
+require "pubid"
 require "relaton/index"
 require "relaton/bib"
 require_relative "version"
@@ -15,7 +16,7 @@ module Relaton
   module Ieee
     class Error < StandardError; end
 
-    INDEXFILE = "index-v1".freeze
+    INDEXFILE = "index-v2".freeze
 
     # Returns hash of XML reammar
     # @return [String]