relaton-iec 1.14.1 → 1.14.2

data/lib/relaton_iec/hit_collection.rb

@@ -6,25 +6,22 @@ require "addressable/uri"
 module RelatonIec
   # Page of hit collection.
   class HitCollection < RelatonBib::HitCollection
-    def_delegators :@array, :detect
+    def_delegators :@array, :detect, :map
 
-    attr_reader :part
-
-    DOMAIN = "https://webstore.iec.ch"
+    # DOMAIN = "https://webstore.iec.ch"
 
     # @param ref [String]
     # @param year [String, nil]
-    # @param part [String, nil]
-    def initialize(ref, year = nil, part = nil)
+    def initialize(ref, year = nil)
       super ref, year
-      @part = part
-      @array = ref ? hits(ref, year) : []
+      @index = Index.new
+      @array = fetch_from_gh
     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
+    def to_all_parts(r_year) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      parts = @array.select { |h| h.part && h.hit[:code].match?(/^[\s\w-]+:#{r_year}/) }
+      hit = parts.min_by { |h| h.part.to_i }
       return @array.first&.fetch unless hit
 
       bibitem = hit.fetch
@@ -41,76 +38,15 @@ module RelatonIec
 
     private
 
-    # @param ref [String]
-    # @param year [String, nil]
-    # @return [Array<RelatonIec::Hit>]
-    def hits(ref, year) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      if /61360-4\sDB|ISO[\s\/]IEC\sDIR/.match?(ref)
-        fetch_from_gh ref
-      else
-        from, to = nil
-        if year
-          from = Date.strptime year, "%Y"
-          to   = from.next_year.prev_day
-        end
-        get_results ref, from, to
-      end
-      # file = "../data/#{ref.sub(/^IEC\s/, '').gsub(/[\s\/]/, '_').upcase}.yaml"
-      # path = File.expand_path file, __dir__
-      # if File.exist? path
-      #   hash = YAML.safe_load File.read(path, encoding: "utf-8")
-      #   hit = Hit.new({ code: ref }, self)
-      #   hit.fetch = IecBibliographicItem.from_hash hash
-      #   return [hit]
-      # end
-    end
-
-    def fetch_from_gh(ref)
-      file = ref.sub(/^IEC\s(?=ISO|CISPR)/, "").gsub(/[\s\/]/, "_").upcase
-      url = "https://raw.githubusercontent.com/relaton/relaton-data-iec/main/data/#{file}.yaml"
-      resp = Net::HTTP.get URI(url)
-      hash = YAML.safe_load resp
-      hash["fetched"] = Date.today.to_s
-      hit = Hit.new({ code: ref }, self)
-      hit.fetch = IecBibliographicItem.from_hash hash
-      [hit]
-    end
+    def fetch_from_gh
+      return [] unless text
 
-    # @param ref [String]
-    # @param from [Date, nil]
-    # @param to [Date, nil]
-    # @return [Array<RelatonIec::Hit>]
-    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)
+      ref = year && !/:\d{4}$/.match?(text) ? "#{text}:#{year}" : text
+      reference = ref.sub(/^IEC\s(?=ISO\/IEC\sDIR)/, "")
+      @index.search(reference).map do |row|
+        # pubid = row[:pubid].is_a?(Array) ? row[:pubid][0] : row[:pubid]
+        Hit.new({ code: row[:pubid], file: row[:file] }, self)
       end
     end
-
-    # @param url [String]
-    # @return [Array<RelatonIec::Hit>]
-    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")
-      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 }.compact
-    end
-
-    def make_hit(hit)
-      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)
-    end
   end
 end

data/lib/relaton_iec/iec_bibliographic_item.rb

@@ -26,6 +26,8 @@ module RelatonIec
     # @option args [String, nil] :function function
     # @option args [String, nil] :updates_document_type updates document type
     # @option args [String, nil] :price_code price code
+    # @option args [Boolean, nil] :cen_processing
+    # @option args [String, nil] :secretary
     # @option args [String, nil] :secretary secretary
     # @option args [String, nil] :interest_to_committees interest to committees
     # @option args [Boolean, nil] :accessibility_color_inside accessibility color inside
@@ -103,7 +105,7 @@ module RelatonIec
     end
 
     # @return [Hash]
-    def to_hash # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+    def to_hash(embedded: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
       hash = super
       hash["function"] = function if function
       if updates_document_type

data/lib/relaton_iec/iec_bibliography.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 # require 'isobib/iso_bibliographic_item'
-require "relaton_iec/scrapper"
 require "relaton_iec/hit_collection"
 require "date"
 
@@ -10,37 +9,27 @@ module RelatonIec
   class IecBibliography
     class << self
       ##
-      # Search for standards entries. To seach packaged document it needs to
-      # pass part parametr.
+      # Search for standards entries.
       #
