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

data/lib/relaton/bipm/bibliography.rb

@@ -1,5 +1,4 @@
 require "mechanize"
-require_relative "id_parser"
 
 module Relaton::Bipm
   class Bibliography
@@ -46,11 +45,14 @@ module Relaton::Bipm
       # @return [RelatonBipm::BipmBibliographicItem]
       #
       def get_bipm(reference) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        ref_id = Id.new.parse reference
-        rows = index.search { |r| ref_id == r[:id] }
-        return unless rows.any?
+        pubid = parse_ref reference
+        rows = search_index pubid, reference
+        return if rows.empty?
 
-        row = rows.sort_by { |r| r[:id][:year] }.last
+        # Latest edition wins. Metrologia and SI Brochure rows carry no year,
+        # so they all score 0; the file path breaks that tie so a repeated
+        # lookup returns the same document (the index sort is not stable).
+        row = rows.max_by { |r| [r[:id].year.to_i, r[:file]] }
         url = "#{GH_ENDPOINT}#{row[:file]}"
         resp = Mechanize.new.get url
         return unless resp.code == "200"
@@ -60,16 +62,163 @@ module Relaton::Bipm
         item
       end
 
+      # Look the reference up in the pubid `index-v2`, narrowing the candidate
+      # rows before the match runs. `Relaton::Index::Type#search` binary-searches
+      # only when given an identifier — the same call shape ISO, OIML and JCGM
+      # use. Both sides are now `Pubid::Bipm` objects, so the bespoke `Id`
+      # grammar takes no part in a query.
+      #
+      # Two escapes sit under the narrowing, each covering a case where the
+      # query's bsearch key cannot equal its row's:
+      #
+      # 1. A bare `SI Brochure` names no edition, so it keys to `""` while its
+      #    row keys to `"9e"`. The rescan finds it.
+      # 2. `CCTF Recommendation 2009-02` parses as the literal number
+      #    `2009-02`, while the row keys on `2`. No row carries that number, so
+      #    a rescan cannot help — only re-reading the tail as number-plus-year.
+      #
+      # @param pubid [Pubid::Bipm::Identifier] the parsed reference
+      # @param reference [String, nil] the raw reference, for the retry
+      # @return [Array<Hash>] the matching index rows
+      def search_index(pubid, reference)
+        # Reduce the query once, not once per row. `#exclude` copies the
+        # identifier, so rebuilding it per candidate dominated the lookup.
+        query_stem = stem pubid, pubid
+        rows = index.search(pubid) { |r| pubid_match? r[:id], pubid, query_stem }
+        rows = index.search { |r| pubid_match? r[:id], pubid, query_stem } if rows.empty?
+        return rows unless rows.empty?
+
+        retry_pubid = year_number_retry reference
+        retry_pubid ? search_index(retry_pubid, nil) : rows
+      end
+
+      # Re-read a trailing `YYYY-NN` as number `NN` of year `YYYY`
+      # (`CCTF Recommendation 2009-02` → `CCTF Recommendation 2 (2009)`). Tried
+      # only after a miss, because `NNNN-NN` is also a real BIPM number
+      # (`CIPM 2005-06`), so the literal reading has to be preferred.
+      #
+      # The re-read string is a machine-derived probe, not the caller's
+      # reference, so a probe that does not parse is a miss (nil), never a
+      # malformed-reference error -- the same rule as ISO's type/stage probe.
+      #
+      # @param reference [String, nil]
+      # @return [Pubid::Bipm::Identifier, nil]
+      def year_number_retry(reference)
+        match = reference&.match(/\A(?<stem>.+)\s(?<year>\d{4})-(?<number>\d+)\z/)
+        return unless match
+
+        parse_ref "#{match[:stem]} #{match[:number].sub(/\A0+(?=\d)/, '')} (#{match[:year]})"
+      rescue ::Pubid::Errors::ParseError
+        nil
+      end
+
+      # Compare a row's identifier with the query. Index rows are stored
+      # language- and form-neutral — verified across all committee-document and
+      # meeting rows — while a reference may name a language (`(2009, E)`) and
+      # always names a form (short `CCTF REC 2` vs long `CCTF Recommendation 2`).
+      # The year joins them when the query omits it, mirroring what `Id#==` did
+      # with `other_hash.delete(:year) unless hash[:year]`.
+      #
+      # @param row_id [Pubid::Bipm::Identifier]
+      # @param query [Pubid::Bipm::Identifier]
+      # @param query_stem [Pubid::Bipm::Identifier, nil] the reduced query, when
+      #   the caller already built it once for the whole search
+      # @return [Boolean]
+      def pubid_match?(row_id, query, query_stem = nil)
+        # A bare brochure names no edition, so it is a partial reference and
+        # cannot equal the `9e v3.01` row. Match any brochure row, which is what
+        # the old `{group: "SI", type: "Brochure"}` projection already meant.
+        if query.is_a?(::Pubid::Bipm::Identifiers::SiBrochure) && query.edition.nil?
+          return row_id.is_a?(::Pubid::Bipm::Identifiers::SiBrochure)
+        end
+
+        return false unless row_id.instance_of?(query.class)
+
+        # `Id#==` treated a document numbered "1" and a number-less one as the
+        # same document when both carried a year, so `CIPM Resolution 1 (1879)`
+        # reached `CIPM RES (1879)`. pubid has no such rule and the six
+        # ordinal-less declarations are only addressable this way, so keep it.
+        if number_collapses?(row_id, query)
+          keys = stem_keys(query) + [:number]
+          return row_id.exclude(*keys) == query.exclude(*keys)
+        end
+
+        return false unless cheap_reject_passes?(row_id, query)
+
+        stem(row_id, query) == (query_stem || stem(query, query))
+      end
+
+      # @param row_id [Pubid::Bipm::Identifier]
+      # @param query [Pubid::Bipm::Identifier]
+      # @return [Boolean] true when one side is number-less, the other is
+      #   numbered "1", and both carry a year
+      def number_collapses?(row_id, query)
+        return false unless row_id.year && query.year
+
+        numbers = [row_id.number.to_s, query.number.to_s]
+        numbers.include?("") && numbers.include?("1")
+      end
+
+      # Attributes the stem never removes, so stem equality implies equality on
+      # every one of them. Comparing them first cannot change the answer, it
+      # only avoids the reduction — and `#exclude` copies the identifier, which
+      # is what made an unguarded compare cost roughly 165x a plain attribute
+      # read and turned a rescan into seconds.
+      CHEAP_KEYS = %i[number group year issue article].freeze
+
+      # @param row_id [Pubid::Bipm::Identifier]
+      # @param query [Pubid::Bipm::Identifier]
+      # @return [Boolean] false as soon as one cheap attribute differs
+      def cheap_reject_passes?(row_id, query)
+        CHEAP_KEYS.all? do |key|
+          # `:year` is dropped from the stem when the query has none, so it is
+          # only significant when the query supplies one.
+          next true if key == :year && query.year.nil?
+          next true unless query.respond_to?(key) && row_id.respond_to?(key)
+
+          row_id.public_send(key).to_s == query.public_send(key).to_s
+        end
+      end
+
+      # @param pubid [Pubid::Bipm::Identifier] the identifier to reduce
+      # @param query [Pubid::Bipm::Identifier] the query that sets which
+      #   attributes are significant
+      # @return [Pubid::Bipm::Identifier] a copy; the cached row id is untouched
+      def stem(pubid, query)
+        pubid.exclude(*stem_keys(query))
+      end
+
+      # @param query [Pubid::Bipm::Identifier]
+      # @return [Array<Symbol>] the attributes a match must ignore
+      def stem_keys(query)
+        keys = %i[language form]
+        keys << :year if query.year.nil?
+        keys
+      end
+
+      # Parse a user reference with `Pubid::Bipm`, which since pubid `a96e9f45`
+      # accepts the loose consumer forms this flavor once needed `Id` for
+      # (`CCDS Recommendation 2 (2009)`, `CIPM 111e Réunion (2022)`,
+      # `CCTF Meeting 14 (1999)`, `SI Brochure Part 1`, …) and normalizes them
+      # to BIPM's canonical spelling. An unrecognized reference raises; like
+      # ISO and 3GPP we let it propagate -- relaton-cli rescues
+      # Pubid::Errors::Error and renders "... is not a recognized standards
+      # identifier".
+      #
+      # @param reference [String]
+      # @return [Pubid::Bipm::Identifier]
+      # @raise [Pubid::Errors::ParseError]
+      def parse_ref(reference)
+        ::Pubid::Bipm.parse reference
+      end
+
       def index
         Relaton::Index.find_or_create(
-          :bipm, url: "#{GH_ENDPOINT}index-v1.zip", file: INDEXFILE, id_keys: %i[group type number year corr part append]
+          :bipm, url: "#{GH_ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+          pubid_class: ::Pubid::Bipm::Identifier
         )
       end
 
