pubid 2.0.0.pre.alpha.13 → 2.0.0.pre.alpha.14

data/lib/pubid/ieee/identifiers/joint_development.rb

@@ -79,6 +79,11 @@ module Pubid
         # Canonical format based on lead party
         # @return [Symbol] :ieee or :iso
         def canonical_format
+          # A stage-tracked D= designator is IEEE draft notation — its
+          # canonical face is the designator spelling (§1.3 spelling 7:
+          # "JOINT PNUMBER/D=<STAGE>[:year]"), whatever the lead party.
+          return :ieee if ieee_draft.to_s.start_with?("D=")
+
           case lead_party
           when "IEEE", "AIEE"
             :ieee
@@ -130,28 +135,39 @@ module Pubid
           # Publishers (slash-separated)
           parts << publishers.join("/") if publishers && !publishers.empty?
 
-          # ISO stage code (only if this was originally ISO-led)
-          # For IEEE-led conversions, we skip the stage since we don't have ISO equivalent
-          if lead_party == "ISO" && (typed_stage || iso_stage)
-            if typed_stage
-              parts << typed_stage.to_iso_format
-            elsif iso_stage
-              parts << iso_stage
-            end
+          # The stage word is the ISO format's own position convention —
+          # it prints whenever the identifier carries one, regardless of
+          # lead party (the format face decides, not the arrangement). A
+          # stage-tracked D= designator decomposes into its stage word
+          # and date ("D=CD.2-2020" → "CD2", 2020); the iteration glues
+          # onto the word only for the stages whose printed ISO spellings
+          # carry it (CD2, DIS2 — the grammar's multi-digit families);
+          # the P project stage is IEEE convention and never prints here.
+          # The printed word is always the bare stage ("CD4" prints "CD",
+          # "DIS3" prints "DIS" — every iso_stage_spellings_spec
+          # expectation); the iteration is draft machinery, not ISO-face
+          # identity.
+          stage_word = iso_stage.to_s.sub(/\A([A-Z]+?)\d+\z/, '\1')
+          stage_word = nil if stage_word.empty?
+          draft_year = nil
+          if stage_word.nil? &&
+             ieee_draft.to_s.match(/\AD=([A-Z]+)(?:\.(\d+[a-z]?))?(?:[-:](\d{4}))?\z/)
+            stage_word = Regexp.last_match(1)
+            draft_year = Regexp.last_match(3)
           end
+          parts << stage_word if stage_word
 
-          # IEEE semantics: P = project (a draft); no P = a standard. The
-          # P-state is identity-bearing and prints as spelled — it is never
-          # added or stripped here.
+          # The P project marker is identity-bearing and prints on both
+          # faces (the standing trademark_leaf_to_s_spec contract:
+          # "ISO/IEC/IEEE P26511:2018").
           code_str = code.to_s
           code_str += mark unless code_str.empty?
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with colon; the joint stage-draft
-          # clause ("D=WD.5") rides after the year in the ISO-led print.
+          # Join with space and add year with colon (the ISO position
+          # convention; a decomposed D= date rides here as the year).
           result = parts.join(" ")
-          result += ":#{year}" if year
-          result += "/#{ieee_draft}" if ieee_draft && ieee_draft.start_with?("D=")
+          result += ":#{year || draft_year}" if year || draft_year
           # Only the language/edition marker ("(E)", "(E/F)") prints; a
           # trailing relationship narrative is metadata, not identity.
           if parenthetical_content&.match?(%r{\A[A-Z](?:\s*[/&]\s*[A-Z])*\z})
@@ -177,18 +193,38 @@ module Pubid
           # Mark after the number, before the draft and the year
           code_str += mark unless code_str.empty?
 
