relaton-bib 1.11.7 → 1.12.2

data/lib/relaton_bib/hash_converter.rb

@@ -6,11 +6,11 @@ module RelatonBib
       # @param args [Hash]
       # @param neated [TrueClas, FalseClass] default false
       # @return [Hash]
-      def hash_to_bib(args, nested = false)
+      def hash_to_bib(args)
         return nil unless args.is_a?(Hash)
 
         ret = Marshal.load(Marshal.dump(symbolize(args))) # deep copy
-        timestamp_hash(ret) unless nested
+        # timestamp_hash(ret) unless nested
         title_hash_to_bib(ret)
         link_hash_to_bib(ret)
         language_hash_to_bib(ret)
@@ -33,8 +33,8 @@ module RelatonBib
         accesslocation_hash_to_bib(ret)
         classification_hash_to_bib(ret)
         validity_hash_to_bib(ret)
-        ret[:keyword] = array(ret[:keyword])
-        ret[:license] = array(ret[:license])
+        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
@@ -42,14 +42,14 @@ module RelatonBib
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      def timestamp_hash(ret)
-        ret[:fetched] ||= Date.today.to_s
-      end
+      # def timestamp_hash(ret)
+      #   ret[:fetched] ||= Date.today.to_s
+      # end
 
       def extent_hash_to_bib(ret)
         return unless ret[:extent]
 
-        ret[:extent] = array(ret[:extent]).map do |e|
+        ret[:extent] = RelatonBib.array(ret[:extent]).map do |e|
           locality e
           # ret[:extent][i] = Locality.new(e[:type], e[:reference_from],
           #                                       e[:reference_to])
@@ -68,7 +68,7 @@ module RelatonBib
       def size_hash_to_bib(ret)
         return unless ret[:size]
 
-        ret[:size] = array(ret[:size])
+        ret[:size] = RelatonBib.array(ret[:size])
         size = ret[:size]&.map do |val|
           BibliographicSize::Value.new(**val)
         end
@@ -78,7 +78,7 @@ module RelatonBib
       def title_hash_to_bib(ret)
         return unless ret[:title]
 
-        ret[:title] = array(ret[:title])
+        ret[:title] = RelatonBib.array(ret[:title])
           .reduce(TypedTitleStringCollection.new) do |m, t|
           if t.is_a?(Hash) then m << t
           else
@@ -90,19 +90,19 @@ module RelatonBib
       def language_hash_to_bib(ret)
         return unless ret[:language]
 
-        ret[:language] = array(ret[:language])
+        ret[:language] = RelatonBib.array(ret[:language])
       end
 
       def script_hash_to_bib(ret)
         return unless ret[:script]
 
-        ret[:script] = array(ret[:script])
+        ret[:script] = RelatonBib.array(ret[:script])
       end
 
       def abstract_hash_to_bib(ret)
         return unless ret[:abstract]
 
-        ret[:abstract] = array(ret[:abstract]).map do |a|
+        ret[:abstract] = RelatonBib.array(ret[:abstract]).map do |a|
           a.is_a?(String) ? FormattedString.new(content: a) : a
         end
       end
@@ -110,13 +110,13 @@ module RelatonBib
       def link_hash_to_bib(ret)
         return unless ret[:link]
 
-        ret[:link] = array(ret[:link])
+        ret[:link] = RelatonBib.array(ret[:link])
       end
 
       def place_hash_to_bib(ret)
         return unless ret[:place]
 
-        ret[:place] = array(ret[:place]).map do |pl|
+        ret[:place] = RelatonBib.array(ret[:place]).map do |pl|
           pl.is_a?(String) ? Place.new(name: pl) : Place.new(**pl)
         end
       end
@@ -124,13 +124,13 @@ module RelatonBib
       def accesslocation_hash_to_bib(ret)
         return unless ret[:accesslocation]
 
-        ret[:accesslocation] = array(ret[:accesslocation])
+        ret[:accesslocation] = RelatonBib.array(ret[:accesslocation])
       end
 
       def dates_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
         return unless ret[:date]
 
-        ret[:date] = array(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]
@@ -143,28 +143,25 @@ module RelatonBib
       def docid_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
         return unless ret[:docid]
 
-        ret[:docid] = array(ret[:docid])
+        ret[:docid] = RelatonBib.array(ret[:docid])
         ret[:docid]&.each_with_index do |id, i|
-          type = id[:type] || id[:id].match(/^\w+(?=\s)/)&.to_s
-          ret[:docid][i] = DocumentIdentifier.new(
-            id: id[:id], type: type, scope: id[:scope], primary: id[:primary],
-          )
+          id[:type] ||= id[:id].match(/^\w+(?=\s)/)&.to_s
+          ret[:docid][i] = DocumentIdentifier.new(**id)
         end
       end
 
       def version_hash_to_bib(ret)
         return unless ret[:version]
 
