relaton-bib 1.16.5 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cd83f1b6817d3aff3fb219312882391f32f69a31e1683e6437e48771985b4a2
-  data.tar.gz: ecbc877b14f379f0138470922b4a40feffcec3be4a7d351d50a134108317d73b
+  metadata.gz: 9f5805d9364d7a5f74ce37acdeb99ea547d928d276541ec7d01870621330f2f1
+  data.tar.gz: 2aff2d7bd6fca3bb87a34509a7b61995f3dcd0eb4bdb68b60e940887eedc4c78
 SHA512:
-  metadata.gz: 04f486d465f35b8214bc0978a15d47678e26fc2e78d72bb6e3875771af2c480bc21f2cef576a3deee9fb99c72ecec40da6a6826c88cbf81607aba51e84757647
-  data.tar.gz: 17a64cd868fa320959cf44a65e0794273aaf8ba992d36d4bf90bd774b66484d4021dde1285144530892a398d84b955f8aba1774ffdcbc7532d56d60ee6c6c738
+  metadata.gz: 7c061fc2df92d1c1418aa9a807e496ec736eec5eddfe5734ce0bdcc3c21995c3abd22fbc9162383f2370a7546f7836b325732f92bbc65ae9484124740cf5f406
+  data.tar.gz: 21c72729a63efff9cf5a312018206b22a8da1a77e4708e27610b2c92c8a4571c0a1cb5b0af973eb5285b4e0fb111353e73499ef00bee45d40cbce7cdc5d7d0f2

data/lib/relaton_bib/bibliographic_item.rb

@@ -46,9 +46,12 @@ module RelatonBib
     attr_accessor :all_parts
 
     # @return [String, nil]
-    attr_reader :id, :type, :docnumber, :doctype, :subdoctype
+    attr_reader :id, :type, :docnumber, :subdoctype
 
-    # @return [RelatonBib::Edition, nil] <description>
+    # @return [RelatonBib::DocumentType] document type
+    attr_reader :doctype
+
+    # @return [RelatonBib::Edition, nil] edition
     attr_reader :edition
 
     # @!attribute [r] title
@@ -157,7 +160,7 @@ module RelatonBib
     # @param validity [RelatonBib:Validity, nil]
     # @param fetched [Date, nil] default nil
     # @param keyword [Array<String>]
-    # @param doctype [String]
+    # @param doctype [RelatonBib::DocumentType]
     # @param subdoctype [String]
     # @param editorialgroup [RelatonBib::EditorialGroup, nil]
     # @param ics [Array<RelatonBib::ICS>]
@@ -421,7 +424,7 @@ module RelatonBib
       hash["fetched"] = fetched.to_s if fetched
       hash["keyword"] = single_element_array(keyword) if keyword&.any?
       hash["license"] = single_element_array(license) if license&.any?
-      hash["doctype"] = doctype if doctype
+      hash["doctype"] = doctype.to_hash if doctype
       hash["subdoctype"] = subdoctype if subdoctype
       if editorialgroup&.presence?
         hash["editorialgroup"] = editorialgroup.to_hash
@@ -576,7 +579,7 @@ module RelatonBib
       end
       out += relation.to_asciibib prefix if relation
       series.each { |s| out += s.to_asciibib prefix, series.size }
-      out += "#{pref}doctype:: #{doctype}\n" if doctype
+      out += doctype.to_asciibib prefix if doctype
       out += "#{pref}subdoctype:: #{subdoctype}\n" if subdoctype
       out += "#{pref}formattedref:: #{formattedref}\n" if formattedref
       keyword.each { |kw| out += kw.to_asciibib "#{pref}keyword", keyword.size }
@@ -639,7 +642,7 @@ module RelatonBib
         elsif opts[:bibdata] && (doctype || editorialgroup || ics&.any? ||
                                  structuredidentifier&.presence?)
           ext = builder.ext do |b|
-            b.doctype doctype if doctype
+            doctype.to_xml b if doctype
             b.subdoctype subdoctype if subdoctype
             editorialgroup&.to_xml b
             ics.each { |i| i.to_xml b }

data/lib/relaton_bib/bibxml_parser.rb

@@ -409,11 +409,12 @@ module RelatonBib
     # @param anchor [String]
     # @return [String]
     def doctype(anchor)
-      case anchor
-      when /I-D/ then "internet-draft"
-      when /IEEE/ then "ieee"
-      else "rfc"
-      end
+      type =  case anchor
+              when /I-D/ then "internet-draft"
+              when /IEEE/ then "ieee"
+              else "rfc"
+              end
+      DocumentType.new type: type
     end
 
     extend BibXMLParser

data/lib/relaton_bib/document_type.rb

@@ -0,0 +1,52 @@
+module RelatonBib
+  class DocumentType
+    attr_reader :type, :abbreviation
+
+    #
+    # Initialize a DocumentType.
+    #
+    # @param [String] type document type
+    # @param [String, nil] abbreviation type abbreviation
+    #
+    def initialize(type:, abbreviation: nil)
+      @type = type
+      @abbreviation = abbreviation
+    end
+
+    #
+    # Build XML representation of the document type.
+    #
+    # @param [Nokogiri::XML::Builder] builder XML builder
+    #
+    def to_xml(builder)
+      xml = builder.doctype @type
+      xml[:abbreviation] = @abbreviation if @abbreviation
+    end
+
+    #
+    # Hash representation of the document type.
+    #
+    # @return [Hash]
+    #
+    def to_hash
+      hash = { "type" => @type }
+      hash["abbreviation"] = @abbreviation if @abbreviation
+      hash
+    end
+
+    #
+    # Asciibib representation of the document type.
+    #
+    # @param [String] prefix prefix
+    #
+    # @return [String] AsciiBib representation
+    #
+    def to_asciibib(prefix = "")
+      pref = prefix.empty? ? prefix : prefix + "."
+      pref += "doctype."
+      out = "#{pref}type:: #{@type}\n"
+      out += "#{pref}abbreviation:: #{@abbreviation}\n" if @abbreviation
+      out
+    end
+  end
+end