-          # Add IEEE draft notation if available (e.g., /D8)
-          if ieee_draft
+          # Add IEEE draft notation if available (e.g., /D8). An ISO stage
+          # word renders in IEEE's stage-tracked position as the ordinal-less
+          # stage draft (docs/IEEE-DRAFT-STAGES.md §1.3, spelling 7):
+          # "IEEE/ISO/IEC CD P42010:2020" → "IEEE/ISO/IEC P42010/D=CD-2020".
+          # The iso_stage branch is checked FIRST — the typed_stage registry
+          # lookup for a stage word answers a draft-equivalent ordinal ("D2"),
+          # which is not the canonical stage-tracked spelling.
+          if ieee_draft.to_s.start_with?("D=") && year
+            # The ordinal-less stage draft's canonical face (the
+            # UpdateCodes rewrite): the publication year colon-joins the
+            # code and the designator trails — "P16326:2017/D=WD.5".
+            code_str += ":#{year}"
+            code_str += "/#{ieee_draft}"
+            @designator_carries_year = true
+          elsif ieee_draft
             code_str += "/#{ieee_draft}"
+          elsif iso_stage
+            # The ordinal-less stage draft: an iteration glued onto the
+            # printed word ("CD2") renders in the doctrine's ".iter" slot
+            # ("D=CD.2" — docs/IEEE-DRAFT-STAGES.md §1.3).
+            stage = iso_stage.match(/\A([A-Z]+?)(\d+)\z/)
+            code_str += stage ? "/D=#{stage[1]}.#{stage[2]}" : "/D=#{iso_stage}"
           elsif typed_stage&.ieee_draft_equivalent
             code_str += "/#{typed_stage.ieee_draft_equivalent}"
           end
 
           parts << code_str if code_str && !code_str.empty?
 
-          # Join with space and add year with dash
+          # Join with space and add year with dash — unless the D=
+          # designator face already carried it above.
           result = parts.join(" ")
-          result += "-#{year}" if year
+          result += "-#{year}" if year && !@designator_carries_year
 
           result
         end

data/lib/pubid/ieee/parser.rb

@@ -595,7 +595,10 @@ module Pubid
         # ISO/IEC/IEEE P26511/D8-2018 or ISO/IEEE P1003.1-2008 or IEC/IEEE P62582-1-2011
         # ALSO handle: IEC/IEEE P60780-323, CDV1 2014 (comma before stage code)
         # ALSO handle: IEEE/CSA P844.1/293.1/D2 (CSA dual numbering)