-        ret[:version][:draft] = array(ret[:version][:draft])
-        ret[:version] && ret[:version] = BibliographicItem::Version.new(
-          ret[:version][:revision_date], ret[:version][:draft]
-        )
+        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] = array(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)
@@ -197,11 +194,11 @@ module RelatonBib
       def contributors_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
         return unless ret[:contributor]
 
-        ret[:contributor] = array(ret[:contributor])
+        ret[:contributor] = RelatonBib.array(ret[:contributor])
         ret[:contributor]&.each_with_index do |c, i|
-          roles = array(ret[:contributor][i][:role]).map do |r|
+          roles = RelatonBib.array(ret[:contributor][i][:role]).map do |r|
             if r.is_a? Hash
-              { type: r[:type], description: array(r[:description]) }
+              { type: r[:type], description: RelatonBib.array(r[:description]) }
             # elsif r.is_a? Array
             #   { type: r[0], description: r.fetch(1) }
             else
@@ -219,13 +216,13 @@ module RelatonBib
         end
       end
 
-      def org_hash_to_bib(org)
+      def org_hash_to_bib(org) # rubocop:disable Metrics/AbcSize
         return nil if org.nil?
 
-        org[:identifier] = array(org[:identifier])&.map do |a|
+        org[:identifier] = RelatonBib.array(org[:identifier])&.map do |a|
           OrgIdentifier.new(a[:type], a[:id])
         end
-        org[:subdivision] = array(org[:subdivision]).map do |sd|
+        org[:subdivision] = RelatonBib.array(org[:subdivision]).map do |sd|
           LocalizedString.new sd
         end
         org[:contact] = contacts_hash_to_bib(org)
@@ -244,17 +241,17 @@ module RelatonBib
       def fullname_hash_to_bib(person) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
         n = person[:name]
         FullName.new(
-          forename: array(n[:forename])&.map { |f| localname(f, person) },
-          initial: array(n[:initial])&.map { |f| localname(f, person) },
-          addition: array(n[:addition])&.map { |f| localname(f, person) },
-          prefix: array(n[:prefix])&.map { |f| localname(f, person) },
+          forename: RelatonBib.array(n[:forename])&.map { |f| localname(f, person) },
+          initial: RelatonBib.array(n[:initial])&.map { |f| localname(f, person) },
+          addition: RelatonBib.array(n[:addition])&.map { |f| localname(f, person) },
+          prefix: RelatonBib.array(n[:prefix])&.map { |f| localname(f, person) },
           surname: localname(n[:surname], person),
           completename: localname(n[:completename], person),
         )
       end
 
       def person_identifiers_hash_to_bib(person)
-        array(person[:identifier])&.map do |a|
+        RelatonBib.array(person[:identifier])&.map do |a|
           PersonIdentifier.new(a[:type], a[:id])
         end
       end
@@ -262,8 +259,8 @@ module RelatonBib
       def affiliation_hash_to_bib(person) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         return [] unless person[:affiliation]
 
-        array(person[:affiliation]).map do |a|
-          a[:description] = array(a[:description])&.map do |d|
+        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] }
@@ -281,14 +278,20 @@ module RelatonBib
       def contacts_hash_to_bib(entity) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         return [] unless entity[:contact]
 
-        array(entity[:contact]).map do |a|
-          if a[:city] || a[:country]
+        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]
             )
-          else
+          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
@@ -297,8 +300,8 @@ module RelatonBib
       def copyright_hash_to_bib(ret)
         return unless ret[:copyright]
 
-        ret[:copyright] = array(ret[:copyright]).map do |c|
-          c[:owner] = array(c[:owner])
+        ret[:copyright] = RelatonBib.array(ret[:copyright]).map do |c|
+          c[:owner] = RelatonBib.array(c[:owner])
           c
         end
       end
@@ -307,7 +310,7 @@ module RelatonBib
       def relations_hash_to_bib(ret)
         return unless ret[:relation]
 
-        ret[:relation] = array(ret[:relation])
+        ret[:relation] = RelatonBib.array(ret[:relation])
         ret[:relation]&.each do |r|
           if r[:description]
             r[:description] = FormattedString.new(**r[:description])
@@ -321,7 +324,7 @@ module RelatonBib
       # @param rel [Hash] relation
       def relation_bibitem_hash_to_bib(rel)
         if rel[:bibitem]