data/lib/relaton_bib/hash_converter.rb

@@ -1,521 +1,534 @@
 module RelatonBib
-  class HashConverter
-    class << self
-      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-
-      # @param args [Hash]
-      # @return [Hash]
-      def hash_to_bib(args)
-        return nil unless args.is_a?(Hash)
-
-        ret = Marshal.load(Marshal.dump(symbolize(args))) # deep copy
-        title_hash_to_bib(ret)
-        link_hash_to_bib(ret)
-        language_hash_to_bib(ret)
-        script_hash_to_bib(ret)
-        dates_hash_to_bib(ret)
-        docid_hash_to_bib(ret)
-        version_hash_to_bib(ret)
-        biblionote_hash_to_bib(ret)
-        abstract_hash_to_bib(ret)
-        formattedref_hash_to_bib(ret)
-        docstatus_hash_to_bib(ret)
-        contributors_hash_to_bib(ret)
-        copyright_hash_to_bib(ret)
-        relations_hash_to_bib(ret)
-        series_hash_to_bib(ret)
-        medium_hash_to_bib(ret)
-        place_hash_to_bib(ret)
-        extent_hash_to_bib(ret)
-        size_hash_to_bib(ret)
-        accesslocation_hash_to_bib(ret)
-        classification_hash_to_bib(ret)
-        validity_hash_to_bib(ret)
-        keyword_hash_to_bib(ret)
-        # ret[:keyword] = RelatonBib.array(ret[:keyword])
-        ret[:license] = RelatonBib.array(ret[:license])
-        editorialgroup_hash_to_bib ret
-        ics_hash_to_bib ret
-        structuredidentifier_hash_to_bib ret
-        ret
-      end
-      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-
-      def keyword_hash_to_bib(ret)
-        ret[:keyword] = RelatonBib.array(ret[:keyword]).map do |keyword|
-          localizedstring keyword
-        end
+  module HashConverter
+    extend self
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+
+    # @param args [Hash]
+    # @return [Hash]
+    def hash_to_bib(args)
+      return nil unless args.is_a?(Hash)
+
+      ret = Marshal.load(Marshal.dump(symbolize(args))) # deep copy
+      title_hash_to_bib(ret)
+      link_hash_to_bib(ret)
+      language_hash_to_bib(ret)
+      script_hash_to_bib(ret)
+      dates_hash_to_bib(ret)
+      docid_hash_to_bib(ret)
+      version_hash_to_bib(ret)
+      biblionote_hash_to_bib(ret)
+      abstract_hash_to_bib(ret)
+      formattedref_hash_to_bib(ret)
+      docstatus_hash_to_bib(ret)
+      contributors_hash_to_bib(ret)
+      copyright_hash_to_bib(ret)
+      relations_hash_to_bib(ret)
+      series_hash_to_bib(ret)
+      medium_hash_to_bib(ret)
+      place_hash_to_bib(ret)
+      extent_hash_to_bib(ret)
+      size_hash_to_bib(ret)
+      accesslocation_hash_to_bib(ret)
+      classification_hash_to_bib(ret)
+      validity_hash_to_bib(ret)
+      keyword_hash_to_bib(ret)
+      # ret[:keyword] = RelatonBib.array(ret[:keyword])
+      ret[:license] = RelatonBib.array(ret[:license])
+      editorialgroup_hash_to_bib ret
+      ics_hash_to_bib ret
+      structuredidentifier_hash_to_bib ret
+      doctype_hash_to_bib ret
+      ret
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    def keyword_hash_to_bib(ret)
+      ret[:keyword] = RelatonBib.array(ret[:keyword]).map do |keyword|
+        localizedstring keyword
       end
+    end
 
-      def extent_hash_to_bib(ret)
-        return unless ret[:extent]
+    def extent_hash_to_bib(ret)
+      return unless ret[:extent]
 
-        ret[:extent] = RelatonBib.array(ret[:extent]).map do |e|
-          locality e
-          # ret[:extent][i] = Locality.new(e[:type], e[:reference_from],
-          #                                       e[:reference_to])
-        end
+      ret[:extent] = RelatonBib.array(ret[:extent]).map do |e|
+        locality e
+        # ret[:extent][i] = Locality.new(e[:type], e[:reference_from],
+        #                                       e[:reference_to])
       end
+    end
 
-      def locality(loc)
-        if loc[:locality_stack]
-          LocalityStack.new(loc[:locality_stack].map { |l| locality(l) })
-        else
-          l = loc[:locality]
-          Locality.new(l[:type], l[:reference_from], l[:reference_to])
-        end
+    def locality(loc)
+      if loc[:locality_stack]
+        LocalityStack.new(loc[:locality_stack].map { |l| locality(l) })
+      else
+        l = loc[:locality]
+        Locality.new(l[:type], l[:reference_from], l[:reference_to])
       end
+    end
 
-      def size_hash_to_bib(ret)
-        return unless ret[:size]
+    def size_hash_to_bib(ret)
+      return unless ret[:size]
 
