relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/ieee/doctype.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Ieee
+    class Doctype < Bib::Doctype
+      TYPES = %w[guide recommended-practice standard whitepaper redline other].freeze
+
+      attribute :type, :string, values: TYPES
+    end
+  end
+end

data/lib/relaton/ieee/editorial_group.rb

@@ -0,0 +1,19 @@
+require_relative "balloting_group"
+
+module Relaton
+  module Ieee
+    class EditorialGroup < Lutaml::Model::Serializable
+      attribute :society, :string
+      attribute :balloting_group, BallotingGroup
+      attribute :working_group, :string
+      attribute :committee, :string
+
+      xml do
+        map_element "society", to: :society
+        map_element "balloting-group", to: :balloting_group
+        map_element "working-group", to: :working_group
+        map_element "committee", to: :committee
+      end
+    end
+  end
+end

data/lib/relaton/ieee/ext.rb

@@ -0,0 +1,36 @@
+require_relative "doctype"
+
+module Relaton
+  module Ieee
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype
+      attribute :subdoctype, :string, values: %w[amendment corrigendum erratum]
+      attribute :trial_use, :boolean
+      attribute :standard_status, :string, values: %w[Inactive Active Superseded]
+      attribute :standard_modified, :string, values: %w[Draft Withdrawn Superseded Superseded Reserved Redline]
+      attribute :pubstatus, :string, values: %w[Active Inactive]
+      attribute :holdstatus, :string, values: %w[Hold Publish]
+      attribute :program, :string
+
+      xml do
+        map_element "trial-use", to: :trial_use
+        map_element "standard_status", to: :standard_status
+        map_element "standard_modified", to: :standard_modified
+        map_element "pubstatus", to: :pubstatus
+        map_element "holdstatus", to: :holdstatus
+        map_element "program", to: :program
+      end
+
+      key_value do
+        map_element "trial_use", to: :trial_use
+        map_element "standard_status", to: :standard_status
+        map_element "standard_modified", to: :standard_modified
+        map_element "pubstatus", to: :pubstatus
+        map_element "holdstatus", to: :holdstatus
+        map_element "program", to: :program
+      end
+
+      def get_schema_version = Relaton.schema_versions["relaton-model-ieee"]
+    end
+  end
+end

data/lib/relaton/ieee/idams_parser.rb

