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

data/lib/relaton/ietf/rfc/is_also.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "rfc_index_namespace"
+
+module Relaton
+  module Ietf
+    module Rfc
+      # Model for <is-also> element containing doc-id references
+      class IsAlso < Lutaml::Model::Serializable
+        attribute :doc_id, :string, collection: true
+
+        xml do
+          root "is-also"
+          namespace RfcIndexNamespace
+
+          map_element "doc-id", to: :doc_id
+        end
+      end
+    end
+  end
+end

data/lib/relaton/ietf/rfc/keywords.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "rfc_index_namespace"
+
+module Relaton
+  module Ietf
+    module Rfc
+      class Keywords < Lutaml::Model::Serializable
+        attribute :kw, :string, collection: true
+
+        xml do
+          root "keywords"
+          namespace RfcIndexNamespace
+          map_element "kw", to: :kw
+        end
+      end
+    end
+  end
+end

data/lib/relaton/ietf/rfc/rfc_index_namespace.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Ietf
+    module Rfc
+      class RfcIndexNamespace < Lutaml::Xml::W3c::XmlNamespace
+        uri "https://www.rfc-editor.org/rfc-index"
+      end
+    end
+  end
+end

data/lib/relaton/ietf/scraper.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Ietf
+    # Scraper module
+    module Scraper
+      extend Scraper
+
+      IDS = "https://raw.githubusercontent.com/relaton/relaton-data-ids/refs/heads/v2/"
+      RFC = "https://raw.githubusercontent.com/relaton/relaton-data-rfcs/refs/heads/v2/"
+      RSS = "https://raw.githubusercontent.com/relaton/relaton-data-rfcsubseries/refs/heads/v2/"
+
+      # @param text [String]
+      # @return [RelatonIetf::IetfBibliographicItem]
+      def scrape_page(text)
+        # Remove initial "IETF " string if specified
+        ref = text.gsub(/^IETF /, "")
+        # ref.sub!(/(?<=^(?:RFC|BCP|FYI|STD))\s(\d+)/) { $1.rjust 4, "0" }
+        rfc_item ref
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+            Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+            Net::ProtocolError, SocketError
+        raise Relaton::RequestError, "No document found for #{ref} reference"
+      end
+
+      private
+
+      # @param ref [String]
+      # @return [RelatonIetf::IetfBibliographicItem]
+      def rfc_item(ref) # rubocop:disable Metrics/MethodLength
+        case ref
+        when /^RFC/ then get_rfcs ref
+        when /^(?:BCP|FYI|STD)/ then get_rfcsubseries ref
+        when /^I-D/
+          ref.sub!(/^I-D[.\s]/, "")
+          get_ids ref
+        end
+      end
+
+      def get_rfcs(ref)
+        index = Relaton::Index.find_or_create :RFC, url: "#{RFC}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
+        row = index.search(ref).first
+        get_page "#{RFC}#{row[:file]}" if row
+      end
+
+      def get_rfcsubseries(ref)
+        index = Relaton::Index.find_or_create :RSS, url: "#{RSS}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
+        row = index.search(ref).first
+        get_page "#{RSS}#{row[:file]}" if row
+      end
+
+      def get_ids(ref)
+        index = Relaton::Index.find_or_create :IDS, url: "#{IDS}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml"
+        row = index.search(ref).first
+        get_page "#{IDS}#{row[:file]}" if row
+      end
+
+      # @param uri [String]
+      # @return [RelatonIetf::IetfBibliographicItem, nil] HTTP response body
+      def get_page(uri)
+        res = Net::HTTP.get_response(URI(uri))
+        return unless res.code == "200"
+
+        Item.from_yaml(res.body).tap { |item| item.fetched = Date.today.to_s }
+      end
+    end
+  end
+end

data/lib/relaton/ietf/util.rb

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

