ftr_ruby 0.1.4

data/lib/dcat_metadata.rb

@@ -0,0 +1,232 @@
+##
+# Module containing FAIR Test Registry (FTR) related classes.
+module FtrRuby
+  ##
+  # Represents a single FAIR Test as a DCAT-compliant DataService with additional
+  # FAIR-specific metadata.
+  #
+  # This class generates RDF metadata (in a DCAT + DQV + FTR vocabulary profile)
+  # describing a test that can be used to assess FAIR compliance of digital objects
+  # (typically datasets). The resulting graph follows the DCAT-AP style for Data Services,
+  # extended with FAIR Test Registry (FTR) semantics.
+  #
+  # == Usage
+  #
+  #   meta = {
+  #     testid:        "ftr-rda-f1-01m",
+  #     testname:      "FAIR Test F1-01M: Persistent Identifier",
+  #     description:   "Checks whether the digital object has a globally unique persistent identifier...",
+  #     keywords:      ["FAIR", "persistent identifier", "F1"],
+  #     creator:       "https://orcid.org/0000-0001-2345-6789",
+  #     indicators:    ["https://w3id.org/ftr/indicator/F1-01M"],
+  #     metric:        "https://w3id.org/ftr/metric/F1-01M",
+  #     license:       "https://creativecommons.org/licenses/by/4.0/",
+  #     testversion:   "1.0",
+  #     # ... other fields
+  #   }
+  #
+  #   record = FtrRuby::DCAT_Record.new(meta: meta)
+  #   graph  = record.get_dcat
+  #
+  class DCAT_Record
+    attr_accessor :identifier, :testname, :description, :keywords, :creator,
+                  :indicators, :end_desc, :end_url, :dctype, :testid, :supportedby,
+                  :license, :themes, :testversion, :implementations, :isapplicablefor, :applicationarea,
+                  :organizations, :individuals, :protocol, :host, :basePath, :metric, :landingpage, :definedby
+
+    require_relative "./output"
+    include TripleEasy # get the :"triplify" function
+    # triplify(s, p, o, repo, datatype: nil, context: nil, language: 'en')
+
+    ##
+    # Creates a new DCAT_Record from metadata hash.
+    #
+    # @param meta [Hash] Metadata describing the FAIR test.
+    # @option meta [String] :testid           Unique identifier for the test (used in URLs)
+    # @option meta [String] :testname         Human-readable name/title of the test
+    # @option meta [String] :description      Detailed description of what the test does
+    # @option meta [String, Array<String>] :keywords   Keywords describing the test
+    # @option meta [String] :creator          URI or literal identifying the creator
+    # @option meta [String, Array<String>] :indicators  URIs of the FAIR indicators this test addresses
+    # @option meta [String] :metric           URI of the metric this test implements
+    # @option meta [String] :license          License URI for the test
+    # @option meta [String, Array<String>] :themes     Thematic categories (DCAT themes)
+    # @option meta [String] :testversion      Version of the test
+    # @option meta [Array<Hash>] :individuals List of contact individuals (name, email)
+    # @option meta [Array<Hash>] :organizations List of responsible organizations (name, url)
+    # @option meta [String] :protocol         Protocol (http/https)
+    # @option meta [String] :host             Hostname of the test service
+    # @option meta [String] :basePath         Base path of the test service
+    #
+    # @note Several fields have sensible defaults (e.g. +dctype+, +supportedby+, +applicationarea+).
+    #       The +end_url+ and +identifier+ are automatically constructed from +protocol+, +host+,
+    #       +basePath+, and +testid+.
+    #
+    def initialize(meta:)
+      indics = [meta[:indicators]] unless meta[:indicators].is_a? Array
+      @indicators = indics
+      @testid = meta[:testid]
+      @testname = meta[:testname]
+      @metric = meta[:metric]
+      @description = meta[:description] || "No description provided"
+      @keywords = meta[:keywords] || []
+      @keywords = [@keywords] unless @keywords.is_a? Array
+      @creator = meta[:creator]
+      @end_desc = meta[:end_desc]
+      @end_url = meta[:end_url]
+      @dctype = meta[:dctype] || "http://edamontology.org/operation_2428"
+      @supportedby = meta[:supportedby] || ["https://tools.ostrails.eu/champion"]
+      @applicationarea = meta[:applicationarea] || ["http://www.fairsharing.org/ontology/subject/SRAO_0000401"]
+      @isapplicablefor = meta[:isapplicablefor] || ["https://schema.org/Dataset"]
+      @license = meta[:license] || "No License"
+      @themes = meta[:themes] || []
+      @themes = [@themes] unless @themes.is_a? Array
+      @testversion = meta[:testversion] || "unversioned"
+      @organizations = meta[:organizations] || []
+      @individuals = meta[:individuals] || []
+      @protocol = meta[:protocol]
+      @host = meta[:host]
+      @basePath = meta[:basePath]
+      cleanhost = @host.gsub("/", "")
+      cleanpath = @basePath.gsub("/", "") # TODO: this needs to check only leading and trailing!  NOt internal...
+      endpointpath = "assess/test"
+      @end_url = "#{protocol}://#{cleanhost}/#{cleanpath}/#{endpointpath}/#{testid}"
+      @end_desc = "#{protocol}://#{cleanhost}/#{cleanpath}/#{testid}/api"
+      @identifier = "#{protocol}://#{cleanhost}/#{cleanpath}/#{testid}"
+      @definedby =  meta[:definedby] || @identifier
+      @landingpage = meta[:landingPage] || @identifier
+
+      unless @testid && @testname && @description && @creator && @end_desc && @end_url && @protocol && @host && @basePath
+        warn "this record is invalid - it is missing one of  testid testname description creator  end_desc end_url protocol  host  basePath"
+      end
+    end
+
+    ##
+    # Returns an RDF::Graph containing the DCAT metadata for this test.
+    #
+    # The graph describes the test as both a +dcat:DataService+ and an +ftr:Test+.
+    # It includes:
+    #
+    # * Core DCAT properties (identifier, title, description, keywords, landing page, etc.)
+    # * FAIR-specific extensions via the FTR vocabulary
+    # * Contact points (individuals and organizations) using vCard
+    # * Link to the metric it implements (SIO)
+    # * Supported-by relationships, application areas, and applicability statements
+    #
+    # @return [RDF::Graph] RDF graph with the complete DCAT record
+    #
+    def get_dcat
+      schema = RDF::Vocab::SCHEMA
+      dcterms = RDF::Vocab::DC
+      xsd = RDF::Vocab::XSD
+      dcat = RDF::Vocab::DCAT
+      sio = RDF::Vocabulary.new("http://semanticscience.org/resource/")
+      ftr = RDF::Vocabulary.new("https://w3id.org/ftr#")
+      dqv = RDF::Vocabulary.new("http://www.w3.org/ns/dqv#")
+      vcard = RDF::Vocabulary.new("http://www.w3.org/2006/vcard/ns#")
+      dpv = RDF::Vocabulary.new("https://w3id.org/dpv#")
+
+      g = RDF::Graph.new
+      #      me = "#{identifier}/about"   # at the hackathon we decided that the test id would return the metadata
+      # so now there is no need for /about
+      me = "#{identifier}"
+
+      triplify(me, RDF.type, dcat.DataService, g)
+      triplify(me, RDF.type, ftr.Test, g)
+
+      # triplify tests and rejects anything that is empty or nil  --> SAFE
+      # Test Unique Identifier	dcterms:identifier	Literal
+      triplify(me, dcterms.identifier, identifier.to_s, g, datatype: xsd.string)
+
+      # Title/Name of the test	dcterms:title	Literal
+      triplify(me, dcterms.title, testname, g)
+
+      # Description	dcterms:description	Literal
+      # descriptions.each do |d|
+      #   triplify(me, dcterms.description, d, g)
+      # end
+      triplify(me, dcterms.description, description, g)
+
+      # Keywords	dcat:keyword	Literal
+      keywords.each do |kw|
+        triplify(me, dcat.keyword, kw, g)
+      end
+
+      # Test creator	dcterms:creator	dcat:Agent (URI)
+      triplify(me, dcterms.creator, creator, g)
+
+      # Dimension	ftr:indicator
+      indicators.each do |ind|
+        triplify(me, dqv.inDimension, ind, g)
+      end
+
+      # API description	dcat:endpointDescription	rdfs:Resource
+      triplify(me, dcat.endpointDescription, end_desc, g)
+
+      # API URL	dcat:endpointURL	rdfs:Resource
+      triplify(me, dcat.endpointURL, end_url, g)
+
+      # API URL	dcat:landingPage	rdfs:Resource
+      triplify(me, dcat.landingPage, landingpage, g)
+
+      # pointer to this turtle file
+      triplify(me, RDF::Vocab::RDFS.isDefinedBy, definedby, g)
+
+      # Functional Descriptor/Operation	dcterms:type	xsd:anyURI
+      triplify(me, dcterms.type, dctype, g)
+
+      # License	dcterms:license	xsd:anyURI
+      triplify(me, dcterms.license, license, g)
+
+      # Semantic Annotation	dcat:theme	xsd:anyURI
+      themes.each do |theme|
+        triplify(me, dcat.theme, theme, g)
+      end
+
+      # Version	dcat:version	rdfs:Literal
+      triplify(me, RDF::Vocab::DCAT.to_s + "version", testversion, g)
+
+      triplify(me, sio["SIO_000233"], metric, g) # is implementation of
+      triplify(metric, RDF.type, dqv.Metric, g) # is implementation of
+
+      # Responsible	dcat:contactPoint	dcat:Kind (includes Individual/Organization)
+      individuals.each do |i|
+        # i = {name: "Mark WAilkkinson", "email": "asmlkfj;askjf@a;lksdjfas"}
+        guid = SecureRandom.uuid
+        cp = "urn:fairchampion:testmetadata:individual#{guid}"
+        triplify(me, dcat.contactPoint, cp, g)
+        triplify(cp, RDF.type, vcard.Individual, g)
+        triplify(cp, vcard.fn, i["name"], g) if i["name"]
+        next unless i["email"]
+
+        email = i["email"].to_s
+        email = "mailto:#{email}" unless email =~ /mailto:/
+        triplify(cp, vcard.hasEmail, RDF::URI.new(email), g)
+      end
+
+      organizations.each do |o|
+        # i = {name: "CBGP", "url": "https://dbdsf.orhf"}
+        guid = SecureRandom.uuid
+        cp = "urn:fairchampion:testmetadata:org:#{guid}"
+        triplify(me, dcat.contactPoint, cp, g)
+        triplify(cp, RDF.type, vcard.Organization, g)
+        triplify(cp, vcard["organization-name"], o["name"], g)
+        triplify(cp, vcard.url, RDF::URI.new(o["url"].to_s), g)
+      end
+
+      supportedby.each do |tool|
+        triplify(me, ftr.supportedBy, tool, g)
+        triplify(tool, RDF.type, schema.SoftwareApplication, g)
+      end
+
+      applicationarea.each do |domain|
+        triplify(me, ftr.applicationArea, domain, g)
+      end
+      isapplicablefor.each do |digitalo|
+        triplify(me, dpv.isApplicableFor, digitalo, g)
+      end
+
+      g
+    end
+  end
+end