-        ret[:size] = RelatonBib.array(ret[:size])
-        size = ret[:size]&.map do |val|
-          BibliographicSize::Value.new(**val)
-        end
-        ret[:size] = BibliographicSize.new(size)
+      ret[:size] = RelatonBib.array(ret[:size])
+      size = ret[:size]&.map do |val|
+        BibliographicSize::Value.new(**val)
       end
+      ret[:size] = BibliographicSize.new(size)
+    end
 
-      def title_hash_to_bib(ret)
-        return unless ret[:title]
+    def title_hash_to_bib(ret)
+      return unless ret[:title]
 
-        ret[:title] = RelatonBib.array(ret[:title])
-          .reduce(TypedTitleStringCollection.new) do |m, t|
-          if t.is_a?(Hash) then m << TypedTitleString.new(**t)
-          else
-            m + TypedTitleString.from_string(t)
-          end
+      ret[:title] = RelatonBib.array(ret[:title])
+        .reduce(TypedTitleStringCollection.new) do |m, t|
+        if t.is_a?(Hash) then m << TypedTitleString.new(**t)
+        else
+          m + TypedTitleString.from_string(t)
         end
       end
+    end
 
-      def language_hash_to_bib(ret)
-        return unless ret[:language]
+    def language_hash_to_bib(ret)
+      return unless ret[:language]
 
-        ret[:language] = RelatonBib.array(ret[:language])
-      end
+      ret[:language] = RelatonBib.array(ret[:language])
+    end
 
-      def script_hash_to_bib(ret)
-        return unless ret[:script]
+    def script_hash_to_bib(ret)
+      return unless ret[:script]
 
-        ret[:script] = RelatonBib.array(ret[:script])
-      end
+      ret[:script] = RelatonBib.array(ret[:script])
+    end
 
-      def abstract_hash_to_bib(ret)
-        return unless ret[:abstract]
+    def abstract_hash_to_bib(ret)
+      return unless ret[:abstract]
 
-        ret[:abstract] = RelatonBib.array(ret[:abstract]).map do |a|
-          a.is_a?(String) ? FormattedString.new(content: a) : a
-        end
+      ret[:abstract] = RelatonBib.array(ret[:abstract]).map do |a|
+        a.is_a?(String) ? FormattedString.new(content: a) : a
       end
+    end
 
-      def link_hash_to_bib(ret)
-        return unless ret[:link]
+    def link_hash_to_bib(ret)
+      return unless ret[:link]
 
-        ret[:link] = RelatonBib.array(ret[:link])
-      end
+      ret[:link] = RelatonBib.array(ret[:link])
+    end
 
-      def place_hash_to_bib(ret)
-        return unless ret[:place]
+    def place_hash_to_bib(ret)
+      return unless ret[:place]
 
-        ret[:place] = RelatonBib.array(ret[:place]).map do |pl|
-          pl.is_a?(String) ? Place.new(name: pl) : Place.new(**pl)
-        end
+      ret[:place] = RelatonBib.array(ret[:place]).map do |pl|
+        pl.is_a?(String) ? Place.new(name: pl) : Place.new(**pl)
       end
+    end
 
-      def accesslocation_hash_to_bib(ret)
-        return unless ret[:accesslocation]
+    def accesslocation_hash_to_bib(ret)
+      return unless ret[:accesslocation]
 
-        ret[:accesslocation] = RelatonBib.array(ret[:accesslocation])
-      end
+      ret[:accesslocation] = RelatonBib.array(ret[:accesslocation])
+    end
 
-      def dates_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
-        return unless ret[:date]
+    def dates_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
+      return unless ret[:date]
 
-        ret[:date] = RelatonBib.array(ret[:date])
-        ret[:date].each_with_index do |d, i|
-          # value is synonym of on: it is reserved word in YAML
-          if d[:value]
-            ret[:date][i][:on] ||= d[:value]
-            ret[:date][i].delete(:value)
-          end
+      ret[:date] = RelatonBib.array(ret[:date])
+      ret[:date].each_with_index do |d, i|
+        # value is synonym of on: it is reserved word in YAML
+        if d[:value]
+          ret[:date][i][:on] ||= d[:value]
+          ret[:date][i].delete(:value)
         end
       end
+    end
 
-      def docid_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
-        return unless ret[:docid]
+    def docid_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
+      return unless ret[:docid]
 
-        ret[:docid] = RelatonBib.array(ret[:docid]).map do |id|
-          id[:type] ||= id[:id].match(/^\w+(?=\s)/)&.to_s
-          create_docid(**id)
-        end
+      ret[:docid] = RelatonBib.array(ret[:docid]).map do |id|
+        id[:type] ||= id[:id].match(/^\w+(?=\s)/)&.to_s
+        create_docid(**id)
       end
+    end
 
-      def create_docid(**args)
-        DocumentIdentifier.new(**args)
-      end
+    def create_docid(**args)
+      DocumentIdentifier.new(**args)
+    end
 
-      def version_hash_to_bib(ret)
-        return unless ret[:version]
+    def version_hash_to_bib(ret)
+      return unless ret[:version]
 
-        ret[:version] = RelatonBib.array(ret[:version]).map do |v|
-          BibliographicItem::Version.new(v[:revision_date], v[:draft])
-        end
+      ret[:version] = RelatonBib.array(ret[:version]).map do |v|
+        BibliographicItem::Version.new(v[:revision_date], v[:draft])
       end
+    end
 
