relaton-bib 1.0.1 → 1.1.1

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/copyright_association.rb

@@ -1,29 +1,41 @@
 module RelatonBib
   # Copyright association.
   class CopyrightAssociation
+    include RelatonBib
+
     # @return [Date]
     attr_reader :from
 
     # @return [Date, NilClass]
     attr_reader :to
 
-    # @return [RelatonBib::ContributionInfo]
+    # @return [String, NilClass]
+    attr_reader :scope
+
+    # @return [Array<RelatonBib::ContributionInfo>]
     attr_reader :owner
 
-    # @param owner [Hash, RelatonBib::ContributionInfo] contributor
+    # rubocop:disable Metrics/AbcSize
+
+    # @param owner [Array<Hash, RelatonBib::ContributionInfo>] contributor
     # @option owner [String] :name
     # @option owner [String] :abbreviation
     # @option owner [String] :url
     # @param from [String] date
     # @param to [String, NilClass] date
-    def initialize(owner:, from:, to: nil)
-      @owner = if owner.is_a?(Hash)
-                 ContributionInfo.new entity: Organization.new(owner)
-               else owner
-               end
+    # @param scope [String, NilClass]
+    def initialize(owner:, from:, to: nil, scope: nil)
+      unless owner.any?
+        raise ArgumentError, "at least one owner should exist."
+      end
+
+      @owner = owner.map do |o|
+        o.is_a?(Hash) ? ContributionInfo.new(entity: Organization.new(o)) : o
+      end
 
       @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?
+      @scope = scope
     end
 
     # @param builder [Nokogiri::XML::Builder]
@@ -31,14 +43,21 @@ module RelatonBib
       builder.copyright do
         builder.from from ? from.year : "unknown"
         builder.to to.year if to
-        builder.owner { owner.to_xml builder }
+        owner.each { |o| builder.owner { o.to_xml builder } }
+        builder.scope scope if scope
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # @return [Hash]
     def to_hash
-      hash = { "owner" => owner.to_hash["organization"], "from" => from.year.to_s }
+      owners = single_element_array(owner.map { |o| o.to_hash["organization"] })
+      hash = {
+        "owner" => owners,
+        "from" => from.year.to_s,
+      }
       hash["to"] = to.year.to_s if to
+      hash["scope"] = scope if scope
       hash
     end
   end

data/lib/relaton_bib/document_relation.rb

@@ -4,11 +4,16 @@ module RelatonBib
     include RelatonBib
 
     TYPES = %w[
-      obsoletes obsoletedBy supersedes supersededBy updates updatedBy
-      complements derivedFrom translatedFrom hasTranslation adoptedFrom
-      equivalent identical nonequivalent includedIn includes instance
-      instanceOf partOf hasPart hasDraft draftOf merges splits amends amendedBy
-      corrects correctedBy revises revisedBy describes describedBy
+      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]
@@ -26,16 +31,20 @@ module RelatonBib
     # @return [Array<RelatonBib::Locality, RelatonBib::LocalityStack>]
     attr_reader :locality
 
-    # @return [Array<RelatonBib::SourceLocality, RelatonBib::SourceLocalityStack>]
+    # @return [Array<RelatonBib::SourceLocality,
+    #   RelatonBib::SourceLocalityStack>]
     attr_reader :source_locality
 
     # @param type [String]
     # @parma description [RelatonBib::FormattedString, NilClass]
-    # @param bibitem [RelatonBib::BibliographicItem, RelatonIso::IsoBibliographicItem]
+    # @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"
+    # @param source_locality [Array<RelatonBib::SourceLocality,
+    #   RelatonBib::SourceLocalityStack>]
+    def initialize(type:, description: nil, bibitem:, locality: [],
+                   source_locality: [])
+      type = "obsoletes" if type == "Now withdrawn"
       unless TYPES.include? type
         warn "[relaton-bib] WARNING: invalid relation type: #{type}"
       end
@@ -46,6 +55,8 @@ module RelatonBib
       @bibitem         = bibitem
     end
 
+    # rubocop:disable Metrics/AbcSize
+
     # @param builder [Nokogiri::XML::Builder]
     def to_xml(builder, **opts)
       opts.delete :bibdata
@@ -57,6 +68,7 @@ module RelatonBib
         source_locality.each { |l| l.to_xml builder }
       end
     end
+    # rubocop:enable Metrics/AbcSize
 
     # @return [Hash]
     def to_hash

data/lib/relaton_bib/document_relation_collection.rb

@@ -8,7 +8,7 @@ module RelatonBib
     extend Forwardable
 
     def_delegators :@array, :<<, :[], :first, :last, :empty?, :any?, :size,
-      :each, :detect, :map, :length
+                   :each, :detect, :map, :length
 
     # @param relation [Array<RelatonBib::DocumentRelation, Hash>]
     # @option relation [String] :type
@@ -20,15 +20,15 @@ module RelatonBib
     #                   RelatonBib::SourceLocalityStack>] :source_locality
     # @option relation [RelatonBib::BibliographicItem, NillClass] :bibitem (nil)
     def initialize(relation)
-      @array =  relation.map { |r| r.is_a?(Hash) ? DocumentRelation.new(r) : r }
+      @array = relation.map { |r| r.is_a?(Hash) ? DocumentRelation.new(r) : r }
     end
 
     # @todo We don't have replace type anymore. Suppose we should update this
     #   method or delete it.
     #
     # @return [RelatonBib::DocRelationCollection]
-    # def replaces
-    #   DocRelationCollection.new @array.select { |r| r.type == "replace" }
-    # end
+    def replaces
+      DocRelationCollection.new(@array.select { |r| r.type == "replace" })
+    end
   end
 end

