relaton-bib 2.0.0.pre.alpha.1 → 2.0.0

data/lib/relaton/bib/hash_parser_v1.rb

@@ -3,7 +3,10 @@ require_relative "../bib"
 module Relaton
   module Bib
     module HashParserV1
+      include Core::ArrayWrapper
+      include Core::DateParser
       extend self
+
       # @param args [Hash]
       # @return [Hash]
       def hash_to_bib(args) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
@@ -11,7 +14,9 @@ module Relaton
 
         ret = Marshal.load(Marshal.dump(symbolize(args))) # deep copy
         ret[:fetched] &&= ::Date.parse(ret[:fetched])
-        ret[:schema_version] = ret.delete(:"schema-version") if ret[:"schema-version"]
+        ret.delete(:"schema-version")
+        ret.delete(:schema_version)
+        id_hash_to_bib ret
         title_hash_to_bib(ret)
         link_hash_to_bib(ret)
         language_hash_to_bib(ret)
@@ -24,6 +29,7 @@ module Relaton
         formattedref_hash_to_bib(ret)
         docstatus_hash_to_bib(ret)
         contributors_hash_to_bib(ret)
+        editorialgroup_hash_to_bib(ret)
         edition_hash_to_bib(ret)
         copyright_hash_to_bib(ret)
         relations_hash_to_bib(ret)
@@ -36,17 +42,22 @@ module Relaton
         classification_hash_to_bib(ret)
         validity_hash_to_bib(ret)
         keyword_hash_to_bib(ret)
-        ret[:license] = Relaton.array(ret[:license])
+        ret[:license] = array(ret[:license])
         ext_hash_to_bib ret
         ret
       end
 
+      def id_hash_to_bib(ret)
+        return unless ret[:id]
+
+        ret[:id] = ret[:id].gsub(/\W+/, "")
+      end
+
       def ext_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
         ret[:ext] ||= {}
         doctype_hash_to_bib ret
         ret[:ext][:subdoctype] = ret.delete(:subdoctype) if ret[:subdoctype]
         ret[:ext][:flavor] ||= flavor(ret)
-        editorialgroup_hash_to_bib ret
         ics_hash_to_bib ret
         structuredidentifier_hash_to_bib ret
         ret[:ext] = Bib::Ext.new(**ret[:ext])
@@ -62,32 +73,32 @@ module Relaton
       end
 
       def keyword_hash_to_bib(ret)
-        ret[:keyword] = Relaton.array(ret[:keyword]).map do |keyword|
-          Bib::Keyword.new taxon: [localizedstring(keyword)]
+        ret[:keyword] = array(ret[:keyword]).map do |keyword|
+          Bib::Keyword.new vocab: localizedstring(keyword)
         end
       end
 
       def extent_hash_to_bib(ret)
         return unless ret[:extent]
 
-        ret[:extent] = Relaton.array(ret[:extent]).map do |e|
+        ret[:extent] = array(ret[:extent]).map do |e|
           Relaton::Bib::Extent.new  locality: locality(e[:locality]),
                                     locality_stack: locality_stack(e[:locality_stack])
         end
       end
 
       def locality(locality)
-        Relaton.array(locality).map { |l| Bib::Locality.new(**l) }
+        array(locality).map { |l| Bib::Locality.new(**l) }
       end
 
       def locality_stack(locality_stack)
-        Relaton.array(locality_stack).map { |l| Bib::LocalityStack.new locality: locality(l[:locality]) }
+        array(locality_stack).map { |l| Bib::LocalityStack.new locality: locality(l[:locality]) }
       end
 
       def size_hash_to_bib(ret)
         return unless ret[:size]
 
-        ret[:size] = Relaton.array(ret[:size])
+        ret[:size] = array(ret[:size])
         value = ret[:size]&.map do |val|
           val[:content] = val.delete(:value)
           Bib::Size::Value.new(**val)
@@ -98,7 +109,7 @@ module Relaton
       def title_hash_to_bib(ret)
         # return unless ret[:title]
 
-        # ret[:title] = Relaton.array(ret[:title]).reduce(Bib::TitleCollection.new) do |m, t|
+        # ret[:title] = array(ret[:title]).reduce(Bib::TitleCollection.new) do |m, t|
         #   m << (t.is_a?(Hash) ? Bib::Title.new(**t) : Bib::Title.new(content: t))
         # end
         ret[:title] &&= title_collection(ret[:title])
@@ -107,31 +118,33 @@ module Relaton
       def language_hash_to_bib(ret)
         return unless ret[:language]
 
-        ret[:language] = Relaton.array(ret[:language])
+        ret[:language] = array(ret[:language])
       end
 
       def script_hash_to_bib(ret)
         return unless ret[:script]
 
-        ret[:script] = Relaton.array(ret[:script])
+        ret[:script] = array(ret[:script])
       end
 
       def abstract_hash_to_bib(ret)
-        ret[:abstract] &&= Relaton.array(ret[:abstract]).map do |a|
-          localized_marked_up_string a
+        ret[:abstract] &&= array(ret[:abstract]).map do |a|
+          a = { content: a } if a.is_a?(String)
+          lang_scrip_array_to_string(a)
+          Bib::Abstract.new(**a)
         end
       end
 
       def link_hash_to_bib(ret)
         return unless ret[:link]
 
-        ret[:source] = Relaton.array(ret[:link]).map do |l|
+        ret[:source] = array(ret[:link]).map do |l|
           Bib::Uri.new(**l)
         end
       end
 
       def place_hash_to_bib(ret)
-        ret[:place] &&= Relaton.array(ret[:place]).map { |pl| create_place(pl) }
+        ret[:place] &&= array(ret[:place]).map { |pl| create_place(pl) }
       end
 
       def create_place(place)
@@ -145,7 +158,7 @@ module Relaton
       end
 
       def create_region(region)
-        Relaton.array(region).map do |r|
+        array(region).map do |r|
           r[:content] ||= r.delete(:name)
           r[:iso] ||= r.delete(:code)
           Bib::Place::RegionType.new(**r)
@@ -155,11 +168,11 @@ module Relaton
       def accesslocation_hash_to_bib(ret)
         return unless ret[:accesslocation]
 
-        ret[:accesslocation] = Relaton.array(ret[:accesslocation])
+        ret[:accesslocation] = array(ret[:accesslocation])
       end
 
       def dates_hash_to_bib(ret)
-        ret[:date] &&= Relaton.array(ret[:date]).map do |d|
+        ret[:date] &&= array(ret[:date]).map do |d|
           # `at` is synonym of `on`, which is reserved word in YAML
           d[:at] = d.delete(:value) if d[:value]
           Bib::Date.new(**d)
@@ -169,7 +182,7 @@ module Relaton
       def docid_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize
         return unless ret[:docid]
 
-        ret[:docidentifier] = Relaton.array(ret[:docid]).map do |id|
+        ret[:docidentifier] = array(ret[:docid]).map do |id|
           id[:type] ||= id[:id].match(/^\w+(?=\s)/)&.to_s
           id[:content] = id[:id]
           create_docid(**id)
@@ -183,14 +196,14 @@ module Relaton
       def version_hash_to_bib(ret)
         return unless ret[:version]
 
-        ret[:version] = Relaton.array(ret[:version]).map do |v|
-          v[:revision_date] &&= ::Date.parse(v[:revision_date])
+        ret[:version] = array(ret[:version]).map do |v|
+          v[:revision_date] &&= parse_date(v[:revision_date], str: false)
           Bib::Version.new(**v)
         end
       end
 
       def biblionote_hash_to_bib(ret)
-        ret[:note] = Relaton.array(ret.delete(:biblionote)).map do |n|
+        ret[:note] = array(ret.delete(:biblionote)).map do |n|
           n.is_a?(String) ? Bib::Note.new(content: n) : Bib::Note.new(**n)
         end
       end
@@ -219,10 +232,10 @@ module Relaton
       end
 
       def contributors_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength,Metrics/PerceivedComplexity
-        ret[:contributor] &&= Relaton.array(ret[:contributor]).map do |c|
-          roles = Relaton.array(c[:role]).map do |r|
+        ret[:contributor] &&= array(ret[:contributor]).map do |c|
+          roles = array(c[:role]).map do |r|
             if r.is_a? Hash
-              desc = Relaton.array(r[:description]).map { |d| localized_marked_up_string d }
+              desc = array(r[:description]).map { |d| localized_marked_up_string d }
               Bib::Contributor::Role.new(type: r[:type], description: desc)
             else
               Bib::Contributor::Role.new(type: r)
@@ -256,20 +269,22 @@ module Relaton
         org[:phone] = phone_hash_to_bib(org[:contact])
         org[:email] = email_hash_to_bib(org[:contact])
         org[:uri] = uri_hash_to_bib(org[:contact] || org)
-        org[:logo] = Bib::Logo.new image: Bib::Image.new(**org[:logo][:image]) if org[:logo]
+        org[:logo] = array(org[:logo]).map do |l|
+          Bib::Logo.new(image: Bib::Image.new(**l[:image]))
+        end
         org[:name] = typed_localized_string(org[:name])
         org[:abbreviation] &&= localizedstring(org[:abbreviation])
         org
       end
 
       def create_org_identifier(identifier)