-      def biblionote_hash_to_bib(ret) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
-        return unless ret[:biblionote]
-
-        ret[:biblionote] = RelatonBib.array(ret[:biblionote])
-          .reduce(BiblioNoteCollection.new([])) do |mem, n|
-          mem << if n.is_a?(String) then BiblioNote.new content: n
-                 else BiblioNote.new(**n)
-                 end
-        end
-      end
+    def biblionote_hash_to_bib(ret) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+      return unless ret[:biblionote]
 
-      def formattedref_hash_to_bib(ret)
-        ret[:formattedref] &&
-          ret[:formattedref] = formattedref(ret[:formattedref])
+      ret[:biblionote] = RelatonBib.array(ret[:biblionote])
+        .reduce(BiblioNoteCollection.new([])) do |mem, n|
+        mem << if n.is_a?(String) then BiblioNote.new content: n
+                else BiblioNote.new(**n)
+                end
       end
+    end
 
-      def docstatus_hash_to_bib(ret)
-        ret[:docstatus] && ret[:docstatus] = DocumentStatus.new(
-          stage: stage(ret[:docstatus][:stage]),
-          substage: stage(ret[:docstatus][:substage]),
-          iteration: ret[:docstatus][:iteration],
-        )
-      end
+    def formattedref_hash_to_bib(ret)
+      ret[:formattedref] &&
+        ret[:formattedref] = formattedref(ret[:formattedref])
+    end
 
-      # @param stg [Hash]
-      # @return [RelatonBib::DocumentStatus::Stage]
-      def stage(stg)
-        return unless stg
+    def docstatus_hash_to_bib(ret)
+      ret[:docstatus] && ret[:docstatus] = DocumentStatus.new(
+        stage: stage(ret[:docstatus][:stage]),
+        substage: stage(ret[:docstatus][:substage]),
+        iteration: ret[:docstatus][:iteration],
+      )
+    end
 
-        args = stg.is_a?(String) ? { value: stg } : stg
-        DocumentStatus::Stage.new(**args)
-      end
+    # @param stg [Hash]
+    # @return [RelatonBib::DocumentStatus::Stage]
+    def stage(stg)
+      return unless stg
 
-      def contributors_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
-        return unless ret[:contributor]
+      args = stg.is_a?(String) ? { value: stg } : stg
+      DocumentStatus::Stage.new(**args)
+    end
 
-        ret[:contributor] = RelatonBib.array(ret[:contributor])
-        ret[:contributor]&.each_with_index do |c, i|
-          roles = RelatonBib.array(ret[:contributor][i][:role]).map do |r|
-            if r.is_a? Hash
-              desc = RelatonBib.array(r[:description]).map { |d| d.is_a?(String) ? d : d[:content] }
-              { type: r[:type], description: desc }
-            # elsif r.is_a? Array
-            #   { type: r[0], description: r.fetch(1) }
-            else
-              { type: r }
-            end
+    def contributors_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
+      return unless ret[:contributor]
+
+      ret[:contributor] = RelatonBib.array(ret[:contributor])
+      ret[:contributor]&.each_with_index do |c, i|
+        roles = RelatonBib.array(ret[:contributor][i][:role]).map do |r|
+          if r.is_a? Hash
+            desc = RelatonBib.array(r[:description]).map { |d| d.is_a?(String) ? d : d[:content] }
+            { type: r[:type], description: desc }
+          # elsif r.is_a? Array
+          #   { type: r[0], description: r.fetch(1) }
+          else
+            { type: r }
           end
-          ret[:contributor][i][:role] = roles
-          ret[:contributor][i][:entity] = if c[:person]
-                                            person_hash_to_bib(c[:person])
-                                          else
-                                            org_hash_to_bib(c[:organization])
-                                          end
-          ret[:contributor][i].delete(:person)
-          ret[:contributor][i].delete(:organization)
         end
+        ret[:contributor][i][:role] = roles
+        ret[:contributor][i][:entity] = if c[:person]
+                                          person_hash_to_bib(c[:person])
+                                        else
+                                          org_hash_to_bib(c[:organization])
+                                        end
+        ret[:contributor][i].delete(:person)
+        ret[:contributor][i].delete(:organization)
       end
+    end
 
-      def org_hash_to_bib(org) # rubocop:disable Metrics/AbcSize
-        return nil if org.nil?
+    def org_hash_to_bib(org) # rubocop:disable Metrics/AbcSize
+      return nil if org.nil?
 
-        org[:identifier] = RelatonBib.array(org[:identifier])&.map do |a|
-          OrgIdentifier.new(a[:type], a[:id])
-        end
-        org[:subdivision] = RelatonBib.array(org[:subdivision]).map do |sd|
-          LocalizedString.new sd
-        end
-        org[:contact] = contacts_hash_to_bib(org)
-        org
+      org[:identifier] = RelatonBib.array(org[:identifier])&.map do |a|
+        OrgIdentifier.new(a[:type], a[:id])
       end
-
-      def person_hash_to_bib(person)
-        Person.new(
-          name: fullname_hash_to_bib(person),
-          affiliation: affiliation_hash_to_bib(person),
-          contact: contacts_hash_to_bib(person),
-          identifier: person_identifiers_hash_to_bib(person),
-        )
+      org[:subdivision] = RelatonBib.array(org[:subdivision]).map do |sd|
+        LocalizedString.new sd
       end
+      org[:contact] = contacts_hash_to_bib(org)
+      org
+    end
 
