relaton-bib 1.20.7 → 2.0.0.pre.alpha.1

data/lib/relaton_bib/renderer/bibxml.rb

@@ -1,296 +0,0 @@
-module RelatonBib
-  module Renderer
-    class BibXML
-      def initialize(bib)
-        @bib = bib
-      end
-
-      #
-      # Render BibXML (RFC)
-      #
-      # @param [Nokogiri::XML::Builder, nil] builder
-      # @param [Boolean] include_keywords (false)
-      #
-      # @return [String, Nokogiri::XML::Builder::NodeBuilder] XML
-      #
-      def render(builder: nil, include_keywords: true)
-        if builder
-          render_bibxml builder, include_keywords
-        else
-          Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
-            render_bibxml xml, include_keywords
-          end.doc.root.to_xml
-        end
-      end
-
-      #
-      # Render BibXML (RFC, BCP)
-      #
-      # @param [Nokogiri::XML::Builder] builder
-      # @param [Boolean] include_bibdata
-      #
-      def render_bibxml(builder, include_keywords) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        target = @bib.link.detect { |l| l.type.casecmp("src").zero? } ||
-          @bib.link.detect { |l| l.type.casecmp("doi").zero? }
-        bxml = if @bib.docnumber&.match(/^BCP/) || (@bib.docidentifier.detect(&:primary)&.id ||
-                    @bib.docidentifier[0].id).include?("BCP")
-                 render_bibxml_refgroup(builder, include_keywords)
-               else
-                 render_bibxml_ref(builder, include_keywords)
-               end
-        bxml[:target] = target.content.to_s if target
-      end
-
-      #
-      # Render BibXML (BCP)
-      #
-      # @param [Nokogiri::XML::Builder] builder
-      # @param [Boolean] include_keywords
-      #
-      def render_bibxml_refgroup(builder, include_keywords)
-        builder.referencegroup(**ref_attrs) do |b|
-          @bib.relation.each do |r|
-            r.bibitem.to_bibxml(b, include_keywords: include_keywords) if r.type == "includes"
-          end
-        end
-      end
-
-      #
-      # Render BibXML (RFC)
-      #
-      # @param [Nokogiri::XML::Builder] builder
-      # @param [Boolean] include_keywords
-      #
-      def render_bibxml_ref(builder, include_keywords) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-        builder.reference(**ref_attrs) do |xml|
-          if @bib.title.any? || @bib.contributor.any? || @bib.date.any? || @bib.abstract.any? ||
-              @bib.editorialgroup&.technical_committee&.any? ||
-              (include_keywords && @bib.keyword.any?)
-            xml.front do
-              xml.title @bib.title[0].title.content if @bib.title.any?
-              render_authors xml
-              render_date xml
-              render_workgroup xml
-              render_keyword xml if include_keywords
-              render_abstract xml
-            end
-          end
-          render_seriesinfo xml
-          render_format xml
-        end
-      end
-
-      #
-      # Create reference attributes
-      #
-      # @return [Hash<Symbol=>String>] attributes
-      #
-      def ref_attrs # rubocop:disable Metrics/AbcSize
-        discopes = %w[anchor docName number]
-        attrs = @bib.docidentifier.each_with_object({}) do |di, h|
-          next unless discopes.include?(di.scope)
-
-          h[di.scope.to_sym] = di.id
-        end
-        return attrs if attrs.any?
-
-        @bib.docidentifier.first&.tap do |di|
-          anchor = di.type == "IANA" ? di.id.split[1..].join(" ").upcase : di.id
-          return { anchor: anchor.gsub(" ", ".") }
-        end
-      end
-
-      #
-      # Render authors
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      #
-      def render_authors(builder) # rubocop:disable Metrics/AbcSize
-        @bib.contributor.each do |c|
-          builder.author do |xml|
-            xml.parent[:role] = "editor" if c.role.detect { |r| r.type == "editor" }
-            if c.entity.is_a?(Person) then render_person xml, c.entity
-            else render_organization xml, c.entity, c.role
-            end
-            render_address xml, c
-          end
-        end
-      end
-
-      #
-      # Render address
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      # @param [RelatonBib::ContributionInfo] contrib contributor
-      #
-      def render_address(builder, contrib) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        address, contact = address_contact contrib.entity.contact
-        if address || contact.any?
-          builder.address do |xml|
-            # address = contrib.entity.contact.detect { |cn| cn.is_a? Address }
-            if address
-              xml.postal do
-                xml.city address.city if address.city
-                xml.code address.postcode if address.postcode
-                xml.country address.country if address.country
-                xml.region address.state if address.state
-                xml.street address.street[0] if address.street.any?
-              end
-            end
-            render_contact xml, contact
-          end
-        end
-      end
-
-      def address_contact(contact) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        addr = contact.detect do |c|
-          c.is_a?(Address) && (c.city || c.postcode || c.country || c.state || c.street.any?)
-        end
-        cont = contact.select { |c| c.is_a?(Contact) }
-        [addr, cont]
-      end
-
-      #
-      # Render contact
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      # @param [Array<RelatonBib::Address, RelatonBib::Contact>] addr contact
-      #
-      def render_contact(builder, addr)
-        %w[phone email uri].each do |type|
-          cont = addr.detect { |cn| cn.is_a?(Contact) && cn.type == type }
-          builder.send type, cont.value if cont
-        end
-      end
-
-      #
-      # Render person
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      # @param [RelatonBib::Person] person person
-      #
-      def render_person(builder, person) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        render_organization builder, person.affiliation.first&.organization
-        if person.name.completename
-          builder.parent[:fullname] = person.name.completename.content
-        elsif person.name.forename.any?
-          builder.parent[:fullname] = person.name.forename.map do |n|
-            n.content || n.initial
-          end.join " "
-        end
-        if person.name.initials
-          builder.parent[:initials] = person.name.initials.content
-        elsif person.name.forename.any?
-          builder.parent[:initials] = person.name.forename.map do |f|
-            "#{f.initial || f.content[0]}."
-          end.join
-        end
-        if person.name.surname
-          if !person.name.completename && person.name.forename.any? && person.name.surname
-            builder.parent[:fullname] += " #{person.name.surname}"
-          end
-          builder.parent[:surname] = person.name.surname.content
-        end
-      end
-
-      #
-      # Render organization
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      # @param [RelatonBib::Organization] org organization
-      #
-      def render_organization(builder, org, _role = []) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/AbcSize
-        abbrev = org&.abbreviation&.content
-        orgname = org&.name&.first&.content
-        orgname = if BibXMLParser::ORGNAMES.key?(abbrev) then abbrev
-                  else BibXMLParser::ORGNAMES.key(orgname) || orgname || abbrev
-                  end
-        # if role.detect { |r| r.description.detect { |d| d.content == "BibXML author" } }
-        #   builder.parent[:fullname] = orgname
-        # else
-        org = builder.organization orgname
-        org[:abbrev] = abbrev if abbrev
-        # end
-      end
-
-      #
-      # Render date
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      #
-      def render_date(builder) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
-        dt = @bib.date.detect { |d| d.type == "published" }
-        return unless dt
-
-        elm = builder.date
-        y = dt.on(:year) || dt.from(:year) || dt.to(:year)
-        elm[:year] = y if y
-        m = dt.on(:month) || dt.from(:month) || dt.to(:month)
-        elm[:month] = Date::MONTHNAMES[m] if m
-        # rfcs = %w[RFC BCP FYI STD]
-        # unless rfcs.include?(doctype) && docidentifier.detect { |di| rfcs.include? di.type }
-        d = dt.on(:day) || dt.from(:day) || dt.to(:day)
-        elm[:day] = d if d
-        # end
-      end
-
-      #
-      # Render workgroup
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      #
-      def render_workgroup(builder)
-        @bib.editorialgroup&.technical_committee&.each do |tc|
-          builder.workgroup tc.workgroup.name
-        end
-      end
-
-      #
-      # Render keyword
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      #
-      def render_keyword(builder)
-        @bib.keyword.each { |kw| builder.keyword kw.content }
-      end
-
-      #
-      # Render abstract
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      #
-      def render_abstract(builder)
-        return unless @bib.abstract.any?
-
-        builder.abstract { |xml| xml << @bib.abstract[0].content.gsub(/(<\/?)p(>)/, '\1t\2') }
-      end
-
-      #
-      # Render seriesinfo
-      #
-      # @param [Nokogiri::XML::Builder] builder xml builder
-      #
-      def render_seriesinfo(builder) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-        @bib.docidentifier.each do |di|
-          if BibXMLParser::SERIESINFONAMES.include?(di.type) && di.scope != "trademark"
-            builder.seriesInfo(name: di.type, value: di.id)
-          end
-        end
-        # di_types = docidentifier.map(&:type)
-        @bib.series.select do |s|
-          s.title && # !di_types.include?(s.title.title.to_s) &&
-            !BibXMLParser::SERIESINFONAMES.include?(s.title.title.to_s)
-        end.uniq { |s| s.title.title.to_s }.each do |s|
-          si = builder.seriesInfo(name: s.title.title.to_s)
-          si[:value] = s.number if s.number
-        end
-      end
-
-      def render_format(builder)
-        @bib.link.select { |l| l.type == "TXT" }.each do |l|
-          builder.format type: l.type, target: l.content
-        end
-      end
-    end
-  end
-end

