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

data/lib/relaton/bsi/scraper.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require "graphql/client"
+require "graphql/client/http"
+
+Encoding.default_internal = Encoding::UTF_8
+Encoding.default_external = Encoding::UTF_8
+
+module Relaton::Bsi
+  # Scraper.
+  module Scraper
+    HTTP = GraphQL::Client::HTTP.new "https://shop-bsi.myshopify.com/api/2021-04/graphql.json" do
+      def headers(_context)
+        { "x-shopify-storefront-access-token": "c935c196c0b7d1d86bfb5139006cfd46" }
+      end
+    end
+
+    Schema = GraphQL::Client.load_schema File.join(__dir__, "schema.json")
+
+    Client = GraphQL::Client.new(schema: Schema, execute: HTTP)
+
+    Product = Client.parse <<~'GRAPHQL'
+      fragment ProductFragment on Product {
+        createdAt
+        publishedAt
+        updatedAt
+        productType
+        committee: metafield(namespace: "global", key: "committee") {
+          value
+        }
+        designated: metafield(namespace: "global", key: "designatedStandard") {
+          value
+        }
+        packContents: metafield(namespace: "global", key: "packContents") {
+          value
+        }
+        summary: metafield(namespace: "global", key: "summary") {
+          value
+        }
+        corrigendumHandle: metafield(namespace: "global", key: "corrigendumHandle") {
+          value
+        }
+        variants(first: 250) {
+          edges {
+            node {
+              version: metafield(namespace: "global", key: "version") {
+                value
+              }
+              isbn: metafield(namespace: "global", key: "isbn") {
+                value
+              }
+            }
+          }
+        }
+        description
+      }
+    GRAPHQL
+
+    Query = Client.parse <<~GRAPHQL
+      query GetProducts($h0: String!) {
+        productByHandle(handle: $h0) {
+          ...Relaton::Bsi::Scraper::Product::ProductFragment
+        }
+      }
+    GRAPHQL
+
+    class << self
+      # Parse page.
+      # @param hit [Relaton::Bsi::Hit]
+      # @return [Relaton::Bsi::IetemData]
+      def parse_page(hit) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # doc = hit.hit_collection.agent.get hit.hit[:url]
+        result = Client.query(Query::GetProducts, variables: { h0: hit.hit[:url] })
+        data = result.data.product_by_handle.to_h
+        item = Relaton::Bsi::ItemData.new(
+          fetched: Date.today.to_s,
+          type: "standard",
+          docidentifier: fetch_docid(hit.hit[:code], data),
+          docnumber: hit.hit[:code].match(/\d+/).to_s,
+          language: ["en"],
+          script: ["Latn"],
+          title: fetch_titles(hit.hit[:title]),
+          status: fetch_status(hit.hit[:status]),
+          date: fetch_dates(hit),
+          contributor: fetch_contributors(hit, data),
+          abstract: fetch_abstract(data),
+          copyright: fetch_copyright(hit),
+          source: fetch_link(hit.hit[:url]),
+          # relation: fetch_relations(doc),
+          place: [Relaton::Bib::Place.new(city: "London")],
+          ext: fetch_ext(hit, data),
+        )
+        item.create_id
+        item
+      end
+
+      private
+
+      def fetch_ext(hit, data)
+        Ext.new(
+          doctype: fetch_doctype(hit),
+          flavor: "bsi",
+          ics: fetch_ics(hit.hit[:ics]),
+          structuredidentifier: fetch_structuredid(hit),
+        )
+      end
+
+      # @param ics [Array<String>]
+      # @return [Array<Relaton::Bib::ICS>]
+      def fetch_ics(ics)
+        ics.map do |s|
+          code, = s.split
+          Relaton::Bib::ICS.new(code: code, text: Isoics.fetch(code).description)
+        end
+      end
+
+      # Fetch abstracts.
+      # @param data [Hash]
+      # @return [Array<Relaton::Bib::Abstract>]
+      def fetch_abstract(data)
+        return [] unless data["description"]
+
+        [Relaton::Bib::Abstract.new(content: data["description"], language: "en", script: "Latn")]
+      end
+
+      # Fetch docid.
+      # @param docid [String]
+      # @param data [Hash]
+      # @return [Array<Relaton::Bib::Docidentifier>]
+      def fetch_docid(docid, data) # rubocop:disable Metrics/AbcSize
+        ids = [{ type: "BSI", content: docid, primary: true }]
+        if data.any? && data["variants"]["edges"][0]["node"]["isbn"]
+          isbn = data["variants"]["edges"][0]["node"]["isbn"]["value"]
+          ids << { type: "ISBN", content: isbn }
+        end
+        ids.map do |did|
+          Relaton::Bsi::Docidentifier.new(**did)
+        end
+      end
+
+      # Fetch status.
+      # @param status [String]
+      # @return [Relaton::Bib::Status, nil]
+      def fetch_status(status)
+        return unless status
+
+        stage = Relaton::Bib::Status::Stage.new(content: status)
+        Relaton::Bib::Status.new(stage: stage)
+      end
+
+      # @param hit [Relaton::Bsi::Hit]
+      # @return [Relaton::Iso::StructuredIdentifier]
+      def fetch_structuredid(hit)
+        content, origyr = hit.hit[:code].split(":")
+        project_number = Relaton::Iso::ProjectNumber.new(content: content, origyr: origyr)
+        Relaton::Iso::StructuredIdentifier.new project_number: project_number
+      end
+
+      # Fetch relations.
+      # @param doc [Mechanize::Page]
+      # @return [Array<Hash>]
+      # def fetch_relations(doc)
+      #   doc.xpath("//tr[th='Replaces']/td/a").map do |r|
+      #     fref = RelatonBib::FormattedRef.new(content: r.text, language: "en", script: "Latn")
+      #     link = fetch_link r[:href]
+      #     bibitem = BsiBibliographicItem.new(formattedref: fref, type: "standard", link: link)
+      #     { type: "complements", bibitem: bibitem }
+      #   end
+      # end
+
+      # Fetch titles.
+      # @param title [String]
+      # @return [Array<Relaton::Bib::Title>]
+      def fetch_titles(title)
+        titles = split_title(title).map do |t|
+          Relaton::Bib::Title.new(**t, language: "en", script: "Latn")
+        end
+        titles << Relaton::Bib::Title.new(type: "main", content: title, language: "en", script: "Latn")
+      end
+
+      def split_title(title)
+        ttls = title.split(/\s(?:-|\u2014)\s/) # if ttls.size == 1
+        case ttls.size
+        when 0, 1 then [{ type: "title-main",  content: ttls.first }]
+        else intro_or_part ttls
+        end
+      end
+
+      # @param ttls [Array<String>]
+      # @return [Array<Hash>]
+      def intro_or_part(ttls)
+        titles = [{ type: "title-intro", content: ttls[0] }, { type: "title-main", content: ttls[1] }]
+        parts = ttls.slice(2..-1)
+        titles << { type: "title-part", content: parts.join(" -- ") } if parts.any?
+        titles
+      end
+
+      #
+      # Fetch doctype.
+      #
+      # @param [Relaton::Bsi::Hit] hit hit
+      #
+      # @return [Relaton::Bsi::Doctype] doctype
+      #
+      def fetch_doctype(hit)
+        Doctype.new(content: doctype(hit))
+      end
+
+      def doctype(hit)
+        case hit.hit[:code]
+        when /(^|\s)Flex\s/ then "flex-standard"
+        when /(^|\s)PAS\s/ then "publicly-available-specification"
+        else hit.hit[:doctype]
+        end
+      end
+
+      # Fetch dates
+      # @param hit [Relaton::Bsi:Hit]
+      # @return [Array<Relaton::Bib::Date>]
+      def fetch_dates(hit)
+        [Relaton::Bib::Date.new(type: "published", at: hit.hit[:date])]
+      end
+
+      # Fetch contributors
+      # @param hit [Relaton::Bsi::Hit]
+      # @param data [Hash]
+      # @return [Array<Relaton::Bib::Contributor>]
+      def fetch_contributors(hit, data)
+        contribs = [create_contributor({ type: "publisher" }, owner_entity(hit))]
+
+        wg = data["committee"]&.fetch("value")
+        if wg
+          subdivision = Relaton::Bib::Subdivision.new(
+            type: "technical-committee",
+            name: [Relaton::Bib::TypedLocalizedString.new(content: wg)],
+          )
+          org = bsi_org(subdivision: [subdivision])
+          desc = Relaton::Bib::LocalizedMarkedUpString.new(content: "committee")
+          role = Relaton::Bib::Contributor::Role.new(type: "author", description: [desc])
+          contribs << Relaton::Bib::Contributor.new(role: [role], organization: org)
+        end
+        contribs
+      end
+
+      def create_contributor(role, org)
+        role = Relaton::Bib::Contributor::Role.new(**role)
+        Relaton::Bib::Contributor.new(role: [role], organization: org)
+      end
+
+      # Fetch links.
+      # @param path [String]
+      # @return [Array<Relaton::Bib::Uri>]
+      def fetch_link(path)
+        url = "#{HitCollection::DOMAIN}/products/#{path}"
+        [Relaton::Bib::Uri.new(type: "src", content: url)]
+      end
+
+      # Fetch copyright.
+      # @param hit [Relaton::Bsi::Hit]
+      # @return [Array<Relaton::Bib::Copyright>]
+      def fetch_copyright(hit)
+        owner = Relaton::Bib::ContributionInfo.new organization: owner_entity(hit)
+        from = Date.parse(hit.hit[:date]).year.to_s
+        [Relaton::Bib::Copyright.new(owner: [owner], from: from)]
+      end
+
+      # @param hit [Relaton::Bsi::Hit]
+      # @return [Relaton::Bib::Organization]
+      def owner_entity(hit)
+        case hit.hit[:publisher]
+        when "BSI" then bsi_org
+        else
+          name = Relaton::Bib::TypedLocalizedString.new(content: hit.hit[:publisher])
+          Relaton::Bib::Organization.new(name: [name])
+        end
+      end
+
+      def bsi_org(subdivision: [])
+        abbre = Relaton::Bib::LocalizedString.new(content: "BSI", language: "en", script: "Latn")
+        name = Relaton::Bib::TypedLocalizedString.new(
+          content: "British Standards Institution", language: "en", script: "Latn"
+        )
+        uri = Relaton::Bib::Uri.new(content: "https://www.bsigroup.com/")
+        Relaton::Bib::Organization.new abbreviation: abbre, name: [name], uri: [uri], subdivision: subdivision
+      end
+    end
+  end
+end