-          rel[:bibitem] = bib_item hash_to_bib(rel[:bibitem], true)
+          rel[:bibitem] = bib_item hash_to_bib(rel[:bibitem])
         else
           warn "[relaton-bib] bibitem missing: #{rel}"
           rel[:bibitem] = nil
@@ -337,14 +340,15 @@ module RelatonBib
       # @param rel [Hash] relation
       # @return [RelatonBib::LocalityStack]
       def relation_locality_hash_to_bib(rel)
-        rel[:locality] = array(rel[:locality])&.map do |bl|
+        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]
-          array(lls[:locality_stack]).map do |l|
+          RelatonBib.array(lls[:locality_stack]).map do |lc|
+            l = lc[:locality] || lc
             Locality.new(l[:type], l[:reference_from], l[:reference_to])
           end
         else
@@ -354,9 +358,9 @@ module RelatonBib
 
       # @param rel [Hash] relation
       def relation_source_locality_hash_to_bib(rel) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        rel[:source_locality] = array(rel[:source_locality])&.map do |sl|
+        rel[:source_locality] = RelatonBib.array(rel[:source_locality])&.map do |sl|
           sls = if sl[:source_locality_stack]
-                  array(sl[:source_locality_stack]).map do |l|
+                  RelatonBib.array(sl[:source_locality_stack]).map do |l|
                     SourceLocality.new(l[:type], l[:reference_from],
                                        l[:reference_to])
                   end
@@ -371,7 +375,7 @@ module RelatonBib
 
       # @param ret [Hash]
       def series_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
-        ret[:series] = array(ret[:series])&.map do |s|
+        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)
@@ -397,7 +401,7 @@ module RelatonBib
       # @param ret [Hash]
       def classification_hash_to_bib(ret)
         if ret[:classification]
-          ret[:classification] = array(ret[:classification]).map do |cls|
+          ret[:classification] = RelatonBib.array(ret[:classification]).map do |cls|
             Classification.new(**cls)
           end
         end
@@ -431,7 +435,7 @@ module RelatonBib
       def editorialgroup_hash_to_bib(ret)
         return unless ret[:editorialgroup]
 
-        technical_committee = array(ret[:editorialgroup]).map do |wg|
+        technical_committee = RelatonBib.array(ret[:editorialgroup]).map do |wg|
           TechnicalCommittee.new WorkGroup.new(**wg)
         end
         ret[:editorialgroup] = EditorialGroup.new technical_committee
@@ -441,15 +445,15 @@ module RelatonBib
       def ics_hash_to_bib(ret)
         return unless ret[:ics]
 
-        ret[:ics] = array(ret[:ics]).map { |ics| ICS.new(**ics) }
+        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]
 
-        sids = array(ret[:structuredidentifier]).map do |si|
-          si[:agency] = array si[:agency]
+        sids = RelatonBib.array(ret[:structuredidentifier]).map do |si|
+          si[:agency] = RelatonBib.array si[:agency]
           StructuredIdentifier.new(**si)
         end
         ret[:structuredidentifier] = StructuredIdentifierCollection.new sids
@@ -469,15 +473,6 @@ module RelatonBib
         end
       end
 
-      # @param arr [NilClass, Array, #is_a?]
-      # @return [Array]
-      def array(arr)
-        return [] unless arr
-        return [arr] unless arr.is_a?(Array)
-
-        arr
-      end
-
       # @param name [Hash, String, NilClass]
       # @param person [Hash]
       # @return [RelatonBib::LocalizedString]

data/lib/relaton_bib/series.rb

@@ -13,7 +13,7 @@ module RelatonBib
     # @return [RelatonBib::FormattedRef, nil]
     attr_reader :formattedref
 
-    # @return [RelatonBib::TypedTitleString, nil] title
+    # @return [RelatonBib::TypedTitleString] title
     attr_reader :title
 
     # @return [String, nil]
@@ -26,8 +26,7 @@ module RelatonBib
 
     # @param type [String, nil]
     # @param formattedref [RelatonBib::FormattedRef, nil]
-    # @param title [RelatonBib::TypedTitleString, nil] title or
-    #   formattedref argument should be passed
+    # @param title [RelatonBib::TypedTitleString] title
     # @param place [String, nil]
     # @param orgaization [String, nil]
     # @param abbreviation [RelatonBib::LocalizedString, nil]
@@ -37,9 +36,8 @@ module RelatonBib
     # @param partnumber [String, nil]
     # @param run [String, nil]
     def initialize(**args)
