Release 0.1.1:

* Update rdf.rb dependency.
* Add more functionality to bin/ldpatch executable.
* Add example to README.
* Improve test coverage.
* Add spec examples to algebra_spec.

Author: gkellogg

README.md

@@ -29,6 +29,30 @@ This gem implements the [LD Patch][] specification with a couple of changes and/
 ## Documentation
 Full documentation available on [Rubydoc.info][LD-Patch doc]
 
+## Examples
+
+    require 'rubygems'
+    require 'ld/patch'
+
+### Example Patch
+
+    queryable = RDF::Repository.load("etc/doap.ttl")
+    patch = %(
+      @prefix doap: <http://usefulinc.com/ns/doap#> .
+      @prefix earl: <http://www.w3.org/ns/earl#> .
+      @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+      Delete { <> a earl:TestSubject, earl:Software } .
+      Add {
+        <http://greggkellogg.net/foaf#me> a foaf:Person;
+          foaf:name "Gregg Kellogg"
+      } .
+      Bind ?ruby <> / doap:programming-language .
+      Cut ?ruby .
+    )
+    operator = LD::Patch.parse(patch, base_uri: "http://rubygems.org/gems/ld-patch")
+    operator.execute(queryable) # alternatively queryable.query(operator)
+
 ## Implementation Notes
 The reader uses the [EBNF][] gem to generate first, follow and branch tables, and uses the `Parser` and `Lexer` modules to implement the LD Patch parser.
 

VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

bin/ldpatch

@@ -10,82 +10,72 @@ rescue LoadError
 end
 require 'getoptlong'
 
-def run(input, options = {})
+def run(graph, options = {})
   if options[:debug]
-    puts "input graph:\n#{options[:graph].dump(:ttl, standard_prefixes: true)}\n" if options[:graph]
-    puts "query:\n#{input}\n"
+    puts "target graph:\n#{graph.dump(:ttl, standard_prefixes: true)}\n"
+    puts "patch:\n#{options[:patch]}\n"
   end
-  options[:graph] ||= RDF::Graph.new
 
   if options[:verbose]
-    puts ("\nPATCH:\n" + input) 
+    puts ("\npatch:\n" + options[:patch]) 
   end
 
-  patch = if options[:sse]
-    SPARQL::Algebra.parse(input, options)
-  else
-    # Only do grammar debugging if we're generating SSE
-    LD::Patch.parse(input, options)
-  end
+  patch =  LD::Patch.parse(options[:patch], options)
 
   puts ("\nSSE:\n" + patch.to_sse) if options[:debug] || options[:to_sse]
 
   unless options[:to_sse]
-    res = patch.execute(options[:graph], debug: options[:debug])
-    puts res.inspect if options[:verbose]
+    res = patch.execute(graph, options)
     puts res.dump(:ttl, base_uri: patch.base_uri, prefixes: patch.prefixes, standard_prefixes: true)
   end
 end
 
 opts = GetoptLong.new(
   ["--debug", GetoptLong::NO_ARGUMENT],
-  ["--dump", GetoptLong::NO_ARGUMENT],
   ["--execute", "-e", GetoptLong::REQUIRED_ARGUMENT],
+  ["--patch", GetoptLong::REQUIRED_ARGUMENT],
   ["--progress", GetoptLong::NO_ARGUMENT],
-  ["--sse", GetoptLong::NO_ARGUMENT],
   ["--to-sse", GetoptLong::NO_ARGUMENT],
   ["--validate", GetoptLong::NO_ARGUMENT],
   ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--help", "-?", GetoptLong::NO_ARGUMENT]
 )
 
-options = {
-  graph: RDF::Repository.new,
-}
-
-input = nil
+options = {}
 
 opts.each do |opt, arg|
   case opt
-  when '--debug'         then options[:debug] = true
-  when '--dump'          then $dump = true
-  when '--execute'       then input = arg
-  when '--progress'      then options[:debug] ||= 2
-  when '--sse'           then options[:sse] = true
-  when '--to-sse'        then options[:to_sse] = true
-  when '--validate'      then options[:validate] = true
-  when '--verbose'       then options[:verbose] = true
+  when '--base'         then options[:base_uri] = arg
+  when '--debug'        then options[:debug] = true
+  when '--execute'      then options[:patch] = arg
+  when '--patch'        then options[:patch] = RDF::Util::File.open_file(arg).read
+  when '--progress'     then options[:debug] ||= 2
+  when '--to-sse'       then options[:to_sse] = true
+  when '--validate'     then options[:validate] = true
+  when '--verbose'      then options[:verbose] = true
   when "--help"
