relaton 3.0.0.pre.alpha.1 → 3.0.0.pre.alpha.3

data/lib/relaton/bsi/hit_collection.rb

@@ -49,14 +49,14 @@ module Relaton::Bsi
     #
     # Filter the search results for a BSI standard.
     #
-    # @param [MatchData] code_parts parts of document identifier
+    # @param [Pubid::Bsi::Identifier] query the parsed query reference
     #
     # @return [self] filtered search results
     #
-    def filter_hits!(code_parts)
-      hits = filter code_parts
-      hits = filter code_parts, skip_rest: true if hits.empty?
-      hits = filter code_parts, drop_amd: true if hits.empty?
+    def filter_hits!(query)
+      hits = filter query
+      hits = filter query, skip_rest: true if hits.empty?
+      hits = filter query, drop_amd: true if hits.empty?
       @array = hits
       self
     end
@@ -93,20 +93,19 @@ module Relaton::Bsi
     end
 
     #
-    # Select hits that match the document identifier.
+    # Select hits that match the query reference.
     #
-    # @param [MatchData] code_parts parts of document identifier
-    # @param [Boolean] drop_amd drop amendments and corrigendums
-    # @param [Boolean] skip_rest skip rest suffix of document identifier
+    # @param [Pubid::Bsi::Identifier] query the parsed query reference
+    # @param [Boolean] drop_amd match base documents only (ignore supplements)
+    # @param [Boolean] skip_rest ignore the free-text suffix (ExComm / Flex version)
     #
-    def filter(code_parts, drop_amd: false, skip_rest: false) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def filter(query, drop_amd: false, skip_rest: false)
       @array.select do |i|
-        code = drop_amd ? i.hit[:code].sub(/\+[AC]\d+.*$/, "") : i.hit[:code]
-        cp = Bibliography.code_parts code
-        match = cp[:code] == code_parts[:code] && cp[:a] == code_parts[:a] &&
-          (!code_parts[:y] || cp[:y] == code_parts[:y]) &&
-          (skip_rest || cp[:rest] == code_parts[:rest])
-        i.hit[:code] = code if drop_amd && match
+        hit = i.pubid or next false
+        match = Bibliography.same_reference?(query, hit, skip_rest: skip_rest, drop_amd: drop_amd)
+        # When matching base documents only, drop the amendment from the hit's
+        # rendered id too, so the returned reference is the base document.
+        i.hit[:code] = hit.base_document.to_s if drop_amd && match
         match
       end
     end

data/lib/relaton/bsi/model/docidentifier.rb

@@ -1,8 +1,114 @@
+require_relative "../../iso/type/pubid"
+
 module Relaton
   module Bsi
+    # BSI document identifier. Keeps the parsed `Pubid::Bsi::Identifier` as the
+    # single stored value of `content` (via `Iso::Type::Pubid`, which preserves
+    # the instance on the way in and stringifies it on the way out), so there is
+    # one source of truth for the identifier — `#pubid` returns it and `#content`
+    # renders it to a string. Non-BSI identifiers (e.g. ISBN) and anything pubid
+    # can't parse are stored verbatim as plain strings.
     class Docidentifier < Bib::Docidentifier
