ftr_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: def2bc2018d1d794afabd625f72f2bc5f78fb363dc4a06f87c2fd8cc2967f7e2
+  data.tar.gz: 6ae0b03ff20569a405c6f34f5e13fd84f6a9bfe9db9d6b67f536ca2cadb4d5e2
+SHA512:
+  metadata.gz: 1f8771dfbcb93530f56ad05f53f2606300f4d829e78d66976f971501bc62d39668eeb5afe67ad0db00adb56dd263964f4d934afc64359285ce889b8389279738
+  data.tar.gz: 13eaaa05362c0290c13377d1b7f7b2e427bc7e00caa5d83a082e02eac6c404ee4d7f41fcfad9486a5a6e527af57487a2156f9a790240701314b4ff957f434abe

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-03-28
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 markwilkinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,179 @@
+# FtrRuby
+
+**Ruby library for generating DCAT-compliant metadata and FAIR test outputs following the FTR Vocabulary**
+
+`FtrRuby` provides two main classes for working with FAIR Tests in Ruby:
+
+- `DCAT_Record` – Creates rich DCAT metadata describing a FAIR Test (as a `dcat:DataService` + `ftr:Test`)
+- `Output` – Generates a standardized FAIR test execution result (as a `ftr:TestResult` with provenance)
+
+The library uses the **TripleEasy** mixin for easy RDF triple creation and produces graphs compatible with DCAT, DQV, PROV, and the **FAIR Test Registry (FTR)** vocabulary.
+
+---
+
+## Features
+
+- Full DCAT 2 metadata generation for FAIR Tests
+- Standardized test result output with provenance (`prov:wasGeneratedBy`, `ftr:TestResult`, etc.)
+- Automatic URL construction for test endpoints and identifiers
+- Support for contact points, indicators, metrics, themes, and guidance
+- JSON-LD output for easy consumption by registries and portals
+- Ready for use in FAIR assessment platforms, OSTrails, and EOSC services
+
+---
+
+## Installation
+
+If published as a gem:
+
+```ruby
+gem 'ftr_ruby'
+```
+
+Or install manually:
+
+```bash
+gem install ftr_ruby
+```
+
+For local development:
+
+```ruby
+require_relative 'lib/ftr_ruby'
+```
+
+---
+
+## Usage
+
+### 1. Documenting a FAIR Test (`DCAT_Record`)
+
+```ruby
+require 'ftr_ruby'
+
+meta = {
+  testid:        "ftr-rda-f1-01m",
+  testname:      "FAIR Test F1-01M: Globally Unique Persistent Identifier",
+  description:   "This test checks whether a digital object is identified by a globally unique persistent identifier.",
+  keywords:      ["FAIR", "F1", "persistent identifier", "PID"],
+  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.0",
+  protocol:      "https",
+  host:          "tests.ostrails.eu",
+  basePath:      "api",
+  individuals:   [{ "name" => "Mark Wilkinson", "email" => "mark.wilkinson@upm.es" }],
+  organizations: [{ "name" => "CBGP", "url" => "https://www.cbgp.upm.es" }]
+}
+
+record = FtrRuby::DCAT_Record.new(meta: meta)
+graph  = record.get_dcat
+
+puts graph.dump(:turtle)
+```
+
+### 2. Generating Test Output (`Output`)
+
+```ruby
+require 'ftr_ruby'
+
+# Meta comes from the same test definition used for DCAT_Record
+meta = { ... }   # same hash as above
+
+output = FtrRuby::Output.new(
+  testedGUID: "https://doi.org/10.1234/example.dataset",
+  meta: meta
+)
+
+# Add test results and comments
+output.score = "pass"
+output.comments << "The resource has a valid persistent identifier."
+output.comments << "Identifier resolves correctly."
+
+# Optional: add guidance for non-passing cases
+output.guidance = [
+  ["https://example.org/fix-pid", "Register a persistent identifier"],
+]
+
+jsonld = output.createEvaluationResponse
+puts jsonld
+```
+
+---
+
+## Classes
+
+### `FtrRuby::DCAT_Record`
+
+Creates metadata describing the test itself.
+
+- Builds a `dcat:DataService` + `ftr:Test`
+- Automatically constructs endpoint URLs, landing pages, and identifiers
+- Includes indicators, metrics, themes, license, contact points, etc.
+
+See the class for full list of supported metadata fields.
+
+### `FtrRuby::Output`
+
+Represents the result of executing a FAIR test against a specific resource.
+
+- Produces a `ftr:TestResult` linked to a `ftr:TestExecutionActivity`
+- Includes score, summary, log/comments, guidance suggestions, and provenance
+- Outputs as JSON-LD (with configurable prefixes)
+- Automatically handles assessment target (the tested GUID)
+
+**Key methods:**
+
+- `new(testedGUID:, meta:)` – Initialize with the tested resource and test metadata
+- `createEvaluationResponse` – Returns JSON-LD string of the full evaluation graph
+
+---
+
+## Vocabulary & Standards Used
+
+- **DCAT** – Data Catalog Vocabulary (W3C)
+- **DQV** – Data Quality Vocabulary
+- **PROV** – Provenance Ontology
+- **FTR** – FAIR Test Registry vocabulary (`https://w3id.org/ftr#`)
+- **SIO** – Semanticscience Integrated Ontology
+- **vCard** – Contact points
+- Schema.org
+
+---
+
+## Project Structure
+
+```
+ftr_ruby/
+├── lib/
+│   └── ftr_ruby.rb
+├── lib/ftr_ruby/
+│   ├── dcat_record.rb
+│   └── output.rb
+└── README.md
+```
+
+---
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at:
+https://github.com/markwilkinson/ftr_ruby
+
+---
+
+## License
+
+This project is licensed under the [MIT License](LICENSE) (or specify your license).
+
+---
+
+## Acknowledgments
+
+Developed in the context of the **OSTrails** project and the **FAIR Champion** initiative.
+
+---
+
+**Made with ❤️ for the FAIR community**

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/dcat_metadata.rb