-    puts "Usage: #{$0} [options] file-or-uri ..."
+    puts "Usage: #{$0} [options] target graph file-or-uri ..."
     puts "Options:"
-    puts "      --execute,-e:         Use option argument as the SPARQL input if no files are given"
-    puts "      --dump:               Dump raw output, otherwise serialize to SSE"
-    puts "      --debug:              Display detailed debug output"
-    puts "      --sse:                Input is in SSE format"
-    puts "      --to-sse:             Generate SSE instead of running query"
-    puts "      --verbose:            Display details of processing"
-    puts "      --help,-?:            This message"
+    puts "      --base:       Base URI of target graph, if different from graph location"
+    puts "      --debug:      Display detailed debug output"
+    puts "      --execute,-e: Use option argument as the patch input"
+    puts "      --patch:      Location of patch document"
+    puts "      --progress    Display parse tree"
+    puts "      --to-sse:     Generate SSE for patch instead of running query"
+    puts "      --validate:   Validate patch document"
+    puts "      --verbose:    Display details of processing"
+    puts "      --help,-?:    This message"
     exit(0)
   end
 end
 
+raise "No patch defined" unless options[:patch]
 if ARGV.empty?
-  s = input ? input : $stdin.read
-  run(s, options)
+  run(RDF::Graph.new, options)
 else
   ARGV.each do |test_file|
-    puts "parse #{test_file}"
-    run(RDF::Util::File.open_file(test_file).read, options.merge(base_uri: RDF::URI(test_file)))
+    puts "patch #{test_file}"
+    run(RDF::Graph.load(test_file), options.merge(base_uri: RDF::URI(test_file)))
   end
 end
 puts

ld-patch.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |gem|
 
   gem.required_ruby_version      = '>= 2.0.0'
   gem.requirements               = []
-  gem.add_runtime_dependency     'rdf',               '~> 1.1', '>= 1.1.13'
+  gem.add_runtime_dependency     'rdf',               '~> 1.1', '>= 1.1.15'
   gem.add_runtime_dependency     'ebnf',              '~> 0.3', '>= 0.3.9'
   gem.add_runtime_dependency     'sparql',            '~> 1.1', '>= 1.1.7'
   gem.add_runtime_dependency     'sxp',               '~> 0.1'

lib/ld/patch.rb

@@ -23,8 +23,10 @@ module Patch
     #
     # @param  [IO, StringIO, String, #to_s]  input
     # @param  [Hash{Symbol => Object}] options
-    # @return [Object]
-    #   The parsed Patch
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when resolving relative URIs
+    # @option (see LD::Patch::Parser#initialize)
+    # @return [SPARQL::Algebra::Operator] The executable parsed Patch
     def self.parse(input, options = {})
       LD::Patch::Parser.new(input, options).parse
     end

lib/ld/patch/algebra/update_list.rb

@@ -32,7 +32,7 @@ def execute(queryable, options = {})
       # Bind variables to path
       if var_or_iri.variable?
         raise LD::Patch::Error("Operand uses unbound variable #{var_or_iri.inspect}", code: 400) unless solution.bound?(var_or_iri)
-        var_or_iri = solution[variable]
+        var_or_iri = solution[var_or_iri]
       end
 
       list_heads = queryable.query(subject: var_or_iri, predicate: predicate).map {|s| s.object}

lib/ld/patch/parser.rb

@@ -383,7 +383,7 @@ def to_s
     #
     # @param [Symbol, #to_s] prod The starting production for the parser.
     #   It may be a URI from the grammar, or a symbol representing the local_name portion of the grammar URI.
-    # @return [SPARQL::Algebra::Operator, Array]
+    # @return [SPARQL::Algebra::Operator, Object]
     # @raise [ParseError] when illegal grammar detected.
     def parse(prod = START)
       ll1_parse(@input, prod.to_sym, @options.merge(branch: BRANCH,