relaton-bib 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2652e6a30640ef8035238e6ae6126063b9057890
-  data.tar.gz: 03f6a59bf6dd3d152578073e55d5d35b235bfc34
+  metadata.gz: ceddccd39bcf1423b79aa28256b8bdc0cd5d1920
+  data.tar.gz: 3f4fb8004a268ebe022e00e989a8f01427f2beb9
 SHA512:
-  metadata.gz: 6ead52473fc5af8a5c86d9fce36bc048f383c3740c2047a7fd7bfc26cfd3f6211587842a0a5add6cdc7d1060e4d9d1d6f167b4e20fb751f8482f3c2a53be2e68
-  data.tar.gz: 540bccaead183468e59e4ea8b3edc64352d1d1df1c12ca6f3a09e4e8f7c3c2f891681490a5f7d548412833dcdc9c05b96839e8a134306b1e464d92041148e863
+  metadata.gz: 59f0667f7628db03cb608f784ba64780796b20933d0531607c53ef51c65d5dd3252f493a8831994d706278de517ec0b6416ddcad7b9056f9f0c86c0e543392f1
+  data.tar.gz: c5df8ae589ab71e155ef6a51edde861350169528982d673fe450a084132aaa895f7ae4efe627f65ddf67ae41d1c1d5f9d2bd1670f394e01452d453eef98158f3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    relaton-bib (0.3.6)
+    relaton-bib (0.3.7)
       addressable
       nokogiri
 

data/lib/relaton_bib/bibliographic_date.rb

@@ -6,8 +6,7 @@ module RelatonBib
   # Bibliographic date.
   class BibliographicDate
     TYPES = %w[published accessed created implemented obsoleted confirmed
-               updated issued transmitted copied unchanged circulated
-    ].freeze
+               updated issued transmitted copied unchanged circulated adapted].freeze
 
     # @return [String]
     attr_reader :type
@@ -28,7 +27,7 @@ module RelatonBib
     def initialize(type:, on: nil, from: nil, to: nil)
       raise ArgumentError, "expected :on or :from argument" unless on || from
 
-      raise ArgumentError, "invalid type: #{type}" unless TYPES.include? type
+      # raise ArgumentError, "invalid type: #{type}" unless TYPES.include? type
 
       @type = type
       @on   = RelatonBib.parse_date on

data/lib/relaton_bib/bibliographic_item.rb

@@ -169,7 +169,7 @@ module RelatonBib
     # @option link [String] :content
     def initialize(**args)
       if args[:type] && !TYPES.include?(args[:type])
-        raise ArgumentError, %{Type "#{args[:type]}" is invalid.}
+        warn %{Document type "#{args[:type]}" is invalid.}
       end
 
       @title = (args[:title] || []).map do |t|

data/lib/relaton_bib/formatted_string.rb

@@ -13,8 +13,8 @@ module RelatonBib
     attr_reader :format
 
     # @param content [String]
-    # @param language [String] language code Iso639
-    # @param script [String] script code Iso15924
+    # @param language [String, NilClass] language code Iso639
+    # @param script [String, NilClass] script code Iso15924
     # @param format [String] the content type
     def initialize(content:, language: nil, script: nil, format: "text/plain")
       # if format && !FORMATS.include?(format)

data/lib/relaton_bib/hash_converter.rb

@@ -35,6 +35,7 @@ module RelatonBib
 
       def extent_hash_to_bib(ret)
         return unless ret[:extent]