+      attribute :content, Iso::Type::Pubid
+
+      def initialize(arg = nil, **kwargs)
+        arg.is_a?(Hash) ? super(arg) : super(**kwargs)
+        # Content may have been set before type during lutaml init. Re-run the
+        # setter so the type-dependent parse (e.g. the ISBN bypass) applies.
+        raw = arg.is_a?(Hash) ? (arg["content"] || arg[:content]) : kwargs[:content]
+        self.content = raw if raw
+      end
+
+      alias_method :original_content=, :content=
+      alias_method :original_content, :content
+
+      # Store the parsed pubid instance (or the raw string for ISBN / anything
+      # pubid can't parse) as the single source of truth.
+      def content=(value)
+        send(:original_content=, parse_pubid(value) || value)
+      end
+
+      # The rendered identifier — pubid instances are stringified.
+      # @return [String, nil]
+      def content
+        original_content&.to_s
+      end
+
+      # The parsed identifier, when the content is a BSI reference. BSI has no
+      # dedicated pubid `AllParts` subclass, so `#to_all_parts!` stores the
+      # generic `Pubid::AllPartsIdentifier` wrapper here — not a
+      # `Pubid::Bsi::Identifier` — hence the second branch.
+      # @return [Pubid::Bsi::Identifier, Pubid::AllParts, nil]
+      def pubid
+        c = original_content
+        c if c.is_a?(::Pubid::Bsi::Identifier) || c.is_a?(::Pubid::AllParts)
+      end
+
+      def to_s
+        content.to_s
+      end
+
+      # Strip the publication date to build a most-recent (undated) reference.
+      # pubid's `exclude` propagates into nested identifiers (so a consolidated
+      # base date is dropped while the amendment is kept); `:month` is excluded
+      # alongside `:date` because Flex stores the month separately.
       def remove_date!
-        content&.sub!(/:\d{4}(?:-\d{2})?/, "")
+        return unless pubid
+
+        self.content = pubid.exclude(:date, :month)
+      end
+
+      # Strip the part (and subpart) to build a whole-standard reference.
+      # pubid's `exclude` returns a new instance and propagates into nested
+      # identifiers, so the part is dropped even on adopted (BS EN ISO …) and
+      # consolidated (…+A1:…) ids while any amendment is kept.
+      def remove_part!
+        return unless pubid
+
+        self.content = pubid.exclude(:part, :subpart)
+      end
+
+      # Reduce to the all-parts form by wrapping `pubid` (not a part-stripped
+      # copy): `to_all_parts`'s own identity computation already strips
+      # part/date for rendering (`#to_s`/`#===`), and wrapping the original
+      # keeps `identifiers` holding the real identifier this reference came
+      # from. The one exception is a supplement's own year: pubid protects an
+      # `Amendment`/`Corrigendum`'s own date from a bare `exclude(:date)` (the
+      # same protection `#remove_date!` above relies on to drop the base
+      # year while keeping the amendment's), but `to_all_parts` builds its
+      # identity through that same `exclude`, so the protection would leave a
+      # consolidated id's amendment year distinguishing editions that
+      # "(all parts)" is meant to collapse — hence the explicit
+      # `exclude(:supplement_year)` pre-step, which force-clears it instead.
+      # BSI has no dedicated pubid `AllParts` subclass (unlike ISO/IEC), so
+      # the wrapper is the generic `Pubid::AllPartsIdentifier` — its `#to_s`
+      # DOES print a "(all parts)" marker, unlike BSI's own renderer, which
+      # never had one. Because BSI stores its parsed pubid as the single
+      # source of `content` (`Iso::Type::Pubid`), `content` and `#pubid`
+      # can't diverge here the way they do for flavors with a separately
+      # cached content string: both now show the marker (see `#pubid` above,
+      # widened to accept it).
+      def to_all_parts!
+        return if !pubid || pubid.all_parts?
+
+        self.content = pubid.exclude(:supplement_year).to_all_parts
+      end
+
+      private
+
+      # @return [Pubid::Bsi::Identifier, nil]
+      def parse_pubid(value)
+        case value
+        when ::Pubid::Bsi::Identifier then value
+        when String
+          return nil if type == "ISBN"
+
+          begin
+            ::Pubid::Bsi::Identifier.parse(value)
+          rescue StandardError
+            nil
+          end
+        end
       end
     end
   end

data/lib/relaton/bsi/processor.rb

@@ -5,6 +5,7 @@ module Relaton::Bsi
     def initialize
       @short = :relaton_bsi
       @prefix = "BSI"
+      @pubid_flavor = :Bsi # global prefixes sourced from Pubid::Bsi.prefixes
       @defaultprefix = %r{^(BSI|BS|PD)\s}
       @idtype = "BSI"
     end

