relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/3gpp/parser.rb

@@ -0,0 +1,400 @@
+require "csv"
+
+module Relaton
+  module ThreeGpp
+    class Parser
+      # DOCTYPES = { "TS" => "Technical Specification", "TR" => "Technical Report" }.freeze
+
+      #
+      # Document parser initalization
+      #
+      # @param [CSV::Row] row CSV row
+      #
+      def initialize(row, errors)
+        @row = row
+        @errors = errors
+      end
+
+      #
+      # Initialize document parser and run it
+      #
+      # @param [CSV:Row] row CSV row
+      # @param [Hash] errors collection of parsing errors
+      #
+      # @return [RelatonBib:BibliographicItem, nil] bibliographic item
+      #
+      def self.parse(row, errors = {})
+        new(row, errors).parse
+      end
+
+      #
+      # Parse document
+      #
+      # @return [Relaton3gpp:BibliographicItem, nil] bibliographic item
+      #
+      def parse # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        ItemData.new(
+          type: "standard",
+          language: ["en"],
+          script: ["Latn"],
+          title: parse_title,
+          source: parse_source,
+          # abstract: parse_abstract,
+          docidentifier: parse_docid,
+          docnumber: number,
+          date: parse_date,
+          version: parse_version,
+          contributor: parse_contributor,
+          place: parse_place,
+          ext: parse_ext,
+          # biblionote: parse_note,
+          # docstatus: parse_status,
+          # common_ims_spec: @spec[:ComIMS] == "1",
+          # internal: @spec[:"For publication"] == "0",
+        )
+      end
+
+      #
+      # Parse title
+      #
+      # @return [RelatonBib::TypedTitleStringCollection] title
+      #
+      def parse_title
+        @errors[:title] &&= @row["Title"].nil? || @row["Title"].empty?
+        [Bib::Title.new(content: @row["Title"], type: "main")]
+      end
+
+      #
+      # Parse link
+      #
+      # @return [Array<RelatonBib::TypedUri>] link
+      #
+      def parse_source
+        @errors[:source] &&= @row["Link"].nil? || @row["Link"].empty?
+        return [] unless @row["Link"]
+
+        [Bib::Uri.new(type: "src", content: @row["Link"])]
+      end
+
+      #
+      # Parse abstract
+      #
+      # @return [Array<RelatonBib::FormattedString>]
+      #
+      # def parse_abstract
+      #   return [] unless @spec[:description]
+
+      #   [RelatonBib::FormattedString.new(content: @spec[:description])]
+      # end
+
+      #
+      # Parse docidentifier
+      #
+      # @return [Arra<RelatonBib::DocumentIdentifier>] docidentifier
+      #
+      def parse_docid
+        @errors[:docid] &&= @row[0].nil? || @row[0].empty?
+        [Docidentifier.new(type: "3GPP", content: "3GPP #{number}", primary: true)]
+      end
+
+      #
+      # Generate number
+      #
+      # @return [String] number
+      #
+      def number
+        num = "#{doctype_abbr} #{@row[0]}"
+        num += ":#{release}" if release
+        "#{num}/#{version}"
+      end
+
+      def version
+        @row["Version"]
+      end
+
+      def parse_version
+        @errors[:version] &&= version.nil? || version.empty?
+        [Bib::Version.new(draft: version)]
+      end
+
+      def doctype_abbr
+        @row["Is TS"] == "1" ? "TS" : "TR"
+      end
+
+      def release
+        @release ||= begin
+          r = case @row["WPM Code 2G"]
+              when /Release_(\d+)/ then "REL-#{$1}"
+              when /PH(\d+)/ then "Ph#{$1}"
+              else @row["Release"]
+              end
+          @errors[:release] &&= r.nil? || r.empty?
+          r
+        end
+      end
+
+      #
+      # Version
+      #
+      # @return [String] version
+      #
+      # def version
+      #   "#{@row[:MAJOR_VERSION_NB]}.#{@row[:TECHNICAL_VERSION_NB]}.#{@row[:EDITORIAL_VERSION_NB]}"
+      # end
+
+      #
+      # Parse date
+      #
+      # @return [Array<RelatonBib::BibliographicDate>] date
+      #
+      def parse_date
+        dates = []
+        if @row["Date"]
+          on = Date.parse(@row["Date"]).to_s
+          dates << Bib::Date.new(type: "published", at: on)
+        end
+        @errors[:date] &&= dates.empty?
+        dates
+      end
+
+      #
+      # Parse note
+      #
+      # @return [RelatonBib::BiblioNoteCollection] notes
+      #
+      # def parse_note
+      #   n = []
+      #   if @specrel && @specrel[:remarks] && @specrel[:remarks] != "."
+      #     n << RelatonBib::BiblioNote.new(type: "remark", content: @specrel[:remarks])
+      #   end
+      #   if @row[:comment] && @row[:comment] != "."
+      #     n << RelatonBib::BiblioNote.new(type: "comment", content: @row[:comment])
+      #   end
+      #   RelatonBib::BiblioNoteCollection.new n
+      # end
+
+      #
+      # Prase status
+      #
+      # @return [RelatnoBib::DocumentStatus, nil] status
+      #
+      # def parse_status
+      #   if @specrel && @specrel[:withdrawn] == "1"
+      #     RelatonBib::DocumentStatus.new stage: "withdrawn"
+      #   elsif @spec[:"For publication"] == "1"
+      #     RelatonBib::DocumentStatus.new stage: "published"
+      #   end
+      # end
+
+      #
+      # Create contributors
+      #
+      # @return [Array<RelatonBib::ContributionInfo>] contributor
+      #
+      def parse_contributor # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        name = Bib::TypedLocalizedString.new(content: "3rd Generation Partnership Project")
+        abbrev = Bib::LocalizedString.new content: "3GPP"
+        org = Bib::Organization.new(name: [name], abbreviation: abbrev, address: [address])
+        contribs = [Bib::Contributor.new(organization: org, role: contributor_role)]
+        if @row["Last Name"] && @row["Last Name"] != "Vacant"
+          role = Bib::Contributor::Role.new type: "author"
+          contribs << Bib::Contributor.new(person: person, role: [role])
+        end
+        @errors[:contributor] &&= contribs.empty?
+        contribs + prime_contribs + other_contribs
+      end
+
+      def other_contribs
+        secondary = @row["Responsible Secondary"]
+        if secondary.nil? || secondary.strip.empty?
+          @errors[:editorial_group_contributor_other] &&= true
+          return []
+        end
+
+        contribs = secondary.strip.split(", ").map do |wg|
+          editorial_group_contributor(wg, "other")
+        end
+        @errors[:editorial_group_contributor_other] &&= contribs.empty?
+        contribs
+      end
+
+      def prime_contribs
+        prime = @row["Responsible Primary"]
+        if prime.nil? || prime.empty?
+          @errors[:editorial_group_contributor_prime] &&= true
+          return []
+        end
+
+        @errors[:editorial_group_contributor_prime] &&= false
+        [editorial_group_contributor(prime, "prime")]
+      end
+
+      def editorial_group_contributor(wg_name, wg_type)
+        Bib::Contributor.new(
+          role: [Bib::Contributor::Role.new(
+            type: "author",
+            description: [Bib::LocalizedMarkedUpString.new(content: "committee")],
+          )],
+          organization: Bib::Organization.new(
+            subdivision: [Bib::Subdivision.new(
+              type: "technical-committee",
+              subtype: wg_type,
+              name: [Bib::TypedLocalizedString.new(content: wg_name)],
+            )],
+          ),
+        )
+      end
+
+      def address
+        Bib::Address.new(
+          street: ["c/o ETSI 650, route des Lucioles", "3GPP Mobile Competence Centre"],
+          postcode: "06921", city: "Sophia Antipolis Cedex", country: "France"
+        )
+      end
+
+      def contributor_role
+        [Bib::Contributor::Role.new(type: "author"), Bib::Contributor::Role.new(type: "publisher")]
+      end
+
+      def person
+        name = Bib::FullName.new(surname: surname, forename: [forename])
+        Bib::Person.new(name: name, affiliation: affiliation)
+      end
+
+      def surname
+        if @row["Last Name"].nil? || @row["Last Name"].empty?
+          @errors[:contributor_person_surname] &&= true
+          return nil
+        end
+
+        @errors[:contributor_person_surname] &&= false
+        Bib::LocalizedString.new content: @row["Last Name"], language: "en", script: "Latn"
+      end
+
+      def forename
+        if @row["First Name"].nil? || @row["First Name"].empty?
+          @errors[:contributor_person_forename] &&= true
+          return nil
+        end
+
+        @errors[:contributor_person_forename] &&= false
+        Bib::FullNameType::Forename.new content: @row["First Name"], language: "en", script: "Latn"
+      end
+
+      def affiliation
+        if @row["Organisation"].nil? || @row["Organisation"].empty?
+          @errors[:contributor_person_affiliation] &&= true
+          return []
+        end
+
+        @errors[:contributor_person_affiliation] &&= false
+        name = Bib::TypedLocalizedString.new(content: @row["Organisation"])
+        org = Bib::Organization.new(name: [name])
+        [Bib::Affiliation.new(organization: org)]
+      end
+
+      def parse_place
+        country = Bib::Place::RegionType.new(content: "France", iso: "FR")
+        [Bib::Place.new(city: "Sophia Antipolis Cedex", country: [country])]
+      end
+
+      def parse_ext
+        Ext.new(
+          doctype: parse_doctype,
+          flavor: "3gpp",
+          radiotechnology: parse_radiotechnology,
+          release: parse_release,
+        )
+      end
+
+      def parse_doctype
+        # type = DOCTYPES[doctype_abbr]
+        # Doctype.new(abbreviation: doctype_abbr, content: type)
+        Doctype.new(content: doctype_abbr) # 3GPP grammar alloves only TS and TR content
+      end
+
+      #
+      # Parse radio technology
+      #
+      # @return [String] radio technology
+      #
+      def parse_radiotechnology
+        result = case @row["WPM Code 3G"]
+                 when /5G/ then "5G"
+                 when /4G/ then "LTE"
+                 when /3G/ then "3G"
+                 else @row["WPM Code 2G"] && "2G"
+                 end
+        @errors[:radiotechnology] &&= result.nil?
+        result
+      end
+
+      #
+      # Parse release
+      #
+      # @return [Relaton3gpp::Release, nil] release
+      #
+      def parse_release # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        unless wmp_code2g || wmp_code3g || stage1_freeze || stage2_freeze ||
+            stage3_freeze || close_meeting || project_start || project_end
+          return
+        end
+
+        Release.new(
+          # version2g: @rel[:version_2g],
+          # version3g: @rel[:version_3g],
+          # defunct: @rel[:defunct] == "1",
+          wpm_code_2g: wmp_code2g,
+          wpm_code_3g: wmp_code3g,
+          # freeze_meeting: @rel[:"freeze meeting"],
+          freeze_stage1_meeting: stage1_freeze,
+          freeze_stage2_meeting: stage2_freeze,
+          freeze_stage3_meeting: stage3_freeze,
+          close_meeting: close_meeting,
+          project_start: project_start,
+          project_end: project_end,
+        )
+      end
+
+      def wmp_code2g
+        @errors[:wmp_code_2g] &&= @row["WPM Code 2G"].nil? || @row["WPM Code 2G"].empty?
+        @row["WPM Code 2G"]
+      end
+
+      def wmp_code3g
+        @errors[:wmp_code_3g] &&= @row["WPM Code 3G"].nil? || @row["WPM Code 3G"].empty?
+        @row["WPM Code 3G"]
+      end
+
+      def stage1_freeze
+        @errors[:freeze_stage1_meeting] &&= @row["Stage 1 Freeze"].nil? || @row["Stage 1 Freeze"].empty?
+        @row["Stage 1 Freeze"]
+      end
+
+      def stage2_freeze
+        @errors[:freeze_stage2_meeting] &&= @row["Stage 2 Freeze"].nil? || @row["Stage 2 Freeze"].empty?
+        @row["Stage 2 Freeze"]
+      end
+
+      def stage3_freeze
+        @errors[:freeze_stage3_meeting] &&= @row["Stage 3 Freeze"].nil? || @row["Stage 3 Freeze"].empty?
+        @row["Stage 3 Freeze"]
+      end
+
+      def close_meeting
+        @errors[:close_meeting] &&= @row["Close Meeting"].nil? || @row["Close Meeting"].empty?
+        @row["Close Meeting"]
+      end
+
+      def project_start
+        @errors[:project_start] &&= @row["Project Start"].nil? || @row["Project Start"].empty?
+        Date.parse(@row["Project Start"]) if @row["Project Start"]
+      end
+
+      def project_end
+        @errors[:project_end] &&= @row["Project End"].nil? || @row["Project End"].empty?
+        Date.parse(@row["Project End"]) if @row["Project End"]
+      end
+    end
+  end
+end

