relaton-bib 1.2.1 → 1.4.0

data/lib/relaton_bib/copyright_association.rb

@@ -33,7 +33,7 @@ module RelatonBib
         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}/
+      @from  = Date.strptime(from.to_s, "%Y") if from.to_s.match? /\d{4}/
       @to    = Date.strptime(to.to_s, "%Y") unless to.to_s.empty?
       @scope = scope
     end
@@ -60,5 +60,18 @@ module RelatonBib
       hash["scope"] = scope if scope
       hash
     end
+
+    # @param prefix [String]
+    # @param count [Iteger] number of copyright elements
+    # @return [String]
+    def to_asciibib(prefix = "", count = 1) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
+      pref = prefix.empty? ? "copyright" : prefix + ".copyright"
+      out = count > 1 ? "#{pref}::\n" : ""
+      owner.each { |ow| out += ow.to_asciibib "#{pref}.owner", owner.size }
+      out += "#{pref}.from:: #{from.year}\n" if from
+      out += "#{pref}.to:: #{to.year}\n" if to
+      out += "#{pref}.scope:: #{scope}\n" if scope
+      out
+    end
   end
 end

data/lib/relaton_bib/document_identifier.rb

@@ -5,34 +5,41 @@ module RelatonBib
     attr_reader :id
 
     # @return [String, NilClass]
-    attr_reader :type
+    attr_reader :type, :scope
 
     # @param id [String]
     # @param type [String, NilClass]
-    def initialize(id:, type: nil)
-      @id   = id
-      @type = type
+    # @param scoope [String, NilClass]
+    def initialize(id:, type: nil, scope: nil)
+      @id    = id
+      @type  = type
+      @scope = scope
     end
 
     # in docid manipulations, assume ISO as the default: id-part:year
     def remove_part
       case @type
       when "Chinese Standard" then @id.sub!(/\.\d+/, "")
-      else
-        @id.sub!(/-\d+/, "")
+      when "ISO", "IEC" then @id.sub!(/-[^:]+/, "")
+      when "URN" then remove_urn_part
       end
     end
 
     def remove_date
       case @type
       when "Chinese Standard" then @id.sub!(/-[12]\d\d\d/, "")
-      else
-        @id.sub!(/:[12]\d\d\d/, "")
+      when "ISO", "IEC" then @id.sub!(/:[12]\d\d\d/, "")
+      when "URN"
+        @id.sub!(/^(urn:iec:std:[^:]+:[^:]+:)[^:]*/, '\1')
       end
     end
 
     def all_parts
-      @id += " (all parts)"
+      if type == "URN"
+        @id.sub!(%r{^(urn:iec:std(?::[^:]*){4}).*}, '\1:ser')
+      else
+        @id += " (all parts)"
+      end
     end
 
     #
@@ -43,13 +50,46 @@ module RelatonBib
     def to_xml(builder)
       element = builder.docidentifier id
       element[:type] = type if type
+      element[:scope] = scope if scope
     end
 
     # @return [Hash]
     def to_hash
       hash = { "id" => id }
       hash["type"] = type if type
+      hash["scope"] = scope if scope
       hash
     end
+
+    # @param prefix [String]
+    # @param count [Integer] number of docids
+    # @return [String]
+    def to_asciibib(prefix = "", count = 1)
+      pref = prefix.empty? ? prefix : prefix + "."
+      out = count > 1 ? "#{pref}docid::\n" : ""
+      out += "#{pref}docid.type:: #{type}\n" if type
+      out += "#{pref}docid.scope:: #{scope}\n" if scope
+      out += "#{pref}docid.id:: #{id}\n"
+      out
+    end
+
+    private
+
+    def remove_urn_part # rubocop:disable Metrics/MethodLength
+      @id.sub!(%r{^
+        (urn:iso:std:[^:]+ # ISO prefix and originator
+          (?::(?:data|guide|isp|iwa|pas|r|tr|ts|tta)) # type
+          ?:\d+) # docnumber
+        (?::-[^:]+)? # partnumber
+        (?::(draft|cancelled|stage-[^:]+))? # status
+        (?::ed-\d+)?(?::v[^:]+)? # edition and version
+        (?::\w{2}(?:,\w{2})*)? # langauge
+      }x, '\1') # remove partnumber, status, version, and language
+      @id.sub!(%r{^
+        (urn:iec:std:[^:]+ # IEC prefix and originator
+          :\d+) # docnumber
+        (?:-[^:]+)? # partnumber
+      }x, '\1') # remove partnumber
+    end
   end
 end