-      # @example Search for packaged standard
-      #   RelatonIec::IecBibliography.search 'IEC 60050-311', nil, '311'
-      #
-      # @param text [String]
+      # @param ref [String]
       # @param year [String, nil]
-      # @param part [String, nil] search for packaged stndard if not nil
       # @return [RelatonIec::HitCollection]
-      def search(text, year = nil, part = nil)
-        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"
+      def search(ref, year = nil)
+        # HitCollection.new text&.sub(/(^\w+)\//, '\1 '), year&.strip
+        HitCollection.new ref, year&.strip
+      rescue SocketError, OpenURI::HTTPError, OpenSSL::SSL::SSLError => e
+        raise RelatonBib::RequestError, e.message
       end
 
-      # @param code [String] the ISO standard Code to look up (e..g "ISO 9000")
+      # @param code [String] the IEC standard code to look up (e..g "IEC 8000")
       # @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/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+      def get(code, year = nil, opts = {}) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
         opts[:all_parts] ||= code.match?(/\s\(all parts\)/)
         ref = code.sub(/\s\(all parts\)/, "")
-        if year.nil?
-          /^(?<code1>[^:]+):(?<year1>[^:]+)/ =~ ref
-          unless code1.nil?
-            ref = code1
-            year = year1
-          end
-        end
+        year ||= ref_parts(ref)[:year]
         return iev if ref.casecmp("IEV").zero?
 
         ret = iecbib_get(ref, year, opts)
@@ -57,65 +46,30 @@ module RelatonIec
       # @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}. "\
+        warn "[relaton-iec] 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-iec] (There was no match for #{year}, though there "\
+          warn "[relaton-iec] (There was no match for #{year}, though there " \
                "were matches found for #{missed_years.join(', ')}.)"
         end
         if /\d-\d/.match? code
-          warn "[relaton-iec] The provided document part may not exist, or "\
+          warn "[relaton-iec] The provided document part may not exist, or " \
                "the document may no longer be published in parts."
         else
-          warn "[relaton-iec] 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, "\
+          warn "[relaton-iec] 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
       end
 
-      # @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
-
       # @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
-        rp1 = ref_parts ref.upcase
-        year ||= rp1[:year]
-        corr = rp1[:corr]&.sub " ", ""
+      def search_filter(ref)
+        code = ref.split(":").first
         warn "[relaton-iec] (\"#{ref}\") fetching..."
-        result = search(rp1[:code], year)
-        code = result.text.dup
-        if result.empty? && /(?<=\d-)(?<part>[\w-]+)/ =~ rp1[:code]
-          # try to search packaged standard
-          result = search rp1[:code], year, part
-          pkg_std = result.any?
-        end
-        result = search rp1[:code] if result.empty?
-        if pkg_std
-          code.sub!(/(?<=\d-)#{part}/, part[0])
-        else
-          code.sub!(/-[-\d]+/, "")
-        end
-        result.select do |i|
-          rp2 = ref_parts i.hit[:code]
-          code2 = if pkg_std
-                    rp2[:code].sub(/(?<=\d-\d)\d+/, "")
-                  else
-                    rp2[:code].sub(/-[-\d]+/, "")
-                  end
-          code == code2 && rp1[:bundle] == rp2[:bundle] && corr == rp2[:corr]
-        end
+        search(code)
       end
 
       def ref_parts(ref)
@@ -160,72 +114,90 @@ module RelatonIec
         XML
       end
 
-      # Sort through the results from Isobib, fetching them three at a time,
+      # Look for a code in the search results
       # and return the first result that matches the code,
-      # matches the year (if provided), and which
+      # matches the year (if provided), and which a part
       # 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 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
+      # If no match, returns any years which caused mismatch, for error reporting
+      def results_filter(result, ref, year, opts)
+        r_code, r_year, r_amd = code_year ref
         r_year ||= year
-        missed_years = []
+        if opts[:all_parts]
+          ret = result.to_all_parts(r_year)
+        else
+          ret, missed_parts = match_result(result, r_code, r_year, r_amd)
+        end
+        { ret: ret, years: missed_years(result, r_year), missed_parts: missed_parts }
+      end
+
+      def missed_years(result, year)
+        result.map { |h| codes_years(h.hit[:code])[1] }.flatten.uniq.reject { |y| y == year }
+      end
+
+      #
+      # Find a match in the search results
+      #
+      # @param [RelatonIec::HitCollection] result search results
+      # @param [String] code code of the document
+      # @param [String] year year of the document
+      # @param [String] amd amendment of the document
+      #
+      # @return [Array<RelatonIec::IecBibliographicItem, Array, nil>] result, missed parts
+      #
+      def match_result(result, code, year, amd) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
         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 }
