relaton-iec 1.7.0 → 1.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: affb3c4e8c5d26115be469d456d5b3de4f89f1184226b7a51b8dbabdd1cae937
-  data.tar.gz: cb850e8a8cbae05c66b629db7f2ee548debf0f1dfe3d03d6dc75e8c6e85900d2
+  metadata.gz: b87aa92de24cc0120f04f0325e2ec419c366b92d775beb1b37ab2cc429c96c1d
+  data.tar.gz: 28aad2f843cd822bca23dc56e0de8526da1993a5e51cab74a80e957d3a125710
 SHA512:
-  metadata.gz: 107761f95543a8f188d45e5aa3ea676fe904a152d32d0ebdd92e1e66ac42e2164287ac0feef3906fbb596bd6807636c3f70938fe301a2b53f2ffaf34cf316b54
-  data.tar.gz: bcd04f967647bed2d2a4cebaff71cf5acf03ad1e388a81d44f150e9d1d4bbdbd9d16e3de222134d5806112453a3e0e4fd82aa3cc2f9ce1e55047b7f9439b9d4c
+  metadata.gz: 261ffff809b27f6b6ff84fd936959819fe315cfe187bb0ecc97b5ae48295fcaa515668d66cb229d3cfbb3f31bcb5127112c5da9064f8699671ce50f40fe5df2b
+  data.tar.gz: a7fc694951f0b4b1a0f57c5d3ea9fcb89c4729d4b28dfe945c6d6c3c7add1be498e961bbf2bc71760b7c88034a0a2ad57295c6cd432ee365c9cb2beb0dcf0950

data/lib/relaton_iec/hit.rb

@@ -8,5 +8,9 @@ module RelatonIec
     def fetch
       @fetch ||= Scrapper.parse_page @hit
     end
+
+    def part
+      @part ||= hit[:code].match(/(?<=-)[\w-]+/)&.to_s
+    end
   end
 end

data/lib/relaton_iec/hit_collection.rb

@@ -6,6 +6,10 @@ require "addressable/uri"
 module RelatonIec
   # Page of hit collection.
   class HitCollection < RelatonBib::HitCollection
+    def_delegators :@array, :detect
+
+    attr_reader :part
+
     DOMAIN = "https://webstore.iec.ch"
 
     # @param ref_nbr [String]
@@ -13,53 +17,73 @@ module RelatonIec
     # @param part [String, nil]
     def initialize(ref_nbr, year = nil, part = nil)
       super ref_nbr, year
-      @array = hits ref_nbr, year, part
+      @part = part
+      @array = hits ref_nbr, year
+    end
+
+    # @return [RelatonIec::IecBibliographicItem]
+    def to_all_parts # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity
+      parts = @array.reject { |h| h.part.nil? }
+      hit = parts.min_by &:part
+      return @array.first.fetch lang unless hit
+
+      bibitem = hit.fetch
+      all_parts_item = bibitem.to_all_parts
+      parts.reject { |h| h.hit[:code] == hit.hit[:code] }.each do |hi|
+        isobib = RelatonIec::IecBibliographicItem.new(
+          formattedref: RelatonBib::FormattedRef.new(content: hi.hit[:code])
+        )
+        all_parts_item.relation << RelatonBib::DocumentRelation.new(type: "partOf", bibitem: isobib)
+      end
+      all_parts_item
     end
 
     private
 
     # @param ref [String]
     # @param year [String, nil]
-    # @param part [String, nil]
     # @return [Array<RelatonIec::Hit>]
-    def hits(ref, year, part)
+    def hits(ref, year)
       from, to = nil
       if year
         from = Date.strptime year, "%Y"
         to   = from.next_year.prev_day
       end
-      get_results ref, from, to, part
+      get_results ref, from, to
     end
 
     # @param ref [String]
     # @param from [Date, nil]
     # @param to [Date, nil]
-    # @param part [String, nil]
     # @return [Array<RelatonIec::Hit>]
-    def get_results(ref, from, to, part = nil)
+    def get_results(ref, from, to)
       code = part ? ref.sub(/(?<=-\d)\d+/, "*") : ref
       [nil, "trf", "wr"].reduce([]) do |m, t|
         url = "#{DOMAIN}/searchkey"
         url += "&type=#{t}" if t
         url += "&RefNbr=#{code}&From=#{from}&To=#{to}&start=1"
-        m + results(Addressable::URI.parse(url).normalize, part)
+        m + results(Addressable::URI.parse(url).normalize)
       end
     end
 
     # @param url [String]
-    # @param part [String, nil]
     # @return [Array<RelatonIec::Hit>]
-    def results(uri, part)
+    def results(uri)
       contains = "[contains(.,'Part #{part}:')]" if part
