relaton-itu 1.14.2 → 1.14.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6766812ad6660d739d3d4e4c1778846119eaca063c3c5cfc34242ffca6414a6b
-  data.tar.gz: 7c3024fc052ddd75a7c82ab1b3231834d6b0c964cf940f5fa1e2c28c0ff5c085
+  metadata.gz: 1bdefbc155c0b9cf2d721888b2512f09913bac76831b421b44444f94dacb4d95
+  data.tar.gz: d5fa79047b6e08c91c8d320c8a95de3a63668a31eac6ae4d958aff3fcb5ce312
 SHA512:
-  metadata.gz: 76647371a1ef4b6eaf3a4f57bd8bff607dda86f63f0f928e8969d9e9a25532eb456f7781740068f094b1fa4d9b505092ff7710e5fb16b9bdbd168207abc70f23
-  data.tar.gz: d87e9793f3802bde3d39d672c7c10900f5fd1298811bf6bb0fa129f577020c5e3cbae9d52ef5623e6d3e7933c322b2cdc555e824830cfa4707e48169fe92cd73
+  metadata.gz: 0ae803ee1490114fd1ed254811aa46dc67ac2b9d273f3424018a3e5cf2a34a2a11876f7281184756a9b3ff4b2541bd9aba1eebdf2c39f530f9eacffe4137c0c6
+  data.tar.gz: a18d437f653e9955467dd9f26946cd853c97389835b271029ff721f9c86dfd11bf775bae72cab5ab5ed957467696c3dfbe0debf76670e0499ed6cc03eebcd9ae

data/lib/relaton_itu/hit_collection.rb

@@ -17,21 +17,22 @@ module RelatonItu
     # @return [Mechanize]
     attr_reader :agent
 
-    # @param ref [String]
-    # @param year [String]
-    def initialize(ref, year = nil) # rubocop:todo Metrics/MethodLength
-      text = ref.sub(/(?<=\.)Imp\s?(?=\d)/, "")
-      super text, year
+    #
+    # @param refid [RelatonItu::Pubid] reference
+    #
+    def initialize(refid) # rubocop:todo Metrics/MethodLength
+      text = refid.to_ref.sub(/(?<=\.)Imp\s?(?=\d)/, "")
+      super text, refid.year
       @agent = Mechanize.new
       agent.user_agent_alias = "Mac Safari"
-      @gi_imp = /\.Imp\d/.match?(ref)
+      @gi_imp = /\.Imp\d/.match?(refid.to_s)
       @array = []
 
-      case ref
+      case refid.to_ref
       when /^(ITU-T|ITU-R\sRR)/
         request_search
       when /^ITU-R\s/
-        request_document(ref)
+        request_document(refid)
       end
     end
 
@@ -44,10 +45,12 @@ module RelatonItu
       @array = hits JSON.parse(resp.body)
     end
 
-    # @param ref [String] a document ref
-    def request_document(ref) # rubocop:todo Metrics/MethodLength, Metrics/AbcSize
+    #
+    # @param refid [RelatonItu::Pubid] a document reference
+    #
+    def request_document(refid) # rubocop:todo Metrics/MethodLength, Metrics/AbcSize
       index = Relaton::Index.find_or_create :itu, url: "#{GH_ITU_R}index-v1.zip", file: INDEX_FILE
-      row = index.search(ref).min_by { |i| i[:id] }
+      row = index.search(refid.to_ref).min_by { |i| i[:id] }
       return unless row
 
       uri = URI("#{GH_ITU_R}#{row[:file]}")

data/lib/relaton_itu/itu_bibliography.rb

@@ -14,134 +14,139 @@ require "date"
 
 module RelatonItu
   # Class methods for search ISO standards.