data/lib/relaton/3gpp/processor.rb

@@ -0,0 +1,71 @@
+require "relaton/core/processor"
+
+module Relaton
+  module ThreeGpp
+    class Processor < Relaton::Core::Processor
+      attr_reader :idtype
+
+      def initialize # rubocop:disable Lint/MissingSuper
+        @short = :relaton_3gpp
+        @prefix = "3GPP"
+        @defaultprefix = %r{^3GPP\s}
+        @idtype = "3GPP"
+        @pubid_flavor = :Tgpp # global prefixes sourced from Pubid::Tgpp.prefixes
+        @datasets = %w[status-smg-3GPP status-smg-3GPP-force]
+      end
+
+      # @param code [String]
+      # @param date [String, NilClass] year
+      # @param opts [Hash]
+      # @return [RelatonBib::BibliographicItem]
+      def get(code, date, opts)
+        require_relative "../3gpp"
+        Bibliography.get(code, date, opts)
+      end
+
+      #
+      # Fetch all the documents from http://xml2rfc.tools.ietf.org/public/rfc/bibxml-3gpp-new/
+      #
+      # @param [String] source source name
+      # @param [Hash] opts
+      # @option opts [String] :output directory to output documents
+      # @option opts [String] :format
+      #
+      def fetch_data(source, opts)
+        require_relative "data_fetcher"
+        DataFetcher.fetch(source, **opts)
+      end
+
+      # @param xml [String]
+      # @return [RelatonBib::BibliographicItem]
+      def from_xml(xml)
+        require_relative "../3gpp"
+        Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::ThreeGpp::Item]
+      def from_yaml(yaml)
+        require_relative "../3gpp"
+        Item.from_yaml(yaml)
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../3gpp"
+        @grammar_hash ||= ThreeGpp.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../3gpp"
+        Relaton::Index.find_or_create(
+          "3GPP", url: true, file: "#{INDEXFILE}.yaml"
+        ).remove_file
+      end
+    end
+  end
+end