+        ret = result.detect do |h|
+          h_codes, h_years, h_amds = codes_years h.hit[:code]
+          match_code = h_codes.include? code
+          match_year = h_years.include?(year)
+          missed_parts ||= !match_code
+          match_code && (!year || match_year) && match_amd(amd, h_amds)
+        end&.fetch
+        [ret, missed_parts]
+      end
+
+      def match_amd(amd, h_amds)
+        (!amd && h_amds.empty?) || h_amds.include?(amd)
       end
 
       # @param ref [String]
-      # @param part [String, nil]
-      # @return [Array<String, nil>]
-      def code_year(ref, part)
+      # @return [Array<Stringl, nil>] code, year, amd
+      def code_year(ref)
         %r{
-          ^(?<code>\S+[^\d]*\s\d+(?:-\w+)*)
+          # ^(?<code>\S+[^\d]*\s\d+(?:-\w+)*)
+          ^(?<code>\S+\s[^:/]+)
           (?::(?<year>\d{4}))?
+          (?:/(?<amd>\w+)(?::\d{4})?)?
         }x =~ ref
-        code.sub!(/-\d+/, "") if part
-        [code, year]
+        [code, year, amd&.upcase]
       end
 
-      # @param code [String]
+      # @param ref [String]
+      # @return [Array<Array<Stringl>>] codes, years, amds
+      def codes_years(refs)
+        RelatonBib.array(refs).map do |r|
+          code_year r
+        end.transpose.map { |a| a.compact.uniq }
+      end
+
+      # @param ref [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)
+      def iecbib_get(ref, year, opts) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        result = search_filter(ref) || return
+        ret = results_filter(result, ref, year, opts)
         if ret[:ret]
-          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)\""
+          if ret[:missed_parts] && !opts[:all_parts]
+            warn "[relaton-iec] WARNING: #{ref} found as #{ret[:ret].docidentifier.first.id} " \
+                 "but also contain parts. If you wanted to cite all document " \
+                 "parts for the reference, use \"#{ref} (all parts)\""
           else
-            warn "[relaton-iec] (\"#{code}\") found #{ret[:ret].docidentifier.first.id}"
+            warn "[relaton-iec] (\"#{ref}\") found #{ret[:ret].docidentifier.first.id}"
           end
           ret[:ret]
         else
-          fetch_ref_err(code, year, ret[:years])
+          fetch_ref_err(ref, year, ret[:years])
         end
       end
     end

data/lib/relaton_iec/index.rb

@@ -0,0 +1,133 @@
+module RelatonIec
+  class Index
+    #
+    # Initialize index.
+    # If index argument is nil, read index from file or from GitHub.
+    # If index argument is not nil, then read index from file or create new
+    # empty index. (use this option for creating index for dataset)
+    #
+    # @param [String, nil] index to index file
+    #
+    def initialize(index = nil)
+      if index
+        @path = index
+        @index = create_index_file
+      else
+        @index = read_index_file || get_index_from_gh
+      end
+    end
+
+    #
+    # Add document to index or update existing document
+    #
+    # @param [String, Array<String>] pubid document identifier
+    # @param [String] file document file name
+    # @param [String] change last change date time
+    #
+    # @return [void]
+    #
+    def add(pubid, file, change = nil)
+      item = @index.find { |i| i[:pubid] == pubid }
+      unless item
+        item = { pubid: pubid }
+        @index << item
+      end
+      item[:file] = file
+      item[:last_change] = change if change
+    end
+
+    #
+    # Clear index
+    #
+    # @return [void]
+    #
+    def clear
+      @index.clear
+    end
+
+    #
+    # Last change date
+    #
+    # @return [String] <description>
+    #
+    def last_change
+      return unless @index.any?
+
+      @last_change ||= @index.max_by { |i| i[:last_change].to_s }[:last_change]
+    end
+
+    #
+    # Find document in index by reference and sort results by document ID
+    #
+    # @param [String] ref reference
+    #
+    # @return [Array<Hash>] search result
+    #
+    def search(ref)
+      upcase_ref = ref.upcase
+      @index.select do |i|
+        RelatonBib.array(i[:pubid]).detect { |r| r.include? upcase_ref }
+      end.sort_by { |r| r[:pubid].is_a?(Array) ? r[:pubid].min : r[:pubid] }
+    end
+
+    #
+    # Save index to file
+    #
+    # @return [void]
+    #
+    def save
+      File.write @path, @index.to_yaml, encoding: "UTF-8"
+    end
+
+    private
+
+    #
+    # Create dir if need and return path to index file
+    #
+    # @return [String] path to index file
+    #
+    def path
+      @path ||= begin
+        dir = File.join Dir.home, ".relaton", "iec"
+        FileUtils.mkdir_p dir
+        File.join dir, "index.yaml"
+      end
+    end
+
+    #
+    # Create index file for dataset
+    #
+    # @return [Array<Hash>] index content
+    #
+    def create_index_file
+      return [] unless File.exist? path
+
+      RelatonBib.parse_yaml File.read(path, encoding: "UTF-8"), [Symbol]
+    end
+
+    #
+    # Read index from file if it exists and not outdated
+    #
+    # @return [Hash, nil] index content
+    #
+    def read_index_file
+      return if !File.exist?(path) || File.ctime(path).to_date < Date.today
+
+      RelatonBib.parse_yaml File.read(path, encoding: "UTF-8"), [Symbol]
+    end
+
+    #
+    # Get index from a GitHub repository
+    #
+    # @return [Hash] index content
+    #
+    def get_index_from_gh # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      resp = Zip::InputStream.new URI("#{Hit::GHURL}index.zip").open
+      zip = resp.get_next_entry
+      yaml = zip.get_input_stream.read
+      index = RelatonBib.parse_yaml yaml, [Symbol]
+      File.write path, index.to_yaml, encoding: "UTF-8"
+      index
+    end
+  end
+end