-  class ItuBibliography
-    class << self
-      # @param text [String]
-      # @return [RelatonItu::HitCollection]
-      def search(text, year = nil)
-        # code = text.sub(/(?<=ITU-T\s\w)\.(\w+\.)(?=\d+)/, ' \1')
-        if text =~ /(ITU-T\s\w)\.(Suppl\.|Annex)\s?(\w?\d+)/
-          correct_ref = "#{$~[1]} #{$~[2]} #{$~[3]}"
-          warn "[relaton-itu] WARNING: Incorrect reference #{text}"
-          warn "[relaton-itu] the reference should be #{correct_ref}"
-        end
-        HitCollection.new text, year
-      rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
-             EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
-             Net::ProtocolError, URI::InvalidURIError => e
-        raise RelatonBib::RequestError, e.message
+  module ItuBibliography
+    extend self
+
+    # @param refid [RelatonItu::Pubid, String] a document reference
+    # @return [RelatonItu::HitCollection]
+    #
+    def search(refid)
+      refid = RelatonItu::Pubid.parse refid if refid.is_a? String
+      if refid.to_ref =~ /(ITU[\s-]T\s\w)\.(Suppl\.|Annex)\s?(\w?\d+)/
+        correct_ref = "#{$~[1]} #{$~[2]} #{$~[3]}"
+        warn "[relaton-itu] WARNING: Incorrect reference #{refid}"
+        warn "[relaton-itu] the reference should be #{correct_ref}"
       end
+      HitCollection.new refid
+    rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse,
+           Net::HTTPHeaderSyntaxError, Net::ProtocolError, URI::InvalidURIError => e
+      raise RelatonBib::RequestError, e.message
+    end
 
-      # @param code [String] the ISO standard Code to look up (e..g "ISO 9000")
-      # @param year [String] the year the standard was published (optional)
-      # @param opts [Hash] options; restricted to :all_parts if all-parts
-      #   reference is required
-      # @return [String] Relaton XML serialisation of reference
-      def get(code, year = nil, opts = {}) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        if year.nil?
-          /^(?<code1>[^\s]+\s[^\s]+)\s\((?:\d{2}\/)?(?<year1>\d+)\)$/ =~ code
-          unless code1.nil?
-            code = code1
-            year = year1
-          end
-        end
+    # def transform_ref(ref)
+    #   ref.sub(/^ITU[\s-](\w)[\s-](?:REC[\s-])?/, 'ITU-\1')
+    # end
 
-        code += "-1" if opts[:all_parts]
-        ret = itubib_get1(code, year, opts)
-        return nil if ret.nil?
+    # @param code [String] the ISO standard Code to look up (e..g "ISO 9000")
+    # @param year [String] the year the standard was published (optional)
+    # @param opts [Hash] options; restricted to :all_parts if all-parts
+    #   reference is required
+    # @return [String] Relaton XML serialisation of reference
+    def get(code, year = nil, opts = {}) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      refid = Pubid.parse code
+      refid.year ||= year
+      # if year.nil?
+      #   /^(?<code1>[^\s]+\s[^\s]+)\s\((?:\d{2}\/)?(?<year1>\d+)\)$/ =~ code
+      #   unless code1.nil?
+      #     code = code1
+      #     year = year1
+      #   end
+      # end
 
-        ret = ret.to_most_recent_reference unless year || opts[:keep_year]
-        ret = ret.to_all_parts if opts[:all_parts]
-        ret
-      end
+      ret = itubib_get1(refid)
+      return nil if ret.nil?
 
-      private
+      ret = ret.to_most_recent_reference unless refid.year || opts[:keep_year]
+      ret = ret.to_all_parts if opts[:all_parts]
+      ret
+    end
 
-      def fetch_ref_err(code, year, missed_years) # rubocop:disable Metrics/MethodLength
-        id = year ? "#{code}:#{year}" : code
-        warn "[relaton-itu] WARNING: no match found online for #{id}. " \
-             "The code must be exactly like it is on the standards website."
-        unless missed_years.empty?
-          warn "[relaton-itu] (There was no match for #{year}, though there " \
-               "were matches found for #{missed_years.join(', ')}.)"
-        end
-        if /\d-\d/.match? code
-          warn "[relaton-itu] The provided document part may not exist, or " \
-               "the document may no longer be published in parts."
-        else
-          warn "[relaton-itu] If you wanted to cite all document parts for the reference, " \
-               "use \"#{code} (all parts)\".\nIf the document is not a standard, " \
-               "use its document type abbreviation (TS, TR, PAS, Guide)."
-        end
-        nil
+    private
+
+    def fetch_ref_err(refid, missed_years) # rubocop:disable Metrics/MethodLength
+      warn "[relaton-itu] WARNING: no match found online for #{refid}. " \
+           "The code must be exactly like it is on the standards website."
+      unless missed_years.empty?
+        warn "[relaton-itu] (There was no match for #{refid.year}, though there " \
+             "were matches found for #{missed_years.join(', ')}.)"
       end