data/lib/relaton/ietf/wg_name_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+
+module Relaton
+  module Ietf
+    # Fetches working group and research group names from the IETF Datatracker API.
+    # Returns a Hash mapping acronym (lowercase) to full group name.
+    module WgNameResolver
+      API_URL = "https://datatracker.ietf.org/api/v1/group/group/"
+
+      # @return [Hash{String => String}] acronym => full name
+      def self.fetch
+        result = {}
+        offset = 0
+        limit = 1000
+        loop do
+          uri = URI("#{API_URL}?type__in=wg,rg&limit=#{limit}&offset=#{offset}&format=json")
+          response = Net::HTTP.get_response(uri)
+          break unless response.is_a?(Net::HTTPSuccess)
+
+          data = JSON.parse(response.body)
+          objects = data["objects"] || []
+          break if objects.empty?
+
+          objects.each do |group|
+            acronym = group["acronym"]
+            name = group["name"]
+            result[acronym] = name if acronym && name
+          end
+          offset += limit
+          break unless data.dig("meta", "next")
+        end
+        result
+      rescue StandardError => e
+        Util.warn "Failed to fetch WG names from Datatracker: #{e.message}"
+        {}
+      end
+    end
+  end
+end

data/lib/relaton/ietf.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "relaton/index"
+require "relaton/bib"
+require_relative "version"
+require_relative "ietf/util"
+require_relative "ietf/item_data"
+require_relative "ietf/item"
+require_relative "ietf/bibitem"
+require_relative "ietf/bibdata"
+require_relative "ietf/rfc/index"
+require_relative "ietf/bibliography"
+
+module Relaton
+  module Ietf
+    INDEXFILE = "index-v1".freeze
+    # 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/iho/bibdata.rb

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

data/lib/relaton/iho/bibitem.rb

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

data/lib/relaton/iho/bibliography.rb