-        (str("ISO/IEC/IEEE") | str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/CSA")).as(:joint_publishers) >>
+        # ALSO handle: IEEE/ISO/IEC P42010/D=CD-2020 — the printed publisher
+        # order is the organization's perspective (pubid#469) and parses as
+        # printed; it is no longer rewritten to ISO-first.
+        (str("ISO/IEC/IEEE") | str("IEEE/ISO/IEC") | str("ISO/IEEE") | str("IEC/IEEE") | str("IEEE/CSA")).as(:joint_publishers) >>
           space >>
           # P = project (the document is a draft): identity-bearing, so it
           # is captured and preserved, never silently consumed.
@@ -605,14 +608,19 @@ module Pubid
           # CSA dual numbering: /293.1 (second number)
           (slash >> digits >> (dot >> digits).maybe >> (dash >> digits.as(:draft_version)).maybe).maybe >>
           (
-            # Variant 1b: the ordinal-less stage draft "D=CDV[:2020]" -
+            # Variant 1b: the ordinal-less stage draft "D=CDV-2020" -
             # D (draft) = CDV (the IEC stage it drafts). The year rides in
             # the draft clause (a distinct key, so the builder keeps the
-            # date inside the designator).
+            # date inside the designator). The year follows IEEE format:
+            # dash-joined ("D=CD-2020", the ruled canonical); the colon
+            # spelling ("D=CDV:2020") stays accepted as the alias it was
+            # frozen with. A dash-year is guarded to 19xx/20xx so a
+            # YYMM monthcode tail can never be read as a year.
             (slash >> str("D") >> str("=") >>
               (str("CDV") | str("FDIS") | str("PWI") | str("WD") |
                str("NP") | str("DIS") | str("CD")).as(:draft_iso_stage) >>
-              (str(":") >> year_digits.as(:draft_stage_year)).maybe) |
+              ((str(":") | str("-")) >>
+               ((str("19") | str("20")) >> digit >> digit).as(:draft_stage_year)).maybe) |
             # Variant 1: /D8 notation (original), with the compound
             # both-systems suffix "=DDIS.3" (docs/IEEE-DRAFT-STAGES.md §1.3)
             (slash >> str("D") >> digits.as(:draft_version) >>
@@ -1468,7 +1476,10 @@ module Pubid
         cleaned
       end
 
-      def self.parse(string)
+      # Pre-parse ingestion normalizations (R2): every parse path —
+      # parslet and PG artifact alike — feeds the grammar the same
+      # normalized string.
+      def self.normalize_input(string)
         # Strip .pdf extension if present (Pattern 3: File Extensions)
         cleaned = string.sub(/\.pdf$/i, "")
 
@@ -1822,11 +1833,10 @@ module Pubid
         # Fix 2H: "IEC XXXX First edition YYYY-MM; IEEE NNNN" -> normalize semicolon
         # Already handled by earlier semicolon normalization
 
-        # Fix 2I: "IEEE/ISO/IEC PXXX/DIS" -> normalize to "ISO/IEC/IEEE PXXX/DIS"
-        cleaned = cleaned.gsub(/^IEEE\/ISO\/IEC\s+(P[\w.-]+)/,
-                               'ISO/IEC/IEEE \1')
-        cleaned = cleaned.gsub(/^IEEE\/IEC\/ISO\s+(P[\w.-]+)/,
-                               'IEC/ISO/IEEE \1')
+        # (Fix 2I removed: "IEEE/ISO/IEC PXXX/…" is no longer rewritten to
+        # ISO-first — the printed publisher order is the organization's
+        # perspective (pubid#469) and the joint P-form rule parses it as
+        # printed.)
 
         # Fix 2J: "IEEE/IEC PXXX D5" -> normalize space to slash before D
         cleaned = cleaned.gsub(/^(IEEE\/IEC P[\w.-]+)\s+D(\d)/, '\1/D\2')
@@ -1925,7 +1935,11 @@ module Pubid
         # Fix 2AF: "IEEE Std 1003.1/2003.l/lNT" -> fix typos
         # .l -> .1 and lNT -> INT handled by existing fixes
 
-        new.parse(cleaned)
+        cleaned
+      end
+
+      def self.parse(string)
+        new.parse(normalize_input(string))
       end
     end
   end

data/lib/pubid/ieee/renderer.rb

@@ -169,9 +169,11 @@ module Pubid
           # ("D08, September, 2018").
           if id.draft_obj
             printed = id.draft_obj.to_s
-            if id.publisher == "IEC" && id.copublisher == ["IEEE"]
-              printed = printed.split(", ").first
-            elsif id.publisher == "IEEE" && id.draft_status.to_s.empty?
+            # The draft designator carries its date on every lead
+            # (docs/IEEE-DRAFT-STAGES.md §3: "the draft designator with its
+            # date" — the IEC/IEEE-led date-drop contradicted the DCD
+            # convention and the raw records).
+            if id.publisher == "IEEE" && id.draft_status.to_s.empty?
               # The long comma form is for dated project drafts; an
               # unapproved-draft render keeps its pinned single-comma form
               # (pubid#318 idempotence).

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

@@ -64,7 +64,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:ietf, identifier)
         Builder.build(parsed)
       end
     end

data/lib/pubid/isbn/identifier.rb

@@ -64,7 +64,7 @@ module Pubid
 
       # @raise [Pubid::Errors::ParseError] if the string is not a valid ISBN
       def self.build_identifier(identifier)
-        parsed = Parser.parse(identifier)
+        parsed = Pubid::Parg::Backend.parse(:isbn, identifier)
         Builder.build(parsed)
       rescue ArgumentError => e
         # The Builder validates length and check digit. Surface that as a parse

data/lib/pubid/iso/identifier.rb

@@ -304,7 +304,10 @@ module Pubid
         when :mr_string
           Pubid::Parsers::MrString.parse(string)
         else
-          parsed = Pubid::Iso::Parser.new.parse(string)
+          # R1 parser swap: the baked PG artifact is the identifier
+          # parser of record; the Builder consumes the same attribute
+          # hash it always has.
+          parsed = Pubid::Parg::Backend.parse(:iso, string)
           Pubid::Iso::Builder.new.build(parsed)
         end
       end

data/lib/pubid/iso/normalizer.rb

@@ -27,7 +27,10 @@ module Pubid
         private
 
         def parse_with_builder(string)
-          parsed = Pubid::Iso.parser.parse(string)
+          # R2 ingestion hook: normalized strings reach the model through
+          # the same parser of record as Identifier.parse (the baked PG
+          # artifact), so every Tier-3 normalization feeds one grammar.
+          parsed = Pubid::Parg::Backend.parse(:iso, string)
           Pubid::Iso.builder.build(parsed)
         end
 

data/lib/pubid/itu/CLAUDE.md

@@ -67,3 +67,49 @@ on any call. The base now derives the key from the class name
 `underscore` is not a dependency. metanorma-itu constructs through this
 lookup; its flavor-local `pubid_contribution.rb` render override can be
 deleted once it migrates.
+
+## relaton's query forms — RR, OB sector, publication ids
+
+Four forms relaton's `Relaton::Itu::Pubid` parsed and `Pubid::Itu` did not
+(hand-off itu-relaton-query-forms). None of them occurs in the published
+`relaton-data-itu` index — no `series: RR`, no OB row, no six-digit part — and
+a replay of all 24,382 rows and every ITU pass fixture showed 0 changes.
+
+- **Radio Regulations** — `Identifiers::RadioRegulations`
+  (`pubid:itu:radio-regulations`): `ITU-R RR`, `ITU-R RR (2020)`, and the URL
+  spelling `ITU-R RR-2020`, which used to build a *wrong* Recommendation
+  (series `RR`, number `2020`) with no error. "RR" is the series; there is no
+  code, so `#number` returns the series and `root.number` is `"RR"`. The rule
+  ends in `any.absent?`: it sits before `with_series`, and PEG never re-enters
+  the alternation, so a partial match on `ITU-R RR.1` must fail inside it.
+- **Operational Bulletins keep their sector.** This reverses the old
+  "cross-bureau, sector must not be set" rule: `validate_ob_no_sector!` is
+  gone, `ITU-T OB.1096 (2016)` renders back as it is, and the sector-less
+  `ITU OB No. 1096` is unchanged. The long forms with a sector (`ITU-T OB No.
+  1096`) now normalise to `ITU-T OB.1096`. `No.` stays in the default
+  render — it is how ITU's bulletin site and pubid v1 write it — and
+  metanorma-itu's `ITU OB 1000` / `Annex to ITU OB 1000` (its i18n template
+  omits `No.`) is accepted on parse (`ob_bare_body`) and rendered with it.
+  The sector is a spelling, not
+  identity: `SpecialPublication#==` skips it, the URN keeps `urn:itu:itu:…`
+  and `mr_type` stays nil, so both spellings are one bulletin on every
+  surface except `to_s`/`to_hash`. The printed date `- 15.III.2016` sets
+  `date.day`, which only this form does, so `render_ob_date` uses the day as
+  the spelling marker; `day_to_kv` emits only then.
+- **`-YYYYMM` is a date, never a part.** `part` refuses a six-digit run with a
+  19xx/20xx year and a 01–12 month (`yyyymm_shape`), and `id_date` reads it as
+  year+month. `-200313`, `-180001` stay parts. `ITU-T REC T.4` drops the
+  uncaptured `rec_word`; `T-REC-T.4-200307-I` is `publication_id`, last in
+  `identifier` (nothing else starts with a bare sector letter), and requires
+  the date. The trailing status letter (`I` in force, `S` superseded) is
+  parsed and dropped: it names the state of an edition, not the edition.
+  **`S` is also the Spanish language suffix**, so it is a status only inside
+  the full `T-REC-…` id (`id_status`); after an `ITU-T …-YYYYMM` print form
+  only `-I` is (`print_id_status`), and `ITU-T Z.100-199911-S` keeps language
+  `S`. The `-YYYYMM` date and `REC` word are also in `base_with_series`/
+  `base_without_series`: the part guard applies there too, so without them
+  `ITU-T G.989-200307 Amd 1` — a (wrong) Amendment on `main` — stopped parsing.
+  The day of an OB date reaches the URN (`…:15/03/2016`), since it is in `==`.
+  **Not done:** an RR supplement (`ITU-R RR (2020) Amd 1` fails; the
+  base-less `ITU-R RR Amd 1` still builds an Amendment on series `RR`), and
+  `ITU-R RR-E` is still a Recommendation numbered `E` — both as on `main`.

