relaton-bib 0.9.2 → 1.0.4

data/lib/relaton_bib/bibliographic_item.rb

@@ -167,8 +167,12 @@ module RelatonBib
     #
     # @param relation [Array<Hash>]
     # @option relation [String] :type
-    # @option relation [RelatonBib::BibliographicItem, RelatonIso::IsoBibliographicItem] :bibitem
-    # @option relation [Array<RelatonBib::BibItemLocality>] :bib_locality
+    # @option relation [RelatonBib::BibliographicItem,
+    #                   RelatonIso::IsoBibliographicItem] :bibitem
+    # @option relation [Array<RelatonBib::Locality,
+    #                   RelatonBib::LocalityStack>] :locality
+    # @option relation [Array<RelatonBib::SourceLocality,
+    #                   RelatonBib::SourceLocalityStack>] :source_locality
     #
     # @param link [Array<Hash, RelatonBib::TypedUri>]
     # @option link [String] :type

data/lib/relaton_bib/bibtex_parser.rb

@@ -147,17 +147,16 @@ module RelatonBib
       # @param bibtex [BibTeX::Entry]
       # @return [Array<RelatonBib::BiblioNote>]
       def fetch_note(bibtex)
-        note = []
-        note << BiblioNote.new(type: "annote", content: bibtex.annote.to_s) if bibtex["annote"]
-
-        if bibtex["howpublished"]
-          note << BiblioNote.new(type: "howpublished", content: bibtex.howpublished.to_s)
+        bibtex.select do |k, _v|
+          %i[annote howpublished comment note content].include? k
+        end.reduce([]) do |mem, note|
+          type = case note[0]
+                 when :note then nil
+                 when :content then "tableOfContents"
+                 else note[0].to_s
+                 end
+          mem << BiblioNote.new(type: type, content: note[1].to_s)
         end
-
-        note << BiblioNote.new(type: "comment", content: bibtex.comment.to_s) if bibtex["comment"]
-        note << BiblioNote.new(content: bibtex.note.to_s) if bibtex["note"]
-        note << BiblioNote.new(type: "tableOfContents", content: bibtex["content"]) if bibtex["content"]
-        note
       end
 
       # @param bibtex [BibTeX::Entry]
@@ -172,16 +171,19 @@ module RelatonBib
       # @param bibtex [BibTeX::Entry]
       # @return [Array<RelatonBib::BibItemLocality>]
       def fetch_extent(bibtex)
-        extent = []
-        extent << BibItemLocality.new("chapter", bibtex.chapter.to_s) if bibtex["chapter"]
-
-        if bibtex["pages"]
-          from, to = bibtex.pages.to_s.split "-"
-          extent << BibItemLocality.new("page", from, to)
+        bibtex.select do |k, _v|
+          %i[chapter pages volume].include? k
+        end.reduce([]) do |mem, loc|
+          if loc[0] == :pages
+            type = "page"
+            from, to = loc[1].to_s.split "-"
+          else
+            type = loc[0].to_s
+            from = loc[1].to_s
+            to = nil
+          end
+          mem << BibItemLocality.new(type, from, to)
         end
-
-        extent << BibItemLocality.new("volume", bibtex.volume.to_s) if bibtex["volume"]
-        extent
       end
 
       # @param bibtex [BibTeX::Entry]
@@ -192,7 +194,7 @@ module RelatonBib
           series << Series.new(
             type: "journal",
             title: TypedTitleString.new(content: bibtex.journal.to_s),
-            number: bibtex["number"]&.to_s
+            number: bibtex["number"]&.to_s,
           )
         end
 

data/lib/relaton_bib/document_relation.rb

@@ -1,59 +1,83 @@
 module RelatonBib
-  # module DocumentRelationType
-  #   PARENT        = 'parent'
-  #   CHILD         = 'child'
-  #   OBSOLETES     = 'obsoletes'
-  #   UPDATES       = 'updates'
-  #   COMPLEMENTS   = 'complements'
-  #   DERIVED_FORM  = 'derivedForm'
-  #   ADOPTED_FORM  = 'adoptedForm'
-  #   EQUIVALENT    = 'equivalent'
-  #   IDENTICAL     = 'identical'
-  #   NONEQUIVALENT = 'nonequivalent'
-  # end
-
   # Documett relation
   class DocumentRelation
     include RelatonBib
 