@@ -0,0 +1,114 @@
+require "net/http"
+
+module Relaton
+  module Iho
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-iho/refs/heads/v2/".freeze
+
+      class << self
+        #
+        # Search for IHO standard by IHO standard Code
+        #
+        # @param text [String] the IHO standard Code to look up (e..g "IHO B-11")
+        #
+        # @return [RelatonIho::IhoBibliographicItem, nil] the IHO standard or nil if not found
+        #
+        def search(text, _year = nil, _opts = {}) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          pubid = text.is_a?(String) ? ::Pubid::Iho::Identifier.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::Iho::Identifiers::* (Relaton::Index deserialized it via the
+          # `pubid_class` passed in `#index`), so `pubid_match?` compares pubids.
+          row = index.search(pubid) { |r| pubid_match?(r[:id], pubid) }
+                     .min_by { |r| r[:id].version.to_s }
+          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::Iho::Item.from_yaml resp.body
+          enrich_with_pubid(item, pubid)
+          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
+
+        # Populate ext.structuredidentifier from the parsed Pubid when the
+        # fetched record doesn't already provide one. Maps `pubid.number`
+        # (with type prefix, e.g. `S-100`) -> docnumber, `pubid.part` -> part,
+        # `pubid.appendix` -> appendixid, `pubid.annex` -> annexid,
+        # `pubid.supplement` -> supplementid.
+        def enrich_with_pubid(item, pubid)
+          return if item.ext&.structuredidentifier&.any?
+
+          sid = StructuredIdentifier.new(
+            docnumber: pubid_docnumber(pubid),
+            part: pubid.part,
+            appendixid: (pubid.appendix if pubid.respond_to?(:appendix)),
+            annexid: (pubid.annex if pubid.respond_to?(:annex)),
+            supplementid: (pubid.supplement if pubid.respond_to?(:supplement)),
+          )
+          item.ext ||= Ext.new
+          item.ext.structuredidentifier = [sid]
+        end
+
+        # "S-100" rather than "100" — keeps the type prefix that distinguishes
+        # the IHO series (S/P/M/B/C). Matches spec/fixtures/iho_part.xml.
+        def pubid_docnumber(pubid)
+          pubid.to_s.sub(/^IHO\s/, "").split(/\s+/, 2).first
+        end
+
+        # @param ref [String] the IHO standard Code to look up (e..g "IHO B-11")
+        # @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 [RelatonIho::IhoBibliographicItem]
+        def get(ref, year = nil, opts = {})
+          search(ref, year, opts)
+        end
+
+        private
+
+        def index
+          Relaton::Index.find_or_create(
+            :iho,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Iho::Identifiers::Base,
+          )
+        end
+
+        # Both `row_id` and `query` are Pubid::Iho::Identifiers::* instances.
+        # Class identity pins the series (S/P/M/B/C). Subdivision keys
+        # (part/appendix/annex/supplement) use strict equality — a nil query
+        # must match a nil row (the umbrella), not an arbitrary subdivision
+        # under the same (number, version). Only :version stays nil-tolerant: an
+        # unqualified `IHO B-11` query is expected to find the latest edition.
+        def pubid_match?(row_id, query)
+          row_id.class == query.class &&
+            row_id.number == query.number &&
+            row_id.part.to_s == query.part.to_s &&
+            row_id.appendix.to_s == query.appendix.to_s &&
+            row_id.annex.to_s == query.annex.to_s &&
+            row_id.supplement.to_s == query.supplement.to_s &&
+            (query.version.nil? || row_id.version.to_s == query.version.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/iho/comment_period.rb

@@ -0,0 +1,13 @@
+module Relaton
+  module Iho
+    class CommentPeriod < Lutaml::Model::Serializable
+      attribute :from, :date
+      attribute :to, :date
+
+      xml do
+        map_element "from", to: :from
+        map_element "to", to: :to
+      end
+    end
+  end
+end

data/lib/relaton/iho/docidentifier.rb

@@ -0,0 +1,31 @@
+module Relaton
+  module Iho
+    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::Iho::Identifier.parse(value) if value
+      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/iho/doctype.rb

@@ -0,0 +1,10 @@
+module Relaton
+  module Iho
+    class Doctype < Bib::Doctype
+      TYPES = %w[policy-and-procedures best-practices supporting-document
+                 report legal directives proposal standard].freeze
+
+      attribute :type, :string, values: TYPES
+    end
+  end
+end

data/lib/relaton/iho/ext.rb

@@ -0,0 +1,20 @@
+require_relative "doctype"
+require_relative "comment_period"
+require_relative "structured_identifier"
+
+module Relaton
+  module Iho
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype, default: -> { Doctype.new(content: "standard") }
+      attribute :commentperiod, CommentPeriod
+      attribute :structuredidentifier, StructuredIdentifier,
+                collection: true, initialize_empty: true
+
+      xml { map_element "commentperiod", to: :commentperiod }
+
+      key_value { map_element "commentperiod", to: :commentperiod }
+
+      def schema_version = Relaton.schema_versions["relaton-model-iho"]
+    end
+  end
+end

data/lib/relaton/iho/hash_parser_v1.rb

@@ -0,0 +1,144 @@
+require "relaton/bib/hash_parser_v1"
+require_relative "../iho"
+
+module Relaton
+  module Iho
+    module HashParserV1
+      include Core::ArrayWrapper
+      include Core::DateParser
+      include Bib::HashParserV1
+      extend self
+
+      private
+
+      def ext_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
+        ret[:ext] ||= {}
+        doctype_hash_to_bib ret
+        ret[:ext][:doctype] ||= Doctype.new(content: "standard")
+        ret[:ext][:subdoctype] = ret.delete(:subdoctype) if ret[:subdoctype]
+        ret[:ext][:flavor] ||= flavor(ret)
+        ics_hash_to_bib ret
+        commentperiod_hash_to_bib ret
+        structuredidentifier_hash_to_bib ret
+        ret[:ext] = Ext.new(**ret[:ext])
+      end
+
+      def structuredidentifier_hash_to_bib(ret)
+        sid = ret.dig(:ext, :structuredidentifier) || ret[:structuredidentifier]
+        return unless sid
+
+        ret[:ext]&.delete(:structuredidentifier)
+        ret.delete(:structuredidentifier)
+        ret[:ext][:structuredidentifier] =
+          array(sid).map { |s| StructuredIdentifier.new(**s) }
+      end
+
+      def commentperiod_hash_to_bib(ret)
+        cp = ret.dig(:ext, :commentperiod) || ret[:commentperiod]
+        return unless cp
+
+        ret[:ext]&.delete(:commentperiod)
+        ret.delete(:commentperiod)
+        cp[:from] = ::Date.parse(cp[:from]) if cp[:from]
+        cp[:to] = ::Date.parse(cp[:to]) if cp[:to]
+        ret[:ext][:commentperiod] = CommentPeriod.new(**cp)
+      end
+
+      # IHO editorialgroup is an array of arrays of committee entries:
+      #   editorialgroup:
+      #   - - committee:
+      #         abbreviation: HSSC
+      #         name: Hydrographic Services and Standards Committee
+      #     - committee:
+      #         abbreviation: IRCC
+      #         name: Inter-Regional Coordination Committee
+      #         committee:
+      #           abbreviation: GEBCO
+      #           name: JOINT IHO-IOC GUIDING COMMITTEE FOR THE GENERAL BATHYMETRIC CHART OF THE OCEANS
+      def editorialgroup_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        eg = ret.dig(:ext, :editorialgroup) || ret[:editorialgroup]
+        return unless eg
+
+        ret[:ext]&.delete(:editorialgroup)
+        ret.delete(:editorialgroup)
+        ret[:contributor] ||= []
+
+        array(eg).flatten.each do |entry|
+          committee = entry[:committee]
+          next unless committee
+
+          subdivision = build_subdivision(committee)
+          ret[:contributor] << Bib::Contributor.new(
+            role: [Bib::Contributor::Role.new(
+              type: "author",
+              description: [Bib::LocalizedMarkedUpString.new(content: "committee")],
+            )],
+            organization: Bib::Organization.new(
+              name: [Bib::TypedLocalizedString.new(content: "International Hydrographic Organization")],
+              abbreviation: Bib::LocalizedString.new(content: "IHO"),
+              subdivision: [subdivision],
+            ),
+          )
+        end
+      end
+
+      def build_subdivision(committee)
+        sub_divisions = []
+        if committee[:committee]
+          sub_divisions << build_subdivision(committee[:committee])
+        end
+
+        identifiers = []
+        if committee[:abbreviation]
+          identifiers << Bib::OrganizationType::Identifier.new(
+            content: committee[:abbreviation],
+          )
+        end
+
+        Bib::Subdivision.new(
+          type: "technical-committee",
+          name: [Bib::TypedLocalizedString.new(content: committee[:name])],
+          identifier: identifiers,
+          subdivision: sub_divisions,
+        )
+      end
+
+      def series_hash_to_bib(ret)
+        ret[:series] &&= array(ret[:series]).map do |s|
+          if s[:title].is_a?(Hash) && s[:title][:content].is_a?(Array)
+            s[:title] = s[:title][:content].map do |c|
+              { type: s[:title][:type], content: c[:content], language: c[:language], script: c[:script] }.compact
+            end
+          end
+          super_series(s)
+        end
+      end
+
+      def super_series(s)
+        s[:formattedref] && s[:formattedref] = formattedref(s[:formattedref])
+        s[:title] &&= title_collection(s[:title])
+        s[:place] &&= create_place(s[:place])
+        s[:abbreviation] &&= localizedstring(s[:abbreviation])
+        s[:from] &&= ::Date.parse(s[:from])
+        s[:to] &&= ::Date.parse(s[:to])
+        Bib::Series.new(**s)
+      end
+
+      def bib_item(item)
+        ItemData.new(**item)
+      end
+
+      def create_doctype(args)
+        Doctype.new(**args)
+      end
+
+      def create_relation(rel)
+        Relation.new(**rel)
+      end
+
+      def create_docid(**args)
+        Docidentifier.new(**args)
+      end
+    end
+  end
+end

data/lib/relaton/iho/item.rb

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

data/lib/relaton/iho/item_base.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Iho
+    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/iho/item_data.rb

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

data/lib/relaton/iho/processor.rb

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

data/lib/relaton/iho/relation.rb

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