@@ -0,0 +1,235 @@
+##
+# 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
+
+    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"]
+      @landingpage = meta[:landingPage] || @end_url
+      @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}"
+
+      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)
+
+      # Source of the test	codemeta:hasSourceCode/schema:codeRepository/ doap:repository	schema:SoftwareSourceCode/URL
+      # TODO
+      # FAIRChampion::Output.triplify(me, dcat.endpointDescription, end_desc, 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)
+
+      # # Version notes	adms:versionNotes	rdfs:Literal
+      # FAIRChampion::Output.triplify(me, dcat.version, version, 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.0"
+end

data/lib/ftr_ruby.rb

@@ -0,0 +1,24 @@
+# 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"
+
+module FtrRuby
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/openapi.rb

@@ -0,0 +1,77 @@
+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}/#{endpointpath}"
+      components:
+        schemas:
+          schemas:
+            required:
+              - resource_identifier
+            properties:
+            - resource_identifier:
+                type: string
+                description: the GUID being tested
+
+    EOF_EOF
+  end
+end

data/lib/output.rb

@@ -0,0 +1,181 @@
+module FtrRuby
+  ##
+  # Represents the output/result of executing a FAIR test against a specific resource.
+  #
+  # This class generates a provenance-rich RDF graph describing a single test execution,
+  # including the result score, log messages, summary, and optional guidance for improvement.
+  #
+  # The output follows the FAIR Test Registry (FTR) vocabulary and uses PROV for tracing
+  # the execution activity and the tested entity.
+  #
+  # @example
+  #   output = FtrRuby::Output.new(
+  #     testedGUID: "https://doi.org/10.5281/zenodo.1234567",
+  #     meta: test_meta_hash
+  #   )
+  #   output.score = "pass"
+  #   output.comments << "Resource has a resolvable persistent identifier."
+  #   jsonld = output.createEvaluationResponse
+  #
+  class Output
+    include TripleEasy # get the :"triplify" function
+    # triplify(s, p, o, repo, datatype: nil, context: nil, language: 'en')
+    include RDF
+
+    attr_accessor :score, :testedGUID, :testid, :uniqueid, :name, :description, :license, :dt, :metric, :softwareid,
+                  :version, :summary, :completeness, :comments, :guidance, :creator, :protocol, :host, :basePath, :api
+
+    OPUTPUT_VERSION = "1.1.1"
+
+    ##
+    # Creates a new test output instance.
+    #
+    # @param testedGUID [String] The identifier (usually URI) of the resource being tested
+    # @param meta [Hash] Metadata about the test (same structure used by DCAT_Record)
+    #
+    def initialize(testedGUID:, meta:)
+      @score = "indeterminate"
+      @testedGUID = testedGUID
+      @uniqueid = "urn:fairtestoutput:" + SecureRandom.uuid
+      @name = meta[:testname]
+      @description = meta[:description]
+      @license = meta[:license] || "https://creativecommons.org/licenses/by/4.0/"
+      @dt = Time.now.iso8601
+      @metric = meta[:metric]
+      @version = meta[:testversion]
+      @summary = meta[:summary] || "Summary:"
+      @completeness = "100"
+      @comments = []
+      @guidance = meta.fetch(:guidance, [])
+      @creator = meta[:creator]
+      @protocol = meta[:protocol].gsub(%r{[:/]}, "")
+      @host = meta[:host].gsub(%r{[:/]}, "")
+      @basePath = meta[:basePath].gsub(%r{[:/]}, "")
+      @softwareid = "#{@protocol}://#{@host}/#{@basePath}/#{meta[:testid]}"
+      @api = "#{@softwareid}/api"
+    end
+
+    ##
+    # Generates the full evaluation response as JSON-LD.
+    #
+    # Builds an RDF graph containing:
+    # * A `ftr:TestExecutionActivity`
+    # * A `ftr:TestResult` with score, summary, log, and guidance
+    # * Links to the tested entity and the test software
+    # * Provenance information
+    #
+    # @return [String] JSON-LD representation of the test result graph
+    #
+    def createEvaluationResponse
+      g = RDF::Graph.new
+      schema = RDF::Vocab::SCHEMA
+      xsd = RDF::Vocab::XSD
+      dct = RDF::Vocab::DC
+      prov = RDF::Vocab::PROV
+      dcat = RDF::Vocab::DCAT
+      dqv = RDF::Vocabulary.new("https://www.w3.org/TR/vocab-dqv/")
+      ftr = RDF::Vocabulary.new("https://w3id.org/ftr#")
+      sio = RDF::Vocabulary.new("http://semanticscience.org/resource/")
+      cwmo = RDF::Vocabulary.new("http://purl.org/cwmo/#")
+
+      add_newline_to_comments
+
+      if summary =~ /^Summary$/
+        summary = "Summary of test results: #{comments[-1]}"
+        summary ||= "Summary of test results: #{comments[-2]}"
+      end
+
+      executionid = "urn:ostrails:testexecutionactivity:" + SecureRandom.uuid
+
+      # tid = 'urn:ostrails:fairtestentity:' + SecureRandom.uuid
+      # The entity is no longer an anonymous node, it is the GUID Of the tested input
+
+      triplify(executionid, RDF.type, ftr.TestExecutionActivity, g)
+      triplify(executionid, prov.wasAssociatedWith, softwareid, g)
+      triplify(uniqueid, prov.wasGeneratedBy, executionid, g)
+
+      triplify(uniqueid, RDF.type, ftr.TestResult, g)
+      triplify(uniqueid, dct.identifier, uniqueid.to_s, g, datatype: xsd.string)
+      triplify(uniqueid, dct.title, "#{name} OUTPUT", g)
+      triplify(uniqueid, dct.description, "OUTPUT OF #{description}", g)
+      triplify(uniqueid, dct.license, license, g)
+      triplify(uniqueid, prov.value, score, g)
+      triplify(uniqueid, ftr.summary, summary, g)
+      triplify(uniqueid, RDF::Vocab::PROV.generatedAtTime, dt, g)
+      triplify(uniqueid, ftr.log, comments.join, g)
+      triplify(uniqueid, ftr.completion, completeness, g)
+
+      triplify(uniqueid, ftr.outputFromTest, softwareid, g)
+      triplify(softwareid, RDF.type, ftr.Test, g)
+      triplify(softwareid, RDF.type, schema.SoftwareApplication, g)
+      triplify(softwareid, RDF.type, dcat.DataService, g)
+      triplify(softwareid, dct.identifier, softwareid.to_s, g, datatype: xsd.string)
+      triplify(softwareid, dct.title, "#{name}", g)
+      triplify(softwareid, dct.description, description, g)
+      triplify(softwareid, dcat.endpointDescription, api, g) # returns yaml
+      triplify(softwareid, dcat.endpointURL, softwareid, g) # POST to execute
+      triplify(softwareid, "http://www.w3.org/ns/dcat#version", "#{version} OutputVersion:#{OPUTPUT_VERSION}", g) # dcat namespace in library has no version - dcat 2 not 3
+      triplify(softwareid, dct.license, "https://github.com/wilkinsonlab/FAIR-Core-Tests/blob/main/LICENSE", g)
+      triplify(softwareid, sio["SIO_000233"], metric, g) # implementation of
+
+      # deprecated after release 1.0
+      # triplify(uniqueid, prov.wasDerivedFrom, tid, g)
+      # triplify(executionid, prov.used, tid, g)
+      # triplify(tid, RDF.type, prov.Entity, g)
+      # triplify(tid, schema.identifier, testedGUID, g, xsd.string)
+      # triplify(tid, schema.url, testedGUID, g) if testedGUID =~ %r{^https?://}
+      testedguidnode = "urn:ostrails:testedidentifiernode:" + SecureRandom.uuid
+
+      begin
+        triplify(uniqueid, ftr.assessmentTarget, testedguidnode, g)
+        triplify(executionid, prov.used, testedguidnode, g)
+        triplify(testedguidnode, RDF.type, prov.Entity, g)
+        triplify(testedguidnode, dct.identifier, testedGUID, g, datatype: xsd.string)
+      rescue StandardError
+        triplify(uniqueid, ftr.assessmentTarget, "not a URI", g)
+        triplify(executionid, prov.used, "not a URI", g)
+        score = "fail"
+      end
+
+      unless score == "pass"
+        guidance.each do |advice, label|
+          adviceid = "urn:ostrails:testexecutionactivity:advice:" + SecureRandom.uuid
+          triplify(uniqueid, ftr.suggestion, adviceid, g)
+          triplify(adviceid, RDF.type, ftr.GuidanceContext, g)
+          triplify(adviceid, RDFS.label, label, g)
+          triplify(adviceid, dct.description, label, g)
+          triplify(adviceid, sio["SIO_000339"], RDF::URI.new(advice), g)
+        end
+      end
+
+      #      g.dump(:jsonld)
+      w = RDF::Writer.for(:jsonld)
+      w.dump(g, nil, prefixes: {
+               xsd: RDF::Vocab::XSD,
+               prov: RDF::Vocab::PROV,
+               dct: RDF::Vocab::DC,
+               dcat: RDF::Vocab::DCAT,
+               ftr: ftr,
+               sio: sio,
+               schema: schema
+             })
+    end
+
+    class << self
+      attr_reader :comments
+    end
+
+    def self.clear_comments
+      @comments = []
+    end
+
+    def add_newline_to_comments
+      cleancomments = []
+      @comments.each do |c|
+        c += "\n" unless c =~ /\n$/
+        cleancomments << c
+      end
+      @comments = cleancomments
+    end
+  end
+end

