relaton-ieee 1.8.0 → 1.9.3

data/lib/relaton_ieee/data_parser.rb

@@ -0,0 +1,274 @@
+module RelatonIeee
+  class DataParser
+    DATETYPES = { "OriginalPub" => "created", "ePub" => "published",
+                  "LastInspecUpd" => "updated" }.freeze
+
+    attr_reader :doc, :fetcher
+
+    #
+    # Create RelatonIeee::DataParser instance
+    #
+    # @param [Nokogiri::XML::Element] doc document
+    # @param [RelatonIeee::DataFetcher] fetcher
+    #
+    def initialize(doc, fetcher)
+      @doc = doc
+      @fetcher = fetcher
+    end
+
+    #
+    # Parse IEEE document
+    #
+    # @param [Nokogiri::XML::Element] doc document
+    # @param [RelatonIeee::DataFetcher] fetcher <description>
+    #
+    # @return [RelatonIeee::IeeeBibliographicItem]
+    #
+    def self.parse(doc, fetcher)
+      new(doc, fetcher).parse
+    end
+
+    #
+    # Parse IEEE document
+    #
+    # @return [RelatonIeee::IeeeBibliographicItem]
+    #
+    def parse # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      args = {
+        type: "standard",
+        docnumber: docnumber,
+        title: parse_title,
+        date: parse_date,
+        docid: parse_docid,
+        contributor: parse_contributor,
+        abstract: parse_abstract,
+        copyright: parse_copyright,
+        language: ["en"],
+        script: ["Latn"],
+        status: parse_status,
+        relation: parse_relation,
+        link: parse_link,
+        keyword: parse_keyword,
+        ics: parse_ics,
+      }
+      IeeeBibliographicItem.new(**args)
+    end
+
+    #
+    # Parse title
+    #
+    # @return [RelatonBib::TypedTitleStringCollection]
+    #
+    def parse_title
+      t = doc.at("./volume/article/title").text
+      RelatonBib::TypedTitleString.from_string t
+    end
+
+    #
+    # Parse date
+    #
+    # @return [Array<RelatonBib::BibliographicDate>]
+    #
+    def parse_date # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+      dates = doc.xpath("./volume/article/articleinfo/date").map do |d|
+        da = [d.at("./year").text]
+        m = d.at("./month")&.text
+        if m
+          month = Date::ABBR_MONTHNAMES.index(m.sub(/\./, "")) || m
+          da << month.to_s.rjust(2, "0")
+        end
+        day = d.at("./day")
+        da << day.text.rjust(2, "0") if day
+        on = da.compact.join "-"
+        RelatonBib::BibliographicDate.new type: DATETYPES[d[:datetype]], on: on
+      end
+      pad = doc.at("./publicationinfo/PubApprovalDate")
+      if pad
+        issued = parse_date_string pad.text
+        dates << RelatonBib::BibliographicDate.new(type: "issued", on: issued)
+      end
+      dates
+    end
+
+    #
+    # Convert date string with month name to numeric date
+    #
+    # @param [String] date source date
+    #
+    # @return [String] numeric date
+    #
+    def parse_date_string(date)
+      case date
+      when /^\d{4}$/ then date
+      when /^\d{1,2}\s\w+\.?\s\d{4}/ then Date.parse(date).to_s
+      end
+    end
+
+    #
+    # Parse identifiers
+    #
+    # @return [Array<RelatonBib::DocumentIdentifier>]
+    #
+    def parse_docid
+      ids = [{ id: pubid.to_s, type: "IEEE" }]
+      isbn = doc.at("./publicationinfo/isbn")
+      ids << { id: isbn.text, type: "ISBN" } if isbn
+      doi = doc.at("./volume/article/articleinfo/articledoi")
+      ids << { id: doi.text, type: "DOI" } if doi
+      ids.map do |dcid|
+        RelatonBib::DocumentIdentifier.new(**dcid)
+      end
+    end
+
+    def pubid
+      @pubid ||= begin
+        nt = doc.at("./normtitle").text
+        RawbibIdParser.parse(nt)
+      end
+    end
+
+    #
+    # Parse docnumber
+    #
+    # @return [String] PubID
+    #
+    def docnumber
+      @docnumber ||= pubid&.to_id # doc.at("./publicationinfo/stdnumber").text
+    end
+
+    #
+    # Parse contributors
+    #
+    # @return [Array<RelatonBib::ContributionInfo>]
+    #
+    def parse_contributor # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      doc.xpath("./publicationinfo/publisher").map do |contrib|
+        n = contrib.at("./publishername").text
+        addr = contrib.xpath("./address").map do |a|
+          RelatonBib::Address.new(
+            street: [],
+            city: a.at("./city")&.text,
+            country: a.at("./country").text,
+          )
+        end
+        e = create_org n, addr
+        RelatonBib::ContributionInfo.new entity: e, role: [type: "publisher"]
+      end
+    end
+
+    #
+    # Create organization
+    #
+    # @param [String] name organization's name
+    # @param [Array<Hash>] addr address
+    #
+    # @return [RelatonBib::Organization]
+    def create_org(name, addr = []) # rubocop:disable Metrics/MethodLength
+      case name
+      when "IEEE"
+        abbr = name
+        n = "Institute of Electrical and Electronics Engineers"
+        url = "http://www.ieee.org"
+      when "ANSI"
+        abbr = name
+        n = "American National Standards Institute"
+        url = "https://www.ansi.org"
+      else n = name
+      end
+      RelatonBib::Organization.new(
+        name: n, abbreviation: abbr, url: url, contact: addr,
+      )
+    end
+
+    #
+    # Parse abstract
+    #
+    # @return [Array<RelatonBib::FormattedString>]
+    #
+    def parse_abstract
+      doc.xpath("./volume/article/articleinfo/abstract").map do |a|
+        RelatonBib::FormattedString.new(
+          content: a.text, language: "en", script: "Latn",
+        )
+      end
+    end
+
+    #
+    # Parse copyright
+    #
+    # @return [Array<RelatonBib::CopyrightAssociation>]
+    #
+    def parse_copyright
+      doc.xpath("./publicationinfo/copyrightgroup/copyright").map do |c|
+        owner = c.at("./holder").text.split("/").map do |own|
+          RelatonBib::ContributionInfo.new entity: create_org(own)
+        end
+        RelatonBib::CopyrightAssociation.new(
+          owner: owner, from: c.at("./year").text,
+        )
+      end
+    end
+
+    #
+    # Parse status
+    #
+    # @return [RelatonBib::DocumentStatus]
+    #
+    def parse_status
+      stage = doc.at("./publicationinfo/standard_status").text
+      RelatonBib::DocumentStatus.new stage: stage
+    end
+
+    #
+    # Parse relation
+    #
+    # @return [RelatonBib::DocRelationCollection]
+    #
+    def parse_relation # rubocop:disable Metrics/AbcSize
+      rels = []
+      doc.xpath("./publicationinfo/standard_relationship").each do |r|
+        if (ref = fetcher.backrefs[r.text])
+          rel = fetcher.create_relation(r[:type], ref)
+          rels << rel if rel
+        elsif !/Inactive Date/.match?(r) && docnumber
+          fetcher.add_crossref(docnumber, r)
+        end
+      end
+      RelatonBib::DocRelationCollection.new rels
+    end
+
+    #
+    # Parce link
+    #
+    # @return [Array<RelatonBib::TypedUri>]
+    #
+    def parse_link
+      doc.xpath("./volume/article/articleinfo/amsid").map do |id|
+        l = "https://ieeexplore.ieee.org/document/#{id.text}"
+        RelatonBib::TypedUri.new content: l, type: "src"
+      end
+    end
+
+    #
+    # Parse keyword
+    #
+    # @return [Array<Strign>]
+    #
+    def parse_keyword
+      doc.xpath(
+        "./volume/article/articleinfo/keywordset/keyword/keywordterm",
+      ).map &:text
+    end
+
+    #
+    # Parse ICS
+    #
+    # @return [Array<RelatonBib::ICS>]
+    #
+    def parse_ics
+      doc.xpath("./publicationinfo/icscodes/code_term").map do |ics|
+        RelatonBib::ICS.new code: ics[:codenum], text: ics.text
+      end
+    end
+  end
+end