-        Relaton.array(identifier).map do |id|
+        array(identifier).map do |id|
           Bib::Organization::Identifier.new(type: id[:type], content: id[:id])
         end
       end
 
       def create_org_subdivision(subdivision)
-        Relaton.array(subdivision).map do |sub|
+        array(subdivision).map do |sub|
           if sub.is_a? String
             orgname = Bib::TypedLocalizedString.new(content: sub)
             Bib::Subdivision.new(name: [orgname])
@@ -281,7 +296,7 @@ module Relaton
       end
 
       def typed_localized_string(typed_strs)
-        Relaton.array(typed_strs).map do |args|
+        array(typed_strs).map do |args|
           if args.is_a? String
             Bib::TypedLocalizedString.new(content: args)
           elsif args.is_a? Hash
@@ -291,7 +306,7 @@ module Relaton
       end
 
       # def create_org_name(name)
-      #   Relaton.array(name).map do |nm|
+      #   array(name).map do |nm|
       #     if nm.is_a?(Hash)
       #       Bib::Organization::Name.new(**nm)
       #     else
@@ -303,7 +318,7 @@ module Relaton
       def create_person(person)
         Bib::Person.new(
           name: fullname_hash_to_bib(person),
-          credential: Relaton.array(person[:credential]),
+          credential: array(person[:credential]),
           affiliation: affiliation_hash_to_bib(person),
           address: address_hash_to_bib(person[:contact]),
           phone: phone_hash_to_bib(person[:contact]),
@@ -320,8 +335,8 @@ module Relaton
           abbreviation: localizedstring(n[:abbreviation]),
           forename: fname,
           formatted_initials: localizedstring(n.dig(:given, :formatted_initials)),
-          addition: Relaton.array(n[:addition])&.map { |f| localizedstring(f) },
-          prefix: Relaton.array(n[:prefix])&.map { |f| localizedstring(f) },
+          addition: array(n[:addition])&.map { |f| localizedstring(f) },
+          prefix: array(n[:prefix])&.map { |f| localizedstring(f) },
           surname: localizedstring(n[:surname]),
           completename: localizedstring(n[:completename]),
         )
@@ -330,7 +345,7 @@ module Relaton
       def given_hash_to_bib(given)
         return unless given
 
-        Relaton.array(given[:forename])&.map { |f| forename_hash_to_bib(f) }
+        array(given[:forename])&.map { |f| forename_hash_to_bib(f) }
       end
 
       def forename_hash_to_bib(fname)
@@ -343,7 +358,7 @@ module Relaton
       end
 
       def person_identifiers_hash_to_bib(person)
-        Relaton.array(person[:identifier])&.map do |a|
+        array(person[:identifier])&.map do |a|
           Bib::Person::Identifier.new(type: a[:type], content: a[:id])
         end
       end
@@ -351,8 +366,8 @@ module Relaton
       def affiliation_hash_to_bib(person) # rubocop:disable Metrics/AbcSize
         return [] unless person[:affiliation]
 