data/lib/relaton_bib/document_relation.rb

@@ -48,11 +48,11 @@ module RelatonBib
       unless self.class::TYPES.include? type
         warn "[relaton-bib] WARNING: invalid relation type: #{type}"
       end
-      @type            = type
-      @description     = description
-      @locality        = locality
+      @type = type
+      @description = description
+      @locality = locality
       @source_locality = source_locality
-      @bibitem         = bibitem
+      @bibitem = bibitem
     end
 
     # rubocop:disable Metrics/AbcSize
@@ -80,5 +80,15 @@ module RelatonBib
       end
       hash
     end
+
+    # @param prefix [String]
+    # @return [String]
+    def to_asciibib(prefix = "")
+      pref = prefix.empty? ? prefix : prefix + "."
+      out = "#{prefix}.type:: #{type}\n"
+      out += description.to_asciibib "#{pref}desctiption" if description
+      out += bibitem.to_asciibib "#{pref}bibitem" if bibitem
+      out
+    end
   end
 end

data/lib/relaton_bib/document_relation_collection.rb

@@ -30,5 +30,17 @@ module RelatonBib
     def replaces
       DocRelationCollection.new(@array.select { |r| r.type == "replace" })
     end
+
+    # @param prefix [String]
+    # @return [String]
+    def to_asciibib(prefix = "")
+      pref = prefix.empty? ? "relation" : prefix + ".relation"
+      out = ""
+      @array.each do |r|
+        out += size > 1 ? "#{pref}::\n" : ""
+        out += r.to_asciibib pref
+      end
+      out
+    end
   end
 end

data/lib/relaton_bib/document_status.rb

@@ -41,6 +41,16 @@ module RelatonBib
       hash
     end
 
+    # @param prefix [String]
+    # @return [String]
+    def to_asciibib(prefix = "")
+      pref = prefix.empty? ? prefix : prefix + "."
+      out = "#{pref}docstatus.stage:: #{stage.value}\n"
+      out += "#{pref}docstatus.substage:: #{substage.value}\n" if substage
+      out += "#{pref}docstatus.iteration:: #{iteration}\n" if iteration
+      out
+    end
+
     private
 
     # @param stg [RelatonBib::DocumentStatus::Stage, Hash, String, NilClass]

data/lib/relaton_bib/editorial_group.rb

@@ -23,5 +23,19 @@ module RelatonBib
     def to_hash
       single_element_array technical_committee
     end
+
+    # @param prefix [String]
+    # @return [String]
+    def to_asciibib(prefix = "")
+      pref = prefix.empty? ? "editorialgroup" : prefix + ".editorialgroup"
+      technical_committee.map do |tc|
+        tc.to_asciibib pref, technical_committee.size
+      end.join
+    end
+
+    # @return [true]
+    def presence?
+      true
+    end
   end
 end

data/lib/relaton_bib/formatted_ref.rb

@@ -6,5 +6,12 @@ module RelatonBib
     def to_xml(builder)
       builder.formattedref { super }
     end
+
+    # @param prefix [String]
+    # @return [String]
+    def to_asciibib(prefix = "")
+      pref = prefix.empty? ? "formattedref" : prefix + ".formattedref"
+      super pref
+    end
   end
 end

data/lib/relaton_bib/formatted_string.rb

@@ -40,5 +40,16 @@ module RelatonBib
       hash["format"] = format
       hash
     end
+
+    # @param prefix [String]
+    # @param count [Integer] number of elements
+    # @return [String]
+    def to_asciibib(prefix = "", count = 1)
+      pref = prefix.empty? ? prefix : prefix + "."
+      # out = count > 1 ? "#{prefix}::\n" : ""
+      out = super
+      out += "#{pref}format:: #{format}\n" if format
+      out
+    end
   end
 end

