relaton-iso 1.11.1 → 1.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57aaa988aba37afa1e4cc8eced55b20d46eda761cad5fc8a68ac33c3793afb82
-  data.tar.gz: 0ff660f7a7ffb558659c9d8577f075cfea9e225c2d9a7bf44d209745b0d7fc76
+  metadata.gz: 3600bb96dbe0079a7a3decb1ed1e72d4bf8b0b1b3e3dbf895ce09babea1180e8
+  data.tar.gz: d01275c03e71b7bcc0137c3b72035cd19894eb39812d70f1ddadbb1e2c0354c7
 SHA512:
-  metadata.gz: 8ef87dc1073df8b8653989494fda55f54cdcd780aaaa9d16e0af6e0ec6778021d73a2e81b23b18b751e95b2c607f6c27a49af50d8df1bbb95c7d9b7df76e3977
-  data.tar.gz: 154c64258dfc69a6ae01822593e0e9759648cc2f773c126f4474cd0aad8483a16e208613ccd582e94f4ea38c4c996cee089c5d5b844782f93ae2ec33be17151c
+  metadata.gz: 4e6d8c80fef320926e2c3fd71be2963e8d68216ee26079640495a610af32efce41fba270929a61bb989d8ddae1bc04bcf168428782e1e9d51643ca1ed49b59c1
+  data.tar.gz: 5d26dd354ca5d1cc6eeaac3ae612343ec63aa79fa5b584720490f7f0780937e47396cabf1fb0e4b2822161a9f7baad27df7c9bd4e9789bbb7387b3e91f80fc52

data/.github/workflows/rake.yml

@@ -10,27 +10,4 @@ on:
 
 jobs:
   rake:
-    name: Test on Ruby ${{ matrix.ruby }} ${{ matrix.os }}
-    runs-on: ${{ matrix.os }}
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: [ '3.0', '2.7', '2.6', '2.5' ]
-        os: [ ubuntu-latest, windows-latest, macos-latest ]
-        experimental: [ false ]
-    steps:
-      - uses: actions/checkout@v2
-        with:
-          submodules: true
-
-      # https://github.com/ruby-debug/debase/issues/89#issuecomment-686827382
-      - if: matrix.os == 'macos-latest' && matrix.ruby == '2.5'
-        run: echo BUNDLE_BUILD__DEBASE="--with-cflags=\"-Wno-error=implicit-function-declaration\"" >> $GITHUB_ENV
-
-      - uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: ${{ matrix.ruby }}
-          bundler-cache: true
-
-      - run: bundle exec rake
+    uses: relaton/support/.github/workflows/rake.yml@master

data/lib/relaton_iso/document_identifier.rb

@@ -0,0 +1,28 @@
+module RelatonIso
+  class DocumentIdentifier < RelatonBib::DocumentIdentifier
+    attr_accessor :all_parts
+
+    def id
+      if @all_parts
+        if type == "URN"
+          return "#{@id.urn}:ser"
+            else
+          return "#{@id} (all parts)"
+        end
+      end
+      type == "URN" ? @id.urn.to_s : @id.to_s
+    end
+
+    def remove_part
+      @id.part = nil
+    end
+
+    def remove_date
+      @id.year = nil
+    end
+
+    def all_parts
+      @all_parts = true
+    end
+  end
+end

data/lib/relaton_iso/hit.rb

@@ -4,13 +4,13 @@ module RelatonIso
   # Hit.
   class Hit < RelatonBib::Hit
     # @return [RelatonIsoBib::IsoBibliographicItem]
-    attr_writer :fetch
+    attr_writer :fetch, :pubid
 
     # Parse page.
     # @param lang [String, NilClass]
     # @return [RelatonIso::IsoBibliographicItem]
-    def fetch(lang = nil)
-      @fetch ||= Scrapper.parse_page @hit, lang
+    def fetch(lang = nil, all_parts = false)
+      @fetch ||= Scrapper.parse_page @hit, lang, all_parts
     end
 
     # @return [Integer]
@@ -23,5 +23,10 @@ module RelatonIso
       else 4
       end
     end
+
+    # @return [Pubid::Iso::Identifier]
+    def pubid
+      Pubid::Iso::Identifier.parse_from_title(hit[:title])
+    end
   end
 end

data/lib/relaton_iso/hit_collection.rb

@@ -11,25 +11,21 @@ module RelatonIso
     # @param text [String] reference to search
     def initialize(text)
       super