data/lib/relaton_bib/series.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-module RelatonBib
-  #
-  # Series class.
-  #
-  class Series
-    # TYPES = %w[main alt].freeze
-
-    # @return [String, nil] allowed values: "main" or "alt"
-    attr_reader :type
-
-    # @return [RelatonBib::FormattedRef, nil]
-    attr_reader :formattedref
-
-    # @return [RelatonBib::TypedTitleString] title
-    attr_reader :title
-
-    # @return [String, nil]
-    attr_reader :place, :organization, :from, :to, :number, :partnumber, :run
-
-    # @return [RelatonBib::LocalizedString, nil]
-    attr_reader :abbreviation
-
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-
-    # @param type [String, nil]
-    # @param formattedref [RelatonBib::FormattedRef, nil]
-    # @param title [RelatonBib::TypedTitleString] title
-    # @param place [String, nil]
-    # @param orgaization [String, nil]
-    # @param abbreviation [RelatonBib::LocalizedString, nil]
-    # @param from [String, nil]
-    # @param to [String, nil]
-    # @param number [String, nil]
-    # @param partnumber [String, nil]
-    # @param run [String, nil]
-    def initialize(**args)
-      unless args[:title].is_a?(RelatonBib::TypedTitleString)
-        raise ArgumentError, "argument `title` should present in series"
-      end
-
-      # if args[:type] && !TYPES.include?(args[:type])
-      #   warn "[relaton-bib] Series type is invalid: #{args[:type]}"
-      # end
-
-      @type         = args[:type] # if %w[main alt].include? args[:type]
-      @title        = args[:title]
-      @formattedref = args[:formattedref]
-      @place        = args[:place]
-      @organization = args[:organization]
-      @abbreviation = args[:abbreviation]
-      @from         = args[:from]
-      @to           = args[:to]
-      @number       = args[:number]
-      @partnumber   = args[:partnumber]
-      @run          = args[:run]
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder) # rubocop:disable Metrics/MethodLength
-      xml = builder.series do
-        formattedref&.to_xml builder
-        builder.title { title.to_xml builder }
-        builder.place place if place
-        builder.organization organization if organization
-        builder.abbreviation { abbreviation.to_xml builder } if abbreviation
-        builder.from from if from
-        builder.to to if to
-        builder.number number if number
-        builder.partnumber partnumber if partnumber
-        builder.run run if run
-      end
-      xml[:type] = type if type
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    # @return [Hash]
-    def to_hash # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
-      hash = {}
-      hash["type"] = type if type
-      hash["formattedref"] = formattedref.to_hash if formattedref
-      hash["title"] = title.to_hash
-      hash["place"] = place if place
-      hash["organization"] = organization if organization
-      hash["abbreviation"] = abbreviation.to_hash if abbreviation
-      hash["from"] = from if from
-      hash["to"] = to if to
-      hash["number"] = number if number
-      hash["partnumber"] = partnumber if partnumber
-      hash["run"] = run if run
-      hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer]
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
-      pref = prefix.empty? ? "series" : prefix + ".series"
-      out = count > 1 ? "#{pref}::\n" : ""
-      out += "#{pref}.type:: #{type}\n" if type
-      out += formattedref.to_asciibib pref if formattedref
-      out += title.to_asciibib pref
-      out += "#{pref}.place:: #{place}\n" if place
-      out += "#{pref}.organization:: #{organization}\n" if organization
-      out += abbreviation.to_asciibib "#{pref}.abbreviation" if abbreviation
-      out += "#{pref}.from:: #{from}\n" if from
-      out += "#{pref}.to:: #{to}\n" if to
-      out += "#{pref}.number:: #{number}\n" if number
-      out += "#{pref}.partnumber:: #{partnumber}\n" if partnumber
-      out += "#{pref}.run:: #{run}\n" if run
-      out
-    end
-  end
-end