+
         ret[:extent] = array(ret[:extent])
         ret[:extent]&.each_with_index do |e, i|
           ret[:extent][i] = BibItemLocality.new(e[:type], e[:reference_from],
@@ -44,45 +45,57 @@ module RelatonBib
 
       def title_hash_to_bib(ret)
         return unless ret[:title]
+
         ret[:title] = array(ret[:title])
         ret[:title] = ret[:title].map do |t|
-          t.is_a?(Hash) ? t : { content: t, language: "en", script: "Latn", 
-                                format: "text/plain", type: "main" }
+          if t.is_a?(Hash) then t
+          else
+            { content: t, language: "en", script: "Latn", format: "text/plain", type: "main" }
+          end
         end
       end
 
       def language_hash_to_bib(ret)
         return unless ret[:language]
+
         ret[:language] = array(ret[:language])
       end
 
       def script_hash_to_bib(ret)
         return unless ret[:script]
+
         ret[:script] = array(ret[:script])
       end
 
       def abstract_hash_to_bib(ret)
         return unless ret[:abstract]
-        ret[:abstract] = array(ret[:abstract])
+
+        ret[:abstract] = 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]
+
         ret[:link] = array(ret[:link])
       end
 
       def place_hash_to_bib(ret)
         return unless ret[:place]
+
         ret[:place] = array(ret[:place])
       end
 
       def accesslocation_hash_to_bib(ret)
         return unless ret[:accesslocation]
+
         ret[:accesslocation] = array(ret[:accesslocation])
       end
 
       def dates_hash_to_bib(ret)
         return unless ret[:date]
+
         ret[:date] = array(ret[:date])
         ret[:date].each_with_index do |d, i|
           # value is synonym of on: it is reserved word in YAML
@@ -95,6 +108,7 @@ module RelatonBib
 
       def docid_hash_to_bib(ret)
         return unless ret[:docid]
+
         ret[:docid] = array(ret[:docid])
         ret[:docid]&.each_with_index do |id, i|
           ret[:docid][i] = DocumentIdentifier.new(id: id[:id], type: id[:type])
@@ -103,32 +117,35 @@ module RelatonBib
 
       def version_hash_to_bib(ret)
         return unless ret[:version]
+
         ret[:version][:draft] = array(ret[:version][:draft])
-        ret[:version] and ret[:version] = BibliographicItem::Version.new(
-            ret[:version][:revision_date], ret[:version][:draft])
+        ret[:version] && ret[:version] = BibliographicItem::Version.new(
+          ret[:version][:revision_date], ret[:version][:draft]
+        )
       end
 
       def biblionote_hash_to_bib(ret)
         return unless ret[:biblionote]
+
         ret[:biblionote] = array(ret[:biblionote])
         (ret[:biblionote])&.each_with_index do |n, i|
-          ret[:biblionote][i] =
-            BiblioNote.new(content: n[:content], type: n[:type], 
-                          language: n[:language], 
-                          script: n[:script], format: n[:format])
+          ret[:biblionote][i] = BiblioNote.new(
+            content: n[:content], type: n[:type], language: n[:language],
+            script: n[:script], format: n[:format]
+          )
         end
       end
 
       def formattedref_hash_to_bib(ret)
-        ret[:formattedref] and ret[:formattedref] =
-          formattedref(ret[:formattedref])
+        ret[:formattedref] && ret[:formattedref] = formattedref(ret[:formattedref])
       end
 
       def docstatus_hash_to_bib(ret)
-        ret[:docstatus] and ret[:docstatus] =
-          DocumentStatus.new(stage: ret[:docstatus][:stage],
-                            substage: ret[:docstatus][:substage],
-                            iteration: ret[:docstatus][:iteration])
+        ret[:docstatus] && ret[:docstatus] = DocumentStatus.new(
+          stage: ret[:docstatus][:stage],
+          substage: ret[:docstatus][:substage],
+          iteration: ret[:docstatus][:iteration],
+        )
       end
 
       def contributors_hash_to_bib(ret)
@@ -146,73 +163,83 @@ module RelatonBib
             end
           end
           ret[:contributor][i][:role] = roles
-          ret[:contributor][i][:entity] = c[:person] ?
-            person_hash_to_bib(c[:person]) : org_hash_to_bib(c[:organization])
+          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(c)
-        return nil if c.nil?
-        c[:identifier] = array(c[:identifier])&.map do |a|
+      def org_hash_to_bib(org)
+        return nil if org.nil?
+
+        org[:identifier] = array(org[:identifier])&.map do |a|
           OrgIdentifier.new(a[:type], a[:id])
         end
