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

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

@@ -0,0 +1,13 @@
+module Relaton
+  module Itu
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        recommendation recommendation-supplement recommendation-amendment recommendation-corrigendum
+        recommendation-errata recommendation-annex focus-group implementers-guide technical-paper
+        technical-report joint-itu-iso-iec resolution service-publication handbook question contribution
+      ].freeze
+
+      attribute :content, :string, values: TYPES
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require_relative "doctype"
+require_relative "question"
+require_relative "recommendation_status"
+require_relative "meeting"
+require_relative "meeting_date"
+require_relative "structured_identifier"
+
+module Relaton
+  module Itu
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype
+      attribute :structuredidentifier, StructuredIdentifier
+      attribute :question, Question, collection: true
+      attribute :recommendationstatus, RecommendationStatus
+      attribute :ip_notice_received, :boolean
+      attribute :meeting, Meeting
+      attribute :meeting_place, :string
+      attribute :meeting_date, MeetingDate
+      attribute :intended_type, :string, values: %w[R C TD]
+      attribute :source, :string
+
+      xml do
+        map_element "question", to: :question
+        map_element "recommendationstatus", to: :recommendationstatus
+        map_element "ip-notice-received", to: :ip_notice_received
+        map_element "meeting", to: :meeting
+        map_element "meeting-place", to: :meeting_place
+        map_element "meeting-date", to: :meeting_date
+        map_element "intended-type", to: :intended_type
+        map_element "source", to: :source
+      end
+
+      key_value do
+        map_element "question", to: :question
+        map_element "recommendationstatus", to: :recommendationstatus
+        map_element "ip_notice_received", to: :ip_notice_received
+        map_element "meeting", to: :meeting
+        map_element "meeting_place", to: :meeting_place
+        map_element "meeting_date", to: :meeting_date
+        map_element "intended_type", to: :intended_type
+        map_element "source", to: :source
+      end
+
+      def get_schema_version = Relaton.schema_versions["relaton-model-itu"]
+    end
+  end
+end

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

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

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

@@ -0,0 +1,13 @@
+module Relaton
+  module Itu
+    class Meeting < Lutaml::Model::Serializable
+      attribute :acronym, :string
+      attribute :content, :string
+
+      xml do
+        map_attribute "acronym", to: :acronym
+        map_content to: :content
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Relaton
+  module Itu
+    class MeetingDate < Lutaml::Model::Serializable
+      attribute :from, :string
+      attribute :to, :string
+      attribute :at, :string
+
+      xml do
+        map_element "from", to: :from
+        map_element "to", to: :to
+        map_element "on", to: :at
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Relaton
+  module Itu
+    class Question < Lutaml::Model::Serializable
+      attribute :identifier, :string
+      attribute :name, :string
+
+      xml do
+        map_element "identifier", to: :identifier
+        map_element "name", to: :name
+      end
+    end
+  end
+end

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,38 @@
+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
+
+      # `Bib::ItemData#ext_to_all_parts!` / `#ext_remove_date` broadcast to
+      # `ext.structuredidentifier` as well as to `docidentifier`. This class
+      # descends from `Lutaml::Model::Serializable` rather than
+      # `Bib::StructuredIdentifier`, so it does not inherit that class's no-op
+      # defaults and the broadcast raised `NoMethodError` on every ITU item.
+      #
+      # ITU structured identifiers model neither a part nor a date: `bureau`,
+      # `docnumber`, `annexid`, `amendment` and `corrigendum` are all identity,
+      # and stripping any of them would name a different document. The date is
+      # handled by `Relaton::Itu::Docidentifier#remove_date!`, which removes the
+      # year and month from the docid's pubid and renders it again. So all
+      # three are no-ops.
+
+      def remove_part!; end
+
+      def remove_date!; end
+
+      def to_all_parts!; end
+    end
+  end
+end

data/lib/relaton/itu/processor.rb

@@ -0,0 +1,72 @@
+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 itu-t]
+      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
+
+      #
+      # Harvest a dataset. Only "itu-t" harvests (the searchRecs corpus); "itu-r"
+      # raises — its bulk-enumeration endpoint is gone (issue #75) — and it stays
+      # in @datasets on purpose, so a stray `relaton fetch-data itu-r` surfaces
+      # that error instead of the registry's warn-and-exit-0 for an unknown
+      # dataset.
+      #
+      # @param [String] source source name (itu-t; itu-r raises)
+      # @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,199 @@
+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) }
+        # "Report" is not decoration: ITU-R Recommendations and Reports number
+        # independently, so "ITU-R BT.2020-1" alone names two different documents
+        # (Rec. BT.2020-1, 06/2014 vs Report BT.2020-1, 2000). ITU writes the
+        # discriminator first ("Report ITU-R BT.2020-1"), which is the form
+        # `Pubid::Itu` parses as `pubid:itu:report`; the sector-first spelling is
+        # accepted too because bibliographies use both.
+        rule(:report) { (str("Report") | str("REP")).as(:type) >> space }
+        rule(:report?) { report.maybe }
+        rule(:type) { separator >> (str("REC") | str("Report") | str("REP")).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) { report? >> (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}"
+        # This grammar is local, so re-raise it as pubid's error: relaton-cli
+        # rescues `Pubid::Errors::Error`. `::` is needed, because inside this
+        # class a bare `Pubid` is `Relaton::Itu::Pubid`.
+        raise ::Pubid::Errors::ParseError.new(e.message, e.parse_failure_cause,
+                                              input: id, flavor: "itu")
+      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
+
+      # @return [Boolean] whether this reference names an ITU-R Report rather
+      #   than a Recommendation — the one type that must survive into #to_ref,
+      #   because it is what tells the two apart (see the `report` parser rule).
+      def report?
+        %w[Report REP].include? type
+      end
+
+      def to_s(ref: false) # rubocop:disable Metrics/AbcSize
+        # "Report" leads, the way ITU cites it and the way Pubid::Itu parses it;
+        # `REC` stays dropped from a reference because it is redundant there.
+        s = report? ? +"Report " : +""
+        s << prefix
+        s << "-#{sector}" if sector
+        s << " #{type}" if type && !ref && !report?
+        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