data/lib/relaton/calconnect/bibliography.rb

@@ -20,26 +20,21 @@ module Relaton::Calconnect
       # @option opts [TrueClass, FalseClass] :bibdata
       #
       # @return [RelatonCalconnect::CcBibliographicItem]
-      def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        code = ref
-
-        if year.nil?
-          /^(?<code1>[^\s]+(?:\s\w+)?\s[\d-]+):?(?<year1>\d{4})?/ =~ ref
-          unless code1.nil?
-            code = code1
-            year = year1
-          end
-        end
-
+      # The reference is no longer split by regex before searching. pubid parses
+      # `CC/DIR 10005:2019` whole, so a dated reference narrows to that row in
+      # the index itself; the `year` ARGUMENT is what still needs filtering
+      # afterwards, because an undated reference reaches every year of the
+      # document. That split is why `bib_results_filter` stays.
+      def get(ref, year = nil, opts = {})
         Util.info "Fetching from Relaton repository ...", key: ref
-        result = search(code, year, opts) || (return nil)
+        result = search(ref, year, opts) || (return nil)
         ret = bib_results_filter(result, year)
         if ret[:ret]
           Util.info "Found: `#{ret[:ret].docidentifier.first.content}`", key: ref
           ret[:ret]
         else
           Util.info "Not found.", key: ref
-          fetch_ref_err(code, year, ret[:years])
+          fetch_ref_err(ref, year, ret[:years])
         end
       end
 
@@ -63,7 +58,10 @@ module Relaton::Calconnect
           item.fetched = Date.today.to_s
           return { ret: item } if !year
 
-          /:(?<id_year>\d{4})$/ =~ r.hit[:id]
+          # The row id is a `Pubid::Calconnect::Identifier` now, so the year is
+          # read off the identifier rather than scraped from a rendered string.
+          # The old `/:(\d{4})$/` regex would raise TypeError against it.
+          id_year = r.hit[:id].date&.year
           return { ret: item } if year.to_i == id_year.to_i
 
           missed_years << id_year.to_i if id_year

data/lib/relaton/calconnect/data_fetcher.rb

@@ -4,6 +4,11 @@ require "json"
 require "mechanize"
 require "relaton/core"
 require "relaton/index"
+# The flavor top-level, for INDEXFILE and ::Pubid::Calconnect::Identifier.
+# `relaton-data-calconnect`'s crawler requires THIS file and nothing else, so
+# without it `#index` NameErrors on the very first document. (The ECMA form;
+# the same invariant the processor's `remove_index_file` follows.)
+require_relative "../calconnect"
 require_relative "scraper"
 require_relative "util"
 
@@ -18,8 +23,18 @@ module Relaton::Calconnect
       @etagfile ||= File.join @output, "etag.txt"
     end
 
+    # The pubid `index-v2` this crawl builds.
+    #
+    # `pubid_class:` is required on the producer too: `FileIO#save` calls
+    # `to_hash` only for instances of it, so without it the crawl writes
+    # v1-shaped rows under a v2 name, silently, and the consumer then rejects
+    # the whole index. Memoized with `||=` — re-creating the Type on every call
+    # evicts the pooled entry a suite (or a sibling call site) set up.
     def index
-      @index = Relaton::Index.find_or_create :CC, file: "index-v1.yaml"
+      @index ||= Relaton::Index.find_or_create(
+        :CC, file: "#{INDEXFILE}.yaml",
+             pubid_class: ::Pubid::Calconnect::Identifier
+      )
     end
 
     def log_error(msg)
@@ -66,21 +81,74 @@ module Relaton::Calconnect
     end
 
     def write_doc(slug, bib) # rubocop:disable Metrics/MethodLength
-      file = output_file slug
+      # Distinct slugs can sanitize to one filename; take a path of our own
+      # rather than overwriting the other document (Core#unique_output_file).
+      file = unique_output_file slug
       if @files.include? file