data/lib/fdp_index.rb

@@ -0,0 +1,168 @@
+require "sparql/client"
+require "sparql"
+require "json/ld"
+require "json/ld/preloaded"
+require "rdf/trig"
+require "rdf/raptor"
+require "fileutils" # For directory creation
+require "digest" # For hashing URLs to filenames
+
+module FtrRuby
+  class FDPIndex
+    # Cache directory and expiry time (in seconds, e.g., 24 hours)
+    CACHE_DIR = File.join(Dir.pwd, "cache", "rdf_repositories")
+    CACHE_EXPIRY = 240 * 60 * 60 # 24 hours in seconds
+
+    def self.retrieve_tests_from_index(indexendpoint: "https://tools.ostrails.eu/repositories/fdpindex-fdp")
+      sparql = SPARQL::Client.new(indexendpoint)
+
+      fdpindexquery = <<EOQUERY
+      PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+      PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+      PREFIX dqv: <http://www.w3.org/ns/dqv#>
+      PREFIX dct: <http://purl.org/dc/terms/>
+      PREFIX dcat: <http://www.w3.org/ns/dcat#>
+      PREFIX sio: <http://semanticscience.org/resource/>
+      PREFIX dpv: <http://www.w3.org/ns/dpv#>
+      PREFIX ftr: <https://w3id.org/ftr#>
+      SELECT distinct ?sub ?identifier ?title ?description ?endpoint ?openapi ?dimension ?objects ?domain ?benchmark_or_metric WHERE {
+        ?sub a <https://w3id.org/ftr#Test> ;
+            dct:title ?title ;
+            dct:description ?description ;
+            dct:identifier ?identifier .
+            OPTIONAL {?sub dpv:isApplicableFor ?objects }
+            OPTIONAL {?sub ftr:applicationArea ?domain  }
+            OPTIONAL {?sub sio:SIO_000233 ?benchmark_or_metric  }  # implementation of#{"            "}
+            OPTIONAL {?sub dcat:endpointDescription ?openapi }
+            OPTIONAL {?sub dcat:endpointURL ?endpoint }
+            OPTIONAL {?sub dqv:inDimension ?dimension }
+      }#{" "}
+EOQUERY
+
+      alltests = []
+
+      begin
+        # Execute the query
+        results = sparql.query(fdpindexquery)
+
+        # Process the results
+        results.each_solution do |solution|
+          test_object = {
+            subj: solution[:sub]&.to_s,
+            identifier: solution[:identifier]&.to_s,
+            title: solution[:title]&.to_s,
+            description: solution[:description]&.to_s,
+            endpoint: solution[:endpoint]&.to_s,
+            openapi: solution[:openapi]&.to_s,
+            dimension: solution[:dimension]&.to_s,
+            objects: solution[:objects]&.to_s,
+            domain: solution[:domain]&.to_s,
+            benchmark_or_metric: solution[:benchmark_or_metric]&.to_s
+          }
+          alltests << test_object
+        end
+      rescue StandardError => e
+        puts "Error executing SPARQL query: #{e.message}"
+      end
+
+      alltests
+    end
+
+    def self.get_metrics_labels_for_tests(tests:)
+      labels = {}
+      cache = {} # In-memory cache for this request
+
+      # Ensure cache directory exists
+      FileUtils.mkdir_p(CACHE_DIR)
+
+      tests.each do |test|
+        metric = test[:benchmark_or_metric] # Assume required
+        warn "Processing metric: #{metric}"
+
+        # Generate a safe filename for the metric URL
+        cache_key = Digest::SHA256.hexdigest(metric)
+        cache_file = File.join(CACHE_DIR, "#{cache_key}.bin")
+
+        # Check in-memory cache first
+        if cache[metric]
+          repository = cache[metric]
+        else
+          # Try to load from disk cache
+          repository = load_from_cache(cache_file)
+          if repository
+            warn "Loaded #{metric} from cache"
+          else
+            # Cache miss: fetch from URL
+            warn "Fetching RDF for #{metric}"
+            repository = RDF::Repository.new
+            headers = { "Accept" => "application/ld+json" }
+            begin
+              RDF::Reader.open(metric, headers: headers) do |reader|
+                repository << reader
+              end
+              # Save to disk cache with timestamp
+              save_to_cache(cache_file, repository)
+              warn "Cached #{metric} to disk"
+            rescue StandardError => e
+              warn "Error fetching RDF for #{metric}: #{e.message}"
+              labels[metric] = "Unable to resolve #{metric} to RDF metadata"
+              next
+            end
+          end
+          cache[metric] = repository # Store in memory for this request
+        end
+
+        # SPARQL query to get label
+        fdpindexquery = <<-METRICLABEL
+          PREFIX dct: <http://purl.org/dc/terms/>
+          PREFIX schema: <http://schema.org/>
+          SELECT DISTINCT ?label WHERE {
+            { ?sub dct:title ?label }
+            UNION
+            { ?sub schema:name ?label }
+          }
+        METRICLABEL
+
+        # Parse and execute the SPARQL query
+        fdpindexquery = SPARQL.parse(fdpindexquery)
+        results = fdpindexquery.execute(repository)
+
+        # Assign the label (first result or fallback)
+        labels[metric] = if results&.first&.[](:label)&.to_s&.length&.positive?
+                           results.first[:label].to_s
+                         else
+                           "Unnamed Metric"
+                         end
+      end
+
+      labels
+    end
+
+    # Load RDF::Repository from disk cache if not expired
+    def self.load_from_cache(cache_file)
+      return nil unless File.exist?(cache_file)
+
+      # Read timestamp and serialized data
+      File.open(cache_file, "rb") do |file|
+        timestamp = Marshal.load(file)
+        if Time.now - timestamp < CACHE_EXPIRY
+          return Marshal.load(file) # Return cached RDF::Repository
+        end
+      end
+      nil # Cache expired or invalid
+    rescue StandardError => e
+      warn "Error loading cache from #{cache_file}: #{e.message}"
+      nil
+    end
+
+    # Save RDF::Repository to disk cache with timestamp
+    def self.save_to_cache(cache_file, repository)
+      File.open(cache_file, "wb") do |file|
+        Marshal.dump(Time.now, file) # Store timestamp
+        Marshal.dump(repository, file) # Store repository
+      end
+    rescue StandardError => e
+      warn "Error saving cache to #{cache_file}: #{e.message}"
+    end
+  end
+end

