ftr_ruby 0.1.4

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:, proxy_url: "https://tools.ostrails.eu/fdp-index-proxy/proxy")
+      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: proxy_url,
+                                                 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,53 @@
+module FtrRuby
+  class TestInfra
+    attr_accessor :test_protocol, :test_host, :basepath
+
+    def initialize(test_host:, basepath:, test_protocol:)
+      @test_host = test_host
+      @test_protocol = test_protocol
+      @basepath = basepath
+    end
+
+    # 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 get_tests_metrics(tests:)
+      labels = {}
+      landingpages = {}
+      tests.each do |testid|
+        warn "getting dcat for #{testid}    #{test_protocol}://#{test_host}/#{basepath}/#{testid}"
+        dcat = RestClient::Request.execute({
+                                             method: :get,
+                                             url: "#{test_protocol}://#{test_host}/#{basepath}/#{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,85 @@
+--- !ruby/object:Gem::Specification
+name: ftr_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.4
+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
+- Rakefile
+- doc/CHANGELOG_md.html
+- doc/FtrRuby.html
+- doc/FtrRuby/DCAT_Record.html
+- doc/FtrRuby/Error.html
+- doc/FtrRuby/FDPIndex.html
+- doc/FtrRuby/Output.html
+- doc/FtrRuby/TestInfra.html
+- doc/FtrRuby/Tests.html
+- doc/Gemfile.html
+- doc/Gemfile_lock.html
+- doc/LICENSE_txt.html
+- doc/OpenAPI.html
+- doc/README_md.html
+- doc/Rakefile.html
+- doc/bin/setup.html
+- doc/created.rid
+- doc/css/rdoc.css
+- doc/index.html
+- doc/js/aliki.js
+- doc/js/bash_highlighter.js
+- doc/js/c_highlighter.js
+- doc/js/search_controller.js
+- doc/js/search_data.js
+- doc/js/search_navigation.js
+- doc/js/search_ranker.js
+- doc/js/theme-toggle.js
+- doc/sig/ftr_ruby_rbs.html
+- 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: []