relaton-bib 1.9.2 → 1.9.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 159e7430eaae042b7130807811e748afeede73d727c865d06a3acedd03e5de08
-  data.tar.gz: 69c3efa7687a851d14aee6a22878b4359928eb692371313384f4332bd1dee068
+  metadata.gz: 04d616ee7971147c734b6e0520531c4e9b529e76b53c22a98dca1c36b6f49285
+  data.tar.gz: 2762c1d26b7a07888c3605939ae18de1b6f2ef44da7f1513dc779e3207ff176f
 SHA512:
-  metadata.gz: 02bc4eceac45f0e63be85121b73a68db0c66625b917d108a5ebde58a6e975373a0e95f9e2b30a056f1551de18357cfeb49c89804758385cbf5e324513fe6037c
-  data.tar.gz: b2cebd03f70db311a4839c4543f02d2011dbed485d79c7823023dd088381424fc9070bf885cd5232d8eef6841c8d8fdd7cb434d61ba93b9c8457635684cbc601
+  metadata.gz: beffce777ed3ef33181363edaf57a8e1efced984bcc19ffae88eaa8087a92e48d044b042686dc4b5e6e545f41fe7f67c1eb573abaddc4e056adc439643f0b12a
+  data.tar.gz: 44d2809601f70d17db2f5601a29614720fa13a0cfa3fbb1665406e0c4396390862688fc41cbd26de421e19efb5643a61e184b73bf2cb47be567c7aa4788ad4a4

data/README.adoc

@@ -366,6 +366,18 @@ RelatonBib::BibliographicItem.from_hash hash
 ...
 ----
 
+=== Create bibliographic item from BibXML
+
+[source,ruby]
+----
+bibxml = File.read "spec/examples/rfc.xml"
+=> <reference anchor=...
+
+RelatonBib::BibXMLParser.parse bibxml
+=> #<RelatonBib::BibliographicItem:0x00007f9d0c75b268
+...
+----
+
 === Export bibliographic item to Hash
 
 [source,ruby]
@@ -416,6 +428,45 @@ title.format:: text/plain
 ...
 ----
 
+=== Export bibliographic item to BibXML (RFC)
+
+[source,ruby]
+----
+item.to_bibxml
+<reference anchor="ISOTC211" target="https://www.iso.org/standard/53798.html">
+  <front>
+    <title>Geographic information</title>
+    <seriesInfo name="DOI" value="10.17487/rfc1149"/>
+    <seriesInfo name="Internet-Draft" value="draft-ietf-somewg-someprotocol-07"/>
+    <seriesInfo name="RFC" value="4"/>
+    <author>
+      <organization abbrev="ISO">International Organization for Standardization</organization>
+    </author>
+    <author fullname="A. Bierman">
+      <organization abbrev="IETF">IETF</organization>
+      <address>
+        <postal>123456</postal>
+        <phone>223322</phone>
+      </address>
+    </author>
+    <author role="editor">
+      <organization abbrev="IETF">IETF</organization>
+    </author>
+    <author initials="A." surname="Bierman">
+      <organization abbrev="IETF">IETF</organization>
+      <address>
+        <postal>123456</postal>
+        <phone>223322</phone>
+      </address>
+    </author>
+    <author>
+      <organization>Institution</organization>
+    </author>
+    <date year="2014" month="April" day="1"/>
+  </front>
+</reference>
+----
+
 == Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -429,4 +480,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/metano
 == License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-

data/lib/relaton_bib/bibliographic_item.rb

@@ -325,6 +325,23 @@ module RelatonBib
       end
     end
 
+    #
+    # Render BibXML (RFC)
+    #
+    # @param [Nokogiri::XML::Builder, nil] builder
+    #
+    # @return [String] <description>
+    #
+    def to_bibxml(builder = nil)
+      if builder
+        render_bibxml builder
+      else
+        Nokogiri::XML::Builder.new(encoding: "UTF-8") do |xml|
+          render_bibxml xml
+        end
+      end.doc.root.to_xml
+    end
+
     # @return [Hash]
     def to_hash # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       hash = {}
@@ -740,8 +757,155 @@ module RelatonBib
       xml[:type] = type if type
       xml
     end