@@ -0,0 +1,330 @@
+require "cgi"
+require "ieee-idams"
+
+module Relaton
+  module Ieee
+    class IdamsParser
+      include Core::ArrayWrapper
+
+      ATTRS = %i[
+        docnumber title date docidentifier contributor abstract copyright status
+        relation source keyword ext
+      ].freeze
+
+      # Upstream IDAMS abstracts sometimes carry escaped ASCII control
+      # characters as printable tokens like `<<ETX>>`. They are meaningless
+      # in output, and `<<…>>` blows up XML serialization downstream
+      # (libxml2 reads `<<` as the start of a tag). Strip the whole family.
+      CONTROL_PLACEHOLDER_RE = /<<[A-Z]{2,5}>>/.freeze
+
+      def initialize(doc, fetcher, errors = {})
+        @doc = doc
+        @fetcher = fetcher
+        @errors = errors
+      end
+
+      #
+      # Parse IEEE document
+      #
+      # @return [Relaton::Ieee::ItemData] bibliographic item data
+      #
+      def parse
+        args = { type: "standard", language: ["en"], script: ["Latn"] }
+        ATTRS.each { |attr| args[attr] = send("parse_#{attr}") }
+        ItemData.new(**args)
+      end
+
+      def parse_docnumber
+        result = docnumber
+        @errors[:docnumber] &&= result.nil?
+        result
+      end
+
+      #
+      # Parse docnumber
+      #
+      # @return [String, nil] canonical pubid string, or nil when unparseable
+      #
+      def docnumber
+        @docnumber ||= pubid&.to_s
+      end
+
+      #
+      # Resolve the document's IEEE identifier (pubid-first, RawbibIdParser
+      # fallback).
+      #
+      # @return [::Pubid::Ieee::Identifier, nil]
+      #
+      def pubid
+        return @pubid if defined?(@pubid)
+
+        normtitle = @doc.normtitle
+        stdnumber = @doc.publicationinfo.stdnumber
+        pid = RawbibIdParser.parse(normtitle, stdnumber)
+        title = @doc.btitle.find { |t| t[:type] == "main" }&.dig(:content)
+        isbn = @doc.isbn_doi.any? { |id| id[:type] == "ISBN" }
+        fabricated = RawbibIdParser.fabricated_title_id?(pid, title, isbn)
+        @pubid = fabricated ? nil : pid
+      end
+
+      #
+      # Parse title
+      #
+      # @return [Array<Relaton::Bib::Title>]
+      #
+      def parse_title
+        result = @doc.btitle.map { |args| Bib::Title.new(**args) }
+        @errors[:title] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse date
+      #
+      # @return [Array<Relaton::Bib::Date>]
+      #
+      def parse_date
+        result = @doc.bdate.map { |args| Bib::Date.new(type: args[:type], at: args[:on]) }
+        @errors[:date] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse identifiers
+      #
+      # @return [Array<Relaton::Bib::Docidentifier>]
+      #
+      def parse_docidentifier # rubocop:disable Metrics/MethodLength
+        ids = @doc.isbn_doi.map { |id| id[:content] = id.delete(:id); id }
+
+        if pubid
+          ids.unshift(content: pubid.to_s(trademark: true), scope: "trademark", type: "IEEE", primary: true)
+          ids.unshift(content: pubid.to_s, type: "IEEE", primary: true)
+        end
+
+        result = ids.map { |dcid| Bib::Docidentifier.new(**dcid) }
+        @errors[:docidentifier] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse contributors
+      #
+      # @return [Array<Relaton::Bib::Contributor>]
+      #
+      def parse_contributor
+        contributors = []
+
+        # Add publisher contributor
+        name, addr = @doc.contrib_name_addr { |args| Relaton::Bib::Address.new(**args) }
+        org = create_org name, addr
+        role = Bib::Contributor::Role.new type: "publisher"
+        contributors << Relaton::Bib::Contributor.new(organization: org, role: [role])
+
+        # Add committee contributors from editorial group
+        result = contributors + parse_committee_contributors
+        @errors[:contributor] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse committee contributors from editorial group
+      #
+      # @return [Array<Relaton::Bib::Contributor>]
+      #
+      def parse_committee_contributors
+        committees = @doc.editorialgroup
+        return [] unless committees
+
+        result = committees.map do |committee|
+          create_committee_contributor(committee)
+        end
+        @errors[:committee] &&= result.empty?
+        result
+      end
+
+      #
+      # Create a committee contributor
+      #
+      # @param [String] committee committee name
+      #
+      # @return [Relaton::Bib::Contributor]
+      #
+      def create_committee_contributor(committee)
+        desc = Bib::LocalizedMarkedUpString.new(content: "committee", language: "en", script: "Latn")
+        role = Bib::Contributor::Role.new(type: "author", description: [desc])
+
+        # Create IEEE organization with committee as subdivision
+        orgname = Bib::TypedLocalizedString.new(
+          content: "Institute of Electrical and Electronics Engineers", language: "en", script: "Latn"
+        )
+        abbr = Bib::LocalizedString.new(content: "IEEE")
+
+        # Create subdivision for the committee
+        subdiv_name = Bib::TypedLocalizedString.new(content: CGI.unescapeHTML(committee), language: "en", script: "Latn")
+        subdivision = Bib::Subdivision.new(type: "committee", name: [subdiv_name])
+
+        org = Bib::Organization.new(name: [orgname], abbreviation: abbr, subdivision: [subdivision])
+        Relaton::Bib::Contributor.new(organization: org, role: [role])
+      end
+
+      #
+      # Parse abstract
+      #
+      # @return [Array<Relaton::Bib::LocalizedMarkedUpString>]
+      #
+      def parse_abstract
+        result = @doc.volume.article.articleinfo.abstract.each_with_object([]) do |abs, acc|
+          next unless abs.abstract_type == "Standard"
+
+          content = abs.value.gsub(CONTROL_PLACEHOLDER_RE, "").strip
+          next if content.empty?
+
+          acc << Bib::Abstract.new(content: content, language: "en", script: "Latn")
+        end
+        @errors[:abstract] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse copyright
+      #
+      # @return [Array<Relaton::Bib::Copyright>]
+      #
+      def parse_copyright
+        result = @doc.copyright.map do |owner, year|
+          contrib = owner.map { |own| Bib::ContributionInfo.new organization: create_org(own) }
+          Bib::Copyright.new(owner: contrib, from: year)
+        end
+        @errors[:copyright] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse status
+      #
+      # @return [Relaton::Bib::Status, nil]
+      #
+      def parse_status
+        return if @doc.docstatus.nil? || @doc.docstatus.empty?
+
+        @errors[:status] &&= @doc.docstatus[:stage].nil?
+        stage = Bib::Status::Stage.new content: @doc.docstatus[:stage]
+        Bib::Status.new stage: stage
+      end
+
+      #
+      # Parse relation
+      #
+      # @return [Array<Relaton::Bib::Relation>]
+      #
+      def parse_relation # rubocop:disable Metrics/AbcSize
+        result = array(@doc.publicationinfo.standard_relationship).each_with_object([]) do |relation, acc|
+          if (ref = @fetcher.backrefs[relation.date_string])
+            rel = @fetcher.create_relation(relation.type, ref)
+            acc << rel if rel
+          elsif !relation.date_string.include?("Inactive Date") && docnumber
+            @fetcher.add_crossref(docnumber, relation)
+          end
+        end
+        @errors[:relation] &&= result.empty?
+        result
+      end
+
+      #
+      # Parce source link
+      #
+      # @return [Array<Relaton::Bib::Uri>]
+      #
+      def parse_source
+        result = @doc.link { |url| Bib::Uri.new(content: url, type: "src") }
+        @errors[:source] &&= result.empty?
+        result
+      end
+
+      #
+      # Parse keyword
+      #
+      # @return [Array<Strign>]
+      #
+      def parse_keyword
+        result = @doc.keyword.map do |kw|
+          Bib::Keyword.new(vocab: Bib::LocalizedString.new(content: CGI.unescapeHTML(kw), language: "en", script: "Latn"))
+        end
+        @errors[:keyword] &&= result.empty?
+        result
+      end
+
+      private
+
+      #
+      # Create organization
+      #
+      # @param [String] name organization's name
+      # @param [Array<Hash>] addr address
+      #
+      # @return [Relaton::Bib::Organization]
+      def create_org(name, addr = []) # rubocop:disable Metrics/MethodLength
+        case name
+        when "IEEE"
+          abbr = Bib::LocalizedString.new content: name
+          n = "Institute of Electrical and Electronics Engineers"
+          uri = Bib::Uri.new content: "http://www.ieee.org", type: "org"
+        when "ANSI"
+          abbr = Bib::LocalizedString.new content: name
+          n = "American National Standards Institute"
+          uri = Bib::Uri.new content: "https://www.ansi.org", type: "org"
+        else n = name
+        end
+        orgname = Bib::TypedLocalizedString.new(content: n, language: "en", script: "Latn")
+        Bib::Organization.new(name: [orgname], abbreviation: abbr, uri: [uri], address: create_address(addr))
+      end
+
+      def create_address(addr)
+        addr.map { |ad| Bib::Address.new(**ad) }
+      end
+
+      def parse_ext
+        standard_status = @doc.publicationinfo.standard_status
+        standard_modified = @doc.standard_modifier
+        pubstatus = @doc.publicationinfo.pubstatus
+        holdstatus = @doc.publicationinfo.holdstatus
+        @errors[:standard_status] &&= standard_status.nil?
+        @errors[:standard_modified] &&= standard_modified.nil?
+        @errors[:pubstatus] &&= pubstatus.nil?
+        @errors[:holdstatus] &&= holdstatus.nil?
+        Ext.new(
+          doctype: parse_doctype,
+          flavor: "ieee",
+          ics: parse_ics,
+          standard_status: standard_status,
+          standard_modified: standard_modified,
+          pubstatus: pubstatus,
+          holdstatus: holdstatus,
+        )
+      end
+
+      #
+      # Parse doctype
+      #
+      # @return [Relaton::Ieee::Doctype] doctype
+      #
+      def parse_doctype
+        Doctype.new content: @doc.doctype
+      end
+
+      #
+      # Parse ICS
+      #
+      # @return [Array<Relaton::Bib::ICS>]
+      #
+      def parse_ics
+        result = @doc.ics.each_with_object([]) do |ics, acc|
+          acc << Bib::ICS.new(**ics) if ics[:code] && !ics[:code].empty?
+        end
+        @errors[:ics] &&= result.empty?
+        result
+      end
+    end
+  end
+end