data/lib/relaton_bib/hash_converter.rb

@@ -4,7 +4,7 @@ module RelatonBib
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
 
       # @param args [Hash]
-      # @param neated [TrueClas, FalseClass] default true
+      # @param neated [TrueClas, FalseClass] default false
       # @return [Hash]
       def hash_to_bib(args, nested = false)
         return nil unless args.is_a?(Hash)
@@ -62,8 +62,6 @@ module RelatonBib
           if t.is_a?(Hash) then m << t
           else
             m + TypedTitleString.from_string(t)
-            # { content: t, language: "en", script: "Latn", format: "text/plain",
-            #   type: "main" }
           end
         end
       end
@@ -127,7 +125,8 @@ module RelatonBib
         ret[:docid] = array(ret[:docid])
         ret[:docid]&.each_with_index do |id, i|
           type = id[:type] || id[:id].match(/^\w+/)&.to_s
-          ret[:docid][i] = DocumentIdentifier.new(id: id[:id], type: type)
+          ret[:docid][i] = DocumentIdentifier.new(id: id[:id], type: type,
+                                                  scope: id[:scope])
         end
       end
 
@@ -140,31 +139,33 @@ module RelatonBib
         )
       end
 
-      def biblionote_hash_to_bib(ret)
+      def biblionote_hash_to_bib(ret) # rubocop:disable Metrics/MethodLength
         return unless ret[:biblionote]
 
         ret[:biblionote] = array(ret[:biblionote])
         (ret[:biblionote])&.each_with_index do |n, i|
           ret[:biblionote][i] = if n.is_a?(String)
-            BiblioNote.new content: n
-          else
-            BiblioNote.new(
-              content: n[:content], type: n[:type], language: n[:language],
-              script: n[:script], format: n[:format]
-            )
-          end
+                                  BiblioNote.new content: n
+                                else
+                                  BiblioNote.new(
+                                    content: n[:content], type: n[:type],
+                                    language: n[:language], script: n[:script],
+                                    format: n[:format]
+                                  )
+                                end
         end
       end
 
       def formattedref_hash_to_bib(ret)
-        ret[:formattedref] && ret[:formattedref] = formattedref(ret[:formattedref])
+        ret[:formattedref] &&
+          ret[:formattedref] = formattedref(ret[:formattedref])
       end
 
       def docstatus_hash_to_bib(ret)
         ret[:docstatus] && ret[:docstatus] = DocumentStatus.new(
           stage: stage(ret[:docstatus][:stage]),
           substage: stage(ret[:docstatus][:substage]),
-          iteration: ret[:docstatus][:iteration],
+          iteration: ret[:docstatus][:iteration]
         )
       end
 
@@ -177,7 +178,7 @@ module RelatonBib
         DocumentStatus::Stage.new(**args)
       end
 
-      def contributors_hash_to_bib(ret)
+      def contributors_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
         return unless ret[:contributor]
 
         ret[:contributor] = array(ret[:contributor])
@@ -216,11 +217,11 @@ module RelatonBib
           name: fullname_hash_to_bib(person),
           affiliation: affiliation_hash_to_bib(person),
           contact: contacts_hash_to_bib(person),
-          identifier: person_identifiers_hash_to_bib(person),
+          identifier: person_identifiers_hash_to_bib(person)
         )
       end
 
-      def fullname_hash_to_bib(person)
+      def fullname_hash_to_bib(person) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         n = person[:name]
         FullName.new(
           forename: array(n[:forename])&.map { |f| localname(f, person) },
@@ -228,7 +229,7 @@ module RelatonBib
           addition: array(n[:addition])&.map { |f| localname(f, person) },
           prefix: array(n[:prefix])&.map { |f| localname(f, person) },
           surname: localname(n[:surname], person),
-          completename: localname(n[:completename], person),
+          completename: localname(n[:completename], person)
         )
       end
 