-      def fullname_hash_to_bib(person) # rubocop:disable Metrics/AbcSize
-        n = person[:name]
-        fname, inits = given_hash_to_bib n[:given] || n # `n` is for backward compatibility
-        FullName.new(
-          forename: fname, initials: inits,
-          addition: RelatonBib.array(n[:addition])&.map { |f| localizedstring(f) },
-          prefix: RelatonBib.array(n[:prefix])&.map { |f| localizedstring(f) },
-          surname: localizedstring(n[:surname]),
-          completename: localizedstring(n[:completename])
-        )
-      end
+    def person_hash_to_bib(person)
+      Person.new(
+        name: fullname_hash_to_bib(person),
+        affiliation: affiliation_hash_to_bib(person),
+        contact: contacts_hash_to_bib(person),
+        identifier: person_identifiers_hash_to_bib(person),
+      )
+    end
 
-      def given_hash_to_bib(given)
-        return [[], nil] unless given
+    def fullname_hash_to_bib(person) # rubocop:disable Metrics/AbcSize
+      n = person[:name]
+      fname, inits = given_hash_to_bib n[:given] || n # `n` is for backward compatibility
+      FullName.new(
+        forename: fname, initials: inits,
+        addition: RelatonBib.array(n[:addition])&.map { |f| localizedstring(f) },
+        prefix: RelatonBib.array(n[:prefix])&.map { |f| localizedstring(f) },
+        surname: localizedstring(n[:surname]),
+        completename: localizedstring(n[:completename])
+      )
+    end
 
-        fname = RelatonBib.array(given[:forename])&.map { |f| forename_hash_to_bib(f) }
-        inits = localizedstring(given[:formatted_initials])
-        [fname, inits]
-      end
+    def given_hash_to_bib(given)
+      return [[], nil] unless given
 
-      def forename_hash_to_bib(fname)
-        case fname
-        when Hash then Forename.new(**fname)
-        when String then Forename.new(content: fname)
-        end
+      fname = RelatonBib.array(given[:forename])&.map { |f| forename_hash_to_bib(f) }
+      inits = localizedstring(given[:formatted_initials])
+      [fname, inits]
+    end
+
+    def forename_hash_to_bib(fname)
+      case fname
+      when Hash then Forename.new(**fname)
+      when String then Forename.new(content: fname)
       end
+    end
 
-      def person_identifiers_hash_to_bib(person)
-        RelatonBib.array(person[:identifier])&.map do |a|
-          PersonIdentifier.new(a[:type], a[:id])
-        end
+    def person_identifiers_hash_to_bib(person)
+      RelatonBib.array(person[:identifier])&.map do |a|
+        PersonIdentifier.new(a[:type], a[:id])
       end
+    end
 
-      def affiliation_hash_to_bib(person) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        return [] unless person[:affiliation]
+    def affiliation_hash_to_bib(person) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      return [] unless person[:affiliation]
 
-        RelatonBib.array(person[:affiliation]).map do |a|
-          a[:description] = RelatonBib.array(a[:description]).map do |d|
-            cnt = if d.is_a?(Hash)
-                    { content: d[:content], language: d[:language],
-                      script: d[:script], format: d[:format] }
-                  else { content: d }
-                  end
-            FormattedString.new(**cnt)
-          end
-          name = LocalizedString.new(a[:name][:content], a[:name][:language], a[:name][:script]) if a[:name]
-          Affiliation.new(
-            organization: Organization.new(**org_hash_to_bib(a[:organization])),
-            description: a[:description], name: name
-          )
+      RelatonBib.array(person[:affiliation]).map do |a|
+        a[:description] = RelatonBib.array(a[:description]).map do |d|
+          cnt = if d.is_a?(Hash)
+                  { content: d[:content], language: d[:language],
+                    script: d[:script], format: d[:format] }
+                else { content: d }
+                end
+          FormattedString.new(**cnt)
         end
+        name = LocalizedString.new(a[:name][:content], a[:name][:language], a[:name][:script]) if a[:name]
+        Affiliation.new(
+          organization: Organization.new(**org_hash_to_bib(a[:organization])),
+          description: a[:description], name: name
+        )
       end
+    end
 
-      def contacts_hash_to_bib(entity) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
-        return [] unless entity[:contact]
-
-        RelatonBib.array(entity[:contact]).map do |a|
-          if a[:city] || a[:country] # it's for old version compatibility, should be removed in the future
-            RelatonBib::Address.new(
-              street: Array(a[:street]), city: a[:city], postcode: a[:postcode],
-              country: a[:country], state: a[:state]
-            )
-          elsif a[:address]
-            a[:address][:street] = RelatonBib.array(a[:address][:street])
-            RelatonBib::Address.new(**a[:address])
-          elsif a[:type] # it's for old version compatibility, should be removed in the future
-            RelatonBib::Contact.new(type: a[:type], value: a[:value])
-          else
-            type, value = a.flatten
-            RelatonBib::Contact.new(type: type.to_s, value: value)
-          end
+    def contacts_hash_to_bib(entity) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength,Metrics/PerceivedComplexity,Metrics/CyclomaticComplexity
+      return [] unless entity[:contact]
+
+      RelatonBib.array(entity[:contact]).map do |a|
+        if a[:city] || a[:country] # it's for old version compatibility, should be removed in the future
+          RelatonBib::Address.new(
+            street: Array(a[:street]), city: a[:city], postcode: a[:postcode],
+            country: a[:country], state: a[:state]
+          )
+        elsif a[:address]
+          a[:address][:street] = RelatonBib.array(a[:address][:street])
+          RelatonBib::Address.new(**a[:address])
+        elsif a[:type] # it's for old version compatibility, should be removed in the future
+          RelatonBib::Contact.new(type: a[:type], value: a[:value])
+        else
+          type, value = a.flatten
+          RelatonBib::Contact.new(type: type.to_s, value: value)
         end
       end