+    TYPES = %w[
+      includes includedIn hasPart partOf merges mergedInto splits splitInto
+      instance hasInstance exemplarOf hasExemplar manifestationOf
+      hasManifestation reproductionOf hasReproduction reprintOf hasReprint
+      expressionOf hasExpression translatedFrom hasTranslation arrangementOf
+      hasArrangement abridgementOf hasAbridgement annotationOf hasAnnotation
+      draftOf hasDraft editionOf hasEdition updates updatedBy derivedFrom
+      derives describes describedBy catalogues cataloguedBy hasSuccessor
+      successorOf adaptedFrom hasAdaptation adoptedFrom adoptedAs reviewOf
+      hasReview commentaryOf hasCommentary related complements complementOf
+      obsoletes obsoletedBy cited isCitedIn
+    ].freeze
+
     # @return [String]
     attr_reader :type
 
+    # @return [RelatonBib::FormattedString, NilClass]
+    attr_reader :description
+
     # @return [String]
     # attr_reader :identifier, :url
 
     # @return [RelatonBib::BibliographicItem]
     attr_reader :bibitem
 
-    # @return [Array<RelatonBib::BibItemLocality>]
-    attr_reader :bib_locality
+    # @return [Array<RelatonBib::Locality, RelatonBib::LocalityStack>]
+    attr_reader :locality
+
+    # @return [Array<RelatonBib::SourceLocality,
+    #   RelatonBib::SourceLocalityStack>]
+    attr_reader :source_locality
 
     # @param type [String]
-    # @param bibitem [RelatonBib::BibliographicItem, RelatonIso::IsoBibliographicItem]
-    # @param bib_locality [Array<RelatonBib::BibItemLocality>]
-    def initialize(type:, bibitem:, bib_locality: [])
+    # @parma description [RelatonBib::FormattedString, NilClass]
+    # @param bibitem [RelatonBib::BibliographicItem,
+    #   RelatonIso::IsoBibliographicItem]
+    # @param locality [Array<RelatonBib::Locality, RelatonBib::LocalityStack>]
+    # @param source_locality [Array<RelatonBib::SourceLocality,
+    #   RelatonBib::SourceLocalityStack>]
+    def initialize(type:, description: nil, bibitem:, locality: [],
+                   source_locality: [])
       type = "obsoletes" if type == "Now withdrawn"
-      @type         = type
-      @bib_locality = bib_locality
-      @bibitem      = bibitem
+      unless TYPES.include? type
+        warn "[relaton-bib] WARNING: invalid relation type: #{type}"
+      end
+      @type            = type
+      @description     = description
+      @locality        = locality
+      @source_locality = source_locality
+      @bibitem         = bibitem
     end
 
+    # rubocop:disable Metrics/AbcSize
+
     # @param builder [Nokogiri::XML::Builder]
     def to_xml(builder, **opts)
       opts.delete :bibdata
       opts.delete :note
       builder.relation(type: type) do
+        builder.description { description.to_xml builder } if description
         bibitem.to_xml(builder, **opts.merge(embedded: true))
-        bib_locality.each do |l|
-          builder.locality { l.to_xml builder }
-        end
+        locality.each { |l| l.to_xml builder }
+        source_locality.each { |l| l.to_xml builder }
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # @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["description"] = description.to_hash if description
+      hash["locality"] = single_element_array(locality) if locality&.any?
+      if source_locality&.any?
+        hash["source_locality"] = single_element_array(source_locality)
+      end
       hash
     end
   end

data/lib/relaton_bib/document_relation_collection.rb

@@ -1,21 +1,34 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module RelatonBib
   # Document relation collection
-  class DocRelationCollection < Array
+  class DocRelationCollection
+    extend Forwardable
+
+    def_delegators :@array, :<<, :[], :first, :last, :empty?, :any?, :size,
+      :each, :detect, :map, :length
+
     # @param relation [Array<RelatonBib::DocumentRelation, Hash>]
     # @option relation [String] :type
     # @option relation [String] :identifier
     # @option relation [String, NIllClass] :url (nil)