data/lib/pubid/itu/builder.rb

@@ -50,6 +50,16 @@ module Pubid
           return sp
         end
 
+        # Radio Regulations — "ITU-R RR (2020)"
+        if data[:radio_regulations]
+          return Identifiers::RadioRegulations.new(
+            sector: Components::Sector.new(sector: data[:sector].to_s),
+            series: Components::Series.new(series: "RR"),
+            date: data[:year] ? build_date(data) : nil,
+            language: data[:language]&.to_s,
+          )
+        end
+
         # Check if this is a supplement identifier
         if data[:supplement_type]
           supp = build_supplement(data)
@@ -153,11 +163,12 @@ module Pubid
         nil
       end
 
-      # Build Special Publication (OB). Sector is silently dropped — OB is a
-      # cross-bureau publication and `Identifier` rejects sector+OB
-      # in its constructor.
+      # Build Special Publication (OB). The sector of the TSB spelling
+      # ("ITU-T OB.1096") is kept so the bulletin renders back as it was cited;
+      # SpecialPublication#== ignores it, since OB is cross-bureau.
       def build_special_publication(data)
         Identifiers::SpecialPublication.new(
+          sector: (Components::Sector.new(sector: data[:sector].to_s) if data[:sector]),
           series: Components::Series.new(series: "OB"),
           code: data[:number] ? build_code(data) : nil,
           date: data[:year] ? build_date(data) : nil,
@@ -344,10 +355,19 @@ module Pubid
         )
       end
 