data/lib/relaton/3gpp/release.rb

@@ -0,0 +1,34 @@
+module Relaton
+  module ThreeGpp
+    class Release < Lutaml::Model::Serializable
+      attribute :version2g, :string
+      attribute :version3g, :string
+      attribute :defunct, :boolean
+      attribute :wpm_code_2g, :string
+      attribute :wpm_code_3g, :string
+      attribute :freeze_meeting, :string
+      attribute :freeze_stage1_meeting, :string
+      attribute :freeze_stage2_meeting, :string
+      attribute :freeze_stage3_meeting, :string
+      attribute :close_meeting, :string
+      attribute :project_start, :date
+      attribute :project_end, :date
+
+      xml do
+        root "release"
+        map_element "version2G", to: :version2g
+        map_element "version3G", to: :version3g
+        map_element "defunct", to: :defunct
+        map_element "wpm-code-2G", to: :wpm_code_2g
+        map_element "wpm-code-3G", to: :wpm_code_3g
+        map_element "freeze-meeting", to: :freeze_meeting
+        map_element "freeze-stage1-meeting", to: :freeze_stage1_meeting
+        map_element "freeze-stage2-meeting", to: :freeze_stage2_meeting
+        map_element "freeze-stage3-meeting", to: :freeze_stage3_meeting
+        map_element "close-meeting", to: :close_meeting
+        map_element "project-start", to: :project_start
+        map_element "project-end", to: :project_end
+      end
+    end
+  end
+end