-    # @option relation [Array<RelatonBib::BibItemLocality>] :bib_locality
+    # @option relation [Array<RelatonBib::Locality,
+    #                   RelatonBib::LocalityStack>] :locality
+    # @option relation [Array<RelatonBib::SourceLocality,
+    #                   RelatonBib::SourceLocalityStack>] :source_locality
     # @option relation [RelatonBib::BibliographicItem, NillClass] :bibitem (nil)
     def initialize(relation)
-      super relation.map { |r| r.is_a?(Hash) ? DocumentRelation.new(r) : r }
+      @array =  relation.map { |r| r.is_a?(Hash) ? DocumentRelation.new(r) : r }
     end
 
-    # @return [Array<RelatonBib::DocumentRelation>]
+    # @todo We don't have replace type anymore. Suppose we should update this
+    #   method or delete it.
+    #
+    # @return [RelatonBib::DocRelationCollection]
     def replaces
-      select { |r| r.type == "replace" }
+      DocRelationCollection.new(@array.select { |r| r.type == "replace" })
     end
   end
 end

data/lib/relaton_bib/document_status.rb

@@ -14,12 +14,12 @@ module RelatonBib
     # @return [String, NilClass]
     attr_reader :iteration
 
-    # @param stage [String]
-    # @param substage [String, NilClass]
+    # @param stage [String, Hash, RelatonBib::DocumentStatus::Stage]
+    # @param substage [String, Hash, NilClass, RelatonBib::DocumentStatus::Stage]
     # @param iteration [String, NilClass]
     def initialize(stage:, substage: nil, iteration: nil)
-      @stage = stage
-      @substage = substage
+      @stage = stage_new stage
+      @substage = stage_new substage
       @iteration = iteration
     end
 
@@ -27,18 +27,56 @@ module RelatonBib
     def to_xml(builder)
       builder.status do
         # FormattedString.instance_method(:to_xml).bind(status).call builder
-        builder.stage stage
-        builder.substage substage if substage
+        builder.stage { |b| stage.to_xml b }
+        builder.substage { |b| substage.to_xml b } if substage
         builder.iteration iteration unless iteration.to_s.empty?
       end
     end
 
     # @return [Hash]
     def to_hash
-      hash = { "stage" => stage }
-      hash["substage"] = substage if substage
+      hash = { "stage" => stage.to_hash }
+      hash["substage"] = substage.to_hash if substage
       hash["iteration"] = iteration if iteration
       hash
     end
+
+    private
+
+    # @param stg [RelatonBib::DocumentStatus::Stage, Hash, String, NilClass]
+    def stage_new(stg)
+      if stg.is_a?(Stage) then stg
+      elsif stg.is_a?(Hash) then Stage.new(stg)
+      elsif stg.is_a?(String) then Stage.new(value: stg)
+      end
+    end
+
+    class Stage
+      # @return [String]
+      attr_reader :value
+
+      # @return [String, NilClass]
+      attr_reader :abbreviation
+
+      # @parma value [String]
+      # @param abbreviation [String, NilClass]
+      def initialize(value:, abbreviation: nil)
+        @value = value
+        @abbreviation = abbreviation
+      end
+
+      # @param [Nokogiri::XML::Builder]
+      def to_xml(builder)
+        builder.parent[:abbreviation] = abbreviation if abbreviation
+        builder.text value
+      end
+
+      # @return [Hash]
+      def to_hash
+        hash = { "value" => value }
+        hash["abbreviation"] = abbreviation if abbreviation
+        hash
+      end
+    end
   end
 end

data/lib/relaton_bib/formatted_string.rb

@@ -12,7 +12,7 @@ module RelatonBib
     # @return [String]
     attr_reader :format
 
-    # @param content [String]
+    # @param content [String, Array<RelatonBib::LocalizedString>]
     # @param language [String, NilClass] language code Iso639
     # @param script [String, NilClass] script code Iso15924
     # @param format [String] the content type
@@ -36,8 +36,8 @@ module RelatonBib
       hash = super
       return hash unless format
 