data/lib/relaton/ieee/item.rb

@@ -0,0 +1,11 @@
+require_relative "ext"
+
+module Relaton
+  module Ieee
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+    end
+  end
+end

data/lib/relaton/ieee/item_data.rb

@@ -0,0 +1,7 @@
+module Relaton
+  module Ieee
+    class ItemData < Bib::ItemData
+
+    end
+  end
+end

data/lib/relaton/ieee/processor.rb

@@ -0,0 +1,71 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Ieee
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize # rubocop:disable Lint/MissingSuper
+        @short = :relaton_ieee
+        @prefix = "IEEE"
+        @pubid_flavor = :Ieee # global prefixes sourced from Pubid::Ieee.prefixes
+        @defaultprefix = %r{^(?:(?:(?:ANSI|NACE)/)?IEEE|ANSI|AIEE|ASA|NACE|IRE)\s}
+        @idtype = "IEEE"
+        @datasets = %w[ieee-rawbib]
+      end
+
+      # @param code [String]
+      # @param date [String, NilClass] year
+      # @param opts [Hash]
+      # @return [Relaton::Ieee::ItemData, nil]
+      def get(code, date, opts)
+        require_relative "../ieee"
+        Bibliography.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)
+        require_relative "data_fetcher"
+        DataFetcher.fetch(source, **opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Ieee::ItemData]
+      def from_xml(xml)
+        require_relative "../ieee"
+        Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::Ieee::ItemData]
+      def hash_to_bib(yaml)
+        require_relative "../ieee"
+        Item.from_yaml yaml
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../ieee"
+        @grammar_hash ||= Ieee.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../ieee"
+        Relaton::Index.find_or_create(
+          :ieee, url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
+      end
+    end
+  end
+end