+    # rubocop:enable Style/NestedParenthesizedCalls, Metrics/BlockLength
+
+    #
+    # Render BibXML (RFC)
+    #
+    # @param [Nokogiri::XML::Builder] builder
+    #
+    def render_bibxml(builder)
+      target = link.detect { |l| l.type == "src" } || link.detect { |l| l.type == "doi" }
+      bxml = builder.reference(anchor: anchor) do |xml|
+        xml.front do
+          xml.title title[0].title.content if title.any?
+          render_seriesinfo xml
+          render_authors xml
+          render_date xml
+          render_workgroup xml
+          render_keyword xml
+          render_abstract xml
+        end
+      end
+      bxml[:target] = target.content.to_s if target
+    end
+
+    def anchor
+      did = docidentifier.detect { |di| di.type == "rfc-anchor" }
+      return did.id if did
+
+      type = docidentifier[0].type
+      "#{type}.#{docnumber}"
+    end
+
+    def render_keyword(builder)
+      keyword.each do |kw|
+        builder.keyword kw.content
+      end
+    end
+
+    def render_workgroup(builder)
+      editorialgroup&.technical_committee&.each do |tc|
+        builder.workgroup tc.workgroup.name
+      end
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    def render_abstract(builder)
+      return unless abstract.any?
+
+      builder.abstract { |xml| xml << abstract[0].content.gsub(/(<\/?)p(>)/, '\1t\2') }
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    def render_date(builder)
+      dt = 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
+      d = dt.on(:day) || dt.from(:day) || dt.to(:day)
+      elm[:day] = d if d
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    def render_seriesinfo(builder)
+      docidentifier.each do |di|
+        if BibXMLParser::SERIESINFONAMES.include? di.type
+          builder.seriesInfo(name: di.type, value: di.id)
+        end
+      end
+      snames = ["ANSI", "BCP", "RFC", "STD"]
+      series.each do |s|
+        next unless s.title && snames.include?(s.title.title.to_s)
+
+        si = builder.seriesInfo(name: s.title.title.to_s)
+        si[:value] = s.number if s.number
+      end
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    def render_authors(builder)
+      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
+          end
+          render_address xml, c
+        end
+      end
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [RelatonBib::ContributionInfo] contrib
+    def render_address(builder, contrib)
+      # addr = contrib.entity.contact.reject do |cn|
+      #   cn.is_a?(Address) && cn.postcode.nil?
+      # end
+      if contrib.entity.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, contrib.entity.contact
+        end
+      end
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [Array<RelatonBib::Address, RelatonBib::Contact>] addr
+    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
+
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [RelatonBib::Person] person
+    def render_person(builder, person)
+      render_organization builder, person.affiliation.first&.organization
+      if person.name.completename
+        builder.parent[:fullname] = person.name.completename
+      end
+      if person.name.initial.any?
+        builder.parent[:initials] = person.name.initial.map(&:content).join
+      end
+      if person.name.surname
+        builder.parent[:surname] = person.name.surname
+      end
+    end
+
+    # @param [Nokogiri::XML::Builder] builder
+    # @param [RelatonBib::Organization] org
+    def render_organization(builder, org)
+      return unless org
+
+      o = builder.organization org.name.first&.content
+      o[:abbrev] = org.abbreviation.content if org.abbreviation
+    end
     # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-    # rubocop:enable Style/NestedParenthesizedCalls, Metrics/BlockLength
   end
 end

data/lib/relaton_bib/bibxml_parser.rb