+        # Same reserved path == same slug: a genuine duplicate. Checked FIRST,
+        # because a disambiguated path stays != output_file forever.
         Util.warn "#{file} exist"
-      else
-        @files << file
+      elsif file != output_file(slug)
+        Util.warn "#{output_file slug} exist; writing #{file} instead"
       end
-      index.add_or_update primary_docid(bib), file
+      @files << file
+      # Write first, index second: an id pubid rejects is skipped from the
+      # index, and the document still has to reach disk.
       File.write file, serialize(bib), encoding: "UTF-8"
+      add_to_index bib, file
+    end
+
+    #
+    # Index the document, or record why it could not be indexed.
+    #
+    # An id pubid cannot rebuild is recorded in `@errors` — the inherited
+    # `report_errors` logs a String value as the message, and its GhIssue
+    # channel opens a GitHub issue at the end of the crawl — and the row is
+    # skipped rather than indexed unparsed: `Relaton::Index` rejects the WHOLE
+    # index if a single row fails to deserialize, and its sort calls
+    # `.root.number` on every id. The data file is already written by the
+    # caller, so the document is unindexed, never lost. (The ECMA/W3C shape.)
+    #
+    # @param bib [Relaton::Calconnect::ItemData]
+    # @param file [String] path the document was written to
+    #
+    def add_to_index(bib, file)
+      id = index_id bib
+      return index.add_or_update(id, file) if id
+
+      docid = primary_docid(bib)&.content || file
+      @errors[docid.to_s] = "Unparseable primary id `#{docid}` was not indexed (#{file})"
+    end
+
+    #
+    # The index key: the primary docidentifier's own
+    # `Pubid::Calconnect::Identifier`.
+    #
+    # Taken from the parsed model, never re-parsed from a rendered string, and
+    # never mutated — unlike ECMA, the CalConnect index key IS the document's
+    # printed id (`CC/DIR 10005:2019`), because pubid renders the publisher by
+    # default and the flavor models no edition or volume. There is no
+    # index-only component to add and none to strip.
+    #
+    # It is still **duplicated**, for a different reason than ECMA's: the index
+    # holds the object, and `Docidentifier#remove_date!` mutates the identifier
+    # in place. Sharing it would let anything that asks a crawled record for its
+    # most-recent reference rewrite an already-indexed key, between
+    # `add_or_update` and `index.save`, with nothing to show for it.
+    #
+    # @param bib [Relaton::Calconnect::ItemData]
+    # @return [Pubid::Calconnect::Identifier, nil] nil if pubid rejects the docid
+    #
+    def index_id(bib)
+      primary_docid(bib)&.pubid&.dup
     end
 
-    # Index entries are keyed by the canonical doc identifier
-    # (e.g. "CC/DIR 10005:2019"), not the upstream slug used for filenames.
+    # The docidentifier the index is keyed on — the canonical one
+    # (e.g. "CC/DIR 10005:2019"), never the upstream slug used for filenames.
+    # Every published record carries exactly one, marked primary; the fallback
+    # is for a record that marks none.
     def primary_docid(bib)
-      docid = bib.docidentifier.find(&:primary) || bib.docidentifier.first
-      docid.content
+      bib.docidentifier.find(&:primary) || bib.docidentifier.first
     end
 
     def to_yaml(bib) = bib.to_yaml

data/lib/relaton/calconnect/docidentifier.rb