@@ -238,7 +239,7 @@ module RelatonBib
         end
       end
 
-      def affiliation_hash_to_bib(person)
+      def affiliation_hash_to_bib(person) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         return [] unless person[:affiliation]
 
         array(person[:affiliation]).map do |a|
@@ -252,12 +253,12 @@ module RelatonBib
           end
           Affiliation.new(
             organization: Organization.new(org_hash_to_bib(a[:organization])),
-            description: a[:description],
+            description: a[:description]
           )
         end
       end
 
-      def contacts_hash_to_bib(person)
+      def contacts_hash_to_bib(person) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         return [] unless person[:contact]
 
         array(person[:contact]).map do |a|
@@ -315,42 +316,48 @@ module RelatonBib
 
       # @param rel [Hash] relation
       # @return [RelatonBib::LocalityStack]
-      def relation_locality_hash_to_bib(rel)
+      def relation_locality_hash_to_bib(rel) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         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])]
+                 l = Locality.new(bl[:type], bl[:reference_from],
+                                  bl[:reference_to])
+                 [l]
                end
           LocalityStack.new ls
         end
       end
 
       # @param rel [Hash] relation
-      def relation_source_locality_hash_to_bib(rel)
+      def relation_source_locality_hash_to_bib(rel) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         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])
+                    SourceLocality.new(l[:type], l[:reference_from],
+                                       l[:reference_to])
                   end
                 else
-                  [SourceLocality.new(sl[:type], sl[:reference_from], sl[:reference_to])]
+                  l = SourceLocality.new(sl[:type], sl[:reference_from],
+                                         sl[:reference_to])
+                  [l]
                 end
           SourceLocalityStack.new sls
         end
       end
 
       # @param ret [Hash]
-      def series_hash_to_bib(ret)
+      def series_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
         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[:title].is_a?(Hash)
             s[:title] = typed_title_strig(s[:title])
           end
-          s[:abbreviation] && s[:abbreviation] = localizedstring(s[:abbreviation])
+          s[:abbreviation] &&
+            s[:abbreviation] = localizedstring(s[:abbreviation])
           Series.new(s)
         end
       end
@@ -375,18 +382,29 @@ module RelatonBib
         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].to_s)
-        ret[:validity][:ends] && e = Time.parse(ret[:validity][:ends].to_s)
-        ret[:validity][:revision] && r = Time.parse(ret[:validity][:revision].to_s)
+        b = parse_validity_time(ret[:validity], :begins)
+        e = parse_validity_time(ret[:validity], :ends)
+        r = parse_validity_time(ret[:validity], :revision)
         ret[:validity] = Validity.new(begins: b, ends: e, revision: r)
       end
-      # rubocop:enable Metrics/AbcSize
+
+      def parse_validity_time(val, period)
+        t = val[period]&.to_s
+        return unless t
+
+        p = period == :ends ? -1 : 1
+        case t
+        when /^\d{4}$/
+          Date.new(t.to_i, p, p).to_time
+        when /^(?<year>\d{4})-(?<month>\d{1,2})$/
+          Date.new($~[:year].to_i, $~[:month].to_i, p).to_time
+        else Time.parse t
+        end
+      end
 
       # @param ret [Hash]
       def editorialgroup_hash_to_bib(ret)
@@ -443,7 +461,7 @@ module RelatonBib
       # @param name [Hash, String, NilClass]
       # @param person [Hash]
       # @return [RelatonBib::LocalizedString]
-      def localname(name, person)
+      def localname(name, person) # rubocop:disable Metrics/CyclomaticComplexity
         return nil if name.nil?
 
         lang = name[:language] if name.is_a?(Hash)
@@ -458,7 +476,8 @@ module RelatonBib
       # @return [RelatonBib::LocalizedString]
       def localizedstring(lst)
         if lst.is_a?(Hash)
-          RelatonBib::LocalizedString.new(lst[:content], lst[:language], lst[:script])
+          RelatonBib::LocalizedString.new(lst[:content], lst[:language],
+                                          lst[:script])
         else
           RelatonBib::LocalizedString.new(lst)
         end