+      # if /\d-\d/.match? refid.code
+      #   warn "[relaton-itu] The provided document part may not exist, or " \
+      #        "the document may no longer be published in parts."
+      # else
+      warn "[relaton-itu] If you wanted to cite all document parts for the reference, " \
+           "use \"#{refid} (all parts)\".\nIf the document is not a standard, " \
+           "use its document type abbreviation (TS, TR, PAS, Guide)."
+      # end
+    end
 
-      def search_filter(code, year) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
-        %r{
-          ^(?<pref1>ITU)?(?:-(?<type1>\w))?\s?(?<code1>[^\s/]+(?:/\w[.\d]+)?)
-          (?:\s\(?(?<ver1>v\d+)\)?)?
-          (?:\s\((?:(?<month1>\d{2})/)?(?<year1>\d{4})\))?
-          (?:\s-\s(?<buldate1>\d{2}\.\w{1,4}\.\d{4}))?
-          (?:\s(?<corr1>(?:Amd|Cor|Amendment|Corrigendum)\.?\s?\d+))?
-          (?:\s\((?:(?<cormonth1>\d{2})/)?(?<coryear1>\d{4})\))?
-        }x =~ code
-        year ||= year1
-        warn "[relaton-itu] (\"#{code}\") fetching..."
-        result = search(code)
-        code1.sub!(/(?<=\.)Imp(?=\d)/, "") if result.gi_imp
-        if corr1
-          corr1.sub!(/[.\s]+/, " ").sub!("Amendment", "Amd")
-          corr1.sub!("Corrigendum", "Corr")
-        end
-        result.select do |i|
-          next true unless i.hit[:code]
+    def search_filter(refid) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      # %r{
+      #   ^(?<pref1>ITU)?(?:-(?<type1>\w))?\s?(?<code1>[^\s/]+(?:/\w[.\d]+)?)
+      #   (?:\s\(?(?<ver1>v\d+)\)?)?
+      #   (?:\s\((?:(?<month1>\d{2})/)?(?<year1>\d{4})\))?
+      #   (?:\s-\s(?<buldate1>\d{2}\.\w{1,4}\.\d{4}))?
+      #   (?:\s(?<corr1>(?:Amd|Cor|Amendment|Corrigendum)\.?\s?\d+))?
+      #   (?:\s\((?:(?<cormonth1>\d{2})/)?(?<coryear1>\d{4})\))?
+      # }x =~ code
+      # year ||= year1
+      warn "[relaton-itu] (\"#{refid}\") fetching..."
+      result = search(refid)
+      # refid.code.sub!(/(?<=\.)Imp(?=\d)/, "") if result.gi_imp
+      # if corr1
+      #   corr1.sub!(/[.\s]+/, " ").sub!("Amendment", "Amd")
+      #   corr1.sub!("Corrigendum", "Corr")
+      # end
+      result.select do |i|
+        next true unless i.hit[:code]
 