@@ -0,0 +1,80 @@
+module Relaton
+  module Calconnect
+    # A CalConnect document identifier that carries its parsed pubid alongside
+    # the source string.
+    #
+    # Every published record carries exactly one docidentifier, `type:
+    # CalConnect`, `primary: true`, in the form `CC[/<series>] <number>[:<date>]`
+    # — `CC/DIR 10005:2019`, `CC 18011:2018`, `CC/WD 51017:2024-07-23`. That is
+    # exactly what `Pubid::Calconnect::Identifier.parse` accepts, so nothing has
+    # to synthesize or strip a publisher prefix.
+    # `DataFetcher#index_id` takes `#pubid` straight from here to build the
+    # `index-v2` rows.
+    #
+    # Follows the IHO/W3C shape rather than the ISO one: `content=` calls
+    # `super` first, so `content` keeps the source string verbatim and
+    # serialization is unchanged. That matters here beyond convention —
+    # `Relaton::Calconnect::ItemData#create_id` derives the record's `id` from
+    # `content.gsub(/\W+/, "")`, so a re-render would move every published id.
+    #
+    # Unlike W3C, CalConnect ids carry a date, so `remove_date!` is real and has
+    # to re-render. It writes back through `store_content`, never `content=`: a
+    # re-parse would rebuild `@pubid` from the string and discard the mutation.
+    #
+    # There is deliberately no `render` option to opt out of. `Pubid::Calconnect`
+    # renders the publisher by default and models no edition or volume, so its
+    # default output IS the stored docid form — the index key and the document's
+    # own printed id are the same string. This is why the flavor needs no
+    # `with_*` flag dance (contrast `Relaton::Ecma::Docidentifier`, which opts
+    # out of two, and `Relaton::ThreeGpp::Docidentifier`, which opts in to one).
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      # Capture the inherited (LocalizedMarkedUpString) content setter before
+      # overriding #content=, so #refresh_content! can write the re-rendered
+      # string back WITHOUT re-parsing.
+      alias_method :store_content, :content=
+
+      def content=(value)
+        super
+        @pubid = value && parse(value)
+      end
+
+      # CalConnect's one optional component, and the only real mutator here.
+      # `CC/DIR 10005:2019` -> `CC/DIR 10005`.
+      def remove_date!
+        return unless @pubid
+
+        @pubid.date = nil
+        refresh_content!
+      end
+
+      # No-ops, and not for lack of an override. A CalConnect number is one
+      # token — `0812-1` and `0707.1` are numbers, not a number plus a part —
+      # so `Pubid::Calconnect::Identifier` models no part, and there is nothing
+      # for either of these to strip. Stated explicitly so the next reader does
+      # not "fix" them by splitting the number.
+      def remove_part!; end
+
+      def to_all_parts!; end
+
+      private
+
+      # An identifier that does not parse is a data defect, so it is reported at
+      # ERROR — never at WARN. It does not raise: an already-published record
+      # still has to deserialize and render. The crawl escalates the same
+      # failure into a tracked GitHub issue (see `DataFetcher#add_to_index` and
+      # `Core::DataFetcher#report_errors`).
+      def parse(value)
+        ::Pubid::Calconnect::Identifier.parse value.to_s
+      rescue StandardError => e
+        Util.error "Failed to parse pubid `#{value}`: #{e.message}"
+        nil
+      end
+
+      def refresh_content!
+        store_content(@pubid.to_s)
+      end
+    end
+  end
+end

data/lib/relaton/calconnect/hit_collection.rb

@@ -1,84 +1,92 @@
-require "yaml"
-require "fileutils"
-
 module Relaton::Calconnect
   class HitCollection < Relaton::Core::HitCollection
-    # ENDPOINT = "https://standards.calconnect.org/relaton/index.yaml".freeze
-    # ENDPOINT = "http://127.0.0.1:4000/relaton/index.yaml".freeze
-    # DATADIR = File.expand_path ".relaton/calconnect", Dir.home
-    # DATAFILE = File.expand_path "bibliography.yml", DATADIR
-    # ETAGFILE = File.expand_path "etag.txt", DATADIR
     GHURL = "https://raw.githubusercontent.com/relaton/relaton-data-calconnect/refs/heads/v2/".freeze
 
     # @param ref [Strig]
     # @param year [String]
-    # @param opts [Hash]
     def initialize(ref, year = nil)
       super
-      # @array = from_yaml(ref).sort_by do |hit|
-      #   hit.hit["revdate"] ? Date.parse(hit.hit["revdate"]) : Date.new
-      # end.reverse
-      index = Relaton::Index.find_or_create :CC, url: "#{GHURL}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
-      @array = index.search(ref).map do |row|
-        Hit.new(row, self)
-      end
+      @array = search_index(ref).map { |row| Hit.new(row, self) }
     end
 