data/lib/relaton_ieee/hit_collection.rb

@@ -15,7 +15,7 @@ module RelatonIeee
     # @param opts [Hash]
     def initialize(ref) # rubocop:disable Metrics/MethodLength
       super
-      code = ref.sub /^IEEE\s(Std\s)?/, ""
+      code = ref.sub(/^IEEE\s(Std\s)?/, "")
       search = CGI.escape({ data: { searchTerm: code } }.to_json)
       url = "#{DOMAIN}/bin/standards/search?data=#{search}"
       resp = Faraday.get url
@@ -23,7 +23,7 @@ module RelatonIeee
       json = JSON.parse resp_json["message"]
       @array = json["response"]["searchResults"]["resultsMapList"]
         .reduce([]) do |s, hit|
-          /^(?:\w+\s)?(?<id>[A-Z\d\.]+)(-(?<year>\d{4}))?/ =~ hit["record"]["recordTitle"]
+          /^(?:\w+\s)?(?<id>[A-Z\d.]+)(?:-(?<year>\d{4}))?/ =~ hit["record"]["recordTitle"]
           next s unless id && code =~ %r{^#{id}}
 
           s << Hit.new(hit["record"].merge(code: id, year: year.to_i), self)

data/lib/relaton_ieee/ieee_bibliographic_item.rb

@@ -5,7 +5,7 @@ module RelatonIeee
 
     # @param committee [Array<RelatonIeee::Committee>]
     def initialize(**args)
-      @committee = args.delete :committee
+      @committee = args.delete(:committee) || []
       super
     end
 
@@ -13,7 +13,7 @@ module RelatonIeee
     # @return [RelatonIeee::IeeeBibliographicItem]
     def self.from_hash(hash)
       item_hash = ::RelatonIeee::HashConverter.hash_to_bib(hash)
-      new **item_hash
+      new(**item_hash)
     end
 
     # @param opts [Hash]
@@ -22,7 +22,7 @@ module RelatonIeee
     # @option opts [String] :lang language
     # @return [String] XML
     def to_xml(**opts)
-      super **opts do |bldr|
+      super(**opts) do |bldr|
         if opts[:bibdata] && committee.any?
           bldr.ext do |b|
             committee.each { |c| c.to_xml b }
@@ -34,7 +34,7 @@ module RelatonIeee
     # @return [Hash]
     def to_hash
       hash = super
-      hash["committee"] = committee.map &:to_hash
+      hash["committee"] = committee.map &:to_hash if committee.any?
       hash
     end
 

data/lib/relaton_ieee/ieee_bibliography.rb

@@ -19,7 +19,7 @@ module RelatonIeee
         warn "[relaton-ieee] (\"#{code}\") fetching..."
         result = search(code) || (return nil)
         year ||= code.match(/(?<=-)\d{4}/)&.to_s
-        ret = bib_results_filter(result, year)
+        ret = bib_results_filter(result, code, year)
         if ret[:ret]
           item = ret[:ret].fetch
           warn "[relaton-ieee] (\"#{code}\") found #{item.docidentifier.first.id}"
@@ -42,9 +42,13 @@ module RelatonIeee
       # @param opts [Hash] options
       #
       # @return [Hash]
-      def bib_results_filter(result, year)
+      def bib_results_filter(result, ref, year)
+        rp1 = ref_parts ref
         missed_years = []
         result.each do |hit|
+          rp2 = ref_parts hit.hit["recordTitle"]
+          next if rp1[:code] != rp2[:code] || rp1[:corr] != rp2[:corr]
+
           return { ret: hit } if !year
 
           return { ret: hit } if year.to_i == hit.hit[:year]
@@ -54,6 +58,15 @@ module RelatonIeee
         { years: missed_years.uniq }
       end
 
+      def ref_parts(ref)
+        %r{
+          ^(?:IEEE\s(?:Std\s)?)?
+          (?<code>[^-/]+)
+          (?:-(?<year>\d{4}))?
+          (?:/(?<corr>\w+\s\d+-\d{4}))?
+        }x.match ref
+      end
+
       # @param code [Strig]
       # @param year [String]
       # @param missed_years [Array<Strig>]

data/lib/relaton_ieee/processor.rb

@@ -4,11 +4,12 @@ module RelatonIeee
   class Processor < Relaton::Processor
     attr_reader :idtype
 
-    def initialize
+    def initialize # rubocop:disable Lint/MissingSuper
       @short = :relaton_ieee
       @prefix = "IEEE"
       @defaultprefix = %r{^IEEE\s}
       @idtype = "IEEE"
+      @datasets = %w[ieee-rawbib]
     end
 
     # @param code [String]
@@ -19,6 +20,18 @@ module RelatonIeee
       ::RelatonIeee::IeeeBibliography.get(code, date, opts)
     end
 
+    #
+    # Fetch all the documents from ./iee-rawbib directory
+    #
+    # @param [String] _source source name
+    # @param [Hash] opts
+    # @option opts [String] :output directory to output documents
+    # @option opts [String] :format
+    #
+    def fetch_data(_source, opts)
+      DataFetcher.fetch(**opts)
+    end
+
     # @param xml [String]
     # @return [RelatonIeee::IeeeBibliographicItem]
     def from_xml(xml)

data/lib/relaton_ieee/pub_id.rb

@@ -0,0 +1,149 @@
+module RelatonIeee
+  class PubId
+    class Id
+      # @return [String]
+      attr_reader :number
+
+      # @return [String, nil]
+      attr_reader :publisher, :stage, :part, :status, :approval, :edition,
+                  :draft, :rev, :corr, :amd, :redline, :year, :month
+
+      #
+      # PubId constructor
+      #
+      # @param [String] number
+      # @param [<Hash>] **args
+      # @option args [String] :number
+      # @option args [String] :publisher
+      # @option args [String] :stage
+      # @option args [String] :part
+      # @option args [String] :status
+      # @option args [String] :approval
+      # @option args [String] :edition
+      # @option args [String] :draft
+      # @option args [String] :rev
+      # @option args [String] :corr
+      # @option args [String] :amd
+      # @option args [Boolean] :redline
+      # @option args [String] :year
+      # @option args [String] :month
+      #
+      def initialize(number:, **args) # rubocop:disable Metrics/MethodLength
+        @publisher = args[:publisher]
+        @stage = args[:stage]
+        @number = number
+        @part = args[:part]
+        @status = args[:status]
+        @approval = args[:approval]
+        @edition = args[:edition]
+        @draft = args[:draft]
+        @rev = args[:rev]
+        @corr = args[:corr]
+        @amd = args[:amd]
+        @year = args[:year]
+        @month = args[:month]
+        @redline = args[:redline]
+      end
+
+      #
+      # PubId string representation
+      #
+      # @return [String]
+      #
+      def to_s # rubocop:disable Metrics/AbcSize
+        out = number
+        out = "#{stage} #{out}" if stage
+        out = "#{approval} #{out}" if approval
+        out = "#{status} #{out}" if status
+        out = "#{publisher} #{out}" if publisher
+        out += "-#{part}" if part
+        out += edition_to_s + draft_to_s + rev_to_s + corr_to_s + amd_to_s
+        out + year_to_s + month_to_s + redline_to_s
+      end
+
+      def edition_to_s
+        edition ? "/E-#{edition}" : ""
+      end
+
+      def draft_to_s
+        draft ? "/D-#{draft}" : ""
+      end
+
+      def rev_to_s
+        rev ? "/R-#{rev}" : ""
+      end
+
+      def corr_to_s
+        corr ? "/Cor#{corr}" : ""
+      end
+
+      def amd_to_s
+        amd ? "/Amd#{amd}" : ""
+      end
+
+      def year_to_s
+        year ? ".#{year}" : ""
+      end
+
+      def month_to_s
+        month ? "-#{month}" : ""
+      end
+
+      def redline_to_s
+        redline ? " Redline" : ""
+      end
+    end
+
+    # @return [Array<RelatonIeee::PubId::Id>]
+    attr_reader :pubid
+
+    #
+    # IEEE publication id
+    #
+    # @param [Array<Hash>, Hash] pubid
+    #
+    def initialize(pubid)
+      @pubid = array(pubid).map { |id| Id.new(**id) }
+    end
+
+    #
+    # Convert to array
+    #
+    # @param [Array<Hash>, Hash] pid
+    #
+    # @return [Array<Hash>]
+    #
+    def array(pid)
+      pid.is_a?(Array) ? pid : [pid]
+    end
+
+    #
+    # PubId string representation
+    #
+    # @return [String]
+    #
+    def to_s
+      pubid.map(&:to_s).join("/")
+    end
+
+    #
+    # Generate ID without publisher and second number
+    #
+    # @return [String]
+    #
+    def to_id # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      out = pubid[0].to_s
+      if pubid.size > 1
+        out += pubid[1].edition_to_s if pubid[0].edition.nil?
+        out += pubid[1].draft_to_s if pubid[0].draft.nil?
+        out += pubid[1].rev_to_s if pubid[0].rev.nil?
+        out += pubid[1].corr_to_s if pubid[0].corr.nil?
+        out += pubid[1].amd_to_s if pubid[0].amd.nil?
+        out += pubid[1].year_to_s if pubid[0].year.nil?
+        out += pubid[1].month_to_s if pubid[0].month.nil?
+        out += pubid[1].redline_to_s unless pubid[0].redline
+      end
+      out
+    end
+  end
+end