data/lib/relaton_iec/processor.rb

@@ -7,6 +7,7 @@ module RelatonIec
       @prefix = "IEC"
       @defaultprefix = %r{^IEC\s|^IEV($|\s)}
       @idtype = "IEC"
+      @datasets = %w[iec-harmonized-all iec-harmonized-latest]
     end
 
     # @param code [String]
@@ -17,6 +18,18 @@ module RelatonIec
       ::RelatonIec::IecBibliography.get(code, date, opts)
     end
 
+    #
+    # Fetch all the documents from a source
+    #
+    # @param [String] source source name (iec-harmonized-all, iec-harmonized-latest)
+    # @param [Hash] opts
+    # @option opts [String] :output directory to output documents
+    # @option opts [String] :format output format (xml, yaml, bibxml)
+    #
+    def fetch_data(source, opts)
+      DataFetcher.new(source, **opts).fetch
+    end
+
     # @param xml [String]
     # @return [RelatonIsoBib::IecBibliographicItem]
     def from_xml(xml)

data/lib/relaton_iec/version.rb

@@ -1,3 +1,3 @@
 module RelatonIec
-  VERSION = "1.14.1".freeze
+  VERSION = "1.14.2".freeze
 end

data/lib/relaton_iec.rb

@@ -1,15 +1,18 @@
-require "relaton_iso_bib"
-require "relaton_iec/hit"
-require "nokogiri"
+require "digest/md5"
 require "net/http"
+require "nokogiri"
+require "zip"
 require "open-uri"
-require "jing"
+require "relaton_iso_bib"
+require "relaton_iec/hit"
 require "relaton_iec/version"
 require "relaton_iec/iec_bibliography"
 require "relaton_iec/iec_bibliographic_item"
 require "relaton_iec/xml_parser"
 require "relaton_iec/hash_converter"
-require "digest/md5"
+require "relaton_iec/index"
+require "relaton_iec/data_fetcher"
+require "relaton_iec/data_parser"
 
 module RelatonIec
   class << self
@@ -73,7 +76,7 @@ module RelatonIec
     # @return [Array<String, nil>]
     def ajunct_to_urn(rest)
       r = rest.sub(%r{
-        (?<pl>\+|\/)(?(<pl>)(?<adjunct>(amd|cor|ish))(?<adjnum>\d+)\s?)
+        (?<pl>\+|/)(?(<pl>)(?<adjunct>(?:amd|cor|ish))(?<adjnum>\d+)\s?)
         (?<_d2>:)?(?(<_d2>)(?<adjdt>[\d-]+)\s?)
       }x, "")
       m = $~ || {}

data/relaton_iec.gemspec

@@ -1,4 +1,4 @@
-lib = File.expand_path("../lib", __FILE__)
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "relaton_iec/version"
 
@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ribose Inc."]
   spec.email         = ["open.source@ribose.com"]
 
-  spec.summary       = "RelatonIec: retrieve IEC Standards for bibliographic "\
+  spec.summary       = "RelatonIec: retrieve IEC Standards for bibliographic " \
                        "use using the IecBibliographicItem model"
-  spec.description   = "RelatonIec: retrieve IEC Standards for bibliographic "\
+  spec.description   = "RelatonIec: retrieve IEC Standards for bibliographic " \
                        "use using the IecBibliographicItem model"
   spec.homepage      = "https://github.com/metanorma/relaton-iec"
   spec.license       = "MIT"
@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "addressable"
   spec.add_dependency "relaton-iso-bib", "~> 1.14.0"
+  spec.add_dependency "rubyzip"
 end