-    # private
+    private
+
+    # @return [Relaton::Index::Type]
+    def index
+      Relaton::Index.find_or_create :CC, url: "#{GHURL}#{INDEXFILE}.zip",
+                                         file: "#{INDEXFILE}.yaml",
+                                         pubid_class: ::Pubid::Calconnect::Identifier
+    end
 
     #
-    # Fetch data from yaml
+    # The index rows matching a reference, most recent first.
     #
-    # @param docid [String]
+    # **The pubid is passed to `Index::Type#search`, not the string.**
+    # `search_candidates` narrows only when the argument is not a `String`, and
+    # a block alone never narrows — so the plain string this used to pass
+    # disabled the binary search however the index was built. `pubid_class:` on
+    # the index alone fixes nothing; both had to change together.
     #
-    # @return [Array<RelatonBib::Hit>]
+    # This also ends the substring scan the old string search did, which was
+    # silently ambiguous: `CC/DIR 1000` answered with all five `CC/DIR 1000x`
+    # documents and `CC/A 1` with every `CC/A 1xxx`. A number now matches
+    # exactly, and a leading zero is significant (`CC/A 0001` is not `CC/A 1`).
     #
-    # def from_yaml(docid, **_opts)
-    #   data["root"]["items"].select do |doc|
-    #     doc["docid"] && doc["docid"]["id"].include?(docid)
-    #   end.map { |h| Hit.new(h, self) }
-    # end
-
+    # The rows are selected with pubid's subset match `pubid === row`, the
+    # default of `Index::Type#search`. A date that the reference omits matches
+    # any value. pubid declares `series` strict for CalConnect, so the series
+    # keeps `CC/CD 51016` and `CC/WD 51016` apart, and a series-less
+    # `CC 36010` does not match `CC/WD 36010`.
     #
-    # Fetches YAML data
+    # @param ref [String]
+    # @return [Array<Hash>] matching index rows
     #
-    # @return [Hash]
-    # def data
-    #   FileUtils.mkdir_p DATADIR
-    #   ctime = File.ctime DATAFILE if File.exist? DATAFILE
-    #   fetch_data if !ctime || ctime.to_date < Date.today
-    #   @data ||= YAML.safe_load File.read(DATAFILE, encoding: "UTF-8")
-    # end
+    def search_index(ref)
+      pubid = parse_ref ref
+      return [] unless pubid
+
+      index.search(pubid).sort_by { |row| [recency_key(row[:id]), row[:file]] }
+    end
 
     #
-    # fetch data from server and save it to file.
+    # Parse a user reference into a `Pubid::Calconnect::Identifier`, or nil.
     #
-    # def fetch_data
-    #   resp = Faraday.new(ENDPOINT, headers: { "If-None-Match" => etag }).get
-    #   # return if there aren't any changes since last fetching
-    #   return unless resp.status == 200
-
-    #   self.etag = resp[:etag]
-    #   @data = YAML.safe_load resp.body
-    #   File.write DATAFILE, @data.to_yaml, encoding: "UTF-8"
-    # end
-
+    # A reference pubid rejects is a **miss, not an error**: this returns nil
+    # outside the transport rescue in `Bibliography.search`, so it never becomes
+    # a `Relaton::RequestError`.
     #
-    # Read ETag from file
+    # @param ref [String]
+    # @return [Pubid::Calconnect::Identifier, nil]
     #
