relaton-bib 1.0.1 → 1.1.1

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

@@ -11,21 +11,35 @@ module RelatonBib
     # @return [Array<String>] script Iso15924 code
     attr_reader :script
 
-    # @return [String]
+    # @return [String, Array<RelatonBib::LocalizedString>]
     attr_accessor :content
 
-    # @param content [String]
+    # @param content [String, Array<RelatonBib::LocalizedString>]
     # @param language [String] language code Iso639
     # @param script [String] script code Iso15924
     def initialize(content, language = nil, script = nil)
+      unless content.is_a?(String) || content.is_a?(Array) &&
+          (inv = content.reject { |c| c.is_a?(LocalizedString) || c.is_a?(Hash) }).
+              none? && content.any?
+        klass = content.is_a?(Array) ? inv.first.class : content.class
+        raise ArgumentError, "invalid LocalizedString content type: #{klass}"
+      end
       @language = language.is_a?(String) ? [language] : language
       @script = script.is_a?(String) ? [script] : script
-      @content = content
+      @content = if content.is_a?(Array)
+                   content.map do |c|
+                     if c.is_a?(Hash)
+                       LocalizedString.new c[:content], c[:language], c[:script]
+                     else c
+                     end
+                   end
+                 else content
+                 end
     end
 
     # @return [String]
     def to_s
-      content
+      content.is_a?(String) ? content : content.first.to_s
     end
 
     # @return [TrueClass, FalseClass]
@@ -37,19 +51,26 @@ module RelatonBib
     def to_xml(builder)
       return unless content
 
-      builder.parent["language"] = language.join(",") if language&.any?
-      builder.parent["script"]   = script.join(",") if script&.any?
-      builder.text content.encode(xml: :text)
+      if content.is_a?(Array)
+        content.each { |c| builder.variant { c.to_xml builder } }
+      else
+        builder.parent["language"] = language.join(",") if language&.any?
+        builder.parent["script"]   = script.join(",") if script&.any?
+        builder.text content.encode(xml: :text)
+      end
     end
 
     # @return [Hash]
     def to_hash
-      return content unless language || script
+      if content.is_a? String
+        return content unless language || script
 
-      hash = { "content" => content }
-      hash["language"] = single_element_array(language) if language&.any?
-      hash["script"] = single_element_array(script) if script&.any?
-      hash
+        hash = { "content" => content }
+        hash["language"] = single_element_array(language) if language&.any?
+        hash["script"] = single_element_array(script) if script&.any?
+        hash
+      else content.map &:to_hash
+      end
     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

@@ -1,14 +1,12 @@
 module RelatonBib
   class TypedTitleString
-    # TITLE_TYPES = %w[alternative original unofficial subtitle main].freeze
-
     # @return [String]
     attr_reader :type
 
     # @return [RelatonBib::FormattedString]
     attr_reader :title
 
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    # rubocop:disable Metrics/MethodLength
 
     # @param type [String]
     # @param title [RelatonBib::FormattedString, Hash]
@@ -16,10 +14,6 @@ module RelatonBib
     # @param language [String]
     # @param script [String]
     def initialize(**args)
-      # if args[:type] && !TITLE_TYPES.include?(args[:type])
-      #   warn %{[relaton-bib] title type "#{args[:type]}" is invalid.}
-      # end
-
       unless args[:title] || args[:content]
         raise ArgumentError, %{Keyword "title" or "content" should be passed.}
       end
@@ -30,12 +24,48 @@ module RelatonBib
         @title = args[:title]
       else
         fsargs = args.select do |k, _v|
-          %i[content language script format].include? k 
+          %i[content language script format].include? k
         end
         @title = FormattedString.new(fsargs)
       end
     end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+    # 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)

data/lib/relaton_bib/version.rb

@@ -1,3 +1,3 @@
 module RelatonBib
-  VERSION = "1.0.1".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

data/lib/relaton_bib/xml_parser.rb

@@ -20,6 +20,7 @@ module RelatonBib
 
       # @return [Hash]
       def item_data(bibitem)
+        ext = bibitem.at "//ext"
         {
           id: bibitem[:id]&.empty? ? nil : bibitem[:id],
           type: bibitem[:type]&.empty? ? nil : bibitem[:type],
@@ -49,6 +50,10 @@ module RelatonBib
           keyword: bibitem.xpath("keyword").map(&:text),
           license: bibitem.xpath("license").map(&:text),
           validity: fetch_validity(bibitem),
+          doctype: ext&.at("doctype")&.text,
+          editorialgroup: fetch_editorialgroup(ext),
+          ics: fetch_ics(ext),
+          structuredidentifier: fetch_structuredidentifier(ext),
         }
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
@@ -159,8 +164,12 @@ module RelatonBib
       def ttitle(title)
         return unless title
 
+        variants = title.xpath("variant").map do |v|
+          LocalizedString.new v.text, v[:language], v[:script]
+        end
+        content = variants.any? ? variants : title.text
         TypedTitleString.new(
-          type: title[:type], content: title.text, language: title[:language],
+          type: title[:type], content: content, language: title[:language],
           script: title[:script], format: title[:format]
         )
       end
@@ -169,14 +178,22 @@ module RelatonBib
         status = item.at("./status")
         return unless status
 
-        stage = status.at "stage"
+        stg = status.at "stage"
         DocumentStatus.new(
-          stage: stage ? stage.text : status.text,
-          substage: status.at("substage")&.text,
+          stage: stg ? stage(stg) : status.text,
+          substage: stage(status.at("substage")),
           iteration: status.at("iteration")&.text,
         )
       end
 
