Finish 3.3.1

Author: gkellogg

.github/workflows/ci.yml

@@ -19,7 +19,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: ['3.0', 3.1, 3.2, ruby-head, jruby]
+        ruby: ['3.0', 3.1, 3.2, 3.3, ruby-head, jruby]
     steps:
       - name: Clone repository
         uses: actions/checkout@v3
@@ -33,6 +33,6 @@ jobs:
         run: ruby --version; bundle exec rspec spec || $ALLOW_FAILURES
       - name: Coveralls GitHub Action
         uses: coverallsapp/github-action@v2
-        if: "matrix.ruby == '3.2'"
+        if: "matrix.ruby == '3.3'"
         with:
           github-token: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -76,11 +76,15 @@ The parser takes branch and follow tables generated from the [LD Patch Grammar](
 
 * [Ruby](http://ruby-lang.org/) (>= 3.0)
 * [RDF.rb](https://rubygems.org/gems/rdf) (~> 3.3)
-* [EBNF][] (~> 2.4)
+* [EBNF][] (~> 2.5)
 * [SPARQL][] (~> 3.2)
-* [SXP][] (~> 1.2)
+* [SXP][] (~> 2.0)
 * [RDF::XSD][] (~> 3.2)
 
+## Change Log
+
+See [Release Notes on GitHub](https://github.com/ruby-rdf/ld-patch/releases)
+
 ## Mailing List
 * <http://lists.w3.org/Archives/Public/public-rdf-ruby/>
 

VERSION

@@ -1 +1 @@
-3.3.0
+3.3.1

ld-patch.gemspec

@@ -30,19 +30,20 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version      = '>= 3.0'
   gem.requirements               = []
   gem.add_runtime_dependency     'rdf',               '~> 3.3'
-  gem.add_runtime_dependency     'ebnf',              '~> 2.4'
+  gem.add_runtime_dependency     'ebnf',              '~> 2.6'
   gem.add_runtime_dependency     'sparql',            '~> 3.3'
-  gem.add_runtime_dependency     'sxp',               '~> 1.3'
+  gem.add_runtime_dependency     'sxp',               '~> 2.0'
   gem.add_runtime_dependency     'rdf-xsd',           '~> 3.3'
 
+  gem.add_development_dependency 'getoptlong',        '~> 0.2'
   gem.add_development_dependency 'json-ld',           '~> 3.3'
-  gem.add_development_dependency 'rack',               '>= 2.2', '< 4'
+  gem.add_development_dependency 'rack',              '~> 3.1'
   gem.add_development_dependency 'rdf-normalize',     '~> 0.7'
   gem.add_development_dependency 'rdf-spec',          '~> 3.3'
-  gem.add_development_dependency 'rspec',             '~> 3.12'
+  gem.add_development_dependency 'rspec',             '~> 3.13'
   gem.add_development_dependency 'rspec-its',         '~> 1.3'
   gem.add_development_dependency 'yard' ,             '~> 0.9'
-  gem.add_development_dependency 'webmock',           '~> 3.19'
+  gem.add_development_dependency 'webmock',           '~> 3.15'
 
   gem.post_install_message       = nil
 end

lib/ld/patch/parser.rb

@@ -539,7 +539,14 @@ def iri(value)
     def ns(prefix, suffix)
       error("pname", "undefined prefix #{prefix.inspect}") unless prefix(prefix)
       base = prefix(prefix).to_s
+
+      # Unescape PN_LOCAL_ESC
+      suffix = suffix.gsub(PN_LOCAL_ESC) {|esc| esc[1]} if
+        suffix.to_s.match?(PN_LOCAL_ESC)
+
+      # Remove any redundant leading hash from suffix
       suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")
+
       debug {"ns(#{prefix.inspect}): base: '#{base}', suffix: '#{suffix}'"}
       iri = iri(base + suffix.to_s)
       # Cause URI to be serialized as a lexical

script/tc

@@ -27,50 +27,60 @@ def earl_preamble(options)
 )
 end
 
-def run_tc(t, options)
-  STDERR.write "run #{t.name}"
+def run_tc(tc, options)
+  STDERR.write "run #{tc.name}"
+
+  if options[:verbose]
+    puts "\nTestCase: #{tc.inspect}"
+    puts "\nInput:\n" + tc.input
+    puts "\nData:\n" + tc.data if tc.data
+    puts "\nExpected:\n" + tc.expected if tc.expected
+  end
+
   result = "untested"
 
   begin
-    operator = LD::Patch.parse(t.input,
-      base_uri: t.base,
+    operator = LD::Patch.parse(tc.input,
+      base_uri: tc.base,
       validate: true,
       errors: []
     )
-    if t.positive_test?
-      if t.evaluate?
-        ug = operator.execute(t.target_graph)
-        result = t.target_graph.isomorphic_with?(t.expected_graph) ? "passed" : "failed"
+    if tc.positive_test?
+      if tc.evaluate?
+        ug = operator.execute(tc.target_graph)
+        result = tc.target_graph.isomorphic_with?(tc.expected_graph) ? "passed" : "failed"
       else
         result = operator.is_a?(SPARQL::Algebra::Operator) ? "passed" : "failed"
       end
     else
-      operator.execute(t.target_graph) if t.evaluate?
-      if %w(turtle-syntax-bad-struct-09 turtle-syntax-bad-struct-10).include?(t.name)
+      operator.execute(tc.target_graph) if tc.evaluate?
+      if %w(turtle-syntax-bad-struct-09 turtle-syntax-bad-struct-10).include?(tc.name)
         STDERR.puts "Multiple '.' allowed in this grammar" unless options[:quiet]
         result = "inapplicable"
       else
         result = "failed"
       end
     end
   rescue LD::Patch::ParseError => e
-    if %w(turtle-eval-bad-01 turtle-eval-bad-02 turtle-eval-bad-03).include?(t.name)
+    if %w(turtle-eval-bad-01 turtle-eval-bad-02 turtle-eval-bad-03).include?(tc.name)
       result = "passed"
-    elsif t.syntax? && t.negative_test?
+    elsif tc.syntax? && tc.negative_test?
       result = "passed"
     else
+      STDERR.puts "#{"exception:" unless options[:quiet]}: #{e}"
       result = "failed"
     end
   rescue LD::Patch::Error => e
-    if t.evaluate? && t.negative_test?
-      result = e.code == t.statusCode.to_i ? "passed" : "failed"
+    if tc.evaluate? && tc.negative_test?
+      result = e.code == tc.statusCode.to_i ? "passed" : "failed"
     else
       result = "failed"
     end
+    STDERR.puts "#{"exception:" unless options[:quiet]}: #{e}" if result == "failed"
   end
 
   if options[:earl]
-    test = t.id.sub("ldp:", Fixtures::SuiteTest::BASE + "manifest.ttl#")
+    test = tc.id.sub("ldp:", Fixtures::SuiteTest::BASE + "manifest.ttl#")
     options[:output].puts %{
 [ a earl:Assertion;
   earl:assertedBy <#{ASSERTOR}>;
@@ -95,7 +105,7 @@ options = {
   validate:     true,
   verbose:      false,
 }
-suite = "rdfxml"
+
 opts = GetoptLong.new(
   ["--debug", GetoptLong::NO_ARGUMENT],
   ["--earl", GetoptLong::NO_ARGUMENT],
@@ -135,7 +145,7 @@ result_count = {}
 
   Fixtures::SuiteTest::Manifest.open(manifest) do |m|
     m.entries.each do |tc|
-      next unless ARGV.empty? || ARGV.any? {|n| tc.name.match(/#{n}/)}
+      next unless ARGV.empty? || ARGV.any? {|n| tc.name.match?(/#{n}/)}
       run_tc(tc, options.merge(result_count: result_count))
     end
   end

spec/suite_helper.rb

@@ -110,7 +110,6 @@ module SuiteTest
     class Manifest < JSON::LD::Resource
       def self.open(file)
         #puts "open: #{file}"
-        prefixes = {}
         g = RDF::Repository.load(file, format:  :ttl)
         JSON::LD::API.fromRDF(g) do |expanded|
           JSON::LD::API.frame(expanded, FRAME) do |framed|
@@ -149,35 +148,35 @@ def input
       end
 
       def data
-        action.is_a?(Hash) && action["data"]
+        @data ||= RDF::Util::File.open_file(CGI.unescape(action["data"])) {|f| f.read} if action["data"]
       end
 
       def target_graph
         @graph ||= RDF::Graph.new do |g|
-          g << RDF::Reader.open(CGI.unescape(data), base_uri: base)
+          g << RDF::Reader.open(CGI.unescape(action["data"]), base_uri: base) if action["data"]
         end
       end
 
       def expected
-        @expected ||= RDF::Util::File.open_file(CGI.unescape(result)) {|f| f.read}
+        @expected ||= RDF::Util::File.open_file(CGI.unescape(result)) {|f| f.read} if result
       end
 
       def expected_graph
         @expected_graph ||= RDF::Graph.new do |g|
-          g << RDF::Reader.open(CGI.unescape(result), base_uri: base)
+          g << RDF::Reader.open(CGI.unescape(result), base_uri: base) if result
         end
       end
 
       def evaluate?
-        Array(attributes['@type']).join(" ").match(/Eval/)
+        Array(attributes['@type']).join(" ").match?(/Eval/)
       end
 
       def syntax?
-        Array(attributes['@type']).join(" ").match(/Syntax/)
+        Array(attributes['@type']).join(" ").match?(/Syntax/)
       end
 
       def positive_test?
-        !Array(attributes['@type']).join(" ").match(/Negative/)
+        !Array(attributes['@type']).join(" ").match?(/Negative/)
       end
 
       def negative_test?
@@ -194,12 +193,21 @@ def logger
       end
 
       def inspect
-        super.sub('>', "\n" +
+        "<Entry id\n" +
+        "  id: #{self.id}\n" +
+        "  type: #{self.type}\n" +
+        "  name: #{self.name}\n" +
+        (self.action.is_a?(Hash) ?
+          "  action.base: #{self.action['base']}\n" +
+          "  action.data: #{self.action['data']}\n" +
+          "  action.patch: #{self.action['patch']}\n"
+        : "  action: #{self.action}"
+        ) +
+        "  result: #{self.result}\n" +
         "  syntax?: #{syntax?.inspect}\n" +
         "  positive?: #{positive_test?.inspect}\n" +
         "  evaluate?: #{evaluate?.inspect}\n" +
         ">"
-      )
       end
     end
   end