relaton-bib 0.3.3 → 0.3.8

data/lib/relaton_bib/copyright_association.rb

@@ -1,10 +1,10 @@
 module RelatonBib
   # Copyright association.
   class CopyrightAssociation
-    # @return [Time]
+    # @return [Date]
     attr_reader :from
 
-    # @return [Time]
+    # @return [Date, NilClass]
     attr_reader :to
 
     # @return [RelatonBib::ContributionInfo]
@@ -22,17 +22,24 @@ module RelatonBib
                else owner
                end
 
-      @from  = Time.strptime(from, "%Y") unless from.empty?
-      @to    = Time.strptime(to, "%Y") unless to.to_s.empty?
+      @from  = Date.strptime(from.to_s, "%Y") if from.to_s =~ /\d{4}/
+      @to    = Date.strptime(to.to_s, "%Y") unless to.to_s.empty?
     end
 
     # @param builder [Nokogiri::XML::Builder]
     def to_xml(builder)
       builder.copyright do
-        builder.from from.year
+        builder.from from ? from.year : "unknown"
         builder.to to.year if to
         builder.owner { owner.to_xml builder }
       end
     end
+
+    # @return [Hash]
+    def to_hash
+      hash = { "owner" => owner.to_hash["organization"], "from" => from.year.to_s }
+      hash["to"] = to.year.to_s if to
+      hash
+    end
   end
 end

data/lib/relaton_bib/document_identifier.rb

@@ -43,5 +43,12 @@ module RelatonBib
     def to_xml(builder)
       builder.docidentifier(id, type: type)
     end
+
+    # @return [Hash]
+    def to_hash
+      hash = { "id" => id }
+      hash["type"] = type if type
+      hash
+    end
   end
 end

data/lib/relaton_bib/document_relation.rb

@@ -14,6 +14,8 @@ module RelatonBib
 
   # Documett relation
   class DocumentRelation
+    include RelatonBib
+
     # @return [String]
     attr_reader :type
 
@@ -47,5 +49,12 @@ module RelatonBib
         end
       end
     end
+
+    # @return [Hash]
+    def to_hash
+      hash = { "type" => type, "bibitem" => bibitem.to_hash }
+      hash["bib_locality"] = single_element_array(bib_locality) if bib_locality&.any?
+      hash
+    end
   end
 end

data/lib/relaton_bib/document_status.rb

@@ -32,5 +32,13 @@ module RelatonBib
         builder.iteration iteration unless iteration.to_s.empty?
       end
     end
+
+    # @return [Hash]
+    def to_hash
+      hash = { "stage" => stage }
+      hash["substage"] = substage if substage
+      hash["iteration"] = iteration if iteration
+      hash
+    end
   end
 end

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)
@@ -30,5 +30,15 @@ module RelatonBib
       builder.parent["format"] = format if format
       super
     end
+
+    # @return [Hash]
+    def to_hash
+      hash = super
+      return hash unless format
+
+      hash = { "content" => hash } if hash.is_a? String
+      hash["format"] = format if format
+      hash
+    end
   end
 end

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,118 +117,135 @@ 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)
         return unless ret[:contributor]
+
         ret[:contributor] = array(ret[:contributor])
         ret[:contributor]&.each_with_index do |c, i|
           roles = array(ret[:contributor][i][:role]).map do |r|
             if r.is_a? Hash
               { type: r[:type], description: array(r[:description]) }
-            elsif r.is_a? Array
-              { type: r[0], description: r.fetch(1) }
+            # elsif r.is_a? Array
+            #   { type: r[0], description: r.fetch(1) }
             else
               { type: r }
             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.new(org_hash_to_bib(a[:organization])), a[:description])
+            organization: Organization.new(org_hash_to_bib(a[:organization])),
+            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
 
       def relations_hash_to_bib(ret)
         return unless ret[:relation]
+
         ret[:relation] = array(ret[:relation])
         ret[:relation]&.each_with_index do |r, i|
           relation_bibitem_hash_to_bib(ret, r, i)
@@ -222,91 +253,123 @@ module RelatonBib
         end
       end
 
-      def relation_bibitem_hash_to_bib(ret, r, i)
-        if r[:bibitem] then ret[:relation][i][:bibitem] =
-            BibliographicItem.new(hash_to_bib(r[:bibitem], true))
+      # @param ret [Hash]
+      # @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
 
-      def relation_biblocality_hash_to_bib(ret, r, i)
-        ret[:relation][i][:bib_locality] =
-          array(r[:bib_locality])&.map do |bl|
+      # @param item [Hash]
+      # @retirn [RelatonBib::BibliographicItem]
+      def bib_item(item)
+        BibliographicItem.new(item)
+      end
+
+      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
       end
 
       def series_hash_to_bib(ret)
-        array(ret[:series])&.each_with_index do |s, i|
-          s[:formattedref] and s[:formattedref] = formattedref(s[:formattedref])
+        ret[:series] = array(ret[:series])&.map do |s|
+          s[:formattedref] && s[:formattedref] = formattedref(s[:formattedref])
           if s[:title]
             s[:title] = { content: s[:title] } unless s.is_a?(Hash)
-            s[:title] = TypedTitleString.new(s[:title])
+            s[:title] = typed_title_strig(s[:title])
           end
-          s[:abbreviation] and
-            s[:abbreviation] = localizedstring(s[:abbreviation])
-          ret[:series][i] = Series.new(s)
+          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
+
       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)
-        #ret[:classification] = [ret[:classification]] unless ret[:classification].is_a?(Array)
-        #ret[:classification]&.each_with_index do |c, i|
-        #ret[:classification][i] = RelatonBib::Classification.new(c)
-        #end
-        ret[:classification] and
+        # ret[:classification] = [ret[:classification]] unless ret[:classification].is_a?(Array)
+        # ret[:classification]&.each_with_index do |c, i|
+        # ret[:classification][i] = RelatonBib::Classification.new(c)
+        # end
+        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