-      # def match_item(ids, ref_id)
-      #   ids.find { |id| Id.new(id) == ref_id }
-      # end
-
       # @param ref [String] the BIPM standard Code to look up (e..g "BIPM B-11")
       # @param year [String] not used
       # @param opts [Hash] not used

data/lib/relaton/bipm/data_fetcher.rb

@@ -1,4 +1,3 @@
-require_relative "id_parser"
 require_relative "../bipm"
 require_relative "data_outcomes_parser"
 require_relative "si_brochure_parser"
@@ -9,13 +8,38 @@ module Relaton::Bipm
     attr_reader :output, :format, :ext, :files, :index, :errors
 
     def index
-      @index ||= Relaton::Index.find_or_create :bipm, file: INDEXFILE
+      @index ||= Relaton::Index.find_or_create(
+        :bipm, file: "#{INDEXFILE}.yaml", pubid_class: ::Pubid::Bipm::Identifier
+      )
     end
 
     def log_error(msg)
       Util.error msg
     end
 
+    #
+    # Index a document by its pubid. Guarded defensively: a docnumber the
+    # `Pubid::Bipm` grammar can't parse (a legacy/inconsistent id, or a
+    # wrong-flavor orphan) is skipped with a warning rather than allowed to
+    # corrupt the whole index (`Relaton::Index` rejects an index if a single
+    # row fails to deserialize). Mirrors `Relaton::Jcgm::DataFetcher#add_to_index`.
+    #
+    # Public so `relaton-data-bipm`'s crawler can index its curated `static/`
+    # docs through the same guarded, sorted, `_type: pubid:bipm:*` path.
+    #
+    # @param [String] docnumber the record's primary docidentifier / docnumber
+    # @param [String] path repo-relative path to the YAML file
+    #
+    def add_to_index(docnumber, path)
+      # Store the Pubid::Bipm identifier object (not a hash): with pubid_class
+      # set, Relaton::Index sorts the index by id number on save and serializes
+      # each id to its `_type: pubid:bipm:*` hash, so the published index is
+      # already sorted (no "not sorted by id number" warning on consumer fetch).
+      index.add_or_update ::Pubid::Bipm.parse(docnumber), path
+    rescue StandardError => e
+      Util.warn "Skipping index entry for `#{docnumber}` (#{path}): #{e.message}"
+    end
+
     #
     # Fetch bipm-data-outcomes or si-brochure
     #