-          %r{
-            ^(?<pref2>ITU)?(?:-(?<type2>\w))?\s?(?<code2>\S+)
-            (?:\s\(?(?<ver2>v\d+)\)?)?
-            (?:\s\((?:(?<month2>\d{2})/)?(?<year2>\d{4})\))?
-            (?:\s(?<corr2>(?:Amd|Cor)\.\s?\d+))?
-            (?:\s\((?:(?<cormonth2>\d{2})/)?(?<coryear2>\d{4})\))?
-          }x =~ i.hit[:code]
-          /:[^(]+\((?<buldate2>\d{2}\.\w{1,4}\.\d{4})\)/ =~ i.hit[:title]
-          corr2&.sub!(/\.\s?/, " ")
-          pref1 == pref2 && (!type1 || type1 == type2) && code2.include?(code1) &&
-            (!year || year == year2) && (!month1 || month1 == month2) &&
-            corr1 == corr2 && (!coryear1 || coryear1 == coryear2) &&
-            buldate1 == buldate2 && (!cormonth1 || cormonth1 == cormonth2) &&
-            (!ver1 || ver1 == ver2)
-        end
+        pubid = Pubid.parse i.hit[:code]
+        refid === pubid
+        # %r{
+        #   ^(?<pref2>ITU)?(?:-(?<type2>\w))?\s?(?<code2>\S+)
+        #   (?:\s\(?(?<ver2>v\d+)\)?)?
+        #   (?:\s\((?:(?<month2>\d{2})/)?(?<year2>\d{4})\))?
+        #   (?:\s(?<corr2>(?:Amd|Cor)\.\s?\d+))?
+        #   (?:\s\((?:(?<cormonth2>\d{2})/)?(?<coryear2>\d{4})\))?
+        # }x =~ i.hit[:code]
+        # /:[^(]+\((?<buldate2>\d{2}\.\w{1,4}\.\d{4})\)/ =~ i.hit[:title]
+        # corr2&.sub!(/\.\s?/, " ")
+        # pref1 == pref2 && (!type1 || type1 == type2) && code2.include?(code1) &&
+        #   (!year || year == year2) && (!month1 || month1 == month2) &&
+        #   corr1 == corr2 && (!coryear1 || coryear1 == coryear2) &&
+        #   buldate1 == buldate2 && (!cormonth1 || cormonth1 == cormonth2) &&
+        #   (!ver1 || ver1 == ver2)
       end
+    end
 
-      # Sort through the results from Isobib, fetching them three at a time,
-      # and return the first result that matches the code,
-      # matches the year (if provided), and which # has a title (amendments do not).
-      # Only expects the first page of results to be populated.
-      # Does not match corrigenda etc (e.g. ISO 3166-1:2006/Cor 1:2007)
-      # If no match, returns any years which caused mismatch, for error reporting
-      def isobib_results_filter(result, year)
-        missed_years = []
-        result.each do |r|
-          /\((?:\d{2}\/)?(?<pyear>\d{4})\)/ =~ r.hit[:code]
-          if !year || year == pyear
-            ret = r.fetch
-            return { ret: ret } if ret
-          end
-
-          missed_years << pyear
+    # Sort through the results from Isobib, fetching them three at a time,
+    # and return the first result that matches the code,
+    # matches the year (if provided), and which # has a title (amendments do not).
+    # Only expects the first page of results to be populated.
+    # Does not match corrigenda etc (e.g. ISO 3166-1:2006/Cor 1:2007)
+    # If no match, returns any years which caused mismatch, for error reporting
+    def isobib_results_filter(result, refid)
+      missed_years = []
+      result.each do |r|
+        /\((?:\d{2}\/)?(?<pyear>\d{4})\)/ =~ r.hit[:code]
+        if !refid.year || refid.year == pyear
+          ret = r.fetch
+          return { ret: ret } if ret
         end
-        { years: missed_years }
+
+        missed_years << pyear
       end
+      { years: missed_years }
+    end
 
-      def itubib_get1(code, year, _opts)
-        result = search_filter(code, year) || return
-        ret = isobib_results_filter(result, year)
-        if ret[:ret]
-          warn "[relaton-itu] (\"#{code}\") found #{ret[:ret].docidentifier.first&.id}"
-          ret[:ret]
-        else
-          fetch_ref_err(code, year, ret[:years])
-        end
+    def itubib_get1(refid)
+      result = search_filter(refid) || return
+      ret = isobib_results_filter(result, refid)
+      if ret[:ret]
+        warn "[relaton-itu] (\"#{refid}\") found #{ret[:ret].docidentifier.first&.id}"
+        ret[:ret]
+      else
+        fetch_ref_err(refid, ret[:years])
       end
     end
   end

data/lib/relaton_itu/pubid.rb

@@ -0,0 +1,142 @@
+module RelatonItu
+  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) >> dot >> month2 >> dot >> year }
+      rule(:date) { date1 | date2 }
+      rule(:date?) { date.maybe }
+
+      rule(:amd) { space >> (str("Amd") | str("Amendment")) >> dot? >> space >> num.repeat(1, 2).as(:amd) }
+      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(:itu_pubid) { prefix >> sector >> type? >> code >> sup? >> annex? >> date? >> amd? >> any.repeat }
+      root(:itu_pubid)
+    end
+
+    attr_accessor :prefix, :sector, :type, :code, :suppl, :annex, :year, :month, :amd
+
+    #
+    # Create a new ITU publication identifier.
+    #
+    # @param [String] prefix
+    # @param [String] sector
+    # @param [String, nil] type
+    # @param [String] code
+    # @param [String, nil] suppl number
+    # @param [String, nil] year
+    # @param [String, nil] month
+    # @param [String, nil] amd amendment number
+    #
+    def initialize(prefix:, sector:, code:, **args)
+      @prefix = prefix
+      @sector = sector
+      @type = args[:type]
+      @code, year, month = date_from_code code
+      @suppl = args[:suppl]
+      @annex = args[:annex]
+      @year = args[:year] || year
+      @month = roman_to_2digit args[:month] || month
+      @amd = args[:amd]
+    end
+
+    def self.parse(id)
+      id_parts = Parser.new.parse(id).to_h.transform_values(&:to_s)
+      new(**id_parts)
+    rescue Parslet::ParseFailed => e
+      warn "[relaton-itu] WARNING: #{id} is invalid ITU publication identifier"
+      warn 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, sector: sector, code: code }
+      hash[:type] = type if type && with_type
+      hash[:suppl] = suppl if suppl
+      hash[:annex] = annex if annex
+      hash[:year] = year if year
+      hash[:month] = month if month
+      hash[:amd] = amd if amd
+      hash
+    end
+
+    def to_ref
+      to_s ref: true
+    end
+
+    def to_s(ref: false) # rubocop:disable Metrics/AbcSize
+      s = "#{prefix}-#{sector}"
+      s << " #{type}" if type && !ref
+      s << " #{code}"
+      s << " Suppl. #{suppl}" if suppl
+      s << " Annex #{annex}" if annex
+      s << date_to_s
+      s << " Amd #{amd}" if amd
+      s
+    end
+
+    def ===(other)
+      hash = to_h with_type: false
+      other_hash = other.to_h with_type: false
+      hash.delete(:month)
+      other_hash.delete(:month)
+      other_hash.delete(:year) unless hash[:year]
+      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 date_to_s
+      if month && year then " (#{month}/#{year})"
+      elsif year then " (#{year})"
+      else ""
+      end
+    end
+  end
+end