+      # The Roman month of a bulletin date ("15.III.2016") is stored as the
+      # two-digit month every other ITU date uses; the day marks the spelling.
       def build_date(data)
+        month = if data[:roman_month]
+                  (Identifiers::SpecialPublication::ROMAN_MONTHS.index(data[:roman_month].to_s) + 1)
+                    .to_s.rjust(2, "0")
+                else
+                  data[:month]&.to_s
+                end
         Pubid::Components::Date.new(
           year: data[:year].to_s,
-          month: data[:month]&.to_s,
+          month: month,
+          day: data[:day]&.to_s,
         )
       end
 

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

@@ -15,7 +15,7 @@ module Pubid
           raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
         end
 
-        parsed = Parser.parse(normalize_whitespace(identifier))
+        parsed = Pubid::Parg::Backend.parse(:itu, normalize_whitespace(identifier))
         Builder.build(parsed)
       end
 
@@ -101,8 +101,6 @@ module Pubid
         end
 
         super
-
-        validate_ob_no_sector!
       end
 
       # The document number lives on the `code` component for ITU; surface it at
@@ -462,6 +460,16 @@ module Pubid
         model.code ||= Components::Code.new
       end
 
+      # The day is set only by the printed bulletin date ("15.III.2016"), so
+      # it emits only there and no existing index row gains a key.
+      def day_to_kv(model, doc)
+        emit_kv(doc, "day", model.date&.day)
+      end
+
+      def day_from_kv(model, value)
+        date_for(model).day = value.to_s
+      end
+
       def date_for(model)
         model.date ||= Pubid::Components::Date.new
       end
@@ -472,21 +480,6 @@ module Pubid
         str = value.to_s
         LANGUAGES[str] || str
       end
-
-      # OB (Operational Bulletin) is a cross-bureau ITU publication and
-      # must not have a sector. Direct construction with both raises;
-      # the parser silently drops sector for legacy strings like
-      # "ITU-T OB.X" (handled in Builder).
-      def validate_ob_no_sector!
-        return unless series&.series == "OB"
-        return if sector.nil?
-        return if sector.is_a?(Components::Sector) && (sector.sector.nil? || sector.sector.to_s.empty?)
-
-        raise ArgumentError,
-              "OB (Operational Bulletin) is a cross-bureau ITU publication; " \
-              "sector must not be set"
-      end
     end
-
   end
 end

