yaml-ld 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c1da1570067d55e5cf71f757cfb5a2e2d8313dc9f63fe045bafde65dcb220a02
-  data.tar.gz: '0096c9115d43889554b3e7f6d7ac92d7c8b94b4adce85d8b811f0321186d9dd0'
+  metadata.gz: ff85402eb62829682e62261e3313de8456944793866fb56dcd7d822c9f8568bb
+  data.tar.gz: af3f18f8c3f34bc297962180db33188999c7366da516b0d07bf157b9e590c1d4
 SHA512:
-  metadata.gz: ea19a5310f145f5abb060fd54903f42312a60d197a268ec3a66ba4421ed0497e3f93b1b8b930cda9797bc00aa92d18d9ca1fb7a633cdf9bf7f37bcac1cc50426
-  data.tar.gz: a861b85988b30f42bb3afdf7d2ecae69663ca069081b4921303c07c72bc17bc19d4fea27c21ce8a2d027b256a5079581deeb5c9dc0a864fe95edd5420b9a8b8b
+  metadata.gz: e253462895a4505847fc9ba8483005b384ba93acbfd2461c84d142d02b5d2b14c3529d9bce31098d89fae86c285381e8f037caa569be0de3e49d54fee56d47d9
+  data.tar.gz: 25939722e72692aa251abca8d472ddb8f05ef47d12830774f0139f87b53e1f279c1a6f9c29e10ba874f826b0e2a5e652b5b81d21f88ecb85450d5604e09b2b1b

data/README.md

@@ -2,8 +2,8 @@
 
 Ruby [YAML-LD][] reader/writer for RDF.rb
 