data/lib/relaton/bsi/util.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Bsi
+    module Util
+      extend Bib::Util
+      PROGNAME = "relaton-bsi".freeze
+    end
+  end
+end

data/lib/relaton/bsi.rb

@@ -0,0 +1,25 @@
+require "relaton/iso"
+require_relative "version"
+require_relative "bsi/util"
+require_relative "bsi/item_data"
+require_relative "bsi/model/item"
+require_relative "bsi/model/relation"
+require_relative "bsi/model/bibitem"
+require_relative "bsi/model/bibdata"
+require_relative "bsi/scraper"
+require_relative "bsi/hit_collection"
+require_relative "bsi/hit"
+require_relative "bsi/bibliography"
+
+module Relaton
+  module Bsi
+    # Returns hash of XML greammar
+    # @return [String]
+    def self.grammar_hash
+      # gem_path = File.expand_path "..", __dir__
+      # grammars_path = File.join gem_path, "grammars", "*"
+      # grammars = Dir[grammars_path].sort.map { |gp| File.read gp }.join
+      Digest::MD5.hexdigest Relaton::VERSION # grammars
+    end
+  end
+end

data/lib/relaton/calconnect/bibliography.rb

@@ -0,0 +1,93 @@
+require "mechanize"
+
+module Relaton::Calconnect
+  class Bibliography
+    class << self
+      # @param text [String]
+      # @return [RelatonCalconnect::HitCollection]
+      def search(text, year = nil, _opts = {})
+        HitCollection.new text, year
+      rescue Mechanize::ResponseCodeError, SocketError, Errno::ECONNREFUSED
+        raise Relaton::RequestError, "Could not access https://standards.calconnect.org"
+      end
+
+      # @param ref [String] the OGC standard Code to look up (e..g "8200")
+      # @param year [String] the year the standard was published (optional)
+      #
+      # @param opts [Hash] options
+      # @option opts [TrueClass, FalseClass] :all_parts restricted to all parts
+      #   if all-parts reference is required
+      # @option opts [TrueClass, FalseClass] :bibdata
+      #
+      # @return [RelatonCalconnect::CcBibliographicItem]
+      # 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(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(ref, year, ret[:years])
+        end
+      end
+
+      private
+
+      # Sort through the results from RelatonNist, 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
+      #
+      # @param result
+      # @param opts [Hash] options
+      #
+      # @return [Hash]
+      def bib_results_filter(result, year)
+        missed_years = Set.new
+        result.each do |r|
+          item = r.item
+          item.fetched = Date.today.to_s
+          return { ret: item } if !year
+
+          # 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
+
+          item.date.select { |d| d.type == "published" }.each do |d|
+            return { ret: item } if year.to_i == d.at.to_date.year
+
+            missed_years << d.at.to_date.year
+          end
+        end
+        { years: missed_years }
+      end
+
+      # @param code [Strig]
+      # @param year [String]
+      # @param missed_years [Array<Strig>]
+      def fetch_ref_err(code, year, missed_years)
+        # id = year ? "`#{code}` year `#{year}`" : code
+        # Util.info "WARNING: No match found online for #{id}. " \
+        #           "The code must be exactly like it is on the standards website."
+        unless missed_years.empty?
+          Util.info "There was no match for `#{year}`, though there " \
+                    "were matches found for `#{missed_years.join('`, `')}`."
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/relaton/calconnect/data_fetcher.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal:true
+
+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"
+
+module Relaton::Calconnect
+  #
+  # Relaton-calconnect data fetcher
+  #
+  class DataFetcher < Relaton::Core::DataFetcher
+    ENDPOINT = "https://standards.calconnect.org/cc/index.json"
+
+    def etagfile
+      @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: "#{INDEXFILE}.yaml",
+             pubid_class: ::Pubid::Calconnect::Identifier
+      )
+    end
+
+    def log_error(msg)
+      Util.error msg
+    end
+
+    def agent
+      @agent ||= Mechanize.new
+    end
+
+    #
+    # fetch data form server and save it to file.
+    #
+    def fetch(_source = nil) # rubocop:disable Metrics/AbcSize
+      agent.request_headers["If-None-Match"] = etag if etag
+      resp = agent.get(ENDPOINT)
+      # 304 Not Modified — nothing changed since the last fetch
+      return if resp.code == "304"
+
+      data = JSON.parse resp.body
+      all_success = true
+      Array(data["documents"]).each { |doc| all_success &&= parse_page doc }
+      self.etag = resp.response["etag"] if all_success
+      index.save
+      report_errors
+    end
+
+    private
+
+    #
+    # Parse document and write it to file
+    #
+    # @param [Hash] doc
+    #
+    def parse_page(doc)
+      bib = Scraper.new(@errors).parse_page doc
+      write_doc doc["id"], bib
+      true
+    rescue StandardError => e
+      Util.warn "Document: #{doc['id']}"
+      Util.warn e.message
+      Util.warn e.backtrace[0..5].join("\n")
+      false
+    end
+
+    def write_doc(slug, bib) # rubocop:disable Metrics/MethodLength
+      # 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"
+      elsif file != output_file(slug)
+        Util.warn "#{output_file slug} exist; writing #{file} instead"
+      end
+      @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
+
+    # 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)
+      bib.docidentifier.find(&:primary) || bib.docidentifier.first
+    end
+
+    def to_yaml(bib) = bib.to_yaml
+    def to_xml(bib) = bib.to_xml(bibdata: true)
+    def to_bibxml(bib) = bib.to_rfcxml
+
+    #
+    # Read ETag from file
+    #
+    # @return [String, NilClass]
+    def etag
+      @etag ||= File.exist?(etagfile) ? File.read(etagfile, encoding: "UTF-8") : nil
+    end
+
+    #
+    # Save ETag to file
+    #
+    # @param tag [String]
+    def etag=(e_tag)
+      File.write etagfile, e_tag, encoding: "UTF-8"
+    end
+  end
+end

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.rb

@@ -0,0 +1,14 @@
+require "mechanize"
+
+module Relaton::Calconnect
+  class Hit < Relaton::Core::Hit
+    # Parse page.
+    # @return [Relaton::Calconnect::ItemData]
+    def item
+      @item ||= begin
+        url = "#{HitCollection::GHURL}#{@hit[:file]}"
+        Item.from_yaml Mechanize.new.get(url).body
+      end
+    end
+  end
+end