+    end
 
-      # @param ret [Hash]
-      def copyright_hash_to_bib(ret)
-        return unless ret[:copyright]
+    # @param ret [Hash]
+    def copyright_hash_to_bib(ret)
+      return unless ret[:copyright]
 
-        ret[:copyright] = RelatonBib.array(ret[:copyright]).map do |c|
-          c[:owner] = RelatonBib.array(c[:owner]).map do |o|
-            org_hash_to_bib(o)
-          end
-          c
+      ret[:copyright] = RelatonBib.array(ret[:copyright]).map do |c|
+        c[:owner] = RelatonBib.array(c[:owner]).map do |o|
+          org_hash_to_bib(o)
         end
+        c
       end
+    end
 
-      # @param ret [Hash]
-      def relations_hash_to_bib(ret)
-        return unless ret[:relation]
+    # @param ret [Hash]
+    def relations_hash_to_bib(ret)
+      return unless ret[:relation]
 
-        ret[:relation] = RelatonBib.array(ret[:relation])
-        ret[:relation]&.each do |r|
-          if r[:description]
-            r[:description] = FormattedString.new(**r[:description])
-          end
-          relation_bibitem_hash_to_bib(r)
-          relation_locality_hash_to_bib(r)
-          relation_source_locality_hash_to_bib(r)
+      ret[:relation] = RelatonBib.array(ret[:relation])
+      ret[:relation]&.each do |r|
+        if r[:description]
+          r[:description] = FormattedString.new(**r[:description])
         end
+        relation_bibitem_hash_to_bib(r)
+        relation_locality_hash_to_bib(r)
+        relation_source_locality_hash_to_bib(r)
       end
+    end
 
-      # @param rel [Hash] relation
-      def relation_bibitem_hash_to_bib(rel)
-        if rel[:bibitem]
-          rel[:bibitem] = bib_item hash_to_bib(rel[:bibitem])
-        else
-          Util.warn "WARNING: bibitem missing: `#{rel}`"
-          rel[:bibitem] = nil
-        end
+    # @param rel [Hash] relation
+    def relation_bibitem_hash_to_bib(rel)
+      if rel[:bibitem]
+        rel[:bibitem] = bib_item hash_to_bib(rel[:bibitem])
+      else
+        Util.warn "WARNING: bibitem missing: `#{rel}`"
+        rel[:bibitem] = nil
       end
+    end
 
-      # @param item_hash [Hash]
-      # @return [RelatonBib::BibliographicItem]
-      def bib_item(item_hash)
-        BibliographicItem.new(**item_hash)
-      end
+    # @param item_hash [Hash]
+    # @return [RelatonBib::BibliographicItem]
+    def bib_item(item_hash)
+      BibliographicItem.new(**item_hash)
+    end
 
-      # @param rel [Hash] relation
-      # @return [RelatonBib::LocalityStack]
-      def relation_locality_hash_to_bib(rel)
-        rel[:locality] = RelatonBib.array(rel[:locality])&.map do |bl|
-          LocalityStack.new locality_locality_stack(bl)
-        end
+    # @param rel [Hash] relation
+    # @return [RelatonBib::LocalityStack]
+    def relation_locality_hash_to_bib(rel)
+      rel[:locality] = RelatonBib.array(rel[:locality])&.map do |bl|
+        LocalityStack.new locality_locality_stack(bl)
       end
+    end
 
-      def locality_locality_stack(lls)
-        if lls[:locality_stack]
-          RelatonBib.array(lls[:locality_stack]).map do |lc|
-            l = lc[:locality] || lc
-            Locality.new(l[:type], l[:reference_from], l[:reference_to])
-          end
-        else
-          [Locality.new(lls[:type], lls[:reference_from], lls[:reference_to])]
+    def locality_locality_stack(lls)
+      if lls[:locality_stack]
+        RelatonBib.array(lls[:locality_stack]).map do |lc|
+          l = lc[:locality] || lc
+          Locality.new(l[:type], l[:reference_from], l[:reference_to])
         end
+      else
+        [Locality.new(lls[:type], lls[:reference_from], lls[:reference_to])]
       end
+    end
 
-      # @param rel [Hash] relation
-      def relation_source_locality_hash_to_bib(rel) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        rel[:source_locality] = RelatonBib.array(rel[:source_locality])&.map do |sl|
-          sls = if sl[:source_locality_stack]
-                  RelatonBib.array(sl[:source_locality_stack]).map do |l|
-                    SourceLocality.new(l[:type], l[:reference_from],
-                                       l[:reference_to])
-                  end
-                else
-                  l = SourceLocality.new(sl[:type], sl[:reference_from],
-                                         sl[:reference_to])
-                  [l]
+    # @param rel [Hash] relation
+    def relation_source_locality_hash_to_bib(rel) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      rel[:source_locality] = RelatonBib.array(rel[:source_locality])&.map do |sl|
+        sls = if sl[:source_locality_stack]
+                RelatonBib.array(sl[:source_locality_stack]).map do |l|
+                  SourceLocality.new(l[:type], l[:reference_from],
+                                      l[:reference_to])
                 end
-          SourceLocalityStack.new sls
-        end
+              else
+                l = SourceLocality.new(sl[:type], sl[:reference_from],
+                                        sl[:reference_to])
+                [l]
+              end
+        SourceLocalityStack.new sls
       end