data/lib/relaton_bib/structured_identifier.rb

@@ -1,173 +0,0 @@
-module RelatonBib
-  class StructuredIdentifierCollection
-    include RelatonBib
-    extend Forwardable
-
-    def_delegators :@collection, :any?, :size, :[], :detect, :map, :each,
-                   :reduce
-
-    # @param collection [Array<RelatonBib::StructuredIdentifier>]
-    def initialize(collection)
-      @collection = collection
-    end
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      @collection.each { |si| si.to_xml builder }
-    end
-
-    # @return [Array<Hash>]
-    def to_hash
-      single_element_array @collection
-    end
-
-    # @param prefix [String]
-    # @return [String]
-    def to_asciibib(prefix = "")
-      pref = prefix.empty? ? prefix : prefix + "."
-      pref += "structured_identifier"
-      @collection.reduce("") do |out, si|
-        out += "#{pref}::\n" if @collection.size > 1
-        out + si.to_asciibib(pref)
-      end
-    end
-
-    # remoe year from docnumber
-    def remove_date
-      @collection.each &:remove_date
-    end
-
-    def remove_part
-      @collection.each &:remove_part
-    end
-
-    def all_parts
-      @collection.each &:all_parts
-    end
-
-    def presence?
-      any?
-    end
-
-    # @return [RelatonBib::StructuredIdentifierCollection]
-    # def map(&block)
-    #   StructuredIdentifierCollection.new @collection.map &block
-    # end
-  end
-
-  class StructuredIdentifier
-    include RelatonBib
-
-    # @return [String]
-    attr_reader :docnumber
-
-    # @return [Array<String>]
-    attr_reader :agency
-
-    # @return [String, nil]
-    attr_reader :type, :klass, :partnumber, :edition, :version, :supplementtype,
-                :supplementnumber, :language, :year
-
-    # rubocop:disable Metrics/MethodLength
-
-    # @param docnumber [String]
-    # @param args [Hash]
-    # @option args [String, nil] :type
-    # @option args [Array<String>] :agency
-    # @option args [Stirng, nil] :class
-    # @option args [String, nil] :partnumber
-    # @option args [String, nil] :edition
-    # @option args [String, nil] :version
-    # @option args [String, nil] :supplementtype
-    # @option args [String, nil] :supplementnumber
-    # @option args [String, nil] :language
-    # @option args [String, nil] :year
-    def initialize(docnumber:, **args)
-      @type = args[:type]
-      @agency = args[:agency]
-      @klass = args[:class]
-      @docnumber = docnumber
-      @partnumber = args[:partnumber]
-      @edition = args[:edition]
-      @version = args[:version]
-      @supplementtype = args[:supplementtype]
-      @supplementnumber = args[:supplementnumber]
-      @language = args[:language]
-      @year = args[:year]
-    end
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      xml = builder.structuredidentifier do |b|
-        agency&.each { |a| b.agency a }
-        b.class_ klass if klass
-        b.docnumber docnumber
-        b.partnumber partnumber if partnumber
-        b.edition edition if edition
-        b.version version if version
-        b.supplementtype supplementtype if supplementtype
-        b.supplementnumber supplementnumber if supplementnumber
-        b.language language if language
-        b.year year if year
-      end
-      xml[:type] = type if type
-    end
-
-    # @return [Hash]
-    def to_hash
-      hash = { "docnumber" => docnumber }
-      hash["type"] = type if type
-      hash["agency"] = single_element_array agency if agency&.any?
-      hash["class"] = klass if klass
-      hash["partnumber"] = partnumber if partnumber
-      hash["edition"] = edition if edition
-      hash["version"] = version if version
-      hash["supplementtype"] = supplementtype if supplementtype
-      hash["supplementnumber"] = supplementnumber if supplementnumber
-      hash["language"] = language if language
-      hash["year"] = year if year
-      hash
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-    # @param prefix [String]
-    # @return [String]
-    def to_asciibib(prefix) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
-      out = "#{prefix}.docnumber:: #{docnumber}\n"
-      agency.each { |a| out += "#{prefix}.agency:: #{a}\n" }
-      out += "#{prefix}.type:: #{type}\n" if type
-      out += "#{prefix}.class:: #{klass}\n" if klass
-      out += "#{prefix}.partnumber:: #{partnumber}\n" if partnumber
-      out += "#{prefix}.edition:: #{edition}\n" if edition
-      out += "#{prefix}.version:: #{version}\n" if version
-      out += "#{prefix}.supplementtype:: #{supplementtype}\n" if supplementtype
-      if supplementnumber
-        out += "#{prefix}.supplementnumber:: #{supplementnumber}\n"
-      end
-      out += "#{prefix}.language:: #{language}\n" if language
-      out += "#{prefix}.year:: #{year}\n" if year
-      out
-    end
-
-    def remove_date
-      if @type == "Chinese Standard"
-        @docnumber.sub!(/-[12]\d\d\d/, "")
-      else
-        @docnumber.sub!(/:[12]\d\d\d/, "")
-      end
-      @year = nil
-    end
-
-    # in docid manipulations, assume ISO as the default: id-part:year
-    def remove_part
-      @partnumber = nil
-      @docnumber = @docnumber.sub(/-\d+/, "")
-    end
-
-    def all_parts
-      @docnumber = @docnumber + " (all parts)"
-    end
-  end
-end

data/lib/relaton_bib/technical_committee.rb

@@ -1,34 +0,0 @@
-require "relaton_bib/workgroup"
-
-module RelatonBib
-  class TechnicalCommittee
-    # @return [RelatonBib::WorkGroup]
-    attr_reader :workgroup
-
-    # @param workgroup [RelatonBib::WorkGroup]
-    def initialize(workgroup)
-      @workgroup = workgroup
-    end
-
-    # @param builder [Nokogiri::XML::Builder]
-    def to_xml(builder)
-      builder.send(:"technical-committee") { |b| workgroup.to_xml b }
-    end
-
-    # @return [Hash]
-    def to_hash
-      workgroup.to_hash
-    end
-
-    # @param prefix [String]
-    # @param count [Integer] number of technical committees
-    # @return [String]
-    def to_asciibib(prefix = "", count = 1)
-      pref = prefix.empty? ? prefix : "#{prefix}."
-      pref += "technical_committee"
-      out = count > 1 ? "#{pref}::\n" : ""
-      out += workgroup.to_asciibib pref
-      out
-    end
-  end
-end