-      Nokogiri::HTML(OpenURI.open_uri(uri)).xpath(
+      resp = OpenURI.open_uri(uri, "User-Agent" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) "\
+        "AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36")
+      doc = Nokogiri::HTML(resp)
+      doc.xpath(
         "//body/li#{contains}",
         "//ul[contains(@class,'search-results')]/li#{contains}",
         "//ul[contains(@class,'morethesame')]/li#{contains}"
-      ).map { |h| make_hit h }
+      ).map { |h| make_hit h }.compact
     end
 
     def make_hit(hit)
-      link  = hit.at('a[@href!="#"]')
+      link = hit.at('a[@href!="#"]')
+      return unless link
+
       code  = link.text.tr [194, 160].pack("c*").force_encoding("UTF-8"), ""
       title = hit.xpath("text()").text.gsub(/[\r\n]/, "")
       Hit.new({ code: code, title: title, url: DOMAIN + link[:href] }, self)

data/lib/relaton_iec/iec_bibliography.rb

@@ -21,7 +21,7 @@ module RelatonIec
       # @param part [String, nil] search for packaged stndard if not nil
       # @return [RelatonIec::HitCollection]
       def search(text, year = nil, part = nil)
-        HitCollection.new text, year, part
+        HitCollection.new text, year&.strip, part
       rescue SocketError, OpenURI::HTTPError, OpenSSL::SSL::SSLError
         raise RelatonBib::RequestError, "Could not access http://www.iec.ch"
       end