data/lib/relaton_itu/version.rb

@@ -1,3 +1,3 @@
 module RelatonItu
-  VERSION = "1.14.2".freeze
+  VERSION = "1.14.3".freeze
 end

data/lib/relaton_itu.rb

@@ -1,7 +1,9 @@
 require "mechanize"
+require "parslet"
 require "digest/md5"
 require "relaton/index"
 require "relaton_itu/version"
+require "relaton_itu/pubid"
 require "relaton_itu/itu_bibliography"
 require "relaton_itu/data_fetcher"
 require "relaton_itu/data_parser_r"

data/relaton-itu.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
   spec.add_dependency "mechanize", "~> 2.8.0"
+  spec.add_dependency "parslet", "~> 2.0.0"
   spec.add_dependency "relaton-bib", "~> 1.14.0"
   spec.add_dependency "relaton-index", "~> 0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-itu
 version: !ruby/object:Gem::Version
-  version: 1.14.2
+  version: 1.14.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-05-27 00:00:00.000000000 Z
+date: 2023-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mechanize
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.8.0
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: relaton-bib
   requirement: !ruby/object:Gem::Requirement
@@ -88,6 +102,7 @@ files:
 - lib/relaton_itu/itu_bibliography.rb
 - lib/relaton_itu/itu_group.rb
 - lib/relaton_itu/processor.rb
+- lib/relaton_itu/pubid.rb
 - lib/relaton_itu/scrapper.rb
 - lib/relaton_itu/structured_identifier.rb
 - lib/relaton_itu/version.rb