data/lib/relaton/bipm/data_outcomes_parser.rb

@@ -39,7 +39,7 @@ module Relaton::Bipm
     # Parse BIPM meeting and write them to YAML files
     #
     def parse
-      dirs = "cctf,cgpm,cipm,ccauv,ccem,ccl,ccm,ccpr,ccqm,ccri,cct,ccu,jcgm,jcrb"
+      dirs = "cctf,cgpm,cipm,ccauv,ccem,ccl,ccm,ccpr,ccqm,ccri,cct,ccu,jcrb"
       source_path = File.join "bipm-data-outcomes", "{#{dirs}}"
       Dir[source_path].each { |body_dir| fetch_body(body_dir) }
     end
@@ -270,9 +270,8 @@ module Relaton::Bipm
     # @param [Relaton::Bipm::ItemData] item bibliographic item
     # @param [String] path path to YAML file
     #
-    def add_to_index(item, path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      key = Id.new.parse(item.docnumber).to_hash
-      @data_fetcher.index.add_or_update key, path
+    def add_to_index(item, path)
+      @data_fetcher.add_to_index item.docnumber, path
     end
 
     #

data/lib/relaton/bipm/id_parser.rb

@@ -92,7 +92,7 @@ module Relaton
       #
       def parse(id)
         # str = StringScanner.new id
-        match = parse_outcome(id) || parse_brochure(id) || parse_metrologia(id) || parse_jcgm(id)
+        match = parse_outcome(id) || parse_brochure(id) || parse_metrologia(id)
         @id = match.named_captures.compact.transform_keys(&:to_sym)
         self
       rescue StandardError => e
@@ -167,9 +167,10 @@ module Relaton
         %r{^(?<group>Metrologia)(?:\s(?<number>[a-zA-Z0-9\s]+))?$}.match(id)
       end
 
-      def parse_jcgm(id)
-        %r{^#{group}\s#{number}(?::#{year})?(?:\s(?<corr>Corrigendum))?$}.match(id)
-      end
+      # NOTE: JCGM is no longer served by the BIPM flavor — it has its own
+      # `Relaton::Jcgm` flavor (pubid-backed, fetching from relaton-data-jcgm).
+      # The old `parse_jcgm` branch and the `JCGM` default-prefix entry were
+      # removed together with the `jcgm` harvest dir in data_outcomes_parser.
 
       # def parse_gorup_num(str)
       #   return unless group = parse_group(str)

data/lib/relaton/bipm/model/structured_identifier.rb

@@ -10,6 +10,27 @@ module Relaton
         map_element "part", to: :part
         map_element "appendix", to: :appendix
       end
+
+      # `Bib::ItemData#ext_to_all_parts!` / `#ext_remove_date` broadcast to
+      # `ext.structuredidentifier` as well as to `docidentifier`. This class
+      # descends from `Lutaml::Model::Serializable` rather than
+      # `Bib::StructuredIdentifier` (BIPM stores a single mapping, not a
+      # sequence), so it does not inherit that class's no-op defaults and the
+      # broadcast raised `NoMethodError` on every BIPM item.
+      #
+      # BIPM structured identifiers carry no date, so `remove_date!` has nothing
+      # to strip; the year lives on the docidentifier. `part` is real and is
+      # cleared. (Identical to `Relaton::Jcgm::StructuredIdentifier`.)
+
+      def remove_part!
+        self.part = nil
+      end
+
+      def remove_date!; end
+
+      def to_all_parts!
+        remove_part!
+      end
     end
   end
 end

data/lib/relaton/bipm/processor.rb

@@ -8,7 +8,7 @@ module Relaton
       def initialize
         @short = :relaton_bipm
         @prefix = "BIPM"
-        @defaultprefix = %r{^(?:BIPM|CCTF|CCDS|CGPM|CIPM|JCRB|JCGM)(?!\w)}
+        @defaultprefix = %r{^(?:BIPM|CCTF|CCDS|CGPM|CIPM|JCRB)(?!\w)}
         @idtype = "BIPM"
         @datasets = %w[bipm-data-outcomes bipm-si-brochure rawdata-bipm-metrologia]
       end
@@ -62,7 +62,7 @@ module Relaton
       #
       def remove_index_file
         require_relative "../bipm"
-        Relaton::Index.find_or_create(:bipm, url: true, file: INDEXFILE).remove_file
+        Relaton::Index.find_or_create(:bipm, url: true, file: "#{INDEXFILE}.yaml").remove_file
       end
     end
   end

data/lib/relaton/bipm/rawdata_bipm_metrologia/fetcher.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../id_parser"
 require_relative "niso_jats_parser"
 
 module Relaton::Bipm
@@ -37,8 +36,7 @@ module Relaton::Bipm
           item = NisoJatsParser.parse path, @data_fetcher.errors
           file = "#{item.docidentifier.first.content.downcase.tr(' ', '-')}.#{@data_fetcher.ext}"
           out_path = File.join(@data_fetcher.output, file)
-          key = Relaton::Bipm::Id.new.parse(item.docidentifier.first.content).to_hash
-          @data_fetcher.index.add_or_update key, out_path
+          @data_fetcher.add_to_index item.docidentifier.first.content, out_path
           @data_fetcher.write_file out_path, item
         end
       end
@@ -80,7 +78,7 @@ module Relaton::Bipm
         )
         file = "#{id.downcase.gsub(' ', '-')}.#{@data_fetcher.ext}"
         path = File.join(@data_fetcher.output, file)
-        @data_fetcher.index.add_or_update Id.new.parse(id).to_hash, path
+        @data_fetcher.add_to_index id, path
         @data_fetcher.write_file path, item
       end
 

data/lib/relaton/bipm/si_brochure_parser.rb

@@ -1,5 +1,4 @@
 require "nokogiri"
-require_relative "id_parser"
 
 module Relaton::Bipm
   class SiBrochureParser
@@ -51,8 +50,11 @@ module Relaton::Bipm
         fix_si_brochure_id item1
         basename = File.join @data_fetcher.output, File.basename(f).sub(/(?:-(?:en|fr))?\.rxl$/, "")
         outfile = "#{basename}.#{@data_fetcher.ext}"
-        key = item1.docnumber || basename
-        @data_fetcher.index.add_or_update Id.new.parse(key).to_hash, outfile
+        # Index by the primary docidentifier content ("BIPM SI Brochure 9e
+        # v3.01 (2019/2024, E)"), which `Pubid::Bipm` parses — unlike the bare
+        # `docnumber` ("SI Brochure 9e …", no "BIPM" prefix), which it rejects.
+        key = primary_id(item1) || item1.docnumber || basename
+        @data_fetcher.add_to_index key, outfile
         item =
           if File.exist? outfile
             warn_duplicate = false

data/lib/relaton/bipm.rb

@@ -4,8 +4,10 @@ require "parslet"
 require "relaton/bib"
 require "relaton/index"
 require "relaton/core"
+require "pubid"
 require_relative "version"
 require_relative "bipm/util"
+require_relative "bipm/id_parser"
 require_relative "bipm/item_data"
 require_relative "bipm/model/item"
 require_relative "bipm/model/bibitem"
@@ -16,7 +18,11 @@ module Relaton
   module Bipm
     class Error < StandardError; end
 
-    INDEXFILE = "index-v1.yaml".freeze
+    # The runtime index is the pubid-backed `index-v2` (`_type: pubid:bipm:*`).
+    # The legacy bespoke `{group,type,number,year}` `index-v1` is still published
+    # by `relaton-data-bipm`'s crawler (using the retained `Relaton::Bipm::Id`),
+    # but this flavor no longer reads or writes it.
+    INDEXFILE = "index-v2".freeze
 
     # Returns hash of gems versions used to generate the data model.
     # @return [String]

data/lib/relaton/bsi/bibliography.rb

@@ -3,6 +3,9 @@
 module Relaton::Bsi
   # Class methods for search ISO standards.
   class Bibliography
+    # pubid identifier types referenced when navigating the parsed object graph.
+    Ids = ::Pubid::Bsi::Identifiers
+
     class << self
       # @param text [String]
       # @return [Relaton::Bsi::HitCollection]
@@ -24,52 +27,127 @@ module Relaton::Bsi
       #
       # @return [String] Relaton XML serialisation of reference
       def get(code, year = nil, opts = {})
-        # y = code.split(":")[1]
-        year ||= code_parts(code)[:year]
+        year ||= publication_year(code)
         ret = bib_get(code, year, opts)
         return nil if ret.nil?
 
         ret = ret.to_most_recent_reference unless year || opts[:keep_year]
-        # ret = ret.to_all_parts if opts[:all_parts]
         ret
       end
 
-      #
-      # Destruct code to its parts.
-      #
+      # Parse a BSI reference with pubid. An unrecognized reference raises;
+      # like ISO and 3GPP we let it propagate -- relaton-cli rescues
+      # Pubid::Errors::Error and renders "... is not a recognized standards
+      # identifier". A catalogue hit code is a different case: `Hit#pubid`
+      # rescues, because one odd Algolia row must not abort the search.
       # @param [String] code document identifier
+      # @return [Pubid::Bsi::Identifier]
+      # @raise [Pubid::Errors::ParseError]
+      def parse(code)
+        ::Pubid::Bsi::Identifier.parse(code)
+      end
+
+      # Publication year of a reference's base document.
+      # @param [String] code document identifier
+      # @return [String, nil]
+      def publication_year(code)
+        year_of parse(code)
+      end
+
+      # Whether a query and a candidate hit denote the same BSI document, at the
+      # fuzziness the hit filter asks for. Built entirely on pubid: `base_document`
+      # peels supplements/wrappers, `matches?` compares ignoring the publication
+      # date, and the `Amendment`/`Corrigendum` `#supplement_type`, `#number` and
+      # `#year` supply the amendment type, number and year.
       #
-      # @return [MatchData] parts of the code
-      #
-      def code_parts(code)
-        %r{
-          ^(?:BSI\s)?(?<code>(?:[A-Z]+\s)*[^:\s+]+(?:\s\d+)?)
-          (?::(?<year>\d{4})(?:-\d{2})?)?
-          (?:\+(?<a>[^:\s]+)(?::(?<y>\d{4}))?)?
-          (?:\s(?<rest>.+))?
-        }x.match code
+      # @param query [Pubid::Bsi::Identifier]
+      # @param hit   [Pubid::Bsi::Identifier]
+      # @param skip_rest [Boolean] ignore the free-text suffix (ExComm / Flex version)
+      # @param drop_amd  [Boolean] reduce the hit to its base document before
+      #   matching, so a query for the base document matches a catalogue entry
+      #   that only exists in amended form (the returned id is de-amended too)
+      # @return [Boolean]
+      def same_reference?(query, hit, skip_rest: false, drop_amd: false)
+        hit = hit.base_document if drop_amd
+
+        base_match?(query, hit) &&
+          same_supplement?(supplement_of(query), supplement_of(hit)) &&
+          (skip_rest || rest_marker(query) == rest_marker(hit))
       end
 
       private
 
-      def fetch_ref_err(code, year, missed_years) # rubocop:disable Metrics/MethodLength
-        # y = code_parts(code)[:year]
-        # id = year && !y ? "#{code}:#{year}" : code
-        # Util.warn "WARNING: no match found online for `#{id}`. " \
-        #           "The code must be exactly like it is on the standards website."
+      # The year of the dated document at the root of a reference. pubid holds
+      # an adopted standard (`BS EN ISO 8848:2021`) in `base`, so its
+      # `base_document.year` is nil; `#root` reaches the dated document for
+      # every form, on the pubid before that change and after it.
+      # @param id [Pubid::Bsi::Identifier, nil]
+      # @return [String, nil]
+      def year_of(id)
+        id&.root&.year&.to_s
+      end
+
+      # Same base document, ignoring the publication date. `:month` is excluded
+      # alongside `:date` because Flex identifiers store the month separately, so
+      # `exclude(:date)` alone leaves them unequal.
+      def base_match?(query, hit)
+        query.base_document.matches?(hit.base_document, ignore: %i[date month])
+      end
+
+      # The `Amendment`/`Corrigendum` supplement of a reference, if any — peeling
+      # an Expert-commentary wrapper first. Both supplements expose
+      # `#supplement_type`, `#number` and `#year`.
+      def supplement_of(id)
+        while id.is_a?(Ids::ExpertCommentary)
+          inner = id.base
+          break if inner.nil? || inner.equal?(id)
+
+          id = inner
+        end
+        return nil unless id.respond_to?(:identifiers) && id.identifiers
+
+        id.identifiers.find { |i| i.respond_to?(:supplement_type) }
+      end
+
+      # Same supplement, with the amendment year treated as optional when the
+      # query omits it (a query for "…+A2" matches a hit for "…+A2:2020").
+      def same_supplement?(query_supp, hit_supp)
+        return hit_supp.nil? if query_supp.nil?
+        return false if hit_supp.nil?
+
+        query_supp.supplement_type == hit_supp.supplement_type &&
+          supplement_number(query_supp) == supplement_number(hit_supp) &&
+          (supplement_year(query_supp).nil? ||
+            supplement_year(query_supp) == supplement_year(hit_supp))
+      end
+
+      # The number and the year of a supplement. pubid removes the
+      # `#supplement_number` / `#supplement_year` aliases and stores the values
+      # in `#number` / `#year`. An older pubid still answers the aliases and
+      # leaves `#number` / `#year` nil, so the alias wins while it exists.
+      # TODO: read `#number` / `#year` directly once pubid `main` has no alias.
+      def supplement_number(supp)
+        supp.respond_to?(:supplement_number) ? supp.supplement_number : supp.number
+      end
+
+      def supplement_year(supp)
+        supp.respond_to?(:supplement_year) ? supp.supplement_year : supp.year
+      end
+
+      # Canonical marker for the free-text suffix pubid parses into a typed
+      # wrapper (so an `ExComm` query matches an `Expert Commentary` hit).
+      def rest_marker(id)
+        return :expert_commentary if id.is_a?(Ids::ExpertCommentary)
+        return :"flex_#{id.edition}" if id.is_a?(Ids::Flex) && id.edition
+
+        nil
+      end
+
+      def fetch_ref_err(_code, year, missed_years)
         unless missed_years.empty?
           Util.info "There was no match for `#{year}`, though there " \
                     "were matches found for `#{missed_years.join('`, `')}`."
         end
-        # if /\d-\d/.match? code
-        #   warn "[relaton-bsi] The provided document part may not exist, or "\
-        #     "the document may no longer be published in parts."
-        # else
-        #   warn "[relaton-bsi] If you wanted to cite all document parts for "\
-        #     "the reference, use \"#{code} (all parts)\".\nIf the document "\
-        #     "is not a standard, use its document type abbreviation (TS, TR, "\
-        #     "PAS, Guide)."
-        # end
         nil
       end
 
@@ -81,26 +159,20 @@ module Relaton::Bsi
       # @return [Relaton::Bsi::HitCollection] a collection of hits
       #
       def search_filter(code)
-        cp = code_parts code
+        query = parse(code)
         Util.info "Fetching from shop.bsigroup.com ...", key: code
-        unless cp
-          Util.info "Could not parse the reference", key: code
-          return []
-        end
-
-        search(code).filter_hits!(cp)
+        search(code).filter_hits!(query)
       end
 
-      # Sort through the results from Isobib, fetching them three at a time,
-      # and return the first result that matches the code,
-      # matches the year (if provided), and which # has a title (amendments do not).
-      # Only expects the first page of results to be populated.
-      # Does not match corrigenda etc (e.g. ISO 3166-1:2006/Cor 1:2007)
-      # If no match, returns any years which caused mismatch, for error reporting
+      # Sort through the results, and return the first result that matches the
+      # code and matches the year (if provided), and which has a title.
+      # If no match, returns any years which caused mismatch, for error reporting.
       def results_filter(result, year)
         missed_years = []
         result.each do |r|
-          pyear = code_parts(r.hit[:code])[:year]
+          # The hit's own parse: a kept hit always parsed, and its base
+          # document's year is the same after a `drop_amd` rewrite.
+          pyear = year_of r.pubid
           return { ret: r.item } if (!year || year == pyear) && r.item
 
           missed_years << pyear

data/lib/relaton/bsi/hit.rb

@@ -10,5 +10,19 @@ module Relaton::Bsi
     def item
       @item ||= Scraper.parse_page self
     end
+
+    # The hit's reference parsed with pubid, memoized so the (up to three) hit
+    # filter passes don't re-parse it. `nil` when pubid can't parse the code:
+    # the Algolia catalogue carries codes like `BS 381C SET:1996 (R2002)`, and
+    # one such row must not abort the search. (A malformed *query* raises; see
+    # `Bibliography.parse`.)
+    # @return [Pubid::Bsi::Identifier, nil]
+    def pubid
+      return @pubid if defined?(@pubid)
+
+      @pubid = Bibliography.parse(hit[:code])
+    rescue StandardError
+      @pubid = nil
+    end
   end
 end