data/lib/relaton/3gpp/util.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module ThreeGpp
+    module Util
+      extend Relaton::Bib::Util
+      PROGNAME = "relaton-3gpp".freeze
+    end
+  end
+end

data/lib/relaton/3gpp.rb

@@ -0,0 +1,29 @@
+require "net/http"
+# pubid loads with the flavor, for the ::Pubid::Tgpp::Identifier that the
+# index code names. Processor#remove_index_file names no pubid class: the
+# delete never reads the index (see lib/relaton/index/CLAUDE.md).
+require "pubid"
+require "relaton/index"
+require "relaton/core"
+require "relaton/bib"
+require_relative "version"
+require_relative "3gpp/util"
+require_relative "3gpp/item"
+require_relative "3gpp/bibitem"
+require_relative "3gpp/bibdata"
+require_relative "3gpp/bibliography"
+
+module Relaton
+  module ThreeGpp
+    INDEXFILE = "index-v2".freeze
+
+    # Returns hash of XML reammar
+    # @return [String]
+    def self.grammar_hash
+      # gem_path = File.expand_path "..", __dir__
+      # grammars_path = File.join gem_path, "grammars", "*"
+      # grammars = Dir[grammars_path].sort.map { |gp| File.read gp }.join
+      Digest::MD5.hexdigest Relaton::VERSION # grammars
+    end
+  end
+end