@@ -0,0 +1,345 @@
+module RelatonBib
+  module BibXMLParser
+    SERIESINFONAMES = ["DOI", "Internet-Draft"].freeze
+    FLAVOR = nil
+
+    def parse(bibxml, url: nil, is_relation: false, ver: nil)
+      doc = Nokogiri::XML bibxml
+      fetch_rfc doc.at("/referencegroup", "/reference"), url: url, is_relation: is_relation, ver: ver
+    end
+
+    # @param reference [Nokogiri::XML::Element, nil]
+    # @param is_relation [Boolean] don't add fetched date for relation if true
+    # @param url [String, nil]
+    # @param ver [String, nil] Internet Draft version
+    # @return [RelatonBib::BibliographicItem]
+    def fetch_rfc(reference, is_relation: false, url: nil, ver: nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      return unless reference
+
+      hash = {
+        is_relation: is_relation,
+        docnumber: docnumber(reference),
+        type: "standard",
+        docid: docids(reference, ver),
+        status: status(reference),
+        language: [language(reference)],
+        script: ["Latn"],
+        link: link(reference, url, ver),
+        title: titles(reference),
+        formattedref: formattedref(reference),
+        abstract: abstracts(reference),
+        contributor: contributors(reference),
+        relation: relations(reference),
+        date: dates(reference),
+        editorialgroup: editorialgroup(reference),
+        series: series(reference),
+        keyword: reference.xpath("front/keyword").map(&:text),
+        doctype: doctype(reference[:anchor]),
+      }
+      # hash[:fetched] = Date.today.to_s unless is_relation
+      bib_item(**hash)
+    end
+
+    def docnumber(reference)
+      reference[:anchor]&.sub(/^\w+\./, "")
+    end
+
+    # @param attrs [Hash]
+    # @return [RelatonBib::IetfBibliographicItem]
+    def bib_item(**attrs)
+      # attrs[:place] = ["Fremont, CA"]
+      BibliographicItem.new(**attrs)
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [String]
+    def language(reference)
+      reference[:lang] || "en"
+    end
+
+    #
+    # Extract document identifiers from reference
+    #
+    # @param reference [Nokogiri::XML::Element]
+    # @param ver [String, nil] Internet Draft version
+    #
+    # @return [Array<RelatonBib::DocumentIdentifier>]
+    #
+    def docids(reference, ver) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize
+      ret = []
+      sfid = reference.at("./seriesInfo[@name='#{self::FLAVOR}']", "./front/seriesInfo[@name='#{self::FLAVOR}']")
+      if sfid
+        ret << DocumentIdentifier.new(type: sfid[:name], id: sfid[:value])
+      elsif self::FLAVOR && (id = (reference[:anchor] || reference[:docName] || reference[:number]))
+        ret << DocumentIdentifier.new( type: self::FLAVOR, id: id.sub(/^(RFC)/, "\\1 "))
+      end
+      if (id = reference[:anchor])
+        ret << DocumentIdentifier.new(type: "rfc-anchor", id: id)
+      end
+      ret + reference.xpath("./seriesInfo", "./front/seriesInfo").map do |si|
+        next unless SERIESINFONAMES.include? si[:name]
+
+        id = si[:value]
+        id.sub!(/(?<=-)\d{2}$/, ver) if ver && si[:name] == "Internet-Draft"
+        DocumentIdentifier.new(id: id, type: si[:name])
+      end.compact
+    end
+
+    #
+    # extract status
+    # @param reference [Nokogiri::XML::Element]
+    #
+    # @return [RelatonBib::DocumentStatus]
+    #
+    def status(reference)
+      st = reference.at("./seriesinfo[@status]")
+      DocumentStatus.new(stage: st[:status]) if st
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @param url [String]
+    # @param ver [String, nil] Internet Draft version
+    # @return [Array<Hash>]
+    def link(reference, url, ver)
+      l = []
+      l << { type: "xml", content: url } if url
+      l << { type: "src", content: reference[:target] } if reference[:target]
+      if /^I-D/.match? reference[:anchor]
+        reference.xpath("format").each do |f|
+          c = ver ? f[:target].sub(/(?<=-)\d{2}(?=\.)/, ver) : f[:target]
+          l << { type: f[:type], content: c }
+        end
+      end
+      l
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<Hash>]
+    def titles(reference)
+      reference.xpath("./front/title").map do |title|
+        { content: title.text, language: language(reference), script: "Latn" }
+      end
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [RelatonBib::FormattedRef, nil]
+    def formattedref(reference)
+      return if reference.at "./front/title"
+
+      cont = (reference[:anchor] || reference[:docName] || reference[:number])
+      if cont
+        FormattedRef.new(
+          content: cont, language: language(reference), script: "Latn",
+        )
+      end
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<RelatonBib::FormattedString>]
+    def abstracts(ref)
+      ref.xpath("./front/abstract").map do |a|
+        FormattedString.new(
+          content: a.children.to_s.gsub(/(<\/?)t(>)/, '\1p\2'),
+          language: language(ref), script: "Latn", format: "text/html"
+        )
+      end
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<Hash>]
+    def contributors(reference)
+      reference.xpath("./front/author").map do |contrib|
+        if contrib[:fullname] || contrib[:surname] then person(contrib, reference)
+        else organization(contrib)
+        end
+      end.compact
+      # persons(reference) + organizations(reference)
+    end
+
+    # @param author [Nokogiri::XML::Element]
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<Hash{Symbol=>RelatonBib::Person,Symbol=>Array<String>}>]
+    def person(author, reference)
+      # reference.xpath("./front/author[@surname]|./front/author[@fullname]")
+      #   .map do |author|
+      entity = Person.new(
+        name: full_name(author, reference),
+        affiliation: affiliation(author),
+        contact: contacts(author.at("./address")),
+      )
+      { entity: entity, role: [contributor_role(author)] }
+      # end
+    end
+
+    # @param contrib [Nokogiri::XML::Element]
+    # @return [Array<Hash{Symbol=>RelatonBib::Organization,
+    #   Symbol=>Array<String>}>]
+    def organization(contrib)
+      # publisher = { entity: new_org, role: [type: "publisher"] }
+      # orgs = reference.xpath("./seriesinfo").reduce([]) do |mem, si|
+      #   next mem unless si[:stream]
+
+      #   mem << { entity: new_org(si[:stream], nil), role: [type: "author"] }
+      # end
+      # orgs + reference.xpath(
+      #   "front/author[not(@surname)][not(@fullname)]/organization",
+      # ).map do |org|
+      org = contrib.at("./organization")
+      { entity: new_org(org.text, org[:abbrev]), role: [contributor_role(contrib)] }
+      # end
+    end
+
+    # @param author [Nokogiri::XML::Element]
+    # @param reference [Nokogiri::XML::Element]
+    # @return [RelatonBib::FullName]
+    def full_name(author, reference)
+      lang = language reference
+      FullName.new(
+        completename: localized_string(author[:fullname], lang),
+        initial: [localized_string(author[:initials], lang)].compact,
+        surname: localized_string(author[:surname], lang),
+      )
+    end
+
+    # @param author [Nokogiri::XML::Element]
+    # @return [Array<RelatonBib::Affiliation>]
+    def affiliation(author)
+      o = author.at("./organization")
+      return [] if o.nil? || o.text.empty?
+
+      org = new_org o.text, o[:abbrev]
+      [Affiliation.new(organization: org)]
+    end
+
+    # @param name [String]
+    # @param abbr [String]
+    # @return [RelatonBib::Organization]
+    def new_org(name, abbr)
+      # (name = "Internet Engineering Task Force", abbr = "IETF")
+      Organization.new name: name, abbreviation: abbr
+    end
+
+    # @param content [String, nil]
+    # @param lang [String, nil]
+    # @return [RelatonBib::LocalizedString, nil]
+    def localized_string(content, lang)
+      LocalizedString.new(content, lang) if content
+    end
+
+    # @param postal [Nokogiri::XML::Element]
+    # @return [Array<RelatonBib::Address, RelatonBib::Phone>]
+    def contacts(addr)
+      conts = []
+      return conts unless addr
+
+      postal = addr.at("./postal")
+      conts << address(postal) if postal
+      add_contact(conts, "phone", addr.at("./phone"))
+      add_contact(conts, "email", addr.at("./email"))
+      add_contact(conts, "uri", addr.at("./uri"))
+      conts
+    end
+
+    # @param postal [Nokogiri::XML::Element]
+    # @rerurn [RelatonBib::Address]
+    def address(postal) # rubocop:disable Metrics/CyclomaticComplexity
+      street = [
+        (postal.at("./postalLine") || postal.at("./street"))&.text
+      ].compact
+      Address.new(
+        street: street,
+        city: postal.at("./city")&.text,
+        postcode: postal.at("./code")&.text,
+        country: postal.at("./country")&.text,
+        state: postal.at("./region")&.text,
+      )
+    end
+
+    # @param conts [Array<RelatonBib::Address, RelatonBib::Contact>]
+    # @param type [String] allowed "phone", "email" or "uri"
+    # @param value [String]
+    def add_contact(conts, type, value)
+      conts << Contact.new(type: type, value: value.text) if value
+    end
+
+    # @param author [Nokogiri::XML::Document]
+    # @return [Hash]
+    def contributor_role(author)
+      { type: author[:role] || "author" }
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Hash]
+    def relations(reference)
+      reference.xpath("reference").map do |ref|
+        { type: "includes", bibitem: fetch_rfc(ref, is_relation: true) }
+      end
+    end
+
+    #
+    # Extract date from reference.
+    #
+    # @param reference [Nokogiri::XML::Element]
+    # @return [Array<RelatonBib::BibliographicDate>] published data.
+    #
+    def dates(reference)
+      return unless (date = reference.at "./front/date")
+
+      d = [date[:year], month(date[:month]), (date[:day] || 1)].compact.join "-"
+      date = Time.parse(d).strftime "%Y-%m-%d"
+      [BibliographicDate.new(type: "published", on: date)]
+    end
+
+    # @param reference [Nokogiri::XML::Element]
+    # @return [RelatonBib::EditorialGroup, nil]
+    def editorialgroup(reference)
+      tc = reference.xpath("./front/workgroup").map do |ed|
+        wg = WorkGroup.new name: ed.text
+        committee wg
+      end
+      EditorialGroup.new tc if tc.any?
+    end
+
+    # @param [RelatonBib::WorkGroup]
+    # @return [RelatonBib::TechnicalCommittee]
+    def committee(wgr)
+      TechnicalCommittee.new wgr
+    end
+
+    def month(mon)
+      return 1 if !mon || mon.empty?
+      return mon if /^\d+$/.match? mon
+
+      Date::MONTHNAMES.index(mon)
+    end
+
+    #
+    # Extract series form reference
+    # @param reference [Nokogiri::XML::Element]
+    #
+    # @return [Array<RelatonBib::Series>]
+    #
+    def series(reference)
+      reference.xpath("./seriesInfo", "./front/seriesInfo").map do |si|
+        next if si[:name] == "DOI" || si[:stream] || si[:status]
+
+        t = TypedTitleString.new(
+          content: si[:name], language: language(reference), script: "Latn",
+        )
+        Series.new(title: t, number: si[:value], type: "main")
+      end.compact
+    end
+
+    # @param anchor [String]
+    # @return [String]
+    def doctype(anchor)
+      case anchor
+      when /I-D/ then "internet-draft"
+      when /IEEE/ then "ieee"
+      else "rfc"
+      end
+    end
+
+    extend BibXMLParser
+  end
+end