-      hash = { "content" => hash } if hash.is_a? String
-      hash["format"] = format if format
+      hash = { "content" => hash } unless hash.is_a? Hash
+      hash["format"] = format
       hash
     end
   end

data/lib/relaton_bib/hash_converter.rb

@@ -1,6 +1,11 @@
 module RelatonBib
   class HashConverter
     class << self
+      # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+
+      # @param args [Hash]
+      # @param neated [TrueClas, FalseClass] default true
+      # @return [Hash]
       def hash_to_bib(args, nested = false)
         return nil unless args.is_a?(Hash)
 
@@ -30,6 +35,7 @@ module RelatonBib
         ret[:license] = array(ret[:license])
         ret
       end
+      # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
       def timestamp_hash(ret)
         ret[:fetched] ||= Date.today.to_s
@@ -151,12 +157,21 @@ module RelatonBib
 
       def docstatus_hash_to_bib(ret)
         ret[:docstatus] && ret[:docstatus] = DocumentStatus.new(
-          stage: ret[:docstatus][:stage],
-          substage: ret[:docstatus][:substage],
+          stage: stage(ret[:docstatus][:stage]),
+          substage: stage(ret[:docstatus][:substage]),
           iteration: ret[:docstatus][:iteration],
         )
       end
 
+      # @param stg [Hash]
+      # @return [RelatonBib::DocumentStatus::Stage]
+      def stage(stg)
+        return unless stg
+
+        args = stg.is_a?(String) ? { value: stg } : stg
+        DocumentStatus::Stage.new(**args)
+      end
+
       def contributors_hash_to_bib(ret)
         return unless ret[:contributor]
 
@@ -252,47 +267,70 @@ module RelatonBib
         end
       end
 
+      # @param ret [Hash]
       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)
-          relation_biblocality_hash_to_bib(ret, r, i)
+        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 ret [Hash]
       # @param rel [Hash] relation
-      # @param idx [Integr] index of relation
-      def relation_bibitem_hash_to_bib(ret, rel, idx)
+      def relation_bibitem_hash_to_bib(rel)
         if rel[:bibitem]
-          ret[:relation][idx][:bibitem] = bib_item(hash_to_bib(rel[:bibitem], true))
+          rel[:bibitem] = bib_item hash_to_bib(rel[:bibitem], true)
         else
           warn "[relaton-bib] bibitem missing: #{rel}"
-          ret[:relation][idx][:bibitem] = nil
+          rel[:bibitem] = nil
         end
       end
 
-      # @param item [Hash]
-      # @retirn [RelatonBib::BibliographicItem]
-      def bib_item(item)
-        BibliographicItem.new(item)
+      # @param item_hash [Hash]
+      # @return [RelatonBib::BibliographicItem]
+      def bib_item(item_hash)
+        BibliographicItem.new item_hash
       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
+      # @param rel [Hash] relation
+      def relation_locality_hash_to_bib(rel)
+        rel[:locality] = array(rel[:locality])&.map do |bl|
+          ls = if bl[:locality_stack]
+                  array(bl[:locality_stack]).map do |l|
+                    Locality.new(l[:type], l[:reference_from], l[:reference_to])
+                  end
+                else
+                  [Locality.new(bl[:type], bl[:reference_from], bl[:reference_to])]
+                end
+          LocalityStack.new ls
+        end
+      end
+
+      # @param rel [Hash] relation
+      def relation_source_locality_hash_to_bib(rel)
+        rel[:source_locality] = array(rel[:source_locality])&.map do |sl|
+          sls = if sl[:source_locality_stack]
+                  array(sl[:source_locality_stack]).map do |l|
+                    SourceLocality.new(l[:type], l[:reference_from], l[:reference_to])
+                  end
+                else
+                  [SourceLocality.new(sl[:type], sl[:reference_from], sl[:reference_to])]
+                end
+          SourceLocalityStack.new sls
+        end
       end
 
       def series_hash_to_bib(ret)
         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] = { content: s[:title] } unless s[:title].is_a?(Hash)
             s[:title] = typed_title_strig(s[:title])
           end
           s[:abbreviation] && s[:abbreviation] = localizedstring(s[:abbreviation])