data/lib/registertest.rb

@@ -0,0 +1,23 @@
+require "rest-client"
+module FtrRuby
+  class Tests
+    def self.register_test(test_uri:)
+      warn "registering new test"
+      #       curl -v -L -H "content-type: application/json"
+      # -d '{"clientUrl": "https://my.domain.org/path/to/DCAT/testdcat.ttl"}'
+      # https://tools.ostrails.eu/fdp-index-proxy/proxy
+      begin
+        response = RestClient::Request.execute({
+                                                 method: :post,
+                                                 url: "https://tools.ostrails.eu/fdp-index-proxy/proxy",
+                                                 headers: { "Accept" => "application/json",
+                                                            "Content-Type" => "application/json" },
+                                                 payload: { "clientUrl": test_uri }.to_json
+                                               }).body
+      rescue StandardError => e
+        warn "response is #{response.inspect} error #{e.inspect}"
+      end
+      response
+    end
+  end
+end

data/lib/test_infrastructure.rb

@@ -0,0 +1,47 @@
+module FtrRuby
+  class TestInfra
+    # there is a need to map between a test and its registered Metric in FS.  This will return the label for the test
+    # in principle, we cojuld return a more complex object, but all I need now is the label
+    def self.get_tests_metrics(tests:)
+      base_url = ENV["TEST_BASE_URL"] || "http://localhost:8282" # Default to local server
+      test_path = ENV["TEST_PATH"] || "community-tests" # Default to local server
+      labels = {}
+      landingpages = {}
+      tests.each do |testid|
+        warn "getting dcat for #{testid}    #{base_url}/#{test_path}/#{testid}"
+        dcat = RestClient::Request.execute({
+                                             method: :get,
+                                             url: "#{base_url}/#{test_path}/#{testid}",
+                                             headers: { "Accept" => "application/json" }
+                                           }).body
+        parseddcat = JSON.parse(dcat)
+        # this next line should probably be done with SPARQL
+        # # TODO TODO TODO
+        jpath = JsonPath.new('[0]["http://semanticscience.org/resource/SIO_000233"][0]["@id"]') # is implementation of
+        metricurl = jpath.on(parseddcat).first
+
+        begin
+          g = RDF::Graph.load(metricurl, format: :turtle)
+        rescue StandardError => e
+          warn "DCAT Metric loading failed #{e.inspect}"
+          g = RDF::Graph.new
+        end
+
+        title = g.query([nil, RDF::Vocab::DC.title, nil])&.first&.object&.to_s
+        lp = g.query([nil, RDF::Vocab::DCAT.landingPage, nil])&.first&.object&.to_s
+
+        labels[testid] = if title != ""
+                           title
+                         else
+                           "Metric label not available"
+                         end
+        landingpages[testid] = if lp != ""
+                                 lp
+                               else
+                                 ""
+                               end
+      end
+      [labels, landingpages]
+    end
+  end
+end

data/sig/ftr_ruby.rbs

@@ -0,0 +1,4 @@
+module FtrRuby
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: ftr_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- markwilkinson
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Libraries supporting the FAIR Testing Resources Vocabulary - Tests and
+  test outputs.
+email:
+- mark.wilkinson@upm.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/dcat_metadata.rb
+- lib/fdp_index.rb
+- lib/ftr_ruby.rb
+- lib/ftr_ruby/version.rb
+- lib/openapi.rb
+- lib/output.rb
+- lib/registertest.rb
+- lib/test_infrastructure.rb
+- sig/ftr_ruby.rbs
+homepage: https://github.com/markwilkinson/FTR-Ruby/tree/master
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/markwilkinson/FTR-Ruby/tree/master
+  source_code_uri: https://github.com/markwilkinson/FTR-Ruby/tree/master
+  documentation_uri: https://rubydoc.info/gems/ftr_ruby
+  bug_tracker_uri: https://github.com/markwilkinson/FTR-Ruby/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.9
+specification_version: 4
+summary: Libraries supporting the FTR Vocabulary.
+test_files: []