-        c
+        org
       end
 
-      def person_hash_to_bib(c)
+      def person_hash_to_bib(person)
         Person.new(
-          name: fullname_hash_to_bib(c),
-          affiliation: affiliation_hash_to_bib(c),
-          contact: contacts_hash_to_bib(c),
-          identifier: person_identifiers_hash_to_bib(c),
+          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 fullname_hash_to_bib(c)
-        n = c[:name]
+      def fullname_hash_to_bib(person)
+        n = person[:name]
         FullName.new(
-          forename: array(n[:forename])&.map { |f| localname(f, c) },
-          initial: array(n[:initial])&.map { |f| localname(f, c) },
-          addition: array(n[:addition])&.map { |f| localname(f, c) },
-          prefix: array(n[:prefix])&.map { |f| localname(f, c) },
-          surname: localname(n[:surname], c),
-          completename: localname(n[:completename], c),
+          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) },
+          surname: localname(n[:surname], person),
+          completename: localname(n[:completename], person),
         )
       end
 
-      def person_identifiers_hash_to_bib(c)
-        array(c[:identifier])&.map do |a|
+      def person_identifiers_hash_to_bib(person)
+        array(person[:identifier])&.map do |a|
           PersonIdentifier.new(a[:type], a[:id])
         end
       end
 
-      def affiliation_hash_to_bib(c)
-        return [] unless c[:affiliation]
-        array(c[:affiliation]).map do |a|
+      def affiliation_hash_to_bib(person)
+        return [] unless person[:affiliation]
+
+        array(person[:affiliation]).map do |a|
           a[:description] = array(a[:description])&.map do |d|