data/lib/relaton/adobe/bibdata.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Adobe
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

data/lib/relaton/adobe/bibitem.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Adobe
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/adobe/bibliography.rb

@@ -0,0 +1,92 @@
+require "net/http"
+
+module Relaton
+  module Adobe
+    # Retrieval front-end for the Adobe flavor. Parses a reference with
+    # Pubid::Adobe, looks it up in the `relaton-data-adobe` index, fetches the
+    # matching YAML record, and deserializes it into a Relaton::Adobe::Item.
+    # Modelled on Relaton::Oiml::Bibliography (pubid-backed, index via
+    # `pubid_class`); adapted because Adobe identifiers carry no edition
+    # year/language, so there is no per-edition selection — each reference maps
+    # to a single record.
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-adobe/main/".freeze
+
+      class << self
+        # Search for an Adobe publication by its identifier.
+        #
+        # @param text [String, Pubid::Adobe::Identifier] the Adobe reference to
+        #   look up (e.g. "Adobe Technical Note #5014", "ATN5014",
+        #   "Adobe Publication adobe-glyph-list")
+        # @param _year [String, nil] unused (Adobe ids carry no edition year)
+        # @param _opts [Hash] options (unused)
+        # @return [Relaton::Adobe::Item, nil]
+        def search(text, _year = nil, _opts = {})
+          pubid = pubid_for(text) or return
+          Util.info "Fetching from Relaton repository ...", key: pubid.to_s
+          # Tech notes narrow by number via binary search; publications have no
+          # number, so pass nil to scan (Relaton::Index::Type#search returns all
+          # rows for a nil id, then applies the block).
+          query = pubid.root.number ? pubid : nil
+          row = index.search(query) { |r| pubid_match?(r[:id], pubid) }.first
+          unless row
+            Util.info "Not found.", key: pubid.to_s
+            return
+          end
+
+          uri = URI("#{ENDPOINT}#{row[:file]}")
+          resp = Net::HTTP.get_response uri
+          unless resp.code == "200"
+            raise Relaton::RequestError, "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
+          item = Relaton::Adobe::Item.from_yaml resp.body
+          Util.info "Found: `#{item.docidentifier.first&.content}`", key: pubid.to_s
+          item.tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+               Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+               Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
+        end
+
+        def get(ref, year = nil, opts = {})
+          search(ref, year, opts)
+        end
+
+        private
+
+        # Coerce a reference to a Pubid::Adobe identifier. A non-canonical or
+        # non-Adobe string (e.g. a title-cased "Adobe Glyph List") is a graceful
+        # miss (logged, returns nil) rather than a raised Parslet error — the
+        # ref reached here only because it matched the flavor's prefix regex.
+        def pubid_for(text)
+          return text unless text.is_a?(String)
+
+          ::Pubid::Adobe.parse(text)
+        rescue StandardError
+          Util.info "Not found.", key: text
+          nil
+        end
+
+        def index
+          Relaton::Index.find_or_create(
+            :adobe,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Adobe::Identifier,
+          )
+        end
+
+        # Identity match on the human render: pubid renders a tech note as
+        # `Adobe TN <n>` (dropping the filename slug, so `ATN5014` and
+        # `Adobe Technical Note #5014` both match a record stored with its slug)
+        # and a publication as `Adobe Publication <slug>` including its version.
+        # Both `row_id` and `query` are Pubid::Adobe identifiers.
+        def pubid_match?(row_id, query)
+          row_id.to_s == query.to_s
+        end
+      end
+    end
+  end
+end