-      @array = text.match?(/^ISO\sTC\s184\/SC\s?4/) ? fetch_github : fetch_iso
+      @array = text.match?(/^ISO\s(?:TC\s184\/SC\s?4|IEC\sDIR\s(?:\d|IEC|JTC))/) ? fetch_github : fetch_iso
     end
 
     # @param lang [String, NilClass]
     # @return [RelatonIsoBib::IsoBibliographicItem]
     def to_all_parts(lang = nil) # rubocop:disable Metrics/CyclomaticComplexity
       # parts = @array.reject { |h| h.hit["docPart"]&.empty? }
-      hit = @array.min_by do |h|
-        IsoBibliography.ref_components(h.hit[:title])[1].to_i
-      end
+      hit = @array.min_by { |h| h.pubid.part }
       return @array.first.fetch lang unless hit
 
-      bibitem = hit.fetch lang
+      bibitem = hit.fetch(lang, true)
       all_parts_item = bibitem.to_all_parts
       @array.reject { |h| h.hit[:uuid] == hit.hit[:uuid] }.each do |hi|
-        %r{^(?<fr>ISO(?:\s|/)[^-/:()]+(?:-[\w-]+)?(?::\d{4})?
-          (?:/\w+(?:\s\w+)?\s\d+(?:\d{4})?)?)}x =~ hi.hit[:title]
         isobib = RelatonIsoBib::IsoBibliographicItem.new(
-          formattedref: RelatonBib::FormattedRef.new(content: fr),
+          formattedref: RelatonBib::FormattedRef.new(content: hi.pubid.to_s),
         )
         all_parts_item.relation << RelatonBib::DocumentRelation.new(
           type: "instance", bibitem: isobib,

data/lib/relaton_iso/iso_bibliography.rb

@@ -27,57 +27,97 @@ module RelatonIso
       # @option opts [Boolean] :keep_year if undated reference should return
       #   actual reference with year
       #
-      # @return [String] Relaton XML serialisation of reference
+      # @return [RelatonIsoBib::IsoBibliographicItem] Relaton XML serialisation of reference
       def get(ref, year = nil, opts = {}) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/AbcSize
         code = ref.gsub(/\u2013/, "-")
-        # %r{\s(?<num>\d+)(?:-(?<part>[\d-]+))?(?::(?<year1>\d{4}))?} =~ code
-        year ||= publish_year ref
+
+        # parse "all parts" request
         code.sub! " (all parts)", ""
         opts[:all_parts] ||= $~ && opts[:all_parts].nil?
-        # opts[:keep_year] ||= opts[:keep_year].nil?
-        # code.sub!("#{num}-#{part}", num) if opts[:all_parts] && part
-        # if %r[^ISO/IEC DIR].match? code
-        #   return RelatonIec::IecBibliography.get(code, year, opts)
-        # end
 
-        ret = isobib_get(code, year, opts)
-        return nil if ret.nil?
+        query_pubid = Pubid::Iso::Identifier.parse(code)
+        query_pubid.year = year if year
+
+        hits = isobib_search_filter(query_pubid, opts)
 
-        if (year && opts[:keep_year].nil?) || opts[:keep_year] || opts[:all_parts]
+        # return only first one if not all_parts
+        ret = if !opts[:all_parts] || hits.size == 1
+                hits.any? && hits.first.fetch(opts[:lang])
+              else
+                hits.to_all_parts(opts[:lang])
+              end
+
+        if ret
+          warn "[relaton-iso] (\"#{query_pubid}\") found #{ret.docidentifier.first.id}"
+        else
+          return fetch_ref_err(query_pubid, query_pubid.year)
+        end
+
+        if (query_pubid.year && opts[:keep_year].nil?) || opts[:keep_year] || opts[:all_parts]
           ret
         else
           ret.to_most_recent_reference
         end
       end
 
-      def ref_components(ref)
-        %r{
-          ^(?<code>ISO(?:\s|/)[^-/:()]+\d+)
-          (?:-(?<part>[\w-]+))?
-          (?::(?<year>\d{4}))?
-          (?:/(?<corr>\w+(?:\s\w+)?\s\d+)(?:(?<coryear>\d{4}))?)?
-        }x =~ ref
-        [code&.strip, part, year, corr, coryear]
+      # @param query_pubid [Pubid::Iso::Identifier]
+      # @param pubid [Pubid::Iso::Identifier]
+      # @param all_parts [Boolean] match with any parts when true
+      # @return [Boolean]
+      def matches_parts?(query_pubid, pubid, all_parts: false)
+        if all_parts
+          # match only with documents with part number
+          !pubid.part.nil?
+        else
+          query_pubid.part == pubid.part
+        end
+      end
+
+      def matches_base?(query_pubid, pubid, any_types_stages: false)
+        query_pubid.publisher == pubid.publisher &&
+          query_pubid.number == pubid.number &&
+          query_pubid.copublisher == pubid.copublisher &&
+          (any_types_stages && query_pubid.stage.nil? || query_pubid.stage == pubid.stage) &&
+          (any_types_stages && query_pubid.type.nil? || query_pubid.type == pubid.type)
+      end
+
+      # @param hit_collection [RelatonIso::HitCollection]
+      # @param year [String]
+      # @return [RelatonIso::HitCollection]
+      def filter_hits_by_year(hit_collection, year)
+        missed_years = []
+
+        # filter by year
+        hits = hit_collection.select do |hit|
+          if hit.pubid.year == year
+            true
+          else
+            missed_years << hit.pubid.year
+            false
+          end
+        end
+
+        if hits.empty? && !missed_years.empty?
+          warn "[relaton-iso] (There was no match for #{year}, though there "\
+               "were matches found for #{missed_years.join(', ')}.)"
+        end
+        hits
       end
 
       private
 
       # rubocop:disable Metrics/MethodLength
 
-      def fetch_ref_err(code, year, missed_years)
-        id = year ? "#{code}:#{year}" : code
+      def fetch_ref_err(query_pubid, year)
+        id = year ? "#{query_pubid}:#{year}" : query_pubid
         warn "[relaton-iso] 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-iso] (There was no match for #{year}, though there "\
-               "were matches found for #{missed_years.join(', ')}.)"
-        end
-        if /\d-\d/.match? code
+        if /\d-\d/.match? query_pubid.to_s
           warn "[relaton-iso] The provided document part may not exist, "\
                "or the document may no longer be published in parts."
         else
           warn "[relaton-iso] If you wanted to cite all document parts for "\
-               "the reference, use \"#{code} (all parts)\".\nIf the document "\
+               "the reference, use \"#{query_pubid} (all parts)\".\nIf the document "\
                "is not a standard, use its document type abbreviation "\
                "(TS, TR, PAS, Guide)."
         end
@@ -88,119 +128,49 @@ module RelatonIso
 
       # Search for hits. If no found then trying missed stages and ISO/IEC.
       #
-      # @param code [String] reference without correction
+      # @param query_pubid [Pubid::Iso::Identifier] reference without correction
       # @param opts [Hash]
       # @return [Array<RelatonIso::Hit>]
-      def isobib_search_filter(code, opts)
-        ref = remove_part code, opts[:all_parts]
-        warn "[relaton-iso] (\"#{code}\") fetching..."
-        result = search(ref)
-        res = search_code result, code, opts
+      def isobib_search_filter(query_pubid, opts)
+        query_pubid.part = nil if opts[:all_parts]
+        warn "[relaton-iso] (\"#{query_pubid}\") fetching..."
+        # fetch hits collection
+        hit_collection = search(query_pubid.to_s(with_date: false))
+        # filter only matching hits
+        res = filter_hits hit_collection, query_pubid,
+                          all_parts: opts[:all_parts]
         return res unless res.empty?
 
-        # try stages
-        case code
-        when %r{^\w+/[^/]+\s\d+} # code like ISO/IEC 123, ISO/IEC/IEE 123
-          res = try_stages(result, opts) do |st|
-            code.sub(%r{^(?<pref>[^\s]+\s)}) { "#{$~[:pref]}#{st} " }
-          end
-          return res unless res.empty?
-        when %r{^\w+\s\d+} # code like ISO 123
-          res = try_stages(result, opts) do |st|
-            code.sub(%r{^(?<pref>\w+)}) { "#{$~[:pref]}/#{st}" }
-          end
-          return res unless res.empty?
-        end
+        # lookup for documents with stages when no match without stage
+        res = filter_hits hit_collection, query_pubid,
+                          all_parts: opts[:all_parts], any_types_stages: true
+        return res unless res.empty?
 
-        if %r{^ISO\s}.match? code # try ISO/IEC if ISO not found
+        # TODO: do this at pubid-iso
+        if query_pubid.publisher == "ISO" && query_pubid.copublisher.nil? # try ISO/IEC if ISO not found
           warn "[relaton-iso] Attempting ISO/IEC retrieval"
-          c = code.sub "ISO", "ISO/IEC"
-          res = search_code result, c, opts
-        end
-        res
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-
-      def remove_part(ref, all_parts)
-        return ref unless all_parts
-
-        ref.sub %r{(\S+\s\d+)[\d-]+}, '\1'
-      end
-
-      # @param result [RelatonIso::HitCollection]
-      # @param opts [Hash]
-      # @return [RelatonIso::HitCollection]
-      def try_stages(result, opts)
-        res = nil
-        %w[NP WD CD DIS FDIS PRF IS AWI TR].each do |st| # try stages
-          c = yield st
-          res = search_code result, c, opts
-          return res unless res.empty?
+          query_pubid.copublisher = "IEC"
+          res = filter_hits hit_collection, query_pubid, all_parts: opts[:all_parts]
         end
         res
       end
 
-      # @param result [RelatonIso::HitCollection]
-      # @param code [String]
-      # @param opts [Hash]
+      # @param hits [RelatonIso::HitCollection]
+      # @param query_pubid [Pubid::Iso::Identifier]
+      # @param all_parts [Boolean]
+      # @param any_stages [Boolean]
       # @return [RelatonIso::HitCollection]
-      def search_code(result, code, opts) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        code1, part1, _, corr1, coryear1 = ref_components code
-        result.select do |i|
-          code2, part2, _, corr2, coryear2 = ref_components i.hit[:title]
-          code1 == code2 && ((opts[:all_parts] && part2) || (!opts[:all_parts] && part1 == part2)) &&
-            corr1 == corr2 && (!coryear1 || coryear1 == coryear2)
+      def filter_hits(hit_collection, query_pubid, all_parts: false, any_types_stages: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        # filter out
+        result = hit_collection.select do |i|
+          hit_pubid = i.pubid
+          matches_base?(query_pubid, hit_pubid, any_types_stages: any_types_stages) &&
+            matches_parts?(query_pubid, hit_pubid, all_parts: all_parts) &&
+            query_pubid.corrigendum == hit_pubid.corrigendum &&
+            query_pubid.amendment == hit_pubid.amendment
         end
-      end
-
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
-      # Sort through the results from RelatonIso, 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, opts)
-        missed_years = []
-        hits = result.reduce!([]) do |hts, h|
-          iyear = publish_year h.hit[:title]
-          if !year || iyear == year
-            hts << h
-          else
-            missed_years << iyear
-            hts
-          end
-        end
-        return { years: missed_years } unless hits.any?
-
-        if !opts[:all_parts] || hits.size == 1
-          return { ret: hits.first.fetch(opts[:lang]) }
-        end
-
-        { ret: hits.to_all_parts(opts[:lang]) }
-      end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-
-      def publish_year(ref)
-        %r{:(?<year>\d{4})(?!.*:\d{4})} =~ ref
-        year
-      end
-
-      # @param code [String]
-      # @param year [String, NilClass]
-      # @param opts [Hash]
-      def isobib_get(code, year, opts)
-        # return iev(code) if /^IEC 60050-/.match code
-        result = isobib_search_filter(code, opts) || return
-        ret = isobib_results_filter(result, year, opts)
-        if ret[:ret]
-          warn "[relaton-iso] (\"#{code}\") found #{ret[:ret].docidentifier.first.id}"
-          ret[:ret]
-        else
-          fetch_ref_err(code, year, ret[:years])
-        end
+        query_pubid.year ? filter_hits_by_year(result, query_pubid.year) : result
       end
     end
   end

data/lib/relaton_iso/scrapper.rb

@@ -52,10 +52,11 @@ module RelatonIso
       # Parse page.
       # @param hit_data [Hash]
       # @param lang [String, NilClass]
-      # @return [Hash]
-      def parse_page(hit_data, lang = nil) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # @return [RelatonIsoBib::IsoBibliographicItem]
+      def parse_page(hit_data, lang = nil, all_parts = false) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         # path = "/contents/data/standard#{hit_data['splitPath']}/"\
         # "#{hit_data['csnumber']}.html"
+
         doc, url = get_page "#{hit_data[:path].sub '/sites/isoorg', ''}.html"
 
         # Fetch edition.
@@ -66,7 +67,7 @@ module RelatonIso
 
         RelatonIsoBib::IsoBibliographicItem.new(
           fetched: Date.today.to_s,
-          docid: fetch_docid(doc, edition, langs),
+          docid: fetch_relaton_docids(Pubid::Iso::Identifier.parse(item_ref(doc))),
           docnumber: fetch_docnumber(doc),
           edition: edition,
           language: langs.map { |l| l[:lang] },
@@ -87,6 +88,20 @@ module RelatonIso
         )
       end
 
+      # Fetch relaton docids.
+      # @param pubid [Pubid::Iso::Identifier]
+      # @param edition [String]
+      # @param langs [Array<Hash>]
+      # @param stage [Float]
+      # @return [Array<RelatonBib::DocumentIdentifier>]
+      def fetch_relaton_docids(pubid)
+        pubid.urn_stage = 60.60
+        [
+          RelatonIso::DocumentIdentifier.new(id: pubid, type: "ISO", primary: true),
+          RelatonIso::DocumentIdentifier.new(id: pubid, type: "URN"),
+        ]
+      end
+
       private
 
       # Fetch titles and abstracts.
@@ -168,44 +183,6 @@ module RelatonIso
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
-      # Fetch docid.
-      # @param doc [Nokogiri:HTML::Document]
-      # @param edition [String]
-      # @param langs [Array<Hash>]
-      # @return [Array<RelatonBib::DocumentIdentifier>]
-      def fetch_docid(doc, edition, langs)
-        pubid = item_ref doc
-        [
-          RelatonBib::DocumentIdentifier.new(id: pubid, type: "ISO", primary: true),
-          RelatonBib::DocumentIdentifier.new(
-            id: fetch_urn(doc, pubid, edition, langs), type: "URN",
-          ),
-        ]
-      end
-
-      # @param doc [Nokogiri:HTML::Document]
-      # @param pubid [String]
-      # @param edition [String]
-      # @param langs [Array<Hash>]
-      # @returnt [String]
-      def fetch_urn(doc, pubid, edition, langs) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength
-        orig = pubid.split.first.downcase.split("/").join "-"
-        %r{(?<=)(?<type>DATA|GUIDE|ISP|IWA|PAS|R|TR|TS|TTA)} =~ pubid
-        _, part, _year, corr, = IsoBibliography.ref_components pubid
-        urn = "urn:iso:std:#{orig}"
-        urn += ":#{type.downcase}" if type
-        urn += ":#{fetch_docnumber(doc)}"
-        urn += ":-#{part}" if part
-        urn += ":stage-#{stage_code(doc)}"
-        urn += ":ed-#{edition}" if edition
-        if corr
-          corrparts = corr.split
-          urn += ":#{corrparts[0].downcase}:#{corrparts[-1]}"
-        end
-        urn += ":#{langs.map { |l| l[:lang] }.join(',')}"
-        urn
-      end
-
       def fetch_docnumber(doc)
         item_ref(doc)&.match(/\d+/)&.to_s
       end

data/lib/relaton_iso/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RelatonIso
-  VERSION = "1.11.1"
+  VERSION = "1.12.0"
 end

data/lib/relaton_iso.rb

@@ -2,3 +2,5 @@
 
 require "relaton_iso/version"
 require "relaton_iso/iso_bibliography"
+require "pubid-iso"
+require "relaton_iso/document_identifier"

data/relaton_iso.gemspec

@@ -42,5 +42,6 @@ Gem::Specification.new do |spec|
 
   # spec.add_dependency "relaton-iec", "~> 1.8.0"
   spec.add_dependency "algolia"
-  spec.add_dependency "relaton-iso-bib", "~> 1.11.0"
+  spec.add_dependency "relaton-iso-bib", "~> 1.12.0"
+  spec.add_dependency "pubid-iso", "~> 0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-iso
 version: !ruby/object:Gem::Version
-  version: 1.11.1
+  version: 1.12.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-05-03 00:00:00.000000000 Z
+date: 2022-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -184,14 +184,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.11.0
+        version: 1.12.0
+- !ruby/object:Gem::Dependency
+  name: pubid-iso
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.7
 description: 'RelatonIso: retrieve ISO Standards for bibliographic use using the IsoBibliographicItem
   model'
 email:
@@ -231,6 +245,7 @@ files:
 - bin/safe_yaml
 - bin/setup
 - lib/relaton_iso.rb
+- lib/relaton_iso/document_identifier.rb
 - lib/relaton_iso/hit.rb
 - lib/relaton_iso/hit_collection.rb
 - lib/relaton_iso/iso_bibliography.rb