-            FormattedString.new(
-              d.is_a?(Hash) ?
-              { content: d[:content], language: d[:language],
-                script: d[:script], format: d[:format] } : 
-            { content: 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
           Affilation.new(
             organization: Organization.new(org_hash_to_bib(a[:organization])),
-            description: a[:description]
+            description: a[:description],
           )
         end
       end
 
-      def contacts_hash_to_bib(c)
-        return [] unless c[:contact]
-        array(c[:contact]).map do |a|
-          (a[:city] || a[:country]) ?
+      def contacts_hash_to_bib(person)
+        return [] unless person[:contact]
+
+        array(person[:contact]).map do |a|
+          if a[:city] || a[:country]
             RelatonBib::Address.new(
               street: Array(a[:street]), city: a[:city], postcode: a[:postcode],
-              country: a[:country], state: a[:state]) :
-          RelatonBib::Contact.new(type: a[:type], value: a[:value])
+              country: a[:country], state: a[:state]
+            )
+          else
+            RelatonBib::Contact.new(type: a[:type], value: a[:value])
+          end
         end
       end
 
@@ -227,14 +254,14 @@ module RelatonBib
       end
 
       # @param ret [Hash]
-      # @param r [Hash] relation
-      # @param i [Integr] index of relation
-      def relation_bibitem_hash_to_bib(ret, r, i)
-        if r[:bibitem]
-          ret[:relation][i][:bibitem] = bib_item(hash_to_bib(r[:bibitem], true))
+      # @param rel [Hash] relation
+      # @param idx [Integr] index of relation
+      def relation_bibitem_hash_to_bib(ret, rel, idx)
+        if rel[:bibitem]
+          ret[:relation][idx][:bibitem] = bib_item(hash_to_bib(rel[:bibitem], true))
         else
-          warn "bibitem missing: #{r}"
-          ret[:relation][i][:bibitem] = nil
+          warn "bibitem missing: #{rel}"
+          ret[:relation][idx][:bibitem] = nil
         end
       end
 
@@ -244,9 +271,9 @@ module RelatonBib
         BibliographicItem.new(item)
       end
 
-      def relation_biblocality_hash_to_bib(ret, r, i)
-        ret[:relation][i][:bib_locality] =
-          array(r[:bib_locality])&.map do |bl|
+      def relation_biblocality_hash_to_bib(ret, rel, idx)
+        ret[:relation][idx][:bib_locality] =
+          array(rel[:bib_locality])&.map do |bl|
             BibItemLocality.new(bl[:type], bl[:reference_from],
                                 bl[:reference_to])
           end
@@ -271,7 +298,7 @@ module RelatonBib
       end
 
       def medium_hash_to_bib(ret)
-        ret[:medium] and ret[:medium] = Medium.new(ret[:medium])
+        ret[:medium] = Medium.new(ret[:medium]) if ret[:medium]
       end
 
       def classification_hash_to_bib(ret)
@@ -279,52 +306,70 @@ module RelatonBib
         # ret[:classification]&.each_with_index do |c, i|
         # ret[:classification][i] = RelatonBib::Classification.new(c)
         # end
-        ret[:classification] and
+        if ret[:classification]
           ret[:classification] = Classification.new(ret[:classification])
+        end
       end
 
       def validity_hash_to_bib(ret)
         return unless ret[:validity]
-        ret[:validity][:begins] and b = Time.parse(ret[:validity][:begins])
-        ret[:validity][:ends] and e = Time.parse(ret[:validity][:ends])
-        ret[:validity][:revision] and r = Time.parse(ret[:validity][:revision])
+
+        ret[:validity][:begins] && b = Time.parse(ret[:validity][:begins])
+        ret[:validity][:ends] && e = Time.parse(ret[:validity][:ends])
+        ret[:validity][:revision] && r = Time.parse(ret[:validity][:revision])
         ret[:validity] = Validity.new(begins: b, ends: e, revision: r)
       end
 
+      # @param ogj [Hash, Array, String]
+      # @return [Hash, Array, String]
       def symbolize(obj)
-        obj.is_a? Hash and
-          return obj.inject({}){|memo,(k,v)| memo[k.to_sym] =  symbolize(v); memo}
-        obj.is_a? Array and
-          return obj.inject([]){|memo,v    | memo           << symbolize(v); memo}
-        return obj
+        if obj.is_a? Hash
+          obj.reduce({}) do |memo, (k, v)|
+            memo[k.to_sym] = symbolize(v)
+            memo
+          end
+        elsif obj.is_a? Array
+          obj.reduce([]) { |memo, v| memo << symbolize(v) }
+        else
+          obj
+        end
       end
 
-      def array(a)
-        return [] unless a
-        return [a] unless a.is_a?(Array)
-        a
+      def array(arr)
+        return [] unless arr
+        return [arr] unless arr.is_a?(Array)
+
+        arr
       end
 
-      def localname(f, c)
-        return nil if f.nil?
-        f.is_a?(Hash) and lang = f[:language] 
-        lang ||= c[:name][:language] 
-        f.is_a?(Hash) and script = f[:script] 
-        script ||= c[:name][:script]
-        f.is_a?(Hash) ?
-          RelatonBib::LocalizedString.new(f[:content], lang, script) :
-          RelatonBib::LocalizedString.new(f, lang, script)
+      def localname(name, person)
+        return nil if name.nil?
+
+        lang = name[:language] if name.is_a?(Hash)
+        lang ||= person[:name][:language]
+        script = name[:script] if name.is_a?(Hash)
+        script ||= person[:name][:script]
+        if name.is_a?(Hash)
+          RelatonBib::LocalizedString.new(name[:content], lang, script)
+        else
+          RelatonBib::LocalizedString.new(name, lang, script)
+        end
       end
 
-      def localizedstring(f)
-        f.is_a?(Hash) ?
-          RelatonBib::LocalizedString.new(f[:content], f[:language], f[:script]) :
-          RelatonBib::LocalizedString.new(f)
+      def localizedstring(lst)
+        if lst.is_a?(Hash)
+          RelatonBib::LocalizedString.new(lst[:content], lst[:language], lst[:script])
+        else
+          RelatonBib::LocalizedString.new(lst)
+        end
       end
 
-      def formattedref(f)
-        f.is_a?(Hash) ? RelatonBib::FormattedRef.new(f) :
-          RelatonBib::FormattedRef.new(content: f)
+      def formattedref(frf)
+        if frf.is_a?(Hash)
+          RelatonBib::FormattedRef.new(frf)
+        else
+          RelatonBib::FormattedRef.new(content: frf)
+        end
       end
     end
   end

data/lib/relaton_bib/hit.rb

@@ -4,7 +4,7 @@ module RelatonBib
     attr_reader :hit
 
     # @param hit [Hash]
-    # @param hit_collection [RelatonNist:HitCollection]
+    # @param hit_collection [RelatonIso::HitCollection, RelatonNist:HitCollection]
     def initialize(hit, hit_collection = nil)
       @hit            = hit
       @hit_collection = hit_collection

data/lib/relaton_bib/hit_collection.rb

@@ -9,7 +9,7 @@ module RelatonBib
     # @return [String]
     attr_reader :year
 
-    # @return [Iecbib::HitCollection]
+    # @return [RelatonIso::HitCollection]
     def fetch
       workers = WorkersPool.new 4
       workers.worker(&:fetch)

data/lib/relaton_bib/typed_title_string.rb

@@ -45,9 +45,16 @@ module RelatonBib
 
     # @return [Hash]
     def to_hash
-      hash = {}
-      hash["type"] = type if type
-      hash.merge title.to_hash
+      th = title.to_hash
+      return th unless type
+
+      hash = { "type" => type }
+      if th.is_a? String
+        hash["content"] = th
+      else
+        hash.merge th
+      end
+      hash
     end
   end
 end

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "0.3.6".freeze
+  VERSION = "0.3.7".freeze
 end

data/lib/relaton_bib/xml_parser.rb

@@ -5,7 +5,7 @@ module RelatonBib
     class << self
       def from_xml(xml)
         doc = Nokogiri::XML(xml)
-        bibitem = doc.at "/bibitem"
+        bibitem = doc.at "/bibitem|/bibdata"
         BibliographicItem.new(item_data(bibitem))
       end
 
@@ -29,8 +29,8 @@ module RelatonBib
           edition: bibitem.at("./edition")&.text,
           version: fetch_version(bibitem),
           biblionote: fetch_note(bibitem),
-          language: bibitem.xpath("./language").map(&:text),
-          script: bibitem.xpath("./script").map(&:text),
+          language: fetch_language(bibitem),
+          script: fetch_script(bibitem),
           abstract: fetch_abstract(bibitem),
           docstatus: fetch_status(bibitem),
           copyright: fetch_copyright(bibitem),
@@ -67,6 +67,14 @@ module RelatonBib
         end
       end
 
+      def fetch_language(item)
+        item.xpath("./language").reduce([]) { |a, l| l.text.empty? ? a : a << l.text }
+      end
+
+      def fetch_script(item)
+        item.xpath("./script").reduce([]) { |a, s| s.text.empty? ? a : a << s.text }
+      end
+
       # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
 
       def fetch_series(item)
@@ -145,8 +153,9 @@ module RelatonBib
         status = item.at("./status")
         return unless status
 
+        stage = status.at "stage"
         DocumentStatus.new(
-          stage: status.at("stage").text,
+          stage: stage ? stage.text : status.text,
           substage: status.at("substage")&.text,
           iteration: status.at("iteration")&.text,
         )
@@ -154,8 +163,9 @@ module RelatonBib
 
       def fetch_dates(item)
         item.xpath("./date").map do |d|
+          type = d[:type].to_s.empty? ? "published" : d[:type]
           RelatonBib::BibliographicDate.new(
-            type: d[:type], on: d.at("on")&.text, from: d.at("from")&.text,
+            type: type, on: d.at("on")&.text, from: d.at("from")&.text,
             to: d.at("to")&.text
           )
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-bib
 version: !ruby/object:Gem::Version
-  version: 0.3.6
+  version: 0.3.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-11 00:00:00.000000000 Z
+date: 2019-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler