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

data/lib/relaton/ccsds/data/iso_references.rb

@@ -0,0 +1,30 @@
+require "csv"
+require "singleton"
+require "mechanize"
+
+module Relaton
+  module Ccsds
+    class IsoReferences
+      include Singleton
+
+      ISO_CSV_URL = "https://isopublicstorageprod.blob.core.windows.net/opendata/_latest"\
+                    "/iso_deliverables_metadata/csv/iso_deliverables_metadata.csv".freeze
+
+      def [](key)
+        data[key]
+      end
+
+      private
+
+      def data
+        @data ||= begin
+          csv = Mechanize.new.get(ISO_CSV_URL).body
+          rows = CSV.parse(csv, headers: true)
+          rows.each_with_object({}) do |row, h|
+            h[row["id"]] = row["reference"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/data/parser.rb

@@ -0,0 +1,194 @@
+require_relative "../model/item"
+require_relative "fetcher"
+require_relative "iso_references"
+
+module Relaton
+  module Ccsds
+    class DataParser
+      include Core::ArrayWrapper
+
+      DOCTYPES = { B: "standard", M: "practice", G: "report", O: "specification", Y: "record" }.freeze
+      DOMAIN = "https://public.ccsds.org".freeze
+
+      AREAS = {
+        "SEA" => "Systems Engineering Area",
+        "MOIMS" => "Mission Operations and Information Management Services Area",
+        "CSS" => "Cross Support Services Area",
+        "SOIS" => "Spacecraft Onboard Interface Services Area",
+        "SLS" => "Space Link Services Area",
+        "SIS" => "Space Internetworking Services Area",
+      }.freeze
+
+      ATTRS = %i[
+        title docidentifier abstract date status source edition relation contributor ext
+      ].freeze
+
+      ID_MAPPING = {
+        "CCSDS 320.0-B-1-S Corrigendum 1" => "CCSDS 320.0-B-1-S Cor. 1", # TODO relaton/relaton-data-ccsds#5
+        "CCSDS 701.00-R-3" => "CCSDS 701.00-R-3-S", # TODO relaton/relaton-data-ccsds#8
+      }.freeze
+
+      def initialize(doc, docs, successor = nil)
+        @doc = doc
+        @docs = docs
+        @successor = successor
+      end
+
+      def parse
+        args = ATTRS.each_with_object({}) { |a, o| o[a] = send "parse_#{a}" }
+        item = ItemData.new(**args)
+        item.create_id
+        item
+      end
+
+      def parse_title
+        t = @doc[3]
+        [Bib::Title.new(content: t, language: "en", script: "Latn")]
+      end
+
+      def parse_docidentifier
+        [Docidentifier.new(content: docidentifier, type: "CCSDS", primary: true)]
+      end
+
+      def docidentifier
+        @docidentifier ||= begin
+          docid = parse_identifier(@doc[2])
+          @successor ? docid.sub(/(-S|s)(?=\s|$)/, "") : docid
+        end
+      end
+
+      def parse_identifier(link)
+        id = link.strip.match(/(?<=>).+(?=<\/a>)/).to_s
+        ID_MAPPING[id] || id
+      end
+
+      def parse_abstract
+        a = @doc[7]
+        [Bib::Abstract.new(content: a, language: "en", script: "Latn")]
+      end
+
+      def parse_doctype
+        />CCSDS\s[\d.]+-(?<type>\w+)/ =~ @doc[2]
+        Doctype.new content: DOCTYPES[type&.to_sym]
+      end
+
+      def parse_date
+        at = @doc[6]
+        [Bib::Date.new(type: "published", at: at)]
+      end
+
+      def parse_status
+        stage = Bib::Status::Stage.new content: @successor ? "withdrawn" : "published"
+        Bib::Status.new stage: stage
+      end
+
+      def parse_source
+        sources = []
+        src = create_source(@doc[2], "src")
+        sources << src if src
+
+        type = @doc[1].match(/https?:[^"]+(pdf|doc)"/)
+        return sources unless type
+
+        download = create_source(@doc[1], type[1])
+        sources.tap { |s| s << download if download }
+      end
+
+      def create_source(link, type)
+        href = parse_href(link)
+        return unless href
+
+        Bib::Uri.new(type: type, content: href)
+      end
+
+      def parse_href(link)
+        /(?<href>https?:[^"]+)/.match(link)&.[](:href)
+      end
+
+      def parse_edition
+        return unless @doc[5]
+
+        Bib::Edition.new content: @doc[5]
+      end
+
+      def parse_relation
+        @docs.each_with_object(successors + adopted) do |d, a|
+          id = parse_identifier d[2]
+          type = relation_type id
+          next unless type
+
+          a << create_relation(type, id)
+        end
+      end
+
+      def adopted
+        /(?<href>https?:[^"]+)/ =~ @doc[9]
+        array(href).each_with_object([]) do |uri, acc|
+          /\/(?<ref_id>\d+)\.html/ =~ uri
+          iso_id = IsoReferences.instance[ref_id]
+          unless iso_id
+            Util.warn "ISO reference not found for #{uri}"
+            next
+          end
+          acc << create_relation("adoptedAs", iso_id, uri, "ISO")
+        end
+      end
+
+      def successors
+        return [] unless @successor
+
+        @successors ||= begin
+          if @successor.relation.none? { |r| r.type == "successorOf" }
+            @successor.relation << create_relation("successorOf", docidentifier)
+          end
+          [create_relation("hasSuccessor", @successor.docidentifier[0].content)]
+        end
+      end
+
+      # TODO: cover this
+      def relation_type(rel_id)
+        return if rel_id == docidentifier ||
+          rel_id.match(DataFetcher::TRRGX).to_s != docidentifier.match(DataFetcher::TRRGX).to_s
+
+        if rel_id.include?(docidentifier.sub(DataFetcher::TRRGX, ""))
+          "updatedBy"
+        elsif docidentifier.include?(rel_id.sub(DataFetcher::TRRGX, ""))
+          "updates"
+        end
+      end
+
+      def create_relation(type, rel_id, uri = nil, id_type = "CCSDS")
+        id = Bib::Docidentifier.new content: rel_id, type: id_type, primary: true
+        source = array(uri).map { |u| Bib::Uri.new(type: "src", content: u) }
+        bibitem = Bib::ItemData.new docidentifier: [id], source: source, formattedref: Bib::Formattedref.new(content: rel_id)
+        Bib::Relation.new type: type, bibitem: bibitem
+      end
+
+      def parse_contributor # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        array(@doc[8]).each_with_object([]) do |wg, acc|
+          /^(?<name>[^<]+)/ =~ wg
+          next if name.nil? || name.strip.empty?
+
+          sdname = Bib::TypedLocalizedString.new content: name.strip
+          subdiv = Bib::Subdivision.new type: "technical-committee", name: [sdname]
+          orgname = Bib::TypedLocalizedString.new content: "CCSDS"
+          org = Bib::Organization.new name: [orgname], subdivision: [subdiv]
+          description = Bib::LocalizedMarkedUpString.new(content: "committee")
+          role = Bib::Contributor::Role.new type: "author", description: [description]
+          acc << Bib::Contributor.new(role: [role], organization: org)
+        end
+      end
+
+      def parse_ext
+        Ext.new flavor: "ccsds", doctype: parse_doctype, technology_area: parse_technology_area
+      end
+
+      def parse_technology_area
+        return unless @doc[8]
+
+        desc = @doc[8].split("-").first
+        AREAS[desc]
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/hit.rb

@@ -0,0 +1,24 @@
+require "mechanize"
+module Relaton
+  module Ccsds
+    class Hit < Relaton::Core::Hit
+      # attr_reader :code
+
+      # def initialize(code:, url:)
+      #   @code = code
+      #   @url = url
+      # end
+
+      def item
+        return @item if @item
+
+        resp = Mechanize.new.get(hit[:url])
+        @item = Item.from_yaml(resp.body)
+        @item.fetched = Date.today.to_s
+        @item
+      rescue Mechanize::Error => e
+        raise Relaton::RequestError, e.message
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/hit_collection.rb

@@ -0,0 +1,47 @@
+require_relative "hit"
+
+module Relaton
+  module Ccsds
+    class HitCollection < Relaton::Core::HitCollection
+      GHURL = "https://raw.githubusercontent.com/relaton/relaton-data-ccsds/refs/heads/v2/".freeze
+
+      #
+      # Search his in index.
+      #
+      # @return [<Type>] <description>
+      #
+      def fetch
+        @array = rows.map { |row| Hit.new code: row[:id], url: "#{GHURL}#{row[:file]}" }
+        self
+      rescue SocketError, OpenURI::HTTPError, OpenSSL::SSL::SSLError, Errno::ECONNRESET => e
+        raise Relaton::RequestError, e.message
+      end
+
+      # Pubid index (index-v2): `:id` deserializes to a Pubid::Ccsds::Identifier
+      # via pubid_class, so search narrows by number with binary search.
+      def index
+        @index ||= Relaton::Index.find_or_create(
+          :ccsds, url: "#{GHURL}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml", pubid_class: Pubid::Ccsds::Identifier
+        )
+      end
+
+      def pubid
+        @pubid ||= Pubid::Ccsds::Identifier.parse(ref)
+      end
+
+      def rows
+        if pubid.edition
+          # `exact:` keeps the match exact. `Type#search` without it takes
+          # pubid's subset match `pubid === row`. pubid declares `language`
+          # `subset_strict`, so a translation no longer matches, but `suffix` is
+          # still a wildcard: `CCSDS 101.0-B-4` would also reach the historical
+          # `CCSDS 101.0-B-4-S` (260 such pairs in the index fixture).
+          index.search(pubid, exact: true)
+        else
+          # search(pubid) narrows candidates by number via binary search first.
+          index.search(pubid) { |r| r[:id].exclude(:edition) == pubid }
+        end
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/item_data.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Ccsds
+    class ItemData < Bib::ItemData
+      def relation=(value)
+        @relation = value || []
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/model/bibdata.rb

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

data/lib/relaton/ccsds/model/bibitem.rb

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

data/lib/relaton/ccsds/model/docidentifier.rb

@@ -0,0 +1,121 @@
+module Relaton
+  module Ccsds
+    # CCSDS document identifier backed by a parsed Pubid::Ccsds::Identifier.
+    #
+    # Mirrors the IEC flavor (lib/relaton/iec/model/docidentifier.rb): the
+    # lutaml `content` stays a plain string for serialization, while the parsed
+    # pubid is kept in `@pubid` so the structural mutators (`remove_part!`,
+    # `remove_date!`, `to_all_parts!`) can edit the identifier graph and
+    # re-render. CCSDS components are simpler than ISO/IEC — plain strings, no
+    # subpart, no supplement/consolidated special-casing beyond the base chain —
+    # so this is the minimal Pubid-backed shape.
+    class Docidentifier < Bib::Docidentifier
+      attribute :content, :string
+
+      attr_reader :pubid
+
+      def initialize(arg = nil, **kwargs)
+        arg.is_a?(Hash) ? super(arg) : super(**kwargs)
+        # lutaml may run the content setter before `type` is assigned; re-run it
+        # from `initialize` so the authoritative value is parsed with type set.
+        raw = arg.is_a?(Hash) ? (arg["content"] || arg[:content]) : kwargs[:content]
+        self.content = raw if raw
+      end
+
+      alias_method :original_content=, :content=
+      alias_method :original_content, :content
+
+      def content=(value)
+        @pubid = nil
+        @raw_content = nil
+
+        parsed =
+          case value
+          when ::Pubid::Ccsds::Identifier then value
+          when String
+            begin
+              ::Pubid::Ccsds::Identifier.parse(value)
+            rescue StandardError
+              # Suppress while `type` is unset: lutaml runs this setter once
+              # during init before `type` is assigned, then `initialize` re-runs
+              # it — only the second pass is authoritative.
+              Util.warn "Failed to parse Pubid: #{value}" if type
+              nil
+            end
+          end
+
+        if parsed
+          @pubid = parsed
+        elsif value.is_a?(String)
+          @raw_content = value
+        end
+
+        send(:original_content=, to_s)
+      end
+
+      def content
+        return @raw_content if @raw_content
+        return @pubid.to_s if @pubid
+
+        original_content
+      end
+
+      def to_s
+        content.to_s
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy, including
+        # the base chain of a supplement/corrigendum — `remove_attr!` walks
+        # and mutates that whole chain in place, so even a shallow `.dup`
+        # would still lose the original part/date to that mutation.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        # `content` is live-derived from `@pubid` (see above), and the wrapped
+        # all-parts identifier renders a "(all parts)" marker pubid-ccsds
+        # itself never has — so freeze the already-stripped rendering into
+        # `@raw_content` (checked first by `content`) before wrapping.
+        @raw_content = to_s
+        # Wrap the ORIGINAL (unstripped) pubid, not the part/date-stripped
+        # working copy above — `identifiers` should hold the real identifier
+        # this all-parts reference was derived from.
+        @pubid = original.to_all_parts
+      end
+
+      def remove_part!
+        remove_attr!(:part)
+      end
+
+      def remove_date!
+        remove_attr!(:date)
+      end
+
+      private
+
+      def remove_attr!(attr)
+        return unless @pubid
+
+        clear_attr_on(@pubid, attr)
+        # Supplements/corrigenda wrap a base identifier; a plain Base returns
+        # nil, so the walk clears the attr down the whole chain and terminates.
+        node = @pubid.base
+        while node
+          clear_attr_on(node, attr)
+          node = node.base
+        end
+        refresh_content!
+      end
+
+      def clear_attr_on(pubid, attr)
+        pubid.send("#{attr}=", nil) if pubid.respond_to?("#{attr}=")
+      end
+
+      def refresh_content!
+        send(:original_content=, to_s)
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/model/doctype.rb

@@ -0,0 +1,9 @@
+module Relaton
+  module Ccsds
+    class Doctype < Bib::Doctype
+      TYPES = %w[standard practice report specification record].freeze
+
+      attribute :content, :string, values: TYPES
+    end
+  end
+end

data/lib/relaton/ccsds/model/ext.rb

@@ -0,0 +1,19 @@
+require_relative "doctype"
+
+module Relaton
+  module Ccsds
+    class Ext < Lutaml::Model::Serializable
+      attribute :schema_version, :string
+      attribute :doctype, Doctype
+      attribute :structuredidentifier, Bib::StructuredIdentifier, collection: true
+      attribute :technology_area, :string, values: %w[SEA MOIMS CSS SOIS SLS SIS]
+
+      xml do
+        map_attribute "schema-version", to: :schema_version
+        map_element "doctype", to: :doctype
+        map_element "structuredidentifier", to: :structuredidentifier
+        map_element "technology-area", to: :technology_area
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/model/item.rb

@@ -0,0 +1,15 @@
+require "relaton/bib"
+require_relative "../item_data"
+require_relative "docidentifier"
+require_relative "ext"
+
+module Relaton
+  module Ccsds
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :docidentifier, Docidentifier, collection: true, initialize_empty: true
+      attribute :ext, Ext
+    end
+  end
+end

data/lib/relaton/ccsds/processor.rb

@@ -0,0 +1,68 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Ccsds
+    class Processor < Relaton::Core::Processor
+      attr_reader :idtype
+
+      def initialize # rubocop:disable Lint/MissingSuper
+        @short = :relaton_ccsds
+        @prefix = "CCSDS"
+        @defaultprefix = %r{^CCSDS(?!\w)}
+        @idtype = "CCSDS"
+        @datasets = %w[ccsds]
+      end
+
+      # @param code [String]
+      # @param date [String, NilClass] year
+      # @param opts [Hash]
+      # @return [Relaton::Ccsds::ItemData, nil]
+      def get(code, date, opts)
+        require_relative "../ccsds"
+        Bibliography.get(code, date, opts)
+      end
+
+      #
+      # Fetch all the documents from a source
+      #
+      # @param [String] source source name
+      # @param [Hash] opts
+      # @option opts [String] :output directory to output documents
+      # @option opts [String] :format
+      #
+      def fetch_data(source = "ccsds", **opts)
+        require_relative "data/fetcher"
+        DataFetcher.fetch(source, **opts)
+      end
+
+      # @param xml [String]
+      # @return [Relaton::Ccsds::ItemData]
+      def from_xml(xml)
+        require_relative "../ccsds"
+        Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Relaton::Ccsds::ItemData]
+      def from_yaml(yaml)
+        require_relative "../ccsds"
+        Item.from_yaml yaml
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../ccsds"
+        @grammar_hash ||= ::Relaton::Ccsds.grammar_hash
+      end
+
+      #
+      # Remove index file
+      #
+      def remove_index_file
+        require_relative "../ccsds"
+        Relaton::Index.find_or_create(:ccsds, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      end
+    end
+  end
+end

data/lib/relaton/ccsds/util.rb

@@ -0,0 +1,10 @@
+require "relaton/bib/util"
+
+module Relaton
+  module Ccsds
+    module Util
+      extend Relaton::Bib::Util
+      PROGNAME = "relaton-ccsds".freeze
+    end
+  end
+end

data/lib/relaton/ccsds.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# require "mechanize"
+# require "relaton/core"
+# require "relaton/bib"
+require "relaton/index"
+require "pubid"
+require_relative "version"
+# require_relative "ccsds/processor"
+require_relative "ccsds/util"
+require_relative "ccsds/model/item"
+require_relative "ccsds/model/bibitem"
+require_relative "ccsds/model/bibdata"
+require_relative "ccsds/bibliography"
+
+module Relaton
+  module Ccsds
+    # The pubid-v2 (lean hash) index this gem produces and consumes. The legacy
+    # index-v1 (pubid-v1 hash, for the released gem line) is rebuilt separately
+    # by the data repo's build_index_v1.rb.
+    INDEXFILE = "index-v2"
+
+    class Error < StandardError; end
+    # Your code goes here...
+
+    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