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

data/lib/relaton/ogc/item.rb

@@ -0,0 +1,13 @@
+require_relative "docidentifier"
+require_relative "ext"
+
+module Relaton
+  module Ogc
+    class Item < Iso::Item
+      model ItemData
+
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+      attribute :ext, Ext
+    end
+  end
+end

data/lib/relaton/ogc/item_data.rb

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

data/lib/relaton/ogc/processor.rb

@@ -0,0 +1,58 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Ogc
+    class Processor < Core::Processor
+      def initialize # rubocop:disable Lint/MissingSuper
+        @short = :relaton_ogc
+        @prefix = "OGC"
+        @defaultprefix = %r{^OGC\s}
+        @idtype = "OGC"
+        @datasets = %w[ogc-naming-authority]
+      end
+
+      # @param code [String]
+      # @param date [String, nil]
+      # @param opts [Hash]
+      # @return [Relaton::Ogc::ItemData]
+      def get(code, date, opts)
+        require_relative "../ogc"
+        Bibliography.get(code, date, opts)
+      end
+
+      # @param source [String]
+      # @param opts [Hash]
+      def fetch_data(_source, opts)
+        require_relative "data_fetcher"
+        DataFetcher.fetch(**opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Ogc::ItemData]
+      def from_xml(xml)
+        require_relative "../ogc"
+        Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::Ogc::ItemData]
+      def from_yaml(yaml)
+        require_relative "../ogc"
+        Item.from_yaml yaml
+      end
+
+      # @return [String]
+      def grammar_hash
+        require_relative "../ogc"
+        @grammar_hash ||= Relaton::Ogc.grammar_hash
+      end
+
+      def remove_index_file
+        require_relative "../ogc"
+        Relaton::Index.find_or_create(
+          :ogc, url: true, file: "#{INDEXFILE}.yaml",
+        ).remove_file
+      end
+    end
+  end
+end

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,26 @@
+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-v1".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,94 @@
+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
+          # Pass the pubid so Relaton::Index narrows candidates by number via
+          # binary search before applying the block. Every row's `:id` is a
+          # Pubid::Oiml::Identifier (Relaton::Index deserialized it via the
+          # `pubid_class` passed in `#index`), so the block compares pubids and
+          # the result picks the latest edition.
+          row = index.search(pubid) { |r| pubid_match?(r[:id], pubid, year) }
+                     .max_by { |r| r[:id].year.to_i }
+          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
+
+        # @see #search
+        def get(ref, year = nil, opts = {})
+          search(ref, year, opts)
+        end
+
+        private
+
+        def index
+          Relaton::Index.find_or_create(
+            :oiml,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Oiml::Identifier,
+          )
+        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 #search). The `year` argument lets a
+        # caller pin an edition the reference string omitted.
+        def pubid_match?(row_id, query, year)
+          wanted_year = (query.year || year)&.to_s
+          stem(row_id) == stem(query) &&
+            row_id.language.to_s == query.language.to_s &&
+            (wanted_year.nil? || row_id.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.
+        def stem(pubid)
+          pubid.exclude(:year, :language).to_s
+        end
+      end
+    end
+  end
+end

data/lib/relaton/oiml/docidentifier.rb

@@ -0,0 +1,33 @@
+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
+
+      def remove_part!
+        @pubid&.part = nil
+      end
+
+      def remove_date!
+        @pubid&.date = nil
+      end
+
+      def to_all_parts!
+        @pubid&.all_parts = true
+      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