relaton 2.1.0 → 3.0.0.pre.alpha.1

data/lib/relaton/itu/model/recommendation_status.rb

@@ -0,0 +1,11 @@
+require_relative "approval_stage"
+
+module Relaton
+  module Itu
+    class RecommendationStatus < Lutaml::Model::Serializable
+      attribute :from, :string
+      attribute :to, :string
+      attribute :approvalstage, ApprovalStage
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Relaton
+  module Itu
+    class StructuredIdentifier < Lutaml::Model::Serializable
+      attribute :bureau, :string, values: %w[T D R]
+      attribute :docnumber, :string
+      attribute :annexid, :string
+      attribute :amendment, :integer
+      attribute :corrigendum, :integer
+
+      xml do
+        map_element "bureau", to: :bureau
+        map_element "docnumber", to: :docnumber
+        map_element "annexid", to: :annexid
+        map_element "amendment", to: :amendment
+        map_element "corrigendum", to: :corrigendum
+      end
+    end
+  end
+end

data/lib/relaton/itu/processor.rb

@@ -0,0 +1,66 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Itu
+    class Processor < Relaton::Core::Processor
+      def initialize
+        @short = :relaton_itu
+        @prefix = "ITU"
+        @defaultprefix = %r{^ITU\s}
+        @idtype = "ITU"
+        @datasets = %w[itu-r]
+      end
+
+      # @param code [String]
+      # @param date [String, nil] year
+      # @param opts [Hash]
+      # @return [Relaton::Itu::ItemData, nil]
+      def get(code, date, opts)
+        require_relative "../itu"
+        Bibliography.get(code, date, opts)
+      end
+
+      #
+      # Fetch all the documents from https://extranet.itu.int/brdocsearch/
+      #
+      # @param [String] source source name (itu-r)
+      # @param [Hash] opts
+      # @option opts [String] :output directory to output documents, default is data
+      # @option opts [String] :format output format, default is yaml
+      #
+      def fetch_data(source, opts)
+        require_relative "data_fetcher"
+        DataFetcher.fetch(source, **opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Itu::ItemData]
+      def from_xml(xml)
+        require_relative "../itu"
+        Item.from_xml xml
+      end
+
+      # @param yaml [Hash]
+      # @return [Relaton::Itu::ItemData]
+      def from_yaml(yaml)
+        require_relative "../itu"
+        Item.from_yaml yaml
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../itu"
+        @grammar_hash ||= Itu.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../itu"
+        Relaton::Index.find_or_create(:itu, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      end
+    end
+  end
+end

data/lib/relaton/itu/pubid.rb

@@ -0,0 +1,177 @@
+module Relaton
+  module Itu
+    class Pubid
+      class Parser < Parslet::Parser
+        rule(:dash) { str("-") }
+        rule(:dot) { str(".") }
+        rule(:dot?) { dot.maybe }
+        rule(:separator) { match['\s-'] }
+        rule(:space) { match("\s") }
+        rule(:num) { match["0-9"] }
+
+        rule(:prefix) { str("ITU").as(:prefix) }
+        rule(:sector) { separator >> match("[A-Z]").as(:sector) }
+        rule(:type) { separator >> str("REC").as(:type) }
+        rule(:type?) { type.maybe }
+        rule(:code) { separator >> (match["A-Z0-9"].repeat(1) >> match["[:alnum:]/.-"].repeat).as(:code) }
+        rule(:year) { (match["12"] >> num.repeat(3, 3)).as(:year) }
+
+        rule(:month1) { num.repeat(2, 2).as(:month) }
+        rule(:date1) { str(" (") >> (month1 >> str("/")).maybe >> year >> str(")") }
+        rule(:month2) { match["IVX"].repeat(1, 3).as(:month) }
+        rule(:date2) { str(" - ") >> num.repeat(2, 2).as(:day) >> dot >> month2 >> dot >> year }
+        rule(:date) { date1 | date2 }
+        rule(:date?) { date.maybe }
+
+        rule(:amd_month) { num.repeat(2, 2) }
+        rule(:amd_year) { num.repeat(4, 4) }
+        rule(:amd_date) { str(" (") >> (amd_month >> str("/") >> amd_year).as(:amd_date) >> str(")") }
+        rule(:amd_date?) { amd_date.maybe }
+        rule(:amd) { space >> (str("Amd") | str("Amendment")) >> dot? >> space >> num.repeat(1, 2).as(:amd) >> amd_date? }
+        rule(:amd?) { amd.maybe }
+
+        rule(:sup) { space >> str("Suppl") >> dot? >> space >> num.repeat(1, 2).as(:suppl) }
+        rule(:sup?) { sup.maybe }
+
+        rule(:annex) { space >> str("Annex") >> space >> match["[:alnum:]"].repeat(1, 2).as(:annex) }
+        rule(:annex?) { annex.maybe }
+
+        rule(:ver) { space >> str("(V") >> num.repeat(1, 2).as(:version) >> str(")") }
+        rule(:ver?) { ver.maybe }
+
+        rule(:itu_pubid_sector) { prefix >> sector >> type? >> code >> sup? >> annex? >> ver? >> date? >> amd? >> any.repeat }
+        rule(:itu_pubid_no_sector) { prefix >> type? >> code >> sup? >> annex? >> ver? >> date? >> amd? >> any.repeat }
+        rule(:itu_pubid) { itu_pubid_sector | itu_pubid_no_sector }
+        root(:itu_pubid)
+      end
+
+      attr_accessor :prefix, :sector, :type, :code, :suppl, :annex, :version, :year, :month, :day, :amd, :amd_date
+
+      #
+      # Create a new ITU publication identifier.
+      #
+      # @param [String] prefix
+      # @param [String] code
+      #
+      def initialize(prefix:, code:, **args)
+        @prefix = prefix
+        @sector = args[:sector]
+        @type = args[:type]
+        @day = args[:day]
+        @code, year, month = date_from_code code
+        @suppl = args[:suppl]
+        @annex = args[:annex]
+        @version = args[:version]
+        @year = args[:year] || year
+        @month = roman_to_2digit args[:month] || month
+        @amd = args[:amd]
+        @amd_date = args[:amd_date]
+      end
+
+      def self.parse(id)
+        id_parts = Parser.new.parse(id).to_h.transform_values(&:to_s)
+        new(**id_parts)
+      rescue Parslet::ParseFailed => e
+        Util.error "`#{id}` is invalid ITU publication identifier\n" \
+                   "#{e.parse_failure_cause.ascii_tree}"
+        raise e
+      end
+
+      def to_h(with_type: true) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        hash = { prefix: prefix, code: code }
+        hash[:sector] = sector if sector
+        hash[:type] = type if type && with_type
+        hash[:suppl] = suppl if suppl
+        hash[:annex] = annex if annex
+        hash[:version] = version if version
+        hash[:year] = year if year
+        hash[:month] = month if month
+        hash[:day] = day if day
+        hash[:amd] = amd if amd
+        hash[:amd_date] = amd_date if amd_date
+        hash
+      end
+
+      def to_ref
+        to_s ref: true
+      end
+
+      def to_s(ref: false) # rubocop:disable Metrics/AbcSize
+        s = prefix.dup
+        s << "-#{sector}" if sector
+        s << " #{type}" if type && !ref
+        s << " #{code}"
+        s << " Suppl. #{suppl}" if suppl
+        s << " Annex #{annex}" if annex
+        s << " (V#{version})" if version
+        s << date_to_s
+        s << " Amd #{amd}" if amd
+        s << " (#{amd_date})" if amd_date
+        s
+      end
+
+      def ===(other, ignore_args = [])
+        hash = to_h with_type: false
+        other_hash = other.to_h with_type: false
+        hash.delete(:version) if ignore_args.include?(:version)
+        other_hash.delete(:version) unless hash[:version]
+        hash.delete(:day)
+        other_hash.delete(:day)
+        hash.delete(:month)
+        other_hash.delete(:month)
+        hash.delete(:year) if ignore_args.include?(:year)
+        other_hash.delete(:year) unless hash[:year]
+        hash.delete(:amd_date) if ignore_args.include?(:amd_date)
+        other_hash.delete(:amd_date) unless hash[:amd_date]
+        hash == other_hash
+      end
+
+      private
+
+      def date_from_code(code)
+        /(?<cod>.+?)-(?<date>\d{6})(?:-I|$)/ =~ code
+        return [code, nil, nil] unless cod && date
+
+        [cod, date[0..3], date[4..5]]
+      end
+
+      def roman_to_2digit(num) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        return unless num
+
+        roman_nums = { "I" => 1, "V" => 5, "X" => 10 }
+        last = roman_nums[num[-1]]
+        return num unless last
+
+        return roman_nums[num].to_s.rjust(2, "0") if num.size == 1
+
+        num.chars.each_cons(2).reduce(last) do |acc, (a, b)|
+          if roman_nums[a] < roman_nums[b]
+            acc - roman_nums[a]
+          else
+            acc + roman_nums[a]
+          end
+        end.to_s.rjust(2, "0")
+      end
+
+      def month_to_roman
+        int = month.to_i
+        return month unless int.between? 1, 12
+
+        roman_tens = ["", "X"]
+        roman_units = ["", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"]
+
+        tens = int / 10
+        units = int % 10
+
+        roman_tens[tens] + roman_units[units]
+      end
+
+      def date_to_s
+        if month && year then " (#{month}/#{year})"
+        elsif year then " (#{year})"
+        else ""
+        end
+      end
+    end
+  end
+end

data/lib/relaton/itu/radio_regulations_parser.rb

@@ -0,0 +1,70 @@
+require "cgi"
+
+module Relaton
+  module Itu
+    class RadioRegulationsParser
+      include Relaton::Core::ArrayWrapper
+
+      ROMAN_MONTHS = %w[I II III IV V VI VII VIII IX X XI XII].freeze
+
+      def initialize(hit)
+        @hit = hit
+      end
+
+      def doc
+        @doc ||= hit.hit_collection.agent.get doc_url
+      rescue Mechanize::ResponseCodeError, SocketError, Timeout::Error, Errno::ECONNRESET,
+              EOFError, Net::ProtocolError, OpenSSL::SSL::SSLError => e
+        raise Relaton::RequestError, "Could not access #{doc_url}: #{e.message}"
+      end
+
+      def doc_url
+        CGI.unescape(hit.hit[:url]).split("dest=").last
+      end
+
+      def fetch_edition = nil
+      def fetch_status = nil
+      def fetch_abstract = []
+      def fetch_relations = []
+      def fetch_workgroup = nil
+
+      # @return [Array<Relaton::Bib::Title>]
+      def fetch_titles
+        title = doc.at("//title")&.text&.strip
+        return [] if title.nil? || title.empty?
+
+        Relaton::Bib::Title.from_string title, "en", "Latn"
+      end
+
+      # @return [Array<Relaton::Bib::Date>]
+      def fetch_dates
+        array(doc_date).map { |on| Relaton::Bib::Date.new(type: "published", at: on) }
+      end
+
+      def doc_date
+        return @doc_date if defined? @doc_date
+
+        date_str = doc.at("//td[@class='title']/text()")&.text&.slice(/(?<=Year:\s)(?:\d{1,2}\.\w+\.)?\d{4}/)
+        @doc_date = date_str ? roman_to_arabic(date_str) : nil
+      end
+
+      # @return [Array<Relaton::Bib::Uri>]
+      def fetch_source
+        [Relaton::Bib::Uri.new(type: "src", content: doc_url)]
+      end
+
+      private
+
+      attr_reader :hit
+
+      def roman_to_arabic(date)
+        %r{(?<rmonth>[IVX]+)} =~ date
+        if ROMAN_MONTHS.index(rmonth)
+          month = ROMAN_MONTHS.index(rmonth) + 1
+          Date.parse(date.sub(%r{[IVX]+}, month.to_s)).to_s
+        else date
+        end
+      end
+    end
+  end
+end

data/lib/relaton/itu/recommendation_parser.rb

@@ -0,0 +1,161 @@
+module Relaton
+  module Itu
+    class RecommendationParser
+      include Relaton::Core::ArrayWrapper
+
+      RECHDR = "https://www.itu.int/mws/api/recommendations/getRecHdrDetail?idrec=%{idrec}&lang=en"
+      RECEDITIONS = "https://www.itu.int/mws/api/recommendations/getRecEditions?idrec=%{idrec}&lang=en"
+      RECSUPPLEMENTS = "https://www.itu.int/mws/api/recommendations/getRecSupplements?idrec=%{idrec}&lang=en"
+      IMPLGUIDES = "https://www.itu.int/mws/api/recommendations/getImplGuides?idrec=%{idrec}&lang=en"
+
+      def initialize(hit, idrec, imp)
+        @hit = hit
+        @idrec = idrec
+        @imp = imp
+      end
+
+      def doc
+        @doc ||= begin
+          url = (imp ? IMPLGUIDES : RECHDR) % { idrec: idrec }
+          resp = get_data url
+          imp ? resp.first : resp
+        end
+      end
+
+      # @return [String, nil]
+      def fetch_edition
+        self_edition&.dig("Version")
+      end
+
+      # @return [Array<Relaton::Bib::Title>]
+      def fetch_titles
+        title = imp ? doc["imp_title_e"] : doc["rec_title"]
+        return [] if title.nil? || title.empty?
+
+        Relaton::Bib::Title.from_string title, "en", "Latn"
+      end
+
+      # @return [Relaton::Bib::Status, nil]
+      def fetch_status
+        inforce = imp ? imp_status : doc["status"]
+        return if inforce.nil? || inforce.empty?
+
+        status = inforce == "In force" ? "Published" : "Withdrawal"
+        Relaton::Bib::Status.new(stage: Relaton::Bib::Status::Stage.new(content: status))
+      end
+
+      # @return [Array<Relaton::Bib::Date>]
+      def fetch_dates
+        array(doc_date).map { |on| Relaton::Bib::Date.new(type: "published", at: on) }
+      end
+
+      # @return [Array<Relaton::Bib::LocalizedMarkedUpString>]
+      def fetch_abstract
+        array(doc["summary"]).map do |content|
+          Relaton::Bib::Abstract.new(content: content, language: "en", script: "Latn")
+        end
+      end
+
+      # @return [Array<Relaton::Bib::Uri>]
+      def fetch_source
+        link = imp ? doc["imp_dms_link"] : doc["handle_id"]
+        links = [Relaton::Bib::Uri.new(type: "src", content: link)]
+        links << Relaton::Bib::Uri.new(type: "pdf", content: doc["handle_id_pdf_link"]) if doc["handle_id_pdf_link"]
+        imp_word_link { |wlink| links << Relaton::Bib::Uri.new(type: "word", content: wlink) }
+        links
+      end
+
+      def doc_date
+        return @doc_date if defined? @doc_date
+
+        date = imp ? doc["imp_approval_date"] : doc["approval_date"]
+        @doc_date = Date.parse(date).to_s rescue date # rubocop:disable Style/RescueModifier
+      end
+
+      # @return [Array<Relaton::Bib::Relation>]
+      def fetch_relations
+        relations = []
+        editions.each do |ed|
+          next if ed["idrec"] == idrec
+
+          relations << create_relation("hasEdition", ed["title"], ed["rec_name"])
+        end
+
+        supplements.each { |supp| relations << create_relation("complementOf", supp["title_text"], supp["rec_name"]) }
+        relations
+      end
+
+        # Fetch the study group name from the recommendation HTML page.
+      # @return [String, nil]
+      def fetch_workgroup
+        url = "https://www.itu.int/ITU-T/recommendations/rec.aspx?rec=#{idrec}&lang=en"
+        page = hit.hit_collection.agent.get(url)
+        wg = page.at('//span[contains(@id, "uc_rec_main_info1_rpt_main_ctl00_Label8")]/a')
+        wg&.text
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      attr_reader :hit, :idrec, :imp
+
+      def get_data(url)
+        JSON.parse request_document(url).body
+      end
+
+      def request_document(url)
+        hit.hit_collection.agent.get url
+      rescue Mechanize::ResponseCodeError, SocketError, Timeout::Error, Errno::ECONNRESET,
+              EOFError, Net::ProtocolError, OpenSSL::SSL::SSLError => e
+        raise Relaton::RequestError, "Could not access #{url}: #{e.message}"
+      end
+
+      def editions
+        @editions ||= begin
+          url = RECEDITIONS % { idrec: idrec }
+          get_data(url) || []
+        end
+      end
+
+      def self_edition
+        @self_edition ||= editions.find { |ed| ed["idrec"] == idrec }
+      end
+
+      def imp_status
+        self_edition&.dig("status")
+      end
+
+      def imp_word_link
+        return unless doc["imp_dms_link"]
+
+        @doc_page ||= request_document(doc["imp_dms_link"])
+        wrd_elm = @doc_page.at("//font[contains(.,'Word')]/../..")
+        yield wrd_elm[:href] if block_given? && wrd_elm
+      end
+
+      def create_relation(type, title_text, id)
+        titles = []
+        if title_text && !title_text.empty?
+          titles << Relaton::Bib::Title.new(content: title_text, language: "en", script: "Latn")
+        end
+
+        fref = titles.empty? ? id : nil
+        did = Relaton::Bib::Docidentifier.new(type: "ITU", content: id, primary: true)
+        bibitem = Relaton::Bib::ItemData.new(title: titles, formattedref: (fref ? Relaton::Bib::Formattedref.new(content: fref) : nil), docidentifier: [did])
+        Relaton::Bib::Relation.new(type: type, bibitem: bibitem)
+      end
+
+      def supplements
+        @supplements ||= begin
+          if imp
+            []
+          else
+            url = RECSUPPLEMENTS % { idrec: idrec }
+            get_data(url) || []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/itu/scraper.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "cgi"
+require_relative "recommendation_parser"
+require_relative "radio_regulations_parser"
+
+module Relaton
+  module Itu
+    # Scraper.
+    class Scraper
+      attr_reader :hit, :imp
+
+      TYPES = {
+        "ISO" => "international-standard",
+        "TS" => "technicalSpecification",
+        "TR" => "technicalReport",
+        "PAS" => "publiclyAvailableSpecification",
+        "AWI" => "appruvedWorkItem",
+        "CD" => "committeeDraft",
+        "FDIS" => "finalDraftInternationalStandard",
+        "NP" => "newProposal",
+        "DIS" => "draftInternationalStandard",
+        "WD" => "workingDraft",
+        "R" => "recommendation",
+        "Guide" => "guide",
+      }.freeze
+
+      def initialize(hit, imp: false)
+        @hit = hit
+        @imp = imp
+      end
+
+      def self.parse_page(hit, imp: false)
+        new(hit, imp: imp).parse_page
+      end
+
+      # Parse page.
+      # @return [Relaton::Itu::ItemData, nil]
+      def parse_page # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        return unless parser.doc
+
+        Relaton::Itu::ItemData.new(
+          fetched: Date.today.to_s,
+          type: "standard",
+          docidentifier: docid,
+          edition: edition,
+          language: ["en"],
+          script: ["Latn"],
+          title: parser.fetch_titles,
+          status: parser.fetch_status,
+          date: parser.fetch_dates,
+          abstract: parser.fetch_abstract,
+          source: parser.fetch_source,
+          relation: parser.fetch_relations,
+          contributor: fetch_contributors,
+          copyright: fetch_copyright,
+          place: [Relaton::Bib::Place.new(city: "Geneva")],
+          ext: Relaton::Itu::Ext.new(
+            doctype: Relaton::Itu::Doctype.new(content: hit.hit[:type]),
+            flavor: "itu",
+          ),
+        )
+      end
+
+      private
+
+      def edition
+        ed = parser.fetch_edition
+        Relaton::Bib::Edition.new(content: ed) if ed
+      end
+
+      def idrec
+        return @idrec if defined? @idrec
+
+        @idrec = CGI.unescape(hit.hit[:url]).split("/").last.slice(/^\d+(?=-)/)&.to_i
+      end
+
+      def parser
+        @parser ||= begin
+          if idrec
+            RecommendationParser.new hit, idrec, imp
+          else
+            RadioRegulationsParser.new hit
+          end
+        end
+      end
+
+      # Fetch docid.
+      # @return [Array<Relaton::Bib::Docidentifier>]
+      def docid
+        @docid ||= begin
+          docids = hit.hit[:code].to_s.split(" | ").map { |c| createdocid(c) }
+          docids << createdocid(doc["rec_name"]) if docids.empty?
+          docids
+        end
+      end
+
+      # @param text [String]
+      # @return [Relaton::Bib::Docidentifier]
+      def createdocid(text) # rubocop:disable Metrics/MethodLength
+        if text.match?(/^(?:ISO|ETSI)/)
+          type = "ISO"
+          text.match(/[^(]+/).to_s.strip.squeeze(" ")
+        else
+          pubid = Pubid.parse(text)
+          type = pubid.prefix
+          pubid.to_s
+        end => id
+        Docidentifier.new(type: type, content: id, primary: true)
+      end
+
+      # @return [Array<Relaton::Bib::Contributor>]
+      def fetch_contributors
+        contribs = fetch_publisher_contributors
+        eg = fetch_editorial_contributor
+        contribs << eg if eg
+        contribs
+      end
+
+      # @return [Array<Relaton::Bib::Contributor>]
+      def fetch_publisher_contributors
+        return [] unless hit.hit[:code]
+
+        abbrev = hit.hit[:code].sub(/-\w\s.*/, "")
+        case abbrev
+        when "ITU"
+          name = "International Telecommunication Union"
+          url = "www.itu.int"
+        end
+        org = Relaton::Bib::Organization.new(
+          name: [Relaton::Bib::TypedLocalizedString.new(content: name)],
+          abbreviation: Relaton::Bib::LocalizedString.new(content: abbrev),
+          uri: [Relaton::Bib::Uri.new(content: url)],
+        )
+        role = Relaton::Bib::Contributor::Role.new(type: "publisher")
+        [Relaton::Bib::Contributor.new(organization: org, role: [role])]
+      end
+
+      # @return [Relaton::Bib::Contributor, nil]
+      def fetch_editorial_contributor
+        wg_name = parser.fetch_workgroup
+        bureau = hit.hit[:code]&.match(/(?<=-)\w/)&.to_s
+        return unless bureau
+
+        org = Relaton::Bib::Organization.new(
+          name: [Relaton::Bib::TypedLocalizedString.new(content: "International Telecommunication Union")],
+          abbreviation: Relaton::Bib::LocalizedString.new(content: "ITU-#{bureau.upcase}"),
+          subdivision: group_subdivision(wg_name),
+        )
+        role = Relaton::Bib::Contributor::Role.new(
+          type: "author",
+          description: [Relaton::Bib::LocalizedMarkedUpString.new(content: "committee")],
+        )
+        Relaton::Bib::Contributor.new(organization: org, role: [role])
+      end
+
+      # @param wg_name [String, nil]
+      # @return [Array<Relaton::Bib::Subdivision>]
+      def group_subdivision(wg_name)
+        return [] unless wg_name
+
+        subtype = case wg_name
+                  when /Advisory Group/ then "tsag"
+                  when /Study Group/ then "study-group"
+                  else "work-group"
+                  end
+        [Relaton::Bib::Subdivision.new(
+          type: "technical-committee",
+          subtype: subtype,
+          name: [Relaton::Bib::TypedLocalizedString.new(content: wg_name)],
+        )]
+      end
+
+      # @return [Array<Relaton::Bib::Copyright>]
+      def fetch_copyright
+        abbreviation = hit.hit[:code].match(/^[^-]+/).to_s
+        case abbreviation
+        when "ITU"
+          name = "International Telecommunication Union"
+          url = "www.itu.int"
+        end
+        org = Relaton::Bib::Organization.new(
+          name: [Relaton::Bib::TypedLocalizedString.new(content: name)],
+          abbreviation: Relaton::Bib::LocalizedString.new(content: abbreviation),
+          uri: [Relaton::Bib::Uri.new(content: url)],
+        )
+        owner = Relaton::Bib::ContributionInfo.new(organization: org)
+        year = parser.doc_date&.match(/\d{4}/)&.to_s
+        [Relaton::Bib::Copyright.new(from: year, owner: [owner])]
+      end
+    end
+  end
+end