-      unless args[:title].is_a?(RelatonBib::TypedTitleString) ||
-          args[:formattedref]
-        raise ArgumentError, "argument `title` or `formattedref` should present"
+      unless args[:title].is_a?(RelatonBib::TypedTitleString)
+        raise ArgumentError, "argument `title` should present in series"
       end
 
       # if args[:type] && !TYPES.include?(args[:type])
@@ -65,19 +63,16 @@ module RelatonBib
     # @param builder [Nokogiri::XML::Builder]
     def to_xml(builder) # rubocop:disable Metrics/MethodLength
       xml = builder.series do
-        if formattedref
-          formattedref.to_xml builder
-        else
-          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
+        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
@@ -89,7 +84,7 @@ module RelatonBib
       hash = {}
       hash["type"] = type if type
       hash["formattedref"] = formattedref.to_hash if formattedref
-      hash["title"] = title.to_hash if title
+      hash["title"] = title.to_hash
       hash["place"] = place if place
       hash["organization"] = organization if organization
       hash["abbreviation"] = abbreviation.to_hash if abbreviation
@@ -109,7 +104,7 @@ module RelatonBib
       out = count > 1 ? "#{pref}::\n" : ""
       out += "#{pref}.type:: #{type}\n" if type
       out += formattedref.to_asciibib pref if formattedref
-      out += title.to_asciibib pref if title
+      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

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "1.11.7".freeze
+  VERSION = "1.12.2".freeze
 end

data/lib/relaton_bib/xml_parser.rb

@@ -33,7 +33,7 @@ module RelatonBib
           docnumber: bibitem.at("./docnumber")&.text,
           date: fetch_dates(bibitem),
           contributor: fetch_contributors(bibitem),
-          edition: bibitem.at("./edition")&.text,
+          edition: fetch_edition(bibitem),
           version: fetch_version(bibitem),
           biblionote: fetch_note(bibitem),
           language: fetch_language(bibitem),
@@ -62,12 +62,18 @@ module RelatonBib
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def fetch_version(item)
-        version = item.at "./version"
-        return unless version
+        item.xpath("./version").map do |v|
+          revision_date = v.at("revision-date")&.text
+          draft = v.at("draft")&.text
+          RelatonBib::BibliographicItem::Version.new revision_date, draft
+        end
+      end
+
+      def fetch_edition(item)
+        edt = item.at("./edition")
+        return unless edt
 
-        revision_date = version.at("revision-date")&.text
-        draft = version.xpath("draft").map &:text
-        RelatonBib::BibliographicItem::Version.new revision_date, draft
+        Edition.new content: edt.text, number: edt[:number]
       end
 
       def fetch_place(item)
@@ -189,10 +195,11 @@ module RelatonBib
       # @param item [Nokogiri::XML::Element]
       # @return [Array<RelatonBib::DocumentIdentifier>]
       def fetch_docid(item)
-        item.xpath("./docidentifier").map do |did|
-          primary = true if did[:primary] == "true"
-          DocumentIdentifier.new(id: did.text, type: did[:type],
-                                 scope: did[:scope], primary: primary)
+        item.xpath("./docidentifier").map do |id|
+          did = id.to_h.transform_keys(&:to_sym)
+          did[:id] = id.text
+          did[:primary] = id[:primary] == "true" ? true : nil
+          DocumentIdentifier.new(**did)
         end
       end
 

data/lib/relaton_bib.rb

@@ -36,6 +36,31 @@ module RelatonBib
         str ? $~[:date] : Date.strptime($~[:date], "%Y")
       end
     end
+
+    # @param arr [NilClass, Array, #is_a?]
+    # @return [Array]
+    def array(arr)
+      return [] unless arr
+      return [arr] unless arr.is_a?(Array)
+
+      arr
+    end
+
+    #
+    # Parse yaml content
+    #
+    # @param [String] yaml content
+    #
+    # @return [Hash] data
+    #
+    def parse_yaml(yaml, classes = [])
+      # Newer versions of Psych uses the `permitted_classes:` parameter
+      if YAML.method(:safe_load).parameters.map(&:last).include? :permitted_classes
+        YAML.safe_load(yaml, permitted_classes: classes)
+      else
+        YAML.safe_load(yaml, classes)
+      end
+    end
   end
 
   private

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-bib
 version: !ruby/object:Gem::Version
-  version: 1.11.7
+  version: 1.12.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: byebug
@@ -249,6 +249,7 @@ files:
 - lib/relaton_bib/document_relation.rb
 - lib/relaton_bib/document_relation_collection.rb
 - lib/relaton_bib/document_status.rb
+- lib/relaton_bib/edition.rb
 - lib/relaton_bib/editorial_group.rb
 - lib/relaton_bib/formatted_ref.rb
 - lib/relaton_bib/formatted_string.rb