relaton-bib 1.0.4 → 1.2.2

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

@@ -45,7 +45,7 @@ module RelatonBib
     def initialize(type:, description: nil, bibitem:, locality: [],
                    source_locality: [])
       type = "obsoletes" if type == "Now withdrawn"
-      unless TYPES.include? type
+      unless self.class::TYPES.include? type
         warn "[relaton-bib] WARNING: invalid relation type: #{type}"
       end
       @type            = type

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,7 +20,7 @@ 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

data/lib/relaton_bib/document_status.rb

@@ -5,10 +5,10 @@ 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]
@@ -44,6 +44,7 @@ module RelatonBib
     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)

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

@@ -23,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)
@@ -33,6 +34,9 @@ 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
@@ -54,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
@@ -267,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]
@@ -299,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
@@ -326,6 +342,7 @@ 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])
@@ -344,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]
@@ -382,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)
@@ -389,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?
 
@@ -396,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])
@@ -411,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)

data/lib/relaton_bib/ics.rb

@@ -0,0 +1,26 @@
+module RelatonBib
+  class ICS
+    # @return [String]
+    attr_reader :code, :text
+
+    # @param code [String]
+    # @param text [String]
+    def initialize(code:, text:)
+      @code = code
+      @text = text
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.ics do |b|
+        b.code code
+        b.text_ text
+      end
+    end
+
+    # @return [Hash]
+    def to_hash
+      { "code" => code, "text" => text }
+    end
+  end
+end

data/lib/relaton_bib/structured_identifier.rb

@@ -0,0 +1,141 @@
+module RelatonBib
+  class StructuredIdentifierCollection
+    include RelatonBib
+    extend Forwardable
+
+    def_delegators :@collection, :any?, :size, :[], :detect
+
+    # @param collection [Array<RelatonBib::StructuredIdentifier>]
+    def initialize(collection)
+      @collection = collection
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      @collection.each { |si| si.to_xml builder }
+    end
+
+    # @return [Array<Hash>]
+    def to_hash
+      single_element_array @collection
+    end
+
+    # remoe year from docnumber
+    def remove_date
+      @collection.each &:remove_date
+    end
+
+    def remove_part
+      @collection.each &:remove_part
+    end
+
+    def all_parts
+      @collection.each &:all_parts
+    end
+
+    def presence?
+      any?
+    end
+
+    # @return [RelatonBib::StructuredIdentifierCollection]
+    # def map(&block)
+    #   StructuredIdentifierCollection.new @collection.map &block
+    # end
+  end
+
+  class StructuredIdentifier
+    include RelatonBib
+
+    # @return [String]
+    attr_reader :docnumber
+
+    # @return [Array<String>]
+    attr_reader :agency
+
+    # @return [String, NilClass]
+    attr_reader :type, :klass, :partnumber, :edition, :version, :supplementtype,
+                :supplementnumber, :language, :year
+
+    # rubocop:disable Metrics/MethodLength
+
+    # @param type [String, NilClass]
+    # @param agency [Array<String>]
+    # @parma class [Stirng, NilClass]
+    # @parma docnumber [String]
+    # @param partnumber [String, NilClass]
+    # @param edition [String, NilClass]
+    # @param version [String, NilClass]
+    # @param supplementtype [String, NilClass]
+    # @param supplementnumber [String, NilClass]
+    # @param language [String, NilClass]
+    # @param year [String, NilClass]
+    def initialize(docnumber:, **args)
+      @type = args[:type]
+      @agency = args[:agency]
+      @klass = args[:class]
+      @docnumber = docnumber
+      @partnumber = args[:partnumber]
+      @edition = args[:edition]
+      @version = args[:version]
+      @supplementtype = args[:supplementtype]
+      @supplementnumber = args[:supplementnumber]
+      @language = args[:language]
+      @year = args[:year]
+    end
+
+    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      xml = builder.structuredidentifier do |b|
+        agency&.each { |a| b.agency a }
+        b.class_ klass if klass
+        b.docnumber docnumber
+        b.partnumber partnumber if partnumber
+        b.edition edition if edition
+        b.version version if version
+        b.supplementtype supplementtype if supplementtype
+        b.supplementnumber supplementnumber if supplementnumber
+        b.language language if language
+        b.year year if year
+      end
+      xml[:type] = type if type
+    end
+
+    # @return [Hash]
+    def to_hash
+      hash = { "docnumber" => docnumber }
+      hash["type"] = type if type
+      hash["agency"] = single_element_array agency if agency&.any?
+      hash["class"] = klass if klass
+      hash["partnumber"] = partnumber if partnumber
+      hash["edition"] = edition if edition
+      hash["version"] = version if version
+      hash["supplementtype"] = supplementtype if supplementtype
+      hash["supplementnumber"] = supplementnumber if supplementnumber
+      hash["language"] = language if language
+      hash["year"] = year if year
+      hash
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+    def remove_date
+      if @type == "Chinese Standard"
+        @docnumber.sub!(/-[12]\d\d\d/, "")
+      else
+        @docnumber.sub!(/:[12]\d\d\d/, "")
+      end
+      @year = nil
+    end
+
+    # in docid manipulations, assume ISO as the default: id-part:year
+    def remove_part
+      @partnumber = nil
+      @docnumber = @docnumber.sub(/-\d+/, "")
+    end
+
+    def all_parts
+      @docnumber = @docnumber + " (all parts)"
+    end
+  end
+end