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

data/lib/relaton/ogc/scraper.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Ogc
+    class Scraper
+      TYPES = {
+        "AS" => { type: "abstract-specification-topic" },
+        "BP" => { type: "best-practice", subtype: "general" },
+        "CAN" => { type: "standard", subtype: "general", stage: "draft" },
+        "CR" => { type: "change-request-supporting-document" },
+        "CP" => { type: "community-practice" },
+        "CS" => { type: "community-standard" },
+        "DP" => { type: "discussion-paper" },
+        "DP-Draft" => { type: "discussion-paper", stage: "draft" },
+        "IPR" => { type: "engineering-report" },
+        "IS" => { type: "standard", subtype: "implementation" },
+        "ISC" => { type: "standard", subtype: "implementation" },
+        "ISx" => { type: "standard", subtype: "extension" },
+        "Notes" => { type: "other" },
+        "ORM" => { type: "reference-model" },
+        "PC" => { type: "standard", subtype: "profile" },
+        "PER" => { type: "engineering-report" },
+        "POL" => { type: "standard" },
+        "Primer" => { type: "other" },
+        "Profile" => { type: "standard", subtype: "profile" },
+        "RFC" => { type: "standard", stage: "draft" },
+        "SAP" => { type: "standard", subtype: "profile" },
+        "WhitePaper" => { type: "white-paper" },
+        "ATB" => { type: "other" },
+        "RP" => { type: "discussion-paper" },
+      }.freeze
+
+      def self.parse_page(hit, errors = Hash.new(true))
+        new(hit, errors).parse
+      end
+
+      # @param hit [Hash]
+      # @param errors [Hash]
+      def initialize(hit, errors = Hash.new(true))
+        @hit = hit
+        @errors = errors
+      end
+
+      # @return [Relaton::Ogc::ItemData]
+      def parse # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        type = fetch_type(@hit["type"])
+        contribs = fetch_contributor(@hit)
+        contribs << fetch_editorialgroup_contributor
+        ItemData.new(
+          type: "standard",
+          title: fetch_title(@hit["title"]),
+          docidentifier: fetch_docid(@hit["identifier"]),
+          source: fetch_link(@hit),
+          status: fetch_status(type[:stage]),
+          edition: fetch_edition(@hit["identifier"]),
+          abstract: fetch_abstract(@hit["description"]),
+          contributor: contribs,
+          language: ["en"],
+          script: ["Latn"],
+          date: fetch_date(@hit["date"]),
+          ext: Ext.new(
+            doctype: fetch_doctype(type[:type]),
+            subdoctype: type[:subtype],
+            flavor: "ogc",
+          ),
+        )
+      end
+
+      private
+
+      def fetch_editorialgroup_contributor # rubocop:disable Metrics/MethodLength
+        desc = Bib::LocalizedMarkedUpString.new(content: "committee")
+        role = Bib::Contributor::Role.new(
+          type: "author", description: [desc],
+        )
+        ogc = "Open Geospatial Consortium"
+        org = Bib::Organization.new(
+          name: [Bib::TypedLocalizedString.new(content: ogc)],
+          abbreviation: Bib::LocalizedString.new(content: "OGC"),
+          subdivision: [Bib::Subdivision.new(
+            type: "technical-committee",
+            name: [Bib::TypedLocalizedString.new(content: "technical")],
+          )],
+        )
+        Bib::Contributor.new(role: [role], organization: org)
+      end
+
+      # @param title [String]
+      # @return [Array<Bib::Title>]
+      def fetch_title(title)
+        result = Bib::Title.from_string title, "en", "Latn"
+        @errors[:title] &&= result.empty?
+        result
+      end
+
+      # @param identifier [String]
+      # @return [Array<Bib::Docidentifier>]
+      def fetch_docid(identifier)
+        @errors[:docid] &&= identifier.to_s.strip.empty?
+        id = Docidentifier.new(
+          content: identifier, type: "OGC", primary: true,
+        )
+        [id]
+      end
+
+      # @param hit [Hash]
+      # @return [Array<Bib::Uri>]
+      def fetch_link(hit) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+        link = []
+        uri = hit["URI"].to_s.strip
+        unless uri.empty?
+          link << Bib::Uri.new(type: "src", content: uri)
+        end
+        return link unless hit["URL"] && !hit["URL"].strip.empty?
+
+        type = link_type(hit["URL"])
+        link << Bib::Uri.new(type: type, content: hit["URL"].strip)
+      ensure
+        @errors[:link] &&= link.empty?
+      end
+
+      def link_type(url)
+        ext = url.match(/(?<=\.)(?<ext>pdf|html|doc)$/)
+        return ext[:ext] if ext
+
+        case url
+        when /portal\.(ogc|opengeospatial)\.org/,
+             /usgif\.org/
+          "pdf"
+        else "html"
+        end
+      end
+
+      # @param type [String]
+      # @return [Doctype]
+      def fetch_doctype(type)
+        Doctype.new(content: type)
+      end
+
+      # @param type [String]
+      # @return [Hash]
+      def fetch_type(type)
+        TYPES[type.sub(/^D-/, "")] || { type: "other" }
+      end
+
+      # @param stage [String, nil]
+      # @return [Bib::Status, nil]
+      def fetch_status(stage)
+        @errors[:status] &&= stage.nil?
+        return unless stage
+
+        stg = Bib::Status::Stage.new(content: stage)
+        Bib::Status.new(stage: stg)
+      end
+
+      # @param identifier [String]
+      # @return [String, nil]
+      def fetch_edition(identifier)
+        %r{(?<=r)(?<edition>\d+)$} =~ identifier
+        @errors[:edition] &&= edition.nil?
+        edition && Bib::Edition.new(content: edition)
+      end
+
+      # @param description [String]
+      # @return [Array<Bib::LocalizedMarkedUpString>]
+      def fetch_abstract(description)
+        @errors[:abstract] &&= description.to_s.strip.empty?
+        abs = Bib::Abstract.new(
+          content: description, language: "en", script: "Latn",
+        )
+        [abs]
+      end
+
+      # @param doc [Hash]
+      # @return [Array<Bib::Contributor>]
+      def fetch_contributor(doc)
+        contribs = doc["creator"].to_s.split(", ").map do |name|
+          person_contrib name
+        end
+        contribs << org_contrib(doc["publisher"]) if doc["publisher"]
+        @errors[:contributor] &&= contribs.empty?
+        contribs
+      end
+
+      # @param name [String]
+      # @return [Bib::Contributor]
+      def person_contrib(name)
+        Bib::Contributor.new(
+          person: Bib::Person.new(
+            name: Bib::FullName.new(
+              completename: Bib::LocalizedString.new(content: name),
+            ),
+          ),
+          role: [Bib::Contributor::Role.new(type: "author")],
+        )
+      end
+
+      # @param name [String]
+      # @return [Bib::Contributor]
+      def org_contrib(name)
+        Bib::Contributor.new(
+          organization: Bib::Organization.new(
+            name: [Bib::TypedLocalizedString.new(content: name)],
+          ),
+          role: [Bib::Contributor::Role.new(type: "publisher")],
+        )
+      end
+
+      # @param date [String, nil]
+      # @return [Array<Bib::Date>]
+      def fetch_date(date)
+        result = if date
+                   [Bib::Date.new(type: "published", at: date)]
+                 else
+                   []
+                 end
+        @errors[:date] &&= result.empty?
+        result
+      rescue Date::Error
+        @errors[:date] &&= true
+        []
+      end
+    end
+  end
+end

