relaton-iec 1.7.4 → 1.8.0

data/lib/relaton_iec/basic_block/text_element.rb

@@ -0,0 +1,27 @@
+module BasicBlock
+  class TextElement
+    TAGS = %w[em strong sub sup tt underline strike smallcap br hr keyword rp
+              rt ruby pagebreak bookmark].freeze
+
+    #
+    # @param [String] tag
+    # @param [Array<String, BasicBlock::TextElement, BasicBlock::Stem>,
+    #   String] content
+    #
+    def initialize(tag:, content:)
+      unless TAGS.include? tag
+        warn "[basic-block] WARNING: invalid tag \"#{tag}\""
+        warn "[basic-block] allowed tags are: #{TAGS.join ', '}"
+      end
+      @tag = tag
+      @content = content
+    end
+
+    # @param [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.send @tag do |b|
+        @content.each { |c| c.is_a?(String) ? c : c.to_xml(b) }
+      end
+    end
+  end
+end

data/lib/relaton_iec/hash_converter.rb

@@ -7,7 +7,7 @@ module RelatonIec
       # @param item [Hash]
       # @retirn [RelatonIec::IecBibliographicItem]
       def bib_item(item)
-        IecBibliographicItem.new(item)
+        IecBibliographicItem.new(**item)
       end
     end
   end

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,50 +6,69 @@ 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]
+    # @param ref [String]
     # @param year [String, nil]
     # @param part [String, nil]
-    def initialize(ref_nbr, year = nil, part = nil)
-      super ref_nbr, year
-      @array = hits ref_nbr, year, part
+    def initialize(ref, year = nil, part = nil)
+      super ref, year
+      @part = part
+      @array = ref ? hits(ref, 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 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
       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")

data/lib/relaton_iec/iec_bibliographic_item.rb

@@ -5,5 +5,97 @@ module RelatonIec
       publicly-available-specification international-workshop-agreement
       guide
     ].freeze