data/lib/ftr_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FtrRuby
+  VERSION = "0.1.4"
+end

data/lib/ftr_ruby.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "ftr_ruby/version"
+require "rest-client"
+require "json"
+require "sparql"
+require "sparql/client"
+require "linkeddata"
+require "safe_yaml"
+require "rdf/nquads"
+require "cgi"
+require "securerandom"
+require "rdf/vocab"
+require "triple_easy" # provides "triplify" top-level function
+
+# lib/ftr_ruby.rb
+
+require "dcat_metadata"
+require "output"
+require "fdp_index"
+require "openapi"
+require "registertest"
+require "test_infrastructure"
+
+module FtrRuby
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/openapi.rb

@@ -0,0 +1,79 @@
+module FtrRuby
+  class OpenAPI
+    attr_accessor :title, :metric, :description, :indicator, :testid,
+                  :organization, :org_url, :version, :creator,
+                  :responsible_developer, :email, :developer_ORCiD, :protocol,
+                  :host, :basePath, :path, :response_description, :schemas, :endpointpath
+
+    def initialize(meta:)
+      indics = [meta[:indicators]] unless meta[:indicators].is_a? Array
+      @testid = meta[:testid]
+      @title = meta[:testname]
+      @version = meta[:testversion]
+      @metric = meta[:metric]
+      @description = meta[:description]
+      @indicator = indics.first
+      @organization = meta[:organization]
+      @org_url = meta[:org_url]
+      @responsible_developer = meta[:responsible_developer]
+      @email = meta[:email]
+      @creator = meta[:creator]
+      @host =  meta[:host]
+      @host = @host.gsub(%r{/$}, "") # remove trailing slash if present
+      @protocol =  meta[:protocol].gsub(%r{[:/]}, "")
+      @basePath =  meta[:basePath].gsub(%r{[:/]}, "")
+      @basePath = "/#{basePath}" unless basePath[0] == "/" # must start with a slash
+      # @path = meta[:path]
+      @response_description = meta[:response_description]
+      @schemas = meta[:schemas]
+      @endpointpath = "assess/test"
+      # @end_url = "#{protocol}://#{host}#{basePath}/#{endpointpath}/#{testid}" # basepath starts with /
+    end
+
+    def get_api
+      <<~"EOF_EOF"
+
+        openapi: 3.0.0
+        info:
+          version: "#{version}"
+          title: "#{title}"
+          x-tests_metric: "#{metric}"
+          description: >-
+            "#{description}"
+          x-applies_to_principle: "#{indicator}"
+          contact:
+            x-organization: "#{organization}"
+            url: "#{org_url}"
+            name: "#{responsible_developer}"
+            x-role: responsible developer
+            email: "#{email}"
+            x-id: "#{creator}"
+        paths:
+          "/#{testid}":
+            post:
+              requestBody:
+                content:
+                  application/json:
+                    schema:
+                      $ref: "#/components/schemas/schemas"
+                required: true
+              responses:
+                "200":
+                  description:  >-
+                    #{response_description}
+        servers:
+          - url: "#{protocol}://#{host}#{basePath}/#{endpointpath}"
+        components:
+          schemas:
+            schemas:
+              required:
+                - resource_identifier
+              properties:
+              - resource_identifier:
+                  type: string
+                  description: the GUID being tested
+
+      EOF_EOF
+    end
+  end
+end