+      # @param node [Nokogiri::XML::Elemen]
+      # @return [RelatonBib::DocumentStatus::Stage]
+      def stage(elm)
+        return unless elm
+
+        DocumentStatus::Stage.new value: elm.text, abbreviation: elm[:abbreviation]
+      end
+
       def fetch_dates(item)
         item.xpath("./date").reduce([]) do |a, d|
           type = d[:type].to_s.empty? ? "published" : d[:type]
@@ -232,14 +249,9 @@ module RelatonBib
         end
 
         cn = person.at "./name/completename"
-        cname = if cn
-                  LocalizedString.new(cn.text, cn[:language], cn[:script])
-                else
-                  nil
-                end
-
+        cname = cn && LocalizedString.new(cn.text, cn[:language], cn[:script])
         sn = person.at "./name/surname"
-        sname = sn ? LocalizedString.new(sn.text, sn[:language], sn[:script]) : nil
+        sname = sn && LocalizedString.new(sn.text, sn[:language], sn[:script])
 
         name = FullName.new(
           completename: cname, surname: sname,
@@ -279,25 +291,24 @@ module RelatonBib
       # @return [Array<RelatonBib::FormattedString>]
       def fetch_abstract(item)
         item.xpath("./abstract").map do |a|
-          FormattedString.new(
-            content: a.text, language: a[:language], script: a[:script], format: a[:format]
-          )
+          FormattedString.new(content: a.text, language: a[:language],
+                              script: a[:script], format: a[:format])
         end
       end
 
       # @param item [Nokogiri::XML::Element]
-      # @return [RelatonBib::CopyrightAssociation]
+      # @return [Array<RelatonBib::CopyrightAssociation>]
       def fetch_copyright(item)
-        cp     = item.at("./copyright") || return
-        org    = cp&.at("owner/organization")
-        name   = org&.at("name")&.text
-        abbr   = org&.at("abbreviation")&.text
-        url    = org&.at("uri")&.text
-        entity = Organization.new(name: name, abbreviation: abbr, url: url)
-        from   = cp.at("from")&.text
-        to     = cp.at("to")&.text
-        owner  = ContributionInfo.new entity: entity
-        CopyrightAssociation.new(owner: owner, from: from, to: to)
+        item.xpath("./copyright").map do |cp|
+          owner = cp.xpath("owner").map do |o|
+            ContributionInfo.new entity: get_org(o.at("organization"))
+          end
+          from = cp.at("from")&.text
+          to   = cp.at("to")&.text
+          scope = cp.at("scope")&.text
+          CopyrightAssociation.new(owner: owner, from: from, to: to,
+                                   scope: scope)
+        end
       end
 
       # @param item [Nokogiri::XML::Element]
@@ -345,7 +356,7 @@ module RelatonBib
           if lc[:type]
             LocalityStack.new [locality(lc)]
           else
-            LocalityStack.new lc.xpath("./locality").map { |l| locality l }
+            LocalityStack.new(lc.xpath("./locality").map { |l| locality l })
           end
         end
       end
@@ -353,7 +364,7 @@ module RelatonBib
       # @param loc [Nokogiri::XML::Element]
       # @return [RelatonBib::Locality]
       def locality(loc, klass = Locality)
-        ref_to = (rt = loc.at("./referenceTo")) ? LocalizedString.new(rt.text) : nil
+        ref_to = (rt = loc.at("./referenceTo")) && LocalizedString.new(rt.text)
         klass.new(
           loc[:type],
           LocalizedString.new(loc.at("./referenceFrom").text),
@@ -385,6 +396,53 @@ module RelatonBib
           language: ident[:language], script: ident[:script]
         )
       end
+
+      # @param ext [Nokogiri::XML::Element]
+      # @return [RelatonBib::EditorialGroup, nil]
+      def fetch_editorialgroup(ext)
+        return unless ext && (eg = ext.at "editorialgroup")
+
+        eg = eg.xpath("technical-committee").map do |tc|
+          wg = WorkGroup.new(content: tc.text, number: tc[:number]&.to_i,
+                             type: tc[:type])
+          TechnicalCommittee.new wg
+        end
+        EditorialGroup.new eg if eg.any?
+      end
+
+      def fetch_ics(ext)
+        return [] unless ext
+
+        ext.xpath("ics").map do |ics|
+          ICS.new code: ics.at("code").text, text: ics.at("text").text
+        end
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+
+      # @param ext [Nokogiri::XML::Element]
+      # @return [RelatonBib::StructuredIdentifierCollection]
+      def fetch_structuredidentifier(ext)
+        return unless ext
+
+        sids = ext.xpath("structuredidentifier").map do |si|
+          StructuredIdentifier.new(
+            type: si[:type],
+            agency: si.xpath("agency").map(&:text),
+            class: si.at("class")&.text,
+            docnumber: si.at("docnumber")&.text,
+            partnumber: si.at("partnumber")&.text,
+            edition: si.at("edition")&.text,
+            version: si.at("version")&.text,
+            supplementtype: si.at("supplementtype")&.text,
+            supplementnumber: si.at("supplementnumber")&.text,
+            language: si.at("language")&.text,
+            year: si.at("year")&.text,
+          )
+        end
+        StructuredIdentifierCollection.new sids
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     end
   end
 end