+
+    FUNCTION = %w[emc safety enviroment quality-assurance].freeze
+
+    # @return [String, nil]
+    attr_reader :function, :updates_document_type, :price_code, :secretary,
+                :interest_to_committees
+
+    # @return [Boolean, nil]
+    attr_reader :accessibility_color_inside, :cen_processing
+
+    # attr_reader :tc_sc_officers_note
+
+    def initialize(**args) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      if args[:function] && !FUNCTION.include?(args[:function])
+        warn "[relaton-iec] WARNING: invalid function \"#{args[:function]}\""
+        warn "[relaton-iec] allowed function values are: #{FUNCTION.join(', ')}"
+      end
+      if args[:updates_document_type] &&
+          !TYPES.include?(args[:updates_document_type])
+        warn "[relaton-iec] WARNING: invalid updates_document_type "\
+          "\"#{args[:updates_document_type]}\""
+        warn "[relaton-iec] allowed updates_document_type values are: "\
+          "#{TYPES.join(', ')}"
+      end
+      @function = args.delete :function
+      @updates_document_type = args.delete :updates_document_type
+      @accessibility_color_inside = args.delete :accessibility_color_inside
+      @price_code = args.delete :price_code
+      @cen_processing = args.delete :cen_processing
+      @secretary = args.delete :secretary
+      @interest_to_committees = args.delete :interest_to_committees
+      super
+    end
+
+    # @param hash [Hash]
+    # @return [RelatonIsoBib::IecBibliographicItem]
+    def self.from_hash(hash)
+      item_hash = ::RelatonIec::HashConverter.hash_to_bib(hash)
+      new **item_hash
+    end
+
+    # @param opts [Hash]
+    # @option opts [Nokogiri::XML::Builder] :builder XML builder
+    # @option opts [Boolean] :bibdata
+    # @option opts [String] :lang language
+    # @return [String] XML
+    def to_xml(**opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      super **opts do |b|
+        if opts[:bibdata]
+          b.ext do
+            b.doctype doctype if doctype
+            b.horizontal horizontal unless horizontal.nil?
+            b.function function if function
+            editorialgroup&.to_xml b
+            ics.each { |i| i.to_xml b }
+            structuredidentifier&.to_xml b
+            b.stagename stagename if stagename
+            if updates_document_type
+              b.send("updates-document-type", updates_document_type)
+            end
+            unless accessibility_color_inside.nil?
+              b.send("accessibility-color-inside", accessibility_color_inside)
+            end
+            b.send("price-code", price_code) if price_code
+            b.send("cen-processing", cen_processing) unless cen_processing.nil?
+            b.secretary secretary if secretary
+            if interest_to_committees
+              b.send("interest-to-committees", interest_to_committees)
+            end
+          end
+        end
+      end
+    end
+
+    # @return [Hash]
+    def to_hash # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      hash = super
+      hash["function"] = function if function
+      if updates_document_type
+        hash["updates_document_type"] = updates_document_type
+      end
+      unless accessibility_color_inside.nil?
+        hash["accessibility_color_inside"] = accessibility_color_inside
+      end
+      hash["price_code"] = price_code if price_code
+      hash["cen_processing"] = cen_processing unless cen_processing.nil?
+      hash["secretary"] = secretary if secretary
+      if interest_to_committees
+        hash["interest_to_committees"] = interest_to_committees
+      end
+      hash
+    end
   end
 end

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&.strip, part
+        HitCollection.new text.sub(/(^\w+)\//, '\1 '), year&.strip, part
       rescue SocketError, OpenURI::HTTPError, OpenSSL::SSL::SSLError
         raise RelatonBib::RequestError, "Could not access http://www.iec.ch"
       end
@@ -32,28 +32,29 @@ 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
 
       private
 
+      # @param code [String]
+      # @param year [String]
+      # @param missed_years [Array<String>]
       def fetch_ref_err(code, year, missed_years) # rubocop:disable Metrics/MethodLength
         id = year ? "#{code}:#{year}" : code
         warn "[relaton-iec] WARNING: no match found online for #{id}. "\
@@ -77,42 +78,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(reference, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      # 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
+
+      # @param ref [String]
+      # @param year [String, nil]
+      # @return [RelatonIec::HitCollection]
+      def search_filter(ref, year) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         %r{
-          ^(?<code>(?:ISO|IEC)[^\d]*\s[\d-]+\w?)
+          ^(?<code>\S+[^\d]*\s\d+((?:-\w+)+)?)
           (:(?<year1>\d{4}))?
           (?<bundle>\+[^\s\/]+)?
           (\/(?<corr>AMD\s\d+))?
-        }x =~ reference.upcase
+        }x =~ ref.upcase
         year ||= year1
         corr&.sub! " ", ""
-        warn "[relaton-iec] (\"#{reference}\") fetching..."
+        warn "[relaton-iec] (\"#{ref}\") 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
         end
+        result = search code if result.empty?
+        code = result.text.dup
+        code&.sub! /((?:-\w+)+)/, ""
         result.select do |i|
           %r{
-            ^(?<code2>(?:ISO|IEC)[^\d]*\s\d+(-\w+)?)
-            (:(?<year2>\d{4}))?
+            ^(?<code2>\S+[^\d]*\s\d+)((?:-\w+)+)?
+            (:\d{4})?
             (?<bundle2>\+[^\s\/]+)?
             (\/(?<corr2>AMD\d+))?
           }x =~ i.hit[:code]
-          code2.sub! /(?<=-\d)\w*/, "" if part
-          code2.sub! /-\d+\w*/, "" if opts[:all_parts]
-          ref == code2 && (year.nil? || year == year2) && bundle == bundle2 &&
-            corr == corr2
+          code == code2 && bundle == bundle2 && corr == corr2
         end
       end
 
@@ -157,30 +159,61 @@ 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, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        r_code, r_year = code_year result.text, 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_years << d.on(:year)
-            end
-          end
-        end
-        { years: missed_years }
+        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
 
-      def iecbib_get1(code, year, opts)
-        return iev if code.casecmp("IEV").zero?
+      # @param ref [String]
+      # @param part [String, nil]
+      # @return [Array<String, nil>]
+      def code_year(ref, part)
+        %r{
+          ^(?<code>\S+[^\d]*\s\d+((?:-\w+)+)?)
+          (:(?<year>\d{4}))?
+        }x =~ ref
+        code.sub!(/-\d+/, "") if part
+        [code, year]
+      end
 
-        result = isobib_search_filter(code, year, opts) || return
-        ret = isobib_results_filter(result, year)
+      # @param code [String]
+      # @param year [String, nil]
+      # @param opts [Hash]
+      # @return [RelatonIec::IecBibliographicItem, nil]
+      def iecbib_get(code, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        result = search_filter(code, year) || return
+        ret = results_filter(result, 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/processor.rb

@@ -26,8 +26,7 @@ module RelatonIec
     # @param hash [Hash]
     # @return [RelatonIsoBib::IecBibliographicItem]
     def hash_to_bib(hash)
-      item_hash = ::RelatonIec::HashConverter.hash_to_bib(hash)
-      ::RelatonIec::IecBibliographicItem.new item_hash
+      ::RelatonIec::IecBibliographicItem.from_hash hash
     end
 
     # Returns hash of XML grammar
@@ -35,5 +34,11 @@ module RelatonIec
     def grammar_hash
       @grammar_hash ||= ::RelatonIec.grammar_hash
     end
+
+    # @param code [String]
+    # @return [String, nil]
+    def urn_to_code(code)
+      RelatonIec.urn_to_code code
+    end
   end
 end

data/lib/relaton_iec/scrapper.rb

@@ -69,38 +69,13 @@ module RelatonIec
       # @param hit [Hash]
       # @return [Array<RelatonBib::DocumentIdentifier>]
       def fetch_docid(hit)
-        rest = hit[:code].downcase.sub(%r{
-          (?<head>[^\s]+)\s
-          (?<type>is|ts|tr|pas|srd|guide|tec|wp)?(?(<type>)\s)
-          (?<pnum>[\d-]+)\s?
-          (?<_dd>:)?(?(<_dd>)(?<date>[\d-]+)\s?)
-        }x, "")
-        m = $~
-        deliv = /cmv|csv|exv|prv|rlv|ser/.match(hit[:code].downcase).to_s
-        urn = ["urn", "iec", "std", m[:head].split("/").join("-"), m[:pnum],
-               m[:date], m[:type], deliv, "en"]
-        urn += fetch_ajunct(rest)
+        urn = RelatonIec.code_to_urn hit[:code], "en"
         [
           RelatonBib::DocumentIdentifier.new(id: hit[:code], type: "IEC"),
-          RelatonBib::DocumentIdentifier.new(id: urn.join(":"), type: "URN"),
+          RelatonBib::DocumentIdentifier.new(id: urn, type: "URN"),
         ]
       end
 
-      # @param rest [String]
-      # @return [Array<String, nil>]
-      def fetch_ajunct(rest)
-        r = rest.sub(%r{
-          (?<_pl>\+)(?(<_pl>)(?<adjunct>amd)(?<adjnum>\d+)\s?)
-          (?<_d2>:)?(?(<_d2>)(?<adjdt>[\d-]+)\s?)
-        }x, "")
-        m = $~ || {}
-        return [] unless m[:adjunct]
-
-        plus = m[:adjunct] && "plus"
-        urn = [plus, m[:adjunct], m[:adjnum], m[:adjdt]]
-        urn + fetch_ajunct(r)
-      end
-
       # Fetch abstracts.
       # @param doc [Nokigiri::HTML::Document]
       # @return [Array<Array>]
@@ -266,14 +241,7 @@ module RelatonIec
 
       def fetch_contributors(code)
         code.sub(/\s.*/, "").split("/").map do |abbrev|
-          case abbrev
-          when "ISO"
-            name = "International Organization for Standardization"
-            url = "www.iso.org"
-          when "IEC"
-            name = "International Electrotechnical Commission"
-            url  = "www.iec.ch"
-          end
+          name, url = name_url abbrev
           { entity: { name: name, url: url, abbreviation: abbrev },
             role: [type: "publisher"] }
         end
@@ -310,11 +278,7 @@ module RelatonIec
       # @return [Array<Hash>]
       def fetch_copyright(code, doc)
         abbreviation = code.match(/.*?(?=\s)/).to_s
-        case abbreviation
-        when "IEC"
-          name = "International Electrotechnical Commission"
-          url = "www.iec.ch"
-        end
+        name, url = name_url abbreviation
         from = code.match(/(?<=:)\d{4}/).to_s
         if from.empty?
           from = doc.xpath("//span[@itemprop='releaseDate']").text
@@ -326,6 +290,14 @@ module RelatonIec
         }]
       end
       # rubocop:enable Metrics/MethodLength
+
+      def name_url(abbrev)
+        case abbrev
+        when "ISO" then ["International Organization for Standardization", "www.iso.org"]
+        when "IEC" then ["International Electrotechnical Commission", "www.iec.ch"]
+        when "CISPR" then ["International special committee on radio interference", "www.iec.ch"]
+        end
+      end
     end
   end
 end