@@ -32,23 +32,21 @@ module RelatonIec
       #   reference is required
       # @return [String] Relaton XML serialisation of reference
       def get(code, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        opts[:all_parts] ||= code.match? /\s\(all parts\)/
+        ref = code.sub /\s\(all parts\)/, ""
         if year.nil?
-          /^(?<code1>[^:]+):(?<year1>[^:]+)/ =~ code
+          /^(?<code1>[^:]+):(?<year1>[^:]+)/ =~ ref
           unless code1.nil?
-            code = code1
+            ref = code1
             year = year1
           end
         end
+        return iev if ref.casecmp("IEV").zero?
 
-        return iev if code.casecmp("IEV").zero?
-
-        opts[:all_parts] ||= !(code =~ / \(all parts\)/).nil?
-        code = code.sub(/ \(all parts\)/, "")
-        ret = iecbib_get1(code, year, opts)
+        ret = iecbib_get(ref, year, opts)
         return nil if ret.nil?
 
         ret = ret.to_most_recent_reference unless year || opts[:keep_year]
-        ret = ret.to_all_parts if opts[:all_parts]
         ret
       end
 
@@ -77,29 +75,43 @@ module RelatonIec
       # @param hits [Array<RelatonIec::Hit>]
       # @param threads [Integer]
       # @return [Array<RelatonIec::Hit>]
-      def fetch_pages(hits, threads)
-        workers = RelatonBib::WorkersPool.new threads
-        workers.worker { |w| { i: w[:i], hit: w[:hit].fetch } }
-        hits.each_with_index { |hit, i| workers << { i: i, hit: hit } }
-        workers.end
-        workers.result.sort_by { |a| a[:i] }.map { |x| x[:hit] }
-      end
-
-      def isobib_search_filter(code, year) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        docidrx = %r{^(ISO|IEC)[^0-9]*\s[0-9-]+}
-        corrigrx = %r{^(ISO|IEC)[^0-9]*\s[0-9-]+:[0-9]+/}
-        warn "[relaton-iec] (\"#{code}\") fetching..."
+      # def fetch_pages(hits, threads)
+      #   workers = RelatonBib::WorkersPool.new threads
+      #   workers.worker { |w| { i: w[:i], hit: w[:hit].fetch } }
+      #   hits.each_with_index { |hit, i| workers << { i: i, hit: hit } }
+      #   workers.end
+      #   workers.result.sort_by { |a| a[:i] }.map { |x| x[:hit] }
+      # end
+
+      def search_filter(reference, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        %r{
+          ^(?<code>(?:ISO|IEC)[^\d]*\s\d+((?:-\w+)+)?)
+          (:(?<year1>\d{4}))?
+          (?<bundle>\+[^\s\/]+)?
+          (\/(?<corr>AMD\s\d+))?
+        }x =~ reference.upcase
+        year ||= year1
+        corr&.sub! " ", ""
+        warn "[relaton-iec] (\"#{reference}\") fetching..."
         result = search(code, year)
-        if result.empty? && /(?<=-)(?<part>\d+)/ =~ code
+        if result.empty? && /(?<=-)(?<part>[\w-]+)/ =~ code
           # try to search packaged standard
           result = search code, year, part
-          ref = code.sub /(?<=-\d)\d+/, ""
-        else ref = code
+          # ref = code.sub /(?<=-\d)\w+/, ""
+          # else ref = code
         end
+        result = search code if result.empty?
+        code.sub! /((?:-\w+)+)/, ""
         result.select do |i|
-          i.hit[:code] &&
-            i.hit[:code].match(docidrx).to_s.include?(ref) &&
-            corrigrx !~ i.hit[:code]
+          %r{
+            ^(?<code2>(?:ISO|IEC)[^\d]*\s\d+)((?:-\w+)+)?
+            (:(?<year2>\d{4}))?
+            (?<bundle2>\+[^\s\/]+)?
+            (\/(?<corr2>AMD\d+))?
+          }x =~ i.hit[:code]
+          # code2.sub! /(?<=-\d)\w*/, "" if part
+          # code2.sub! /((?:-\w+)+)/, "" if opts[:all_parts]
+          code == code2 && bundle == bundle2 && corr == corr2 # (year.nil? || year == year2) &&
         end
       end
 
@@ -144,30 +156,56 @@ module RelatonIec
       # 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) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+      def results_filter(result, ref, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        r_code, r_year = code_year ref, result.part
+        r_year ||= year
         missed_years = []
-        result.each_slice(3) do |s| # ISO website only allows 3 connections
-          fetch_pages(s, 3).each_with_index do |r, _i|
-            return { ret: r } if !year
-
-            r.date.select { |d| d.type == "published" }.each do |d|
-              return { ret: r } if year.to_i == d.on(:year)
+        missed_parts = false
+        # result.each_slice(3) do |s| # ISO website only allows 3 connections
+        ret = if opts[:all_parts]
+                result.to_all_parts
+              else
+                result.detect do |h|
+                  h_code, h_year = code_year h.hit[:code], result.part
+                  missed_parts ||= !opts[:all_parts] && r_code != h_code
+                  missed_years << h_year unless !r_year || h_year == r_year
+                  r_code == h_code && (!year || h_year == r_year)
+                  # fetch_pages(s, 3).each_with_index do |r, _i|
+                  # return { ret: r } if !year
+
+                  # r.date.select { |d| d.type == "published" }.each do |d|
+                  # return { ret: r } if year.to_i == d.on(:year)
+
+                  # missed_years << d.on(:year)
+                  # end
+                  # end
+                end&.fetch
+              end
+        { ret: ret, years: missed_years, missed_parts: missed_parts }
+      end
 
-              missed_years << d.on(:year)
-            end
-          end
-        end
-        { years: missed_years }
+      def code_year(ref, part)
+        %r{
+          ^(?<code>(?:ISO|IEC)[^\d]*\s\d+((?:-\w+)+)?)
+          (:(?<year>\d{4}))?
+        }x =~ ref
+        code.sub!(/-\d+/, "") if part
+        [code, year]
       end
 
-      def iecbib_get1(code, year, _opts)
-        return iev if code.casecmp("IEV").zero?
+      def iecbib_get(code, year, opts)
+        # return iev if code.casecmp("IEV").zero?
 
-        result = isobib_search_filter(code, year) || return
-        ret = isobib_results_filter(result, year)
+        result = search_filter(code, year, opts) || return
+        ret = results_filter(result, code, year, opts)
         if ret[:ret]
-          warn "[relaton-iec] (\"#{code}\") found "\
-          "#{ret[:ret].docidentifier.first.id}"
+          if ret[:missed_parts]
+            warn "[relaton-iec] WARNING: #{code} found as #{ret[:ret].docidentifier.first.id} "\
+            "but also contain parts. If you wanted to cite all document parts for the reference, use "\
+            "\"#{code} (all parts)\""
+          else
+            warn "[relaton-iec] (\"#{code}\") found #{ret[:ret].docidentifier.first.id}"
+          end
           ret[:ret]
         else
           fetch_ref_err(code, year, ret[:years])

data/lib/relaton_iec/scrapper.rb

@@ -170,8 +170,10 @@ module RelatonIec
       def fetch_status(doc)
         wip = doc.at('//ROW[STATUS[.="PREPARING"]]')
         if wip
-          statuses = YAML.load_file "lib/relaton_iec/statuses.yml"
+          statuses = YAML.load_file File.join __dir__, "statuses.yml"
           s = wip.at("STAGE").text
+          return unless statuses[s]
+
           stage, substage = statuses[s]["stage"].split "."
         else
           stage    = "60"

data/lib/relaton_iec/version.rb

@@ -1,3 +1,3 @@
 module RelatonIec
-  VERSION = "1.7.0".freeze
+  VERSION = "1.7.5".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-iec
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-11-27 00:00:00.000000000 Z
+date: 2021-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debase