data/lib/relaton_bib/document_status.rb

@@ -5,21 +5,21 @@ require "relaton_bib/localized_string"
 module RelatonBib
   # Document status.
   class DocumentStatus
-    # @return [String]
+    # @return [RelatonBib::DocumentStatus::Stage]
     attr_reader :stage
 
-    # @return [String, NilClass]
+    # @return [RelatonBib::DocumentStatus::Stage, NilClass]
     attr_reader :substage
 
     # @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,57 @@ 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]
+    # @return [RelatonBib::DocumentStatus::Stage]
+    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/editorial_group.rb

@@ -0,0 +1,27 @@
+require "relaton_bib/technical_committee"
+
+module RelatonBib
+  class EditorialGroup
+    include RelatonBib
+
+    # @return [Array<RelatonBib::TechnicalCommittee>]
+    attr_accessor :technical_committee
+
+    # @param technical_committee [Array<RelatonBib::TecnicalCommittee>]
+    def initialize(technical_committee)
+      @technical_committee = technical_committee
+    end
+
+    # @param builder [Nokogigi::XML::Builder]
+    def to_xml(builder)
+      builder.editorialgroup do |b|
+        technical_committee.each { |tc| tc.to_xml b }
+      end
+    end
+
+    # @return [Hash]
+    def to_hash
+      single_element_array technical_committee
+    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)
 
@@ -18,6 +23,7 @@ module RelatonBib
         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)
@@ -28,8 +34,12 @@ module RelatonBib
         validity_hash_to_bib(ret)
         ret[:keyword] = array(ret[:keyword])
         ret[:license] = 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 timestamp_hash(ret)
         ret[:fetched] ||= Date.today.to_s
@@ -48,11 +58,12 @@ module RelatonBib
       def title_hash_to_bib(ret)
         return unless ret[:title]
 
-        ret[:title] = array(ret[:title])
-        ret[:title] = ret[:title].map do |t|
-          if t.is_a?(Hash) then t
+        ret[:title] = array(ret[:title]).reduce([]) do |m, t|
+          if t.is_a?(Hash) then m << t
           else
-            { content: t, language: "en", script: "Latn", format: "text/plain", type: "main" }
+            m + TypedTitleString.from_string(t)
+            # { content: t, language: "en", script: "Latn", format: "text/plain",
+            #   type: "main" }
           end
         end
       end
@@ -151,12 +162,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,6 +272,16 @@ module RelatonBib
         end
       end
 
+      # @param ret [Hash]
+      def copyright_hash_to_bib(ret)
+        return unless ret[:copyright]
+
+        ret[:copyright] = array(ret[:copyright]).map do |c|
+          c[:owner] = array(c[:owner])
+          c
+        end
+      end
+
       # @param ret [Hash]
       def relations_hash_to_bib(ret)
         return unless ret[:relation]
@@ -284,15 +314,16 @@ module RelatonBib
       end
 
       # @param rel [Hash] relation
+      # @return [RelatonBib::LocalityStack]
       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
+                 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
@@ -311,11 +342,12 @@ module RelatonBib
         end
       end
 
+      # @param ret [Hash]
       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])
@@ -329,28 +361,60 @@ module RelatonBib
         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 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
         if ret[:classification]
-          ret[:classification] = array(ret[:classification]).map { |cls| Classification.new cls }
+          ret[:classification] = array(ret[:classification]).map do |cls|
+            Classification.new cls
+          end
         end
       end
 
+      # rubocop:disable Metrics/AbcSize
+
+      # @param ret [Hash]
       def validity_hash_to_bib(ret)
         return unless ret[:validity]
 
-        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][:begins] && b = Time.parse(ret[:validity][:begins].to_s)
+        ret[:validity][:ends] && e = Time.parse(ret[:validity][:ends].to_s)
+        ret[:validity][:revision] && r = Time.parse(ret[:validity][:revision].to_s)
         ret[:validity] = Validity.new(begins: b, ends: e, revision: r)
       end
+      # rubocop:enable Metrics/AbcSize
+
+      # @param ret [Hash]
+      def editorialgroup_hash_to_bib(ret)
+        return unless ret[:editorialgroup]
+
+        technical_committee = 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]
+
+        ret[:ics] = 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]
+          StructuredIdentifier.new si
+        end
+        ret[:structuredidentifier] = StructuredIdentifierCollection.new sids
+      end
 
       # @param ogj [Hash, Array, String]
       # @return [Hash, Array, String]
@@ -367,6 +431,8 @@ 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)
@@ -374,6 +440,9 @@ module RelatonBib
         arr
       end
 
+      # @param name [Hash, String, NilClass]
+      # @param person [Hash]
+      # @return [RelatonBib::LocalizedString]
       def localname(name, person)
         return nil if name.nil?
 
@@ -381,13 +450,12 @@ module RelatonBib
         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
+        n = name.is_a?(Hash) ? name[:content] : name
+        RelatonBib::LocalizedString.new(n, lang, script)
       end
 
+      # @param lst [Hash, Array<RelatonBib::LocalizedString>]
+      # @return [RelatonBib::LocalizedString]
       def localizedstring(lst)
         if lst.is_a?(Hash)
           RelatonBib::LocalizedString.new(lst[:content], lst[:language], lst[:script])
@@ -396,6 +464,8 @@ module RelatonBib
         end
       end
 
+      # @param frf [Hash, String]
+      # @return [RelatonBib::FormattedRef]
       def formattedref(frf)
         if frf.is_a?(Hash)
           RelatonBib::FormattedRef.new(frf)