relaton-bib 1.1.0 → 1.1.1

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

@@ -34,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
@@ -55,12 +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
@@ -311,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
@@ -338,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])
@@ -356,20 +361,23 @@ 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]
 
@@ -378,6 +386,35 @@ module RelatonBib
         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]
@@ -394,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)
@@ -401,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?
 
@@ -408,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])
@@ -423,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

data/lib/relaton_bib/technical_committee.rb

@@ -0,0 +1,25 @@
+require "relaton_bib/workgroup"
+
+module RelatonBib
+  class TechnicalCommittee
+    # @return [RelatonBib::WorkGroup]
+    attr_reader :workgroup
+
+    # @param workgroup [RelatonBib::WorkGroup]
+    def initialize(workgroup)
+      @workgroup = workgroup
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.send "technical-committee" do |b|
+        workgroup.to_xml b
+      end
+    end
+
+    # @return [Hash]
+    def to_hash
+      workgroup.to_hash
+    end
+  end
+end

data/lib/relaton_bib/typed_title_string.rb

@@ -31,6 +31,42 @@ module RelatonBib
     end
     # rubocop:enable Metrics/MethodLength
 
+    # @param title [String]
+    # @return [Array<self>]
+    def self.from_string(title, lang = nil, script = nil)
+      types = %w[title-intro title-main title-part]
+      ttls = split_title(title)
+      tts = ttls.map.with_index do |p, i|
+        new type: types[i], content: p, language: lang, script: script if p
+      end.compact
+      tts << new(type: "main", content: ttls.compact.join(" - "),
+                 language: lang, script: script)
+    end
+
+    # @param title [String]
+    # @return [Array<String, nil>]
+    def self.split_title(title)
+      ttls = title.sub(/\w\.Imp\s?\d+\u00A0:\u00A0/, "").split " - "
+      case ttls.size
+      when 0, 1 then [nil, ttls.first.to_s, nil]
+      else intro_or_part ttls
+      # when 2, 3 then intro_or_part ttls
+      # else [ttls[0], ttls[1], ttls[2..-1].join(" -- ")]
+      end
+    end
+
+    # @param ttls [Array<String>]
+    # @return [Array<Strin, nil>]
+    def self.intro_or_part(ttls)
+      if /^(Part|Partie) \d+:/ =~ ttls[1]
+        [nil, ttls[0], ttls[1..-1].join(" -- ")]
+      else
+        parts = ttls.slice(2..-1)
+        part = parts.join " -- " if parts.any?
+        [ttls[0], ttls[1], part]
+      end
+    end
+
     # @param builder [Nokogiri::XML::Builder]
     def to_xml(builder)
       builder.parent[:type] = type if type

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "1.1.0".freeze
+  VERSION = "1.1.1".freeze
 end

data/lib/relaton_bib/workgroup.rb

@@ -0,0 +1,36 @@
+module RelatonBib
+  class WorkGroup
+    # @return [String]
+    attr_reader :content
+
+    # @return [Integer, nil]
+    attr_reader :number
+
+    # @return [String, nil]
+    attr_reader :type
+
+    # @param content [String]
+    # @param number [Integer, nil]
+    # @param type [String, nil]
+    def initialize(content:, number: nil, type: nil)
+      @content = content
+      @number = number
+      @type = type
+    end
+
+    # @param builder [Nokogiri::XML::Builder]
+    def to_xml(builder)
+      builder.text content
+      builder.parent[:number] = number if number
+      builder.parent[:type] = type if type
+    end
+
+    # @return [Hash]
+    def to_hash
+      hash = { "content" => content }
+      hash["number"] = number if number
+      hash["type"] = type if type
+      hash
+    end
+  end
+end