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

data/lib/relaton/bib/model/structured_identifier.rb

@@ -0,0 +1,48 @@
+module Relaton
+  module Bib
+    class StructuredIdentifier < Lutaml::Model::Serializable
+      attribute :type, :string
+      attribute :agency, :string, collection: (1..)
+      attribute :klass, :string
+      attribute :docnumber, :string
+      attribute :partnumber, :string
+      attribute :edition, :string
+      attribute :version, :string
+      attribute :supplementtype, :string
+      attribute :supplementnumber, :string
+      attribute :amendment, :string
+      attribute :corrigendum, :string
+      attribute :language, :string
+      attribute :year, :string
+
+      xml do
+        root "structuredidentifier"
+        map_attribute "type", to: :type
+        map_element "agency", to: :agency
+        map_element "class", to: :klass
+        map_element "docnumber", to: :docnumber
+        map_element "partnumber", to: :partnumber
+        map_element "edition", to: :edition
+        map_element "version", to: :version
+        map_element "supplementtype", to: :supplementtype
+        map_element "supplementnumber", to: :supplementnumber
+        map_element "amendment", to: :amendment
+        map_element "corrigendum", to: :corrigendum
+        map_element "language", to: :language
+        map_element "year", to: :year
+      end
+
+      def remove_part!
+        raise NotImplementedError, "`remove_part!` method not implemented in #{self.class}"
+      end
+
+      def to_all_parts!
+        raise NotImplementedError, "`to_all_parts!` method not implemented in #{self.class}"
+      end
+
+      def remove_date!
+        raise NotImplementedError, "`remove_date!` method not implemented in #{self.class}"
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/subdivision.rb

@@ -0,0 +1,14 @@
+module Relaton
+  module Bib
+    class Subdivision < Lutaml::Model::Serializable
+      include OrganizationType
+
+      attribute :type, :string
+
+      xml do
+        root "subdivision"
+        map_attribute "type", to: :type
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/technical_committee.rb

@@ -0,0 +1,14 @@
+require_relative "workgroup"
+
+module Relaton
+  module Bib
+    class TechnicalCommittee < Lutaml::Model::Serializable
+      attribute :workgroup, WorkGroup
+
+      xml do
+        root "technical-committee"
+        map_content to: :workgroup
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/title.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    class Title < LocalizedMarkedUpString
+      attribute :type, :string
+      attribute :format, :string # @DEPRECATED
+
+      xml do
+        map_attribute "type", to: :type
+        map_attribute "format", to: :format
+      end
+
+      key_value do
+        map "type", to: :type
+        map "format", to: :format
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/uri.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Bib
+    class Uri < LocalizedStringAttrs
+      attribute :type, :string
+      attribute :content, :string
+
+      xml do
+        map_attribute "type", to: :type
+        map_content to: :content
+      end
+
+      key_value do
+        map "type", to: :type
+        map "content", to: :content
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/validity.rb

@@ -0,0 +1,16 @@
+module Relaton
+  module Bib
+    class Validity < Lutaml::Model::Serializable
+      attribute :begins, :date
+      attribute :ends, :date
+      attribute :revision, :date
+
+      xml do
+        root "validity"
+        map_element "validityBegins", to: :begins
+        map_element "validityEnds", to: :ends
+        map_element "revision", to: :revision
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/version.rb

@@ -0,0 +1,14 @@
+module Relaton
+  module Bib
+    class Version < Lutaml::Model::Serializable
+      attribute :revision_date, :date
+      attribute :draft, :string
+
+      xml do
+        root "version"
+        map_element "revision-date", to: :revision_date
+        map_element "draft", to: :draft
+      end
+    end
+  end
+end

data/lib/relaton/bib/model/workgroup.rb

@@ -0,0 +1,20 @@
+module Relaton
+  module Bib
+    class WorkGroup < Lutaml::Model::Serializable
+      attribute :number, :integer
+      attribute :type, :string
+      attribute :identifier, :string
+      attribute :prefix, :string
+      attribute :content, :string
+
+      xml do
+        root "workgroup"
+        map_attribute "number", to: :number
+        map_attribute "type", to: :type
+        map_attribute "identifier", to: :identifier
+        map_attribute "prefix", to: :prefix
+        map_content to: :content
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_address.rb

@@ -0,0 +1,60 @@
+module Relaton
+  module Bib
+    module Parser
+      # Class for transforming RFC Postal to Relaton Address
+      class RfcAddress
+        def initialize(postal)
+          @postal = postal
+        end
+
+        #
+        # Transform address from RFC Postal to Relaton Address
+        #
+        # @param [Rfcxml::V3::Address] address RFC Address
+        #
+        # @return [Array<Relaton::Bib::Address>]
+        #
+        def self.transform(address)
+          return [] unless address&.postal
+
+          new(address.postal).transform
+        end
+
+        def transform # rubocop:disable Metrics/CyclomaticComplexity
+          street = @postal.street || []
+          city = @postal.city || []
+          region = @postal.region || []
+          country = @postal.country || []
+          code = @postal.code || []
+          postal_line = @postal.postal_line || []
+          transform_args(
+            street: street, city: city, region: region, country: country, code: code, postal_line: postal_line,
+          )
+        end
+
+        def transform_args(**args)
+          i = 0
+          addrs = []
+          while args.values.any? { |v| v[i] }
+            addrs << create_address(**args.transform_values { |v| v[i] })
+            i += 1
+          end
+          addrs
+        end
+
+        def create_address(**args) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/AbcSize,Metrics/PerceivedComplexity
+          street = []
+          street << args[:street]&.content if args[:street]
+          Address.new(
+            street: street,
+            city: args[:city]&.content,
+            state: args[:region]&.content,
+            country: args[:country]&.content,
+            postcode: args[:code]&.content,
+            formatted_address: args[:postal_line]&.content,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_contacts.rb

@@ -0,0 +1,35 @@
+require_relative "rfc_address"
+
+module Relaton
+  module Bib
+    module Parser
+      module RfcContacts
+        def initialize(author)
+          @author = author
+        end
+
+        def address
+          RfcAddress.transform(@author.address)
+        end
+
+        def phone
+          return [] unless @author.address&.phone
+
+          [Phone.new(content: @author.address.phone.content)]
+        end
+
+        def email
+          return [] unless @author.address&.email
+
+          @author.address.email.map(&:content)
+        end
+
+        def uri
+          return [] unless @author.address&.uri
+
+          [Uri.new(content: @author.address.uri.content)]
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_docidentifier.rb

@@ -0,0 +1,70 @@
+module Relaton
+  module Bib
+    module Parser
+      class RfcDocidentifier
+        RFCPREFIXES = %w[RFC BCP FYI STD].freeze
+
+        def initialize(reference)
+          @reference = reference
+        end
+
+        def transform
+          docids = [create_docid(@reference.anchor, primary: true)]
+          create_internet_draft_id { |id| docids << id }
+          docids + docid_from_sereies_info
+        end
+
+        def create_docid(id, primary: false) # , ver) # rubocop:disable Metrics/MethodLength
+          pref, num = id_to_pref_num(id)
+          if RFCPREFIXES.include?(pref)
+            pid = "#{pref} #{num.sub(/^-?0+/, '')}"
+            type = pubid_type id
+          elsif %w[I-D draft].include?(pref)
+            pid = "draft-#{num}"
+            type = "Internet-Draft"
+          else
+            pid = pref ? "#{pref} #{num}" : id
+            type = pubid_type id
+          end
+          Docidentifier.new(type: type, content: pid, primary: primary)
+        end
+
+        def pubid_type(id)
+          id_to_pref_num(id)&.first
+        end
+
+        def id_to_pref_num(id)
+          tn = /^(?<pref>I-D|draft|3GPP|W3C|[A-Z]{2,})[._-]?(?<num>.+)/.match id
+          tn && tn.to_a[1..2]
+        end
+
+        def create_internet_draft_id
+          return unless @reference.respond_to?(:front) && @reference.front
+
+          si = internet_draft_series_info(@reference.front) || internet_draft_series_info(@reference)
+          if si
+            content = si.value
+            yield Docidentifier.new(type: "Internet-Draft", content: content)
+          end
+        end
+
+        def internet_draft_series_info(parent)
+          (parent.series_info || []).find { |si| si.name == "Internet-Draft" }
+        end
+
+        def docid_from_sereies_info # rubocop:disable Metrics/CyclomaticComplexity
+          return [] unless @reference.respond_to?(:front) && @reference.front
+
+          si = (@reference.front.series_info || []) + (@reference.series_info || [])
+          si.reduce([]) do |acc, s|
+            next acc unless s.name.casecmp("doi").zero?
+
+            acc << Docidentifier.new(type: "DOI", content: s.value)
+          end
+        end
+
+        def create_docidentifier(**args) = Docidentifier.new(**args)
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_organization.rb

@@ -0,0 +1,31 @@
+module Relaton
+  module Bib
+    module Parser
+      class RfcOrganization
+        ORGNAMES = {
+          "IEEE" => "Institute of Electrical and Electronics Engineers",
+          "W3C" => "World Wide Web Consortium",
+          "3GPP" => "3rd Generation Partnership Project",
+        }.freeze
+
+        include RfcContacts
+
+        def self.transform(author)
+          org = author.organization
+          return if org.nil? || org.content.empty?
+
+          new(author).transform
+        end
+
+        def transform
+          name = ORGNAMES[@author.organization.content] || @author.organization.content
+          orgname = TypedLocalizedString.new(content: name, language: "en")
+          abbrev = LocalizedString.new(content: @author.organization.abbrev, language: "en")
+          Organization.new(
+            name: [orgname], abbreviation: abbrev, address: address, phone: phone, email: email, uri: uri,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_person.rb

@@ -0,0 +1,42 @@
+module Relaton
+  module Bib
+    module Parser
+      class RfcPerson
+        include RfcContacts
+
+        def self.transform(author)
+          return unless author.fullname || author.surname
+
+          new(author).transform
+        end
+
+        def transform
+          Person.new(
+            name: name, affiliation: affiliation, address: address, phone: phone, email: email, uri: uri,
+          )
+        end
+
+        def name
+          FullName.new(
+            completename: LocalizedString.new(content: @author.fullname, language: "en"),
+            formatted_initials: initials,
+            surname: LocalizedString.new(content: @author.surname, language: "en"),
+          )
+        end
+
+        def initials
+          return unless @author.initials
+
+          LocalizedString.new(content: @author.initials, language: "en")
+        end
+
+        def affiliation
+          org = RfcOrganization.transform(@author)
+          return [] unless org
+
+          [Affiliation.new(organization: org)]
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_reference.rb

@@ -0,0 +1,143 @@
+require_relative "rfc_shared"
+require_relative "rfc_contacts"
+require_relative "rfc_person"
+require_relative "rfc_organization"
+require_relative "rfc_docidentifier"
+
+module Relaton
+  module Bib
+    module Parser
+      class RfcReference
+        include RfcShared
+
+        def initialize(reference)
+          @reference = reference
+        end
+
+        def self.from_xml(xml)
+          reference = Rfcxml::V3::Reference.from_xml xml
+          new(reference).transform
+        end
+
+        def transform # rubocop:disable Metrics/MethodLength
+          ItemData.new(
+            docnumber: @reference.anchor.sub(/^\w+\./, ""),
+            type: "standard",
+            docidentifier: RfcDocidentifier.new(@reference).transform,
+            status: status,
+            language: ["en"],
+            script: ["Latn"],
+            source: source,
+            title: title,
+            formattedref: formattedref,
+            abstract: abstract,
+            contributor: contributor,
+            date: date,
+            series: series,
+            keyword: keyword,
+            ext: ext,
+          )
+        end
+
+        def status
+          si = @reference.front.series_info&.find(&:status) || @reference.series_info&.status
+          return unless si
+
+          stage = Status::Stage.new(content: si.status)
+          Status.new(stage: stage)
+        end
+
+        def title
+          [Title.new(content: @reference.front.title.content, language: "en", script: "Latn")]
+        end
+
+        def formattedref
+          return if @reference.front.title
+
+          @reference.anchor
+        end
+
+        def abstract
+          return [] unless @reference.front.abstract
+
+          @reference.front.abstract.t.map do |t|
+            LocalizedMarkedUpString.new(content: t.content, language: "en", script: "Latn")
+          end
+        end
+
+        def contributor
+          (@reference.front.author || []).reduce([]) do |acc, author|
+            p = person(author)
+            o = organization(author)
+            next acc unless p || o
+
+            acc << Contributor.new(person: p, organization: o, role: [contributor_role(author)])
+          end
+        end
+
+        def contributor_role(author)
+          type = author.role || "author"
+          Contributor::Role.new(type: type)
+        end
+
+        def person(author) = RfcPerson.transform(author)
+        def organization(author) = RfcOrganization.transform(author)
+
+        def date # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          dt = @reference.front&.date
+          return [] unless dt || dt.year || dt.month || dt.day
+
+          dparts = [dt.year, month_to_num(dt.month), dt.day].compact.reject(&:empty?)
+          at = dt.content.empty? ? dparts.join("-") : dt.content
+          [Date.new(type: "published", at: at)]
+        end
+
+        def month_to_num(month)
+          return unless month
+
+          ::Date::MONTHNAMES.index(month.capitalize).to_s
+        end
+
+        def series # rubocop:disable Metrics/CyclomaticComplexity
+          ((@reference.series_info || []) + (@reference.front.series_info || [])).map do |si|
+            next if si.name == "DOI" || si.stream || si.status
+
+            t = Title.new(content: si.name, language: "en", script: "Latn")
+            Series.new(title: [t], number: si.value, type: "main")
+          end.compact
+        end
+
+        def keyword
+          (@reference.front.keyword || []).map do |kw|
+            taxon = LocalizedString.new(content: kw.content, language: "en", script: "Latn")
+            Keyword.new(taxon: [taxon])
+          end
+        end
+
+        def ext
+          eg = editorialgroup
+          dt = doctype
+          return unless eg || dt
+
+          Bib::Ext.new editorialgroup: eg, doctype: dt
+        end
+
+        def editorialgroup
+          return unless @reference.front.workgroup
+
+          tc = @reference.front.workgroup.map { |wg| WorkGroup.new content: wg.content }
+          EditorialGroup.new(technical_committee: tc) if tc.any?
+        end
+
+        def doctype
+          type =  case @reference.anchor
+                  when /I-D/ then "internet-draft"
+                  when /IEEE/ then "ieee"
+                  else "rfc"
+                  end
+          Doctype.new content: type
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_referencegroup.rb

@@ -0,0 +1,45 @@
+require_relative "rfc_shared"
+
+module Relaton
+  module Bib
+    module Parser
+      # Class for transforming RFC ReferenceGroup to Relaton ReferenceGroup
+      class RfcReferencegroup
+        include RfcShared
+
+        def initialize(reference)
+          @reference = reference
+        end
+
+        #
+        # Transform reference group from RFC ReferenceGroup to Relaton ReferenceGroup
+        #
+        # @param [Rfcxml::V3::ReferenceGroup] reference_group RFC ReferenceGroup
+        #
+        # @return [Relaton::Bib::ReferenceGroup]
+        #
+        def self.from_xml(xml) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+          reference = Rfcxml::V3::Referencegroup.from_xml xml
+          new(reference).transform
+        end
+
+        def transform
+          ItemData.new(
+            docnumber: @reference.anchor.sub(/^\w+\./, ""),
+            type: "standard",
+            docidentifier: RfcDocidentifier.new(@reference).transform,
+            source: source,
+            relation: relation,
+          )
+        end
+
+        def relation
+          (@reference.reference || []).map do |ref|
+            item = RfcReference.new(ref).transform
+            Relation.new(type: "includes", bibitem: item)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/bib/parser/rfc_shared.rb

@@ -0,0 +1,23 @@
+module Relaton
+  module Bib
+    module Parser
+      module RfcShared
+        def source # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          s = []
+          s << Uri.new(type: "src", content: @reference.target) if @reference.target
+          # if /^I-D/.match? @reference.anchor
+          #   @reference.format.each do |f|
+          #     s << Uri.new(type: f.type, content: f.target)
+          #   end
+          # end
+          return s unless @reference.respond_to?(:front) && @reference.front
+
+          (@reference.format || []).each do |fr|
+            s << Uri.new(type: fr.type, content: fr.target)
+          end
+          s
+        end
+      end
+    end
+  end
+end