-        Relaton.array(person[:affiliation]).map do |a|
-          a[:description] = Relaton.array(a[:description]).map do |d|
+        array(person[:affiliation]).map do |a|
+          a[:description] = array(a[:description]).map do |d|
             localized_marked_up_string d
           end
           Bib::Affiliation.new(
@@ -363,7 +378,7 @@ module Relaton
       end
 
       def address_hash_to_bib(contact)
-        Relaton.array(contact).reduce([]) do |a, c|
+        array(contact).reduce([]) do |a, c|
           next a unless c[:address]
 
           a << create_address(c[:address])
@@ -371,7 +386,7 @@ module Relaton
       end
 
       def phone_hash_to_bib(contact)
-        Relaton.array(contact).reduce([]) do |a, c|
+        array(contact).reduce([]) do |a, c|
           next a unless c[:phone]
 
           c[:type] ||= "work"
@@ -380,7 +395,7 @@ module Relaton
       end
 
       def email_hash_to_bib(contact)
-        Relaton.array(contact).reduce([]) do |a, c|
+        array(contact).reduce([]) do |a, c|
           next a unless c[:email]
 
           a << c[:email]
@@ -388,7 +403,7 @@ module Relaton
       end
 
       def uri_hash_to_bib(contact)
-        Relaton.array(contact).reduce([]) do |a, c|
+        array(contact).reduce([]) do |a, c|
           next a unless c[:uri] || c[:url]
 
           a << Bib::Uri.new(content: c[:uri] || c[:url])
@@ -415,7 +430,7 @@ module Relaton
 
       def create_address(adr)
         if adr.is_a?(Hash)
-          adr[:street] = Relaton.array(adr[:street])
+          adr[:street] = array(adr[:street])
           Bib::Address.new(**adr)
         else
           Bib::Address.new(formatted_address: adr)
@@ -424,8 +439,8 @@ module Relaton
 
       # @param ret [Hash]
       def copyright_hash_to_bib(ret)
-        ret[:copyright] &&= Relaton.array(ret[:copyright]).map do |c|
-          c[:owner] = Relaton.array(c[:owner]).map do |o|
+        ret[:copyright] &&= array(ret[:copyright]).map do |c|
+          c[:owner] = array(c[:owner]).map do |o|
             create_contribution_info(o)
           end
           Bib::Copyright.new(**c)
@@ -444,7 +459,7 @@ module Relaton
       def relations_hash_to_bib(ret) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
         return unless ret[:relation]
 
-        ret[:relation] &&= Relaton.array(ret[:relation]).map do |rel|
+        ret[:relation] &&= array(ret[:relation]).map do |rel|
           rel[:description] = LocalizedMarkedUpString.new(**rel[:description]) if rel[:description]
           relation_bibitem_hash_to_bib(rel)
           relation_locality_hash_to_bib(rel)
@@ -480,7 +495,7 @@ module Relaton
       def relation_locality_hash_to_bib(rel)
         return unless rel[:locality]&.any?
 
-        rel[:locality] = Relaton.array(rel[:locality]).map do |bl|
+        rel[:locality] = array(rel[:locality]).map do |bl|
           Bib::Locality.new(**bl)
         end
       end
@@ -488,7 +503,7 @@ module Relaton
       def relation_locality_stack_hash_to_bib(rel)
         return unless rel[:locality_stack]&.any?
 
-        rel[:locality_stack] = Relaton.array(rel[:locality_stack]).map do |ls|
+        rel[:locality_stack] = array(rel[:locality_stack]).map do |ls|
           Bib::LocalityStack.new locality: relation_locality_hash_to_bib(ls)
         end
       end
@@ -506,15 +521,15 @@ module Relaton
 
       # @param rel [Hash] relation
       def relation_source_locality_hash_to_bib(rel)
-        rel[:source_locality] = Relaton.array(rel[:source_locality]).map do |loc|
+        rel[:source_locality] = array(rel[:source_locality]).map do |loc|
           Bib::Locality.new(**loc)
         end
       end
 
       def relaton_source_locality_stack_hash_to_bib(rel) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-        sls = Relaton.array(rel[:source_locality_stack])
-        Relaton.array(rel[:source_locality]).each do |loc|
-          sls << Relaton.array(loc[:source_locality_stack]) if loc[:source_locality_stack]
+        sls = array(rel[:source_locality_stack])
+        array(rel[:source_locality]).each do |loc|
+          sls << array(loc[:source_locality_stack]) if loc[:source_locality_stack]
         end
 
         case rel[:source_locality]
@@ -529,13 +544,13 @@ module Relaton
 
       # @param ret [Hash]
       def series_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-        ret[:series] &&= Relaton.array(ret[:series]).map do |s|
+        ret[:series] &&= array(ret[:series]).map do |s|
           s[:formattedref] && s[:formattedref] = formattedref(s[:formattedref])
           s[:title] &&= title_collection(s[:title])
           s[:place] &&= create_place(s[:place])
           s[:abbreviation] &&= localizedstring(s[:abbreviation])
-          s[:from] &&= ::Date.parse(s[:from])
-          s[:to] &&= ::Date.parse(s[:to])
+          s[:from] &&= s[:from].to_s
+          s[:to] &&= s[:to].to_s
           Bib::Series.new(**s)
         end
       end
@@ -546,7 +561,7 @@ module Relaton
       # @return [Relaton::Bib::TitleCollection]
       #
       def title_collection(title)
-        Relaton.array(title).map do |t|
+        array(title).map do |t|
           if t.is_a?(Hash)
             lang_scrip_array_to_string t
             Bib::Title.new(**t)
@@ -564,7 +579,7 @@ module Relaton
       # @param ret [Hash]
       def classification_hash_to_bib(ret)
         if ret[:classification]
-          ret[:classification] = Relaton.array(ret[:classification]).map do |cls|
+          ret[:classification] = array(ret[:classification]).map do |cls|
             cls[:content] ||= cls.delete(:value)
             Docidentifier.new(**cls)
           end
@@ -588,29 +603,58 @@ module Relaton
         p = period == :ends ? -1 : 1
         case t
         when /^\d{4}$/
-          ::Date.new(t.to_i, p, p).to_time
+          ::Date.new(t.to_i, p, p).to_datetime.to_time.utc
         when /^(?<year>\d{4})-(?<month>\d{1,2})$/
-          ::Date.new($~[:year].to_i, $~[:month].to_i, p).to_time
-        else ::Date.parse t
+          ::Date.new($~[:year].to_i, $~[:month].to_i, p).to_datetime.to_time.utc
+        else
+          # Default to UTC when no timezone is specified
+          t += " UTC" unless t.match?(/[+-]\d{2}:?\d{2}\s*$|Z\s*$/i)
+          ::Time.parse t
         end
       end
 
       # @param ret [Hash]
-      def editorialgroup_hash_to_bib(ret)
-        eg = ret.dig(:ext, :editorialgroup) || ret[:editorialgroup] # @todo remove ret[:editorialgroup] in the future
+      def editorialgroup_hash_to_bib(ret) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        eg = ret.dig(:ext, :editorialgroup) || ret[:editorialgroup]
         return unless eg
 
-        technical_committee = workgroup_hash_to_bib eg
-        ret[:ext][:editorialgroup] = Bib::EditorialGroup.new technical_committee: technical_committee
-      end
-
-      def workgroup_hash_to_bib(wrkg)
-        Relaton.array(wrkg).map { |wg| create_workgroup wg }
+        ret[:ext]&.delete(:editorialgroup)
+        ret.delete(:editorialgroup)
+        ret[:contributor] ||= []
+        array(eg).each do |wg|
+          wg[:content] ||= wg.delete(:name)
+          ret[:contributor] << Bib::Contributor.new(
+            role: [Bib::Contributor::Role.new(
+              type: "author",
+              description: [Bib::LocalizedMarkedUpString.new(content: "committee")],
+            )],
+            organization: Bib::Organization.new(
+              name: wg[:prefix] ? [Bib::TypedLocalizedString.new(content: wg[:prefix])] : [],
+              subdivision: [Bib::Subdivision.new(
+                type: "technical-committee",
+                subtype: wg[:type],
+                name: [Bib::TypedLocalizedString.new(content: wg[:content])],
+                identifier: eg_identifiers(wg),
+              )],
+              abbreviation: wg[:prefix] ? Bib::LocalizedString.new(content: wg[:prefix]) : nil,
+            ),
+          )
+        end
       end
 
-      def create_workgroup(wrkg)
-        wrkg[:content] ||= wrkg.delete(:name)
-        Bib::WorkGroup.new(**wrkg)
+      def eg_identifiers(workgroup) # rubocop:disable Metrics/MethodLength
+        ids = []
+        if workgroup[:number]
+          ids << Bib::OrganizationType::Identifier.new(
+            content: workgroup[:number].to_s,
+          )
+        end
+        if workgroup[:identifier]
+          ids << Bib::OrganizationType::Identifier.new(
+            content: workgroup[:identifier],
+          )
+        end
+        ids
       end
 
       # @param ret [Hash]
@@ -618,7 +662,7 @@ module Relaton
         ics = ret.dig(:ext, :ics) || ret[:ics] # @todo remove ret[:ics] in the future
         return unless ics
 
-        ret[:ext][:ics] = Relaton.array(ics).map { |item| Bib::ICS.new(**item) }
+        ret[:ext][:ics] = array(ics).map { |item| Bib::ICS.new(**item) }
       end
 
       # @param ret [Hash]
@@ -626,8 +670,8 @@ module Relaton
         struct_id = ret.dig(:ext, :structuredidentifier) || ret[:structuredidentifier] # @todo remove ret[:structuredidentifier] in the future
         return unless struct_id
 
-        sids = Relaton.array(struct_id).map do |si|
-          si[:agency] = Relaton.array si[:agency]
+        sids = array(struct_id).map do |si|
+          si[:agency] = array si[:agency]
           si[:klass] = si.delete(:class)
           Bib::StructuredIdentifier.new(**si)
         end
@@ -679,11 +723,10 @@ module Relaton
       # @return [Relaton::Bib::Formattedref]
       def formattedref(frf)
         if frf.is_a?(Hash)
-          # Relaton::Bib::Formattedref.new(**frf)
-          frf[:content]
+          lang_scrip_array_to_string(frf)
+          Relaton::Bib::Formattedref.new(**frf)
         else
-          # Relaton::Bib::Formattedref.new(content: frf)
-          frf
+          Relaton::Bib::Formattedref.new(content: frf)
         end
       end