data/lib/pubid/itu/identifiers/radio_regulations.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Itu
+    module Identifiers
+      # The ITU Radio Regulations — the treaty text revised by each World
+      # Radiocommunication Conference.
+      # Format: ITU-R RR [(YYYY)]
+      # Example: ITU-R RR (2020)
+      #
+      # It has no document number: "RR" is the whole designation, stored as
+      # the series. `#number` returns it, so `root.number` (the relaton-index
+      # key) is not empty.
+      class RadioRegulations < Identifier
+        include StandardSerialization
+
+        def number
+          series&.series
+        end
+
+        def render_base(**_opts)
+          "#{publisher}-#{sector} #{series}#{render_date_suffix}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/itu/identifiers/special_publication.rb

@@ -4,26 +4,60 @@ module Pubid
   module Itu
     module Identifiers
       # ITU Special Publication — currently models the Operational Bulletin (OB).
-      # OB is a cross-bureau publication (no sector) rendered as
-      # "ITU OB No. {number}" with optional date.
-      #
-      # Pattern: "ITU OB No. 1283 (01/2024)"
+      # OB is a cross-bureau publication. ITU prints it without a sector
+      # ("ITU OB No. 1283 (01/2024)"); the TSB spelling carries one
+      # ("ITU-T OB.1096 (2016)"), which is kept and rendered back. The sector
+      # is not part of the identity: `==`, the URN and the MR slug ignore it,
+      # so both spellings name one bulletin.
       class SpecialPublication < Identifier
         include StandardSerialization
 
+        ROMAN_MONTHS = %w[I II III IV V VI VII VIII IX X XI XII].freeze
+
         def render_base(**_opts)
           number = code&.number
-          result = "#{publisher} #{series} No. #{number}"
-
-          if date
-            result += if date.month
-                        " (#{date.month.to_s.rjust(2, '0')}/#{date.year})"
-                      else
-                        " (#{date.year})"
-                      end
-          end
+          result = if sector
+                     "#{publisher}-#{sector} #{series}.#{number}"
+                   else
+                     "#{publisher} #{series} No. #{number}"
+                   end
+
+          result + render_ob_date
+        end
+
+        # Cross-bureau: the sector is how one bureau cites the bulletin, not
+        # which bulletin it is.
+        def ==(other)
+          return false unless other.instance_of?(self.class)
+
+          series == other.series &&
+            code == other.code &&
+            date == other.date &&
+            language == other.language &&
+            common_text_twin == other.common_text_twin
+        end
+
+        # Keep the MR slug sector-free, like `==` (it was always so, because
+        # the sector used to be dropped).
+        def mr_type
+          nil
+        end
 
-          result
+        private
+
+        # " (MM/YYYY)" or " (YYYY)"; the day-bearing date is the printed
+        # bulletin form " - 15.III.2016", the only spelling that sets a day.
+        def render_ob_date
+          return "" unless date
+
+          if date.day && date.month
+            roman = ROMAN_MONTHS[date.month.to_i - 1]
+            " - #{date.day.to_s.rjust(2, '0')}.#{roman}.#{date.year}"
+          elsif date.month
+            " (#{date.month.to_s.rjust(2, '0')}/#{date.year})"
+          else
+            " (#{date.year})"
+          end
         end
       end
     end

data/lib/pubid/itu/identifiers/standard_serialization.rb

@@ -46,6 +46,8 @@ module Pubid
                 with: { to: :year_to_kv, from: :year_from_kv }
             map "month",
                 with: { to: :month_to_kv, from: :month_from_kv }
+            map "day",
+                with: { to: :day_to_kv, from: :day_from_kv }
             map "language", to: :language
             map "common_text_twin",
                 with: { to: :common_text_twin_to_kv,

data/lib/pubid/itu/identifiers.rb

@@ -16,6 +16,7 @@ module Pubid
       autoload :Errata, "#{__dir__}/identifiers/errata"
       autoload :Handbook, "#{__dir__}/identifiers/handbook"
       autoload :Question, "#{__dir__}/identifiers/question"
+      autoload :RadioRegulations, "#{__dir__}/identifiers/radio_regulations"
       autoload :Recommendation, "#{__dir__}/identifiers/recommendation"
       autoload :Report, "#{__dir__}/identifiers/report"
       autoload :SpecialPublication, "#{__dir__}/identifiers/special_publication"