+    end
 
-      # @param ret [Hash]
-      def series_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-        ret[:series] = RelatonBib.array(ret[:series])&.map do |s|
-          s[:formattedref] && s[:formattedref] = formattedref(s[:formattedref])
-          if s[:title]
-            s[:title] = { content: s[:title] } unless s[:title].is_a?(Hash)
-            s[:title] = typed_title_strig(s[:title])
-          end
-          s[:abbreviation] &&
-            s[:abbreviation] = localizedstring(s[:abbreviation])
-          Series.new(**s)
+    # @param ret [Hash]
+    def series_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      ret[:series] = RelatonBib.array(ret[:series])&.map do |s|
+        s[:formattedref] && s[:formattedref] = formattedref(s[:formattedref])
+        if s[:title]
+          s[:title] = { content: s[:title] } unless s[:title].is_a?(Hash)
+          s[:title] = typed_title_strig(s[:title])
         end
+        s[:abbreviation] &&
+          s[:abbreviation] = localizedstring(s[:abbreviation])
+        Series.new(**s)
       end
+    end
 
-      # @param title [Hash]
-      # @return [RelatonBib::TypedTitleString]
-      def typed_title_strig(title)
-        TypedTitleString.new(**title)
-      end
+    # @param title [Hash]
+    # @return [RelatonBib::TypedTitleString]
+    def typed_title_strig(title)
+      TypedTitleString.new(**title)
+    end
 
-      # @param ret [Hash]
-      def medium_hash_to_bib(ret)
-        ret[:medium] = Medium.new(**ret[:medium]) if ret[:medium]
-      end
+    # @param ret [Hash]
+    def medium_hash_to_bib(ret)
+      ret[:medium] = Medium.new(**ret[:medium]) if ret[:medium]
+    end
 
-      # @param ret [Hash]
-      def classification_hash_to_bib(ret)
-        if ret[:classification]
-          ret[:classification] = RelatonBib.array(ret[:classification]).map do |cls|
-            Classification.new(**cls)
-          end
+    # @param ret [Hash]
+    def classification_hash_to_bib(ret)
+      if ret[:classification]
+        ret[:classification] = RelatonBib.array(ret[:classification]).map do |cls|
+          Classification.new(**cls)
         end
       end
+    end
 
-      # @param ret [Hash]
-      def validity_hash_to_bib(ret)
-        return unless ret[:validity]
+    # @param ret [Hash]
+    def validity_hash_to_bib(ret)
+      return unless ret[:validity]
 
-        b = parse_validity_time(ret[:validity], :begins)
-        e = parse_validity_time(ret[:validity], :ends)
-        r = parse_validity_time(ret[:validity], :revision)
-        ret[:validity] = Validity.new(begins: b, ends: e, revision: r)
-      end
+      b = parse_validity_time(ret[:validity], :begins)
+      e = parse_validity_time(ret[:validity], :ends)
+      r = parse_validity_time(ret[:validity], :revision)
+      ret[:validity] = Validity.new(begins: b, ends: e, revision: r)
+    end
 
-      def parse_validity_time(val, period)
-        t = val[period]&.to_s
-        return unless t
+    def parse_validity_time(val, period)
+      t = val[period]&.to_s
+      return unless t
 
-        p = period == :ends ? -1 : 1
-        case t
-        when /^\d{4}$/
-          Date.new(t.to_i, p, p).to_time
-        when /^(?<year>\d{4})-(?<month>\d{1,2})$/
-          Date.new($~[:year].to_i, $~[:month].to_i, p).to_time
-        else Time.parse t
-        end
+      p = period == :ends ? -1 : 1
+      case t
+      when /^\d{4}$/
+        Date.new(t.to_i, p, p).to_time
+      when /^(?<year>\d{4})-(?<month>\d{1,2})$/
+        Date.new($~[:year].to_i, $~[:month].to_i, p).to_time
+      else Time.parse t
       end
+    end
 
-      # @param ret [Hash]
-      def editorialgroup_hash_to_bib(ret)
-        return unless ret[:editorialgroup]
+    # @param ret [Hash]
+    def editorialgroup_hash_to_bib(ret)
+      return unless ret[:editorialgroup]
 
-        technical_committee = RelatonBib.array(ret[:editorialgroup]).map do |wg|
-          TechnicalCommittee.new WorkGroup.new(**wg)
-        end
-        ret[:editorialgroup] = EditorialGroup.new technical_committee
+      technical_committee = RelatonBib.array(ret[:editorialgroup]).map do |wg|
+        TechnicalCommittee.new WorkGroup.new(**wg)
       end
+      ret[:editorialgroup] = EditorialGroup.new technical_committee
+    end
 
-      # @param ret [Hash]
-      def ics_hash_to_bib(ret)
-        return unless ret[:ics]
+    # @param ret [Hash]
+    def ics_hash_to_bib(ret)
+      return unless ret[:ics]
 
-        ret[:ics] = RelatonBib.array(ret[:ics]).map { |ics| ICS.new(**ics) }
-      end
+      ret[:ics] = RelatonBib.array(ret[:ics]).map { |ics| ICS.new(**ics) }
+    end
 
-      # @param ret [Hash]
-      def structuredidentifier_hash_to_bib(ret)
-        return unless ret[:structuredidentifier]
+    # @param ret [Hash]
+    def structuredidentifier_hash_to_bib(ret)
+      return unless ret[:structuredidentifier]
 