-[![Gem Version](https://badge.fury.io/rb/yaml-ld.png)](https://rubygems.org/gems/yaml-ld)
-[![Build Status](https://secure.travis-ci.org/ruby-rdf/yaml-ld.png?branch=develop)](https://github.com/ruby-rdf/yaml-ld/actions?query=workflow%3ACI)
+[![Gem Version](https://badge.fury.io/rb/yaml-ld.svg)](https://rubygems.org/gems/yaml-ld)
+[![Build Status](https://github.com/ruby-rdf/yaml-ld/workflows/CI/badge.svg?branch=develop)](https://github.com/ruby-rdf/yaml-ld/actions?query=workflow%3ACI)
 [![Coverage Status](https://coveralls.io/repos/ruby-rdf/yaml-ld/badge.svg?branch=develop)](https://coveralls.io/github/ruby-rdf/yaml-ld?branch=develop)
 [![Gitter chat](https://badges.gitter.im/ruby-rdf.png)](https://gitter.im/gitterHQ/gitter)
 
@@ -102,12 +102,17 @@ In addition to the input, both a `context` and `frame` may be specified using ei
 * [Psych](https://rubygems.org/gems/psych) (>= 4.0)
 * [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.2)
 
+### Ubuntu limitation
+
+As of October 2023, Ubuntu distributions are running with libyaml 0.2.1, which does not support YAML 1.2. The minimum version needed is libyaml 0.2.5.
+
 ## Installation
 The recommended installation method is via [RubyGems](https://rubygems.org/).
 To install the latest official release of the `JSON-LD` gem, do:
 
     % [sudo] gem install yaml-ld
 
+
 ## Download
 To get a local working copy of the development repository, do:
 

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/yaml_ld/representation.rb

@@ -39,6 +39,16 @@ module YAML_LD
       end
 
       result.is_a?(Array) && result.empty? ? fallback : result
+    rescue Psych::SyntaxError => e
+      msg = filename ? "file: #{filename} #{e.message}" : e.message
+      if yaml.respond_to?(:read)
+        msg << "Content:\n" + yaml.tap(:rewind).read
+      end
+      if e.message.match?(/invalid leading UTF-8 octet/)
+        raise YAML_LD::Error::InvalidEncoding, msg
+      else
+        raise JSON::LD::JsonLdError::LoadingDocumentFailed, msg
+      end
     end
     module_function :load_stream
 
@@ -100,18 +110,46 @@ module YAML_LD
     def as_jsonld_ir(node, **options)
       # Scans scalars for built-in classes
       @ss ||= Psych::ScalarScanner.new(Psych::ClassLoader::Restricted.new([], %i()))
+
+      # Record in-scope anchors to check for circular alias references.
+      in_scope_anchors = options[:in_scope_anchors] ||= {}
+
       case node
       when Psych::Nodes::Stream
         node.children.map {|n| as_jsonld_ir(n, **options)}
-      when Psych::Nodes::Document then as_jsonld_ir(node.children.first, **options)
-      when Psych::Nodes::Sequence then node.children.map {|n| as_jsonld_ir(n, **options)}
+      when Psych::Nodes::Document
+        as_jsonld_ir(node.children.first, named_nodes: {}, **options)
+      when Psych::Nodes::Sequence
+        value = []
+        if node.anchor
+          options = options.merge(in_scope_anchors: in_scope_anchors.merge(node.anchor => true))
+          options[:named_nodes][node.anchor] = value
+        end
+        node.children.each {|n| value << as_jsonld_ir(n, **options)}
+        value
       when Psych::Nodes::Mapping
-        node.children.each_slice(2).inject({}) do |memo, (k,v)|
-          memo.merge(as_jsonld_ir(k) => as_jsonld_ir(v, **options))
+        value = {}
+        if node.anchor
+          options = options.merge(in_scope_anchors: in_scope_anchors.merge(node.anchor => true))
+          options[:named_nodes][node.anchor] = value
+        end
+        node.children.each_slice(2) do |k, v|
+          key = as_jsonld_ir(k)
+          raise YAML_LD::Error::MappingKeyError, "mapping key #{k} (#{key.inspect}) not a string" unless key.is_a?(String)
+          value[as_jsonld_ir(k)] = as_jsonld_ir(v, **options)
+        end
+        value
+      when ::Psych::Nodes::Scalar
+        value = scan_scalar(node, **options)
+        if node.anchor
+          options = options.merge(in_scope_anchors: in_scope_anchors.merge(node.anchor => true))
+          options[:named_nodes][node.anchor] = value
         end
-      when ::Psych::Nodes::Scalar then scan_scalar(node, **options)
+        value
       when ::Psych::Nodes::Alias
-        # FIXME
+       raise JSON::LD::JsonLdError::LoadingDocumentFailed, "anchor for *#{node.anchor} not found" unless options[:named_nodes].key?(node.anchor)
+       raise JSON::LD::JsonLdError::LoadingDocumentFailed, "anchor for *#{node.anchor} creates a cycle" if in_scope_anchors.key?(node.anchor)
+       options[:named_nodes][node.anchor]
       end
     end
     module_function :as_jsonld_ir

data/lib/yaml_ld.rb

@@ -35,4 +35,11 @@ module YAML_LD
   # YAML-LD profiles
   YAML_LD_NS = "http://www.w3.org/ns/yaml-ld#"
   PROFILES = %w(extended).map {|p| YAML_LD_NS + p}.freeze
+
+  class Error < JSON::LD::JsonLdError
+    class InvalidEncoding < YAML_LD::Error; @code = "invalid encoding"; end
+    class MappingKeyError < YAML_LD::Error; @code = "mapping-key-error"; end
+    class ProfileError < YAML_LD::Error; @code = "profile-error"; end
+  end
+
 end

data/spec/suite_helper.rb

@@ -0,0 +1,410 @@
+require 'yaml_ld'
+
+# For now, override RDF::Utils::File.open_file to look for the file locally before attempting to retrieve it
+module RDF::Util
+  module File
+    LOCAL_PATHS = {
+      "https://json-ld.github.io/yaml-ld/tests/" => ::File.expand_path("../../../w3c-yaml-ld/tests", __FILE__) + '/',
+      "file:" => ""
+    }
+
+    class << self
+      alias_method :original_open_file, :open_file
+    end
+
+    ##
+    # Override to use Patron for http and https, Kernel.open otherwise.
+    #
+    # @param [String] filename_or_url to open
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Array, String] :headers
+    #   HTTP Request headers.
+    # @return [IO] File stream
+    # @yield [IO] File stream
+    def self.open_file(filename_or_url, **options, &block)
+      LOCAL_PATHS.each do |r, l|
+        next unless Dir.exist?(l) && filename_or_url.start_with?(r)
+        #puts "attempt to open #{filename_or_url} locally"
+        url_no_frag_or_query = RDF::URI(filename_or_url).dup
+        url_no_frag_or_query.query = nil
+        url_no_frag_or_query.fragment = nil
+        localpath = url_no_frag_or_query.to_s.sub(r, l)
+        response = begin
+          ::File.open(localpath)
+        rescue Errno::ENOENT => e
+          raise IOError, e.message
+        end
+
+        document_options = {
+          base_uri:     RDF::URI(filename_or_url),
+          charset:      Encoding::UTF_8,
+          code:         200,
+          headers:      options.fetch(:headers, {})
+        }
+        #puts "use #{filename_or_url} locally"
+        document_options[:headers][:content_type] = case localpath
+        when /\.ttl$/    then 'text/turtle'
+        when /\.nq$/     then 'application/n-quads'
+        when /\.nt$/     then 'application/n-triples'
+        when /\.html$/   then 'text/html'
+        when /\.jsonld$/ then 'application/ld+json'
+        when /\.json$/   then 'application/json'
+        when /\.yamlld$/ then 'application/ld+yaml'
+        when /\.yaml$/   then 'application/yaml'
+        else                  'unknown'
+        end
+
+        document_options[:headers][:content_type] = response.content_type if response.respond_to?(:content_type)
+        # For overriding content type from test data
+        document_options[:headers][:content_type] = options[:contentType] if options[:contentType]
+
+        remote_document = RDF::Util::File::RemoteDocument.new(response.read, **document_options)
+        response.close
+        if block_given?
+          return yield remote_document
+        else
+          return remote_document
+        end
+      end
+
+      original_open_file(filename_or_url, **options, &block)
+    end
+  end
+end
+
+module Fixtures
+  module SuiteTest
+    SUITE = RDF::URI("https://json-ld.github.io/yaml-ld/tests/")
+
+    class Manifest < JSON::LD::Resource
+      attr_accessor :manifest_url
+
+      def self.open(file)
+        RDF::Util::File.open_file(file) do |remote|
+          json = JSON.parse(remote.read)
+          if block_given?
+            yield self.from_jsonld(json, manifest_url: RDF::URI(file))
+          else
+            self.from_jsonld(json, manifest_url: RDF::URI(file))
+          end
+        end
+      end
+
+      def initialize(json, manifest_url:)
+        @manifest_url = manifest_url
+        super
+      end
+
+      # @param [Hash] json framed JSON-LD
+      # @return [Array<Manifest>]
+      def self.from_jsonld(json, manifest_url: )
+        Manifest.new(json, manifest_url: manifest_url)
+      end
+
+      def entries
+        # Map entries to resources
+        attributes['sequence'].map do |e|
+          e.is_a?(String) ? Manifest.open(manifest_url.join(e).to_s) : Entry.new(e, manifest_url: manifest_url)
+        end
+      end
+    end
+
+    class Entry < JSON::LD::Resource
+      attr_accessor :logger
+      attr_accessor :manifest_url
+
+      def initialize(json, manifest_url:)
+        @manifest_url = manifest_url
+        super
+      end
+
+      # Base is expanded input if not specified
+      def base
+        options.fetch('base', manifest_url.join(property('input')).to_s)
+      end
+
+      def options
+        @options ||= begin
+          opts = {
+            documentLoader: Fixtures::SuiteTest.method(:documentLoader),
+            validate: true,
+            lowercaseLanguage: true,
+          }
+          (property('option') || {}).each do |k, v|
+            opts[k.to_sym] = v
+          end
+          if opts[:expandContext] && !RDF::URI(opts[:expandContext]).absolute?
+            # Resolve relative to manifest location
+            opts[:expandContext] = manifest_url.join(opts[:expandContext]).to_s
+          end
+          opts
+        end
+      end
+
+      # Alias input, context, expect and frame
+      %w(input context expect frame).each do |m|
+        define_method(m.to_sym) do
+          return nil unless property(m)
+          res = nil
+          file = self.send("#{m}_loc".to_sym)
+
+          dl_opts = {safe: true}
+          dl_opts[:contentType] = options[:contentType] if m == 'input' && options[:contentType]
+          RDF::Util::File.open_file(file, **dl_opts) do |remote_doc|
+            res = remote_doc.read
+          end
+          res
+        end
+
+        define_method("#{m}_loc".to_sym) do
+          file = property(m)
+
+          # Handle redirection internally
+          if m == "input" && options[:redirectTo]
+            file = options[:redirectTo]
+          end
+
+          property(m) && manifest_url.join(file).to_s
+        end
+
+        define_method("#{m}_json".to_sym) do
+          JSON.parse(self.send(m)) if property(m)
+        end
+      end
+
+      def testType
+        property('@type').reject {|t| t =~ /EvaluationTest|SyntaxTest/}.first
+      end
+
+      def evaluationTest?
+        property('@type').to_s.include?('EvaluationTest')
+      end
+
+      def positiveTest?
+        property('@type').to_s.include?('Positive')
+      end
+
+      def syntaxTest?
+        property('@type').to_s.include?('Syntax')
+      end
+      
+
+      # Execute the test
+      def run(rspec_example = nil)
+        logger = @logger = RDF::Spec.logger
+        logger.info "test: #{inspect}"
+        logger.info "purpose: #{purpose}"
+        logger.info "source: #{input rescue nil}"
+        logger.info "context: #{context}" if context_loc
+        logger.info "options: #{options.inspect}" unless options.empty?
+        logger.info "frame: #{frame}" if frame_loc
+
+        options = self.options
+        if options[:specVersion] == "json-ld-1.0"
+          skip "1.0 test" 
+          return
+        end
+
+        # Because we're doing exact comparisons when ordered.
+        options[:lowercaseLanguage] = true if options[:ordered]
+
+        if positiveTest?
+          logger.info "expected: #{expect rescue nil}" if expect_loc
+          begin
+            result = case testType
+            when "jld:ExpandTest"
+              YAML_LD::API.expand(input_loc, logger: logger, **options)
+            when "jld:CompactTest"
+              YAML_LD::API.compact(input_loc, context_json['@context'], logger: logger, **options)
+            when "jld:FlattenTest"
+              YAML_LD::API.flatten(input_loc, (context_json['@context'] if context_loc), logger: logger, **options)
+            when "jld:FrameTest"
+              YAML_LD::API.frame(input_loc, frame_loc, logger: logger, **options)
+            when "jld:FromRDFTest"
+              # Use an array, to preserve input order
+              repo = RDF::NQuads::Reader.open(input_loc, rdfstar: options[:rdfstar]) do |reader|
+                reader.each_statement.to_a
+              end.to_a.uniq.extend(RDF::Enumerable)
+              logger.info "repo: #{repo.dump(self.id == '#t0012' ? :nquads : :trig)}"
+              YAML_LD::API.fromRdf(repo, logger: logger, **options)
+            when "jld:ToRDFTest"
+              repo = RDF::Repository.new
+              if manifest_url.to_s.include?('stream')
+                YAML_LD::Reader.open(input_loc, stream: true, logger: logger, **options) do |statement|
+                  repo << statement
+                end
+              else
+                YAML_LD::API.toRdf(input_loc, rename_bnodes: false, logger: logger, **options) do |statement|
+                  repo << statement
+                end
+              end
+              logger.info "nq: #{repo.map(&:to_nquads)}"
+              repo
+            when "jld:HttpTest"
+              res = input_json
+              rspec_example.instance_eval do
+                # use the parsed input file as @result for Rack Test application
+                @results = res
+                get "/", {}, "HTTP_ACCEPT" => options.fetch(:httpAccept, ""), "HTTP_LINK" => options.fetch(:httpLink, nil)
+                expect(last_response.status).to eq 200
+                expect(last_response.content_type).to eq options.fetch(:contentType, "")
+                last_response.body
+              end
+            else
+              fail("Unknown test type: #{testType}")
+            end
+
+            result = YAML_LD::Representation.load(result, extendedYAML: options[:extendedYAML]) if result.is_a?(String)
+
+            if evaluationTest?
+              if testType == "jld:ToRDFTest"
+                expected = RDF::Repository.new << RDF::NQuads::Reader.new(expect, rdfstar: options[:rdfstar], logger: [])
+                rspec_example.instance_eval {
+                  expect(result).to be_equivalent_graph(expected, logger)
+                }
+              else
+                expected = YAML_LD::Representation.load(expect, extendedYAML: options[:extendedYAML])
+
+                # If called for, remap bnodes
+                result = remap_bnodes(result, expected) if options[:remap_bnodes]
+
+                if options[:ordered]
+                  # Compare without transformation
+                  rspec_example.instance_eval {
+                    expect(result).to produce(expected, logger)
+                  }
+                else
+                  # Without key ordering, reorder result and expected embedded array values and compare
+                  # If results are compacted, expand both, reorder and re-compare
+                  rspec_example.instance_eval {
+                    expect(result).to produce_yamlld(expected, logger)
+                  }
+
+                  # If results are compacted, expand both, reorder and re-compare
+                  if result.to_s.include?('@context')
+                    exp_expected = JSON::LD::API.expand(expected, **options)
+                    exp_result = JSON::LD::API.expand(result, **options)
+                    rspec_example.instance_eval {
+                      expect(exp_result).to produce_yamlld(exp_expected, logger)
+                    }
+                  end
+                end
+              end
+            else
+              rspec_example.instance_eval {
+                expect(result).to_not be_nil
+              }
+            end
+          rescue JSON::LD::JsonLdError => e
+            fail("Processing error: #{e.message}")
+          end
+        else
+          logger.info "expected: #{property('expect')}" if property('expect')
+          t = self
+          rspec_example.instance_eval do
+            if t.evaluationTest?
+              expect do
+                case t.testType
+                when "jld:ExpandTest"
+                  JSON::LD::API.expand(t.input_loc, logger: logger, **options)
+                when "jld:CompactTest"
+                  JSON::LD::API.compact(t.input_loc, t.context_json['@context'], logger: logger, **options)
+                when "jld:FlattenTest"
+                  JSON::LD::API.flatten(t.input_loc, t.context_loc, logger: logger, **options)
+                when "jld:FrameTest"
+                  JSON::LD::API.frame(t.input_loc, t.frame_loc, logger: logger, **options)
+                when "jld:FromRDFTest"
+                  repo = RDF::Repository.load(t.input_loc, rdfstar: options[:rdfstar])
+                  logger.info "repo: #{repo.dump(t.id == '#t0012' ? :nquads : :trig)}"
+                  JSON::LD::API.fromRdf(repo, logger: logger, **options)
+                when "jld:HttpTest"
+                  rspec_example.instance_eval do
+                    # use the parsed input file as @result for Rack Test application
+                    @results = t.input_json
+                    get "/", {}, "HTTP_ACCEPT" => options.fetch(:httpAccept, "")
+                    expect(last_response.status).to eq t.property('expect')
+                    expect(last_response.content_type).to eq options.fetch(:contentType, "")
+                    raise "406" if t.property('expect') == 406
+                    raise "Expected status #{t.property('expectErrorCode')}, not #{last_response.status}"
+                  end
+                when "jld:ToRDFTest"
+                  if t.manifest_url.to_s.include?('stream')
+                    JSON::LD::Reader.open(t.input_loc, stream: true, logger: logger, **options).each_statement {}
+                  else
+                    JSON::LD::API.toRdf(t.input_loc, rename_bnodes: false, logger: logger, **options) {}
+                  end
+                else
+                  success("Unknown test type: #{testType}")
+                end
+              end.to raise_error(/#{t.property('expectErrorCode')}/)
+            else
+              fail("No support for NegativeSyntaxTest")
+            end
+          end
+        end
+      end
+
+      # Don't use NQuads writer so that we don't escape Unicode
+      def to_quad(thing)
+        case thing
+        when RDF::URI
+          thing.to_ntriples
+        when RDF::Node
+          escaped(thing)
+        when RDF::Literal::Double
+          thing.canonicalize.to_ntriples
+        when RDF::Literal
+          v = quoted(escaped(thing.value))
+          case thing.datatype
+          when nil, "http://www.w3.org/2001/XMLSchema#string", "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString"
+            # Ignore these
+          else
+            v += "^^#{to_quad(thing.datatype)}"
+          end
+          v += "@#{thing.language}" if thing.language
+          v
+        when RDF::Statement
+          thing.to_quad.map {|r| to_quad(r)}.compact.join(" ") + " .\n"
+        end
+      end
+
+      ##
+      # @param  [String] string
+      # @return [String]
+      def quoted(string)
+        "\"#{string}\""
+      end
+
+      ##
+      # @param  [String, #to_s] string
+      # @return [String]
+      def escaped(string)
+        string.to_s.gsub('\\', '\\\\').gsub("\t", '\\t').
+          gsub("\n", '\\n').gsub("\r", '\\r').gsub('"', '\\"')
+      end
+    end
+
+    ##
+    # Document loader to use for tests having `useDocumentLoader` option
+    #
+    # @param [RDF::URI, String] url
+    # @param [Hash<Symbol => Object>] options
+    # @option options [Boolean] :validate
+    #   Allow only appropriate content types
+    # @return [RDF::Util::File::RemoteDocument] retrieved remote document and context information unless block given
+    # @yield remote_document
+    # @yieldparam [RDF::Util::File::RemoteDocument] remote_document
+    # @raise [JsonLdError]
+    def documentLoader(url, **options, &block)
+      options[:headers] ||= JSON::LD::API::OPEN_OPTS[:headers].dup
+      options[:headers][:link] = Array(options[:httpLink]).join(',') if options[:httpLink]
+    
+      url = url.to_s[5..-1] if url.to_s.start_with?("file:")
+      YAML_LD::API.documentLoader(url, **options, &block)
+    rescue JSON::LD::JsonLdError::LoadingDocumentFailed, JSON::LD::JsonLdError::MultipleContextLinkHeaders
+      raise unless options[:safe]
+      "don't raise error"
+    end
+    module_function :documentLoader
+  end
+end

data/spec/suite_spec.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+require_relative 'spec_helper'
+
+describe YAML_LD do
+  describe "test suite" do
+    require_relative 'suite_helper'
+    m = Fixtures::SuiteTest::Manifest.open("#{Fixtures::SuiteTest::SUITE}manifest.jsonld")
+    describe m.name do
+      m.entries.each do |t|
+        specify "#{t.property('@id')}: #{t.name} #{t.positiveTest? ? 'unordered' : '(negative test)'}" do
+          t.options[:ordered] = false
+          expect{t.run self}.not_to write.to(:error)
+        end
+
+        specify "#{t.property('@id')}: #{t.name} ordered" do
+          t.options[:ordered] = true
+          expect {t.run self}.not_to write.to(:error)
+        end if t.positiveTest?
+      end
+    end
+  end
+end unless ENV['CI']

data/spec/support/extensions.rb

@@ -42,3 +42,11 @@ class Array
     end
   end
 end
+
+class String
+  def equivalent_yamlld?(other, ordered: false, extendedYAML: false)
+    actual = YAML_LD::Representation.load(self, aliases: true, extendedYAML: extendedYAML)
+    expected = other.is_a?(String) ? YAML_LD::Representation.load(other, aliases: true, extendedYAML: extendedYAML) : other
+    actual.equivalent_structure?(expected, ordered: ordered)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: yaml-ld
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-07 00:00:00.000000000 Z
+date: 2023-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: json-ld
@@ -16,20 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.3
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.3
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: psych
   requirement: !ruby/object:Gem::Requirement
@@ -50,132 +44,126 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 3.2.9
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-isomorphic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-trig
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-turtle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-vocab
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '3.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.10'
+        version: '3.12'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -234,6 +222,8 @@ files:
 - spec/reader_spec.rb
 - spec/representation_spec.rb
 - spec/spec_helper.rb
+- spec/suite_helper.rb
+- spec/suite_spec.rb
 - spec/support/extensions.rb
 - spec/test-files/test-1-compacted.jsonld
 - spec/test-files/test-1-compacted.yamlld
@@ -302,14 +292,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.6'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: YAML-LD reader/writer for Ruby.
@@ -325,6 +315,8 @@ test_files:
 - spec/reader_spec.rb
 - spec/representation_spec.rb
 - spec/spec_helper.rb
+- spec/suite_helper.rb
+- spec/suite_spec.rb
 - spec/support/extensions.rb
 - spec/to_rdf_spec.rb
 - spec/writer_spec.rb