-    # @return [String, NilClass]
-    # def etag
-    #   @etag ||= if File.exist? ETAGFILE
-    #               File.read ETAGFILE, encoding: "UTF-8"
-    #             end
-    # end
+    # An unrecognized reference **raises**; like ISO, ETSI and 3GPP we let it
+    # propagate. relaton-cli rescues `Pubid::Errors::Error` and renders
+    # `"..." is not a recognized standards identifier`
+    # (`gems/relaton-cli/lib/relaton/cli/command.rb:324`), and `Db#fetch`
+    # logs it through the `StandardError` arm at `lib/relaton/db.rb:122`.
+    # Rescuing here would collapse "this identifier is malformed" into "no
+    # such document", leaving a caller unable to tell them apart.
+    def parse_ref(ref)
+      ::Pubid::Calconnect::Identifier.parse ref.to_s.strip
+    end
 
     #
-    # Save ETag to file
+    # Sort key placing the most recent document first.
+    #
+    # The index is sorted by number, so rows sharing a number arrive in no
+    # meaningful order — without this, `Bibliography.get "CC/S 0601"` would
+    # answer with an arbitrary one of the 2005 and 2006 documents. Segments are
+    # compared as integers and negated for descending order; an absent month or
+    # day sorts as 0, which is right because only one row in the corpus carries
+    # either.
     #
-    # @param tag [String]
-    # def etag=(e_tag)
-    #   File.write ETAGFILE, e_tag, encoding: "UTF-8"
-    # end
+    # @param id [Pubid::Calconnect::Identifier]
+    # @return [Array<Integer>]
+    #
+    def recency_key(id)
+      date = id.date
+      return [0, 0, 0] unless date
+
+      [date.year, date.month, date.day].map { |part| -part.to_i }
+    end
   end
 end

data/lib/relaton/calconnect/model/item.rb

@@ -1,5 +1,6 @@
 require "relaton/bib"
 require_relative "../item_data"
+require_relative "../docidentifier"
 require_relative "ext"
 
 module Relaton
@@ -7,6 +8,12 @@ module Relaton
     class Item < Bib::Item
       model ItemData
 
+      # The flavor's own Docidentifier, so every parsed record carries a
+      # `#pubid` for `DataFetcher#index_id` to key the index-v2 on. Bibitem and
+      # Bibdata subclass Item, so they inherit it.
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
+
       attribute :ext, Ext
     end
   end

data/lib/relaton/calconnect/processor.rb

@@ -10,6 +10,7 @@ module Relaton::Calconnect
       @defaultprefix = %r{^CC(?!\w)}
       @idtype = "CC"
       @datasets = %w[calconnect-org]
+      @pubid_flavor = :Calconnect
     end
 
     # @param code [String]
@@ -58,9 +59,14 @@ module Relaton::Calconnect
     #
     # Remove index file
     #
+    # `url: true` names the cached file. No `pubid_class:`: `Type#remove_file`
+    # deletes the file and never reads the index.
+    #
     def remove_index_file
       require_relative "../calconnect"
-      Relaton::Index.find_or_create(:CC, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      Relaton::Index.find_or_create(
+        :CC, url: true, file: "#{INDEXFILE}.yaml"
+      ).remove_file
     end
   end
 end

data/lib/relaton/calconnect.rb

@@ -1,3 +1,8 @@
+# Not lazy: DataFetcher names ::Pubid::Calconnect::Identifier as the index
+# `pubid_class:`, and Docidentifier parses every docid through it.
+# (The ECMA/IANA/IHO/OGC form; spec/relaton/lazy_loading_spec.rb guards that
+# this file is not itself loaded when a Db is built.)
+require "pubid"
 require "relaton/index"
 require "relaton/core"
 require_relative "version"
@@ -12,7 +17,12 @@ require_relative "calconnect/scraper"
 
 module Relaton
   module Calconnect
-    INDEXFILE = "index-v1".freeze
+    # The one index this flavor builds and reads: pubid-keyed rows
+    # (`_type: pubid:calconnect:standard`), via
+    # `pubid_class: ::Pubid::Calconnect::Identifier`.
+    # `relaton-data-calconnect`'s crawler derives the legacy `index-v1` from
+    # these rows for released consumers, so it is not produced or read here.
+    INDEXFILE = "index-v2".freeze
 
     # Returns hash of XML reammar
     # @return [String]