data/lib/relaton/ogc/util.rb

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

data/lib/relaton/ogc.rb

@@ -0,0 +1,30 @@
+# pubid loads with the flavor, for the ::Pubid::Ogc::Identifier that the
+# index code names. Processor#remove_index_file names no pubid class: the
+# delete never reads the index (see lib/relaton/index/CLAUDE.md).
+require "pubid"
+require "relaton/index"
+require "relaton/iso"
+require_relative "version"
+require_relative "ogc/util"
+require_relative "ogc/item_data"
+require_relative "ogc/item"
+require_relative "ogc/bibitem"
+require_relative "ogc/bibdata"
+require_relative "ogc/hit_collection"
+require_relative "ogc/bibliography"
+
+module Relaton
+  module Ogc
+    INDEXFILE = "index-v2".freeze
+    class Error < StandardError; end
+
+    # Returns hash of XML reammar
+    # @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/oiml/bibdata.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Oiml
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

data/lib/relaton/oiml/bibitem.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Oiml
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/oiml/bibliography.rb

@@ -0,0 +1,169 @@
+require "net/http"
+
+module Relaton
+  module Oiml
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-oiml/main/".freeze
+
+      class << self
+        #
+        # Search for an OIML publication by its identifier.
+        #
+        # @param text [String, Pubid::Oiml::Identifier] the OIML reference to
+        #   look up (e.g. "OIML R 138" or "OIML R 138:2007 (E)")
+        # @param year [String, nil] the edition year (optional; may also be
+        #   embedded in the reference)
+        # @param _opts [Hash] options (unused)
+        #
+        # @return [Relaton::Oiml::Item, nil] the publication or nil if not found
+        #
+        def search(text, year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          pubid = text.is_a?(String) ? ::Pubid::Oiml.parse(text) : text
+          Util.info "Fetching from Relaton repository ...", key: pubid.to_s
+          row = best_row(pubid, year)
+          unless row
+            Util.info "Not found.", key: pubid.to_s
+            return
+          end
+
+          uri = URI("#{ENDPOINT}#{row[:file]}")
+          resp = Net::HTTP.get_response uri
+          unless resp.code == "200"
+            raise Relaton::RequestError, "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
+          item = Relaton::Oiml::Item.from_yaml resp.body
+          Util.info "Found: `#{item.docidentifier.first&.content}`", key: pubid.to_s
+          item.tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+               Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+               Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
+        end
+
+        # Fetch an OIML publication, suppressing the edition year for an undated
+        # citation so the designation renders undated (`OIML B 18`), the way the
+        # ISO fetcher does. A dated citation (`OIML B 18:2022`, or an explicit
+        # `year`) still pins that edition. Mirrors `Relaton::Iso::Bibliography#get`.
+        #
+        # @param opts [Hash] options
+        # @option opts [Boolean] :keep_year retain the edition year even for an
+        #   undated citation (or, when false, strip it even for a dated one)
+        #
+        # @see #search
+        def get(ref, year = nil, opts = {})
+          item = search(ref, year, opts)
+          return item unless item
+
+          pubid = ref.is_a?(String) ? ::Pubid::Oiml.parse(ref) : ref
+          dated = oiml_side(pubid).year || year
+          # Keep the year only when the citation genuinely asks for it: a resolved
+          # year (unless keep_year is explicitly false), or keep_year truthy. (ISO
+          # also keeps for :all_parts; OIML has no all-parts retrieval, so search
+          # ignores opts and there is nothing to mirror here.)
+          return item if (dated && opts[:keep_year].nil?) || opts[:keep_year]
+
+          item.to_most_recent_reference
+        end
+
+        private
+
+        def index
+          Relaton::Index.find_or_create(
+            :oiml,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Oiml::Identifier,
+          )
+        end
+
+        # The index row for a reference: the latest edition among the rows it
+        # matches.
+        #
+        # The pubid is passed to `Index::Type#search`, so the index narrows
+        # candidates by number via binary search, and each row's `:id` is a
+        # Pubid::Oiml::Identifier (deserialized via the `pubid_class` in
+        # `#index`).
+        #
+        # A Bulletin matches exactly (`exact: true`). Its year is part of its
+        # locator, not an edition: the issue and the sequence render after the
+        # year, so the stem below reduces every article of one year to
+        # `OIML Bulletin`, and a lookup used to return any one of them.
+        #
+        # This flavor does not use pubid's subset match `===` yet. Measured
+        # over the full `relaton-data-oiml` index, `===` lets a language-less
+        # Amendment, Annex or Errata reference reach its translations
+        # (`language` is not strict), lets `OIML R 137-1 (F)` reach
+        # `OIML R 137-1-2:2012 (F)` (`subpart` is not strict), and rejects
+        # `OIML R 102:1995 Annex B-C` for `OIML R 102 Annex B-C` (the
+        # `year_on_base` render flag is compared).
+        #
+        # @param query [Pubid::Oiml::Identifier]
+        # @param year [String, nil]
+        # @return [Hash, nil] the index row (`{ id:, file: }`)
+        def best_row(query, year)
+          return index.search(query, exact: true).first if bulletin?(query)
+
+          index.search(query) { |r| pubid_match?(r[:id], query, year) }
+               .max_by { |r| oiml_side(r[:id]).year.to_i }
+        end
+
+        # @return [Boolean] true for an identifier of an OIML Bulletin
+        def bulletin?(pubid)
+          pubid.is_a?(::Pubid::Oiml::Identifiers::Bulletin)
+        end
+
+        # A document OIML co-publishes with another SDO (ISO confirmed so far)
+        # is a Pubid::Oiml::Identifiers::DualPublished — a "|"-joined pair
+        # (pubid#437), e.g. `ISO 4064-1:2024|OIML R 49-1:2024`. It delegates
+        # #root/#code/#type/#stage/#iteration/#publisher to whichever side is
+        # OIML, but NOT #year or #language — those read nil on the wrapper
+        # itself regardless of what either side holds. This unwraps to the
+        # OIML side for those reads (a plain, non-dual pubid is returned
+        # unchanged), so a query and a row agree on year/language/stem
+        # whether either one is dual-published or not, and regardless of
+        # which side print order named first.
+        #
+        # @param pubid [Pubid::Oiml::Identifier] a plain or dual-published pubid
+        # @return [Pubid::Oiml::Identifier] the OIML-flavored side (itself, for
+        #   a plain pubid)
+        def oiml_side(pubid)
+          pubid.is_a?(::Pubid::Oiml::Identifiers::DualPublished) ? pubid.oiml_identifier : pubid
+        end
+
+        # Both `row_id` and `query` are Pubid::Oiml::Identifier instances.
+        # Matching is on the year/language-stripped "stem" (e.g. `OIML R 138`),
+        # which keeps the type letter and any amendment suffix — so an amendment
+        # (`OIML R 138-Amend`) never matches the base record, even though pubid
+        # does not expose the suffix as its own attribute. Language must match
+        # exactly (a language-less query targets the language-less abstract
+        # record); year is nil-tolerant so an unqualified query finds the latest
+        # edition (selected by `max_by` in #best_row). The `year` argument lets
+        # a caller pin an edition the reference string omitted.
+        def pubid_match?(row_id, query, year)
+          row = oiml_side(row_id)
+          q = oiml_side(query)
+          wanted_year = (q.year || year)&.to_s
+          stem(row) == stem(q) &&
+            row.language.to_s == q.language.to_s &&
+            (wanted_year.nil? || row.year.to_s == wanted_year)
+        end
+
+        # The identifier without its edition year or language, e.g.
+        # `OIML R 138:2007 (E)` -> `OIML R 138`. Built from pubid's own model
+        # via #exclude (returns a copy, so the cached index id is untouched)
+        # rather than string surgery on #to_s. The amendment suffix is kept, so
+        # an amendment (`OIML R 138-Amend`) never reduces to the base record.
+        #
+        # Reduced through #oiml_side first: `#exclude` recurses correctly into
+        # both sides of a DualPublished (unlike a direct #year/#language read),
+        # but a plain query has no external side to reduce to, so comparing
+        # full dual-published stems against a plain one would never match.
+        def stem(pubid)
+          oiml_side(pubid).exclude(:year, :language).to_s
+        end
+      end
+    end
+  end
+end

data/lib/relaton/oiml/docidentifier.rb

@@ -0,0 +1,48 @@
+module Relaton
+  module Oiml
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        @pubid = ::Pubid::Oiml.parse(value) if value
+      rescue StandardError
+        @pubid = nil
+      end
+
+      # Both mutators go through #exclude (an immutable copy) rather than
+      # mutating `@pubid` in place: for a plain identifier the two are
+      # equivalent, but for a Pubid::Oiml::Identifiers::DualPublished
+      # (pubid#437, e.g. `ISO 4064-1:2024|OIML R 49-1:2024`) a direct
+      # `@pubid.part = nil`/`@pubid.date = nil` is a silent no-op — neither
+      # attribute is delegated to either side — while `#exclude` correctly
+      # recurses into both sides. `content=` re-parses the rendered string,
+      # which resyncs `@pubid` too, so there is nothing left to reassign here.
+      def remove_part!
+        return unless @pubid
+
+        self.content = @pubid.exclude(:part).to_s
+      end
+
+      def remove_date!
+        return unless @pubid
+
+        # Re-sync `content` from the now-dateless pubid: it is the string that
+        # actually renders (e.g. `OIML R 138`, or `OIML R 138 (E)` keeping the
+        # language). Mutating `@pubid` alone leaves the dated `content` in place.
+        self.content = @pubid.exclude(:date).to_s
+      end
+
+      def to_all_parts!
+        @pubid &&= @pubid.to_all_parts
+      end
+    end
+  end
+end

data/lib/relaton/oiml/doctype.rb

@@ -0,0 +1,13 @@
+module Relaton
+  module Oiml
+    # OIML document types, per relaton/relaton-oiml#1. The value is carried in
+    # the inherited `content` attribute (e.g. `recommendation`). `bulletin`
+    # (the online OIML Bulletin) is listed for forward-compatibility; the
+    # dataset does not yet contain such records. The list is intentionally not
+    # enforced as an enum so unforeseen dataset values still round-trip.
+    class Doctype < Bib::Doctype
+      TYPES = %w[recommendation document guide vocabulary basic-publication
+                 expert-report seminar-report translation bulletin].freeze
+    end
+  end
+end

data/lib/relaton/oiml/ext.rb

@@ -0,0 +1,42 @@
+require_relative "doctype"
+
+module Relaton
+  module Oiml
+    # OIML bibliographic item extension. Adds the OIML-specific structured
+    # metadata (relaton/relaton-oiml#2) on top of the shared Relaton::Bib::Ext.
+    # These fields are populated on the enhanced OIML Recommendations and are
+    # absent on most records; they round-trip through both XML and YAML.
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype
+      attribute :scope, :string
+      attribute :quantity, :string
+      attribute :measuring_instrument, :string
+      attribute :focus_area, :string
+      attribute :sustainability_framework, :string
+      attribute :doi, :string
+
+      xml do
+        map_element "scope", to: :scope
+        map_element "quantity", to: :quantity
+        map_element "measuring_instrument", to: :measuring_instrument
+        map_element "focus_area", to: :focus_area
+        map_element "sustainability_framework", to: :sustainability_framework
+        map_element "doi", to: :doi
+      end
+
+      key_value do
+        map_element "scope", to: :scope
+        map_element "quantity", to: :quantity
+        map_element "measuring_instrument", to: :measuring_instrument
+        map_element "focus_area", to: :focus_area
+        map_element "sustainability_framework", to: :sustainability_framework
+        map_element "doi", to: :doi
+      end
+
+      # No dedicated OIML (flavor) model exists yet, so the extension reuses the
+      # base Relaton::Bib behaviour and does not advertise a flavor-specific
+      # schema version. Add a `relaton-model-oiml` entry to relaton-bib's
+      # versions.json and override #schema_version here once that model lands.
+    end
+  end
+end

data/lib/relaton/oiml/item.rb

@@ -0,0 +1,20 @@
+require_relative "item_data"
+require_relative "ext"
+require_relative "docidentifier"
+
+module Relaton
+  module Oiml
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
+    end
+  end
+end
+
+require_relative "relation"
+
+Relaton::Oiml::Item.attribute :relation, Relaton::Oiml::Relation,
+                              collection: true, initialize_empty: true

data/lib/relaton/oiml/item_base.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Oiml
+    class ItemBase < Lutaml::Model::Serializable
+      include Bib::NamespaceHelper
+
+      attr_accessor :type
+
+      model ItemData
+
+      instance_exec(&Bib::ItemShared::ATTRIBUTES)
+
+      xml do
+        map_attribute "type", to: :type
+        instance_exec(&Bib::ItemShared::XML_BODY)
+      end
+    end
+  end
+end

data/lib/relaton/oiml/item_data.rb

@@ -0,0 +1,6 @@
+module Relaton
+  module Oiml
+    class ItemData < Bib::ItemData
+    end
+  end
+end

data/lib/relaton/oiml/processor.rb

@@ -0,0 +1,54 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Oiml
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize
+        @short = :relaton_oiml
+        @prefix = "OIML"
+        @defaultprefix = %r{^OIML\s}
+        @idtype = "OIML"
+      end
+
+      # @param code [String]
+      # @param date [String, nil] year
+      # @param opts [Hash]
+      # @return [Relaton::Oiml::ItemData, nil]
+      def get(code, date, opts)
+        require_relative "../oiml"
+        Bibliography.get(code, date, opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Oiml::ItemData]
+      def from_xml(xml)
+        require_relative "../oiml"
+        Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::Oiml::ItemData]
+      def from_yaml(yaml)
+        require_relative "../oiml"
+        Item.from_yaml(yaml)
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../oiml"
+        @grammar_hash ||= ::Relaton::Oiml.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../oiml"
+        Relaton::Index.find_or_create(:oiml, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      end
+    end
+  end
+end

data/lib/relaton/oiml/relation.rb

@@ -0,0 +1,9 @@
+require_relative "item_base"
+
+module Relaton
+  module Oiml
+    class Relation < Bib::Relation
+      attribute :bibitem, ItemBase
+    end
+  end
+end

data/lib/relaton/oiml/util.rb

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