-        sids = RelatonBib.array(ret[:structuredidentifier]).map do |si|
-          si[:agency] = RelatonBib.array si[:agency]
-          StructuredIdentifier.new(**si)
-        end
-        ret[:structuredidentifier] = StructuredIdentifierCollection.new sids
+      sids = RelatonBib.array(ret[:structuredidentifier]).map do |si|
+        si[:agency] = RelatonBib.array si[:agency]
+        StructuredIdentifier.new(**si)
       end
+      ret[:structuredidentifier] = StructuredIdentifierCollection.new sids
+    end
 
-      # @param ogj [Hash, Array, String]
-      # @return [Hash, Array, String]
-      def symbolize(obj)
-        case obj
-        when Hash
-          obj.reduce({}) do |memo, (k, v)|
-            memo[k.to_sym] = symbolize(v)
-            memo
-          end
-        when Array then obj.reduce([]) { |memo, v| memo << symbolize(v) }
-        else obj
+    # @param ogj [Hash, Array, String]
+    # @return [Hash, Array, String]
+    def symbolize(obj)
+      case obj
+      when Hash
+        obj.reduce({}) do |memo, (k, v)|
+          memo[k.to_sym] = symbolize(v)
+          memo
         end
+      when Array then obj.reduce([]) { |memo, v| memo << symbolize(v) }
+      else obj
       end
+    end
 
-      # @param lst [Hash, Array<RelatonBib::LocalizedString>, String]
-      # @return [RelatonBib::LocalizedString]
-      def localizedstring(lst)
-        return unless lst
+    # @param lst [Hash, Array<RelatonBib::LocalizedString>, String]
+    # @return [RelatonBib::LocalizedString]
+    def localizedstring(lst)
+      return unless lst
 
-        if lst.is_a?(Hash)
-          LocalizedString.new(lst[:content], lst[:language], lst[:script])
-        else LocalizedString.new(lst)
-        end
+      if lst.is_a?(Hash)
+        LocalizedString.new(lst[:content], lst[:language], lst[:script])
+      else LocalizedString.new(lst)
       end
+    end
 
-      # @param frf [Hash, String]
-      # @return [RelatonBib::FormattedRef]
-      def formattedref(frf)
-        if frf.is_a?(Hash)
-          RelatonBib::FormattedRef.new(**frf)
-        else
-          RelatonBib::FormattedRef.new(content: frf)
-        end
+    # @param frf [Hash, String]
+    # @return [RelatonBib::FormattedRef]
+    def formattedref(frf)
+      if frf.is_a?(Hash)
+        RelatonBib::FormattedRef.new(**frf)
+      else
+        RelatonBib::FormattedRef.new(content: frf)
       end
     end
+
+    def doctype_hash_to_bib(ret)
+      return unless ret[:doctype]
+
+      ret[:doctype] = if ret[:doctype].is_a?(String)
+                        create_doctype(type: ret[:doctype])
+                      else create_doctype(**ret[:doctype])
+                      end
+    end
+
+    def create_doctype(**args)
+      DocumentType.new(**args)
+    end
   end
 end

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "1.16.5".freeze
+  VERSION = "1.17.0".freeze
 end

data/lib/relaton_bib/xml_parser.rb

@@ -63,7 +63,7 @@ module RelatonBib
           keyword: bibitem.xpath("keyword").map(&:text),
           license: bibitem.xpath("license").map(&:text),
           validity: fetch_validity(bibitem),
-          doctype: ext&.at("doctype")&.text,
+          doctype: fetch_doctype(ext),
           subdoctype: ext&.at("subdoctype")&.text,
           editorialgroup: fetch_editorialgroup(ext),
           ics: fetch_ics(ext),
@@ -274,6 +274,13 @@ module RelatonBib
         Validity.new begins: begins, ends: ends, revision: revision
       end
 
+      def fetch_doctype(ext)
+        dt = ext&.at("doctype")
+        return unless dt
+
+        DocumentType.new type: dt.text, abbreviation: dt[:abbreviation]
+      end
+
       # @param item [Nokogiri::XML::Element]
       # @return [Array<RelatonBib::DocumentIdentifier>]
       def fetch_docid(item)

data/lib/relaton_bib.rb

@@ -9,6 +9,7 @@ require "relaton_bib/localized_string"
 require "relaton_bib/forename"
 require "relaton_bib/full_name"
 require "relaton_bib/contributor"
+require "relaton_bib/document_type"
 require "relaton_bib/bibliographic_item"
 require "relaton_bib/hit_collection"
 require "relaton_bib/hit"

data/relaton-bib.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "bibtex-ruby"
   spec.add_dependency "htmlentities"
   spec.add_dependency "iso639"
-  spec.add_dependency "nokogiri", "~> 1.14.0"
+  spec.add_dependency "nokogiri", "~> 1.15.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-bib
 version: !ruby/object:Gem::Version
-  version: 1.16.5
+  version: 1.17.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-11-17 00:00:00.000000000 Z
+date: 2023-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.14.0
+        version: 1.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.14.0
+        version: 1.15.0
 description: 'RelatonBib: Ruby XMLDOC impementation.'
 email:
 - open.source@ribose.com
@@ -127,6 +127,7 @@ files:
 - lib/relaton_bib/document_relation.rb
 - lib/relaton_bib/document_relation_collection.rb
 - lib/relaton_bib/document_status.rb
+- lib/relaton_bib/document_type.rb
 - lib/relaton_bib/edition.rb
 - lib/relaton_bib/editorial_group.rb
 - lib/relaton_bib/forename.rb