data/lib/relaton_bib/contributor.rb

@@ -138,7 +138,7 @@ module RelatonBib
         desc = description.select { |d| d.language&.include? opts[:lang] }
         desc = description unless desc.any?
         desc.each { |d| builder.description { d.to_xml builder } }
-        organization.to_xml **opts
+        organization.to_xml(**opts)
       end
     end
 

data/lib/relaton_bib/editorial_group.rb

@@ -7,7 +7,7 @@ module RelatonBib
     # @return [Array<RelatonBib::TechnicalCommittee>]
     attr_accessor :technical_committee
 
-    # @param technical_committee [Array<RelatonBib::TecnicalCommittee>]
+    # @param technical_committee [Array<RelatonBib::TechnicalCommittee>]
     def initialize(technical_committee)
       @technical_committee = technical_committee
     end

data/lib/relaton_bib/localized_string.rb

@@ -56,7 +56,7 @@ module RelatonBib
       else
         builder.parent["language"] = language.join(",") if language&.any?
         builder.parent["script"]   = script.join(",") if script&.any?
-        builder.text content.encode(xml: :text)
+        builder.parent << content # .encode(xml: :text)
       end
     end
 

data/lib/relaton_bib/organization.rb

@@ -99,7 +99,7 @@ module RelatonBib
         builder.abbreviation { |a| abbreviation.to_xml a } if abbreviation
         builder.uri url if uri
         identifier.each { |identifier| identifier.to_xml builder }
-        super
+        super builder
       end
     end
 

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "1.9.2".freeze
+  VERSION = "1.9.6".freeze
 end

data/lib/relaton_bib/xml_parser.rb

@@ -320,7 +320,7 @@ module RelatonBib
       # @return [Array<RelatonBib::FormattedString>]
       def fetch_abstract(item)
         item.xpath("./abstract").map do |a|
-          FormattedString.new(content: a.text, language: a[:language],
+          FormattedString.new(content: a.children.to_s, language: a[:language],
                               script: a[:script], format: a[:format])
         end
       end

data/lib/relaton_bib.rb

@@ -1,10 +1,12 @@
 require "forwardable"
+require "yaml"
 require "relaton_bib/version"
 require "relaton_bib/deep_dup"
 require "relaton_bib/localized_string"
 require "relaton_bib/bibliographic_item"
 require "relaton_bib/hit_collection"
 require "relaton_bib/hit"
+require "relaton_bib/bibxml_parser"
 
 module RelatonBib
   class Error < StandardError; end

data/relaton-bib.gemspec

@@ -27,6 +27,9 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "equivalent-xml", "~> 0.6"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "rubocop-performance"
+  spec.add_development_dependency "rubocop-rails"
   spec.add_development_dependency "ruby-jing"
   spec.add_development_dependency "simplecov"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-bib
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.9.6
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-22 00:00:00.000000000 Z
+date: 2021-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -66,6 +66,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: ruby-jing
   requirement: !ruby/object:Gem::Requirement
@@ -182,6 +224,7 @@ files:
 - lib/relaton_bib/bibliographic_date.rb
 - lib/relaton_bib/bibliographic_item.rb
 - lib/relaton_bib/bibtex_parser.rb
+- lib/relaton_bib/bibxml_parser.rb
 - lib/relaton_bib/classification.rb
 - lib/relaton_bib/contribution_info.rb
 - lib/relaton_bib/contributor.rb