Separate out ParserError from Error and add #code accessor for generated statusCode.

Author: gkellogg

lib/ld/patch.rb

@@ -30,6 +30,23 @@ def self.parse(input, options = {})
     end
 
     class Error < StandardError
+      # The status code associated with this error
+      attr_reader :code
+
+      ##
+      # Initializes a new patch error instance.
+      #
+      # @param  [String, #to_s]          message
+      # @param  [Hash{Symbol => Object}] options
+      # @option options [Integer]        :code (422)
+      def initialize(message, options = {})
+        @code = options.fetch(:status_code, 422)
+        super(message.to_s)
+      end
+    end
+
+    # Indicates bad syntax found in LD Patch document
+    class ParserError < Error
       ##
       # The invalid token which triggered the error.
       #
@@ -41,17 +58,19 @@ class Error < StandardError
       #
       # @return [Integer]
       attr_reader :lineno
+
       ##
-      # Initializes a new lexer error instance.
+      # Initializes a new parser error instance.
       #
       # @param  [String, #to_s]          message
       # @param  [Hash{Symbol => Object}] options
       # @option options [String]         :token  (nil)
       # @option options [Integer]        :lineno (nil)
+      # @option options [Integer]        :code (400)
       def initialize(message, options = {})
         @token      = options[:token]
         @lineno     = options[:lineno] || (@token.lineno if @token.respond_to?(:lineno))
-        super(message.to_s)
+        super(message.to_s, code: options.fetch(:code, 400))
       end
     end
   end

lib/ld/patch/algebra/add.rb

@@ -37,12 +37,10 @@ def execute(queryable, options = {})
         case var
         when RDF::Query::Pattern
           s = var.bind(solution)
-          # FIXME 400 Bad Request
-          raise LD::Patch::Error, "Operand uses unbound pattern #{var.inspect}" if s.variable?
+          raise LD::Patch::Error.new("Operand uses unbound pattern #{var.inspect}", code: 400) if s.variable?
           s
         when RDF::Query::Variable
-          # FIXME 400 Bad Request
-          raise LD::Patch::Error, "Operand uses unbound variable #{var.inspect}" unless solution.bound?(var)
+          raise LD::Patch::Error.new("Operand uses unbound variable #{var.inspect}", code: 400) unless solution.bound?(var)
           solution[var]
         end
       end

lib/ld/patch/algebra/bind.rb

@@ -74,8 +74,7 @@ def execute(queryable, options = {})
 
       # Bind variables to path
       if value.variable?
-        # FIXME 400 Bad Request
-        raise LD::Patch::Error, "Operand uses unbound variable #{value.inspect}" unless solution.bound?(value)
+        raise LD::Patch::Error.new("Operand uses unbound variable #{value.inspect}", code: 400) unless solution.bound?(value)
         value = solution[value]
       end
 

lib/ld/patch/algebra/cut.rb

@@ -32,8 +32,7 @@ def execute(queryable, options = {})
       var = operand(0)
 
       # Bind variable
-      # FIXME 400 Bad Request
-      raise LD::Patch::Error, "Operand uses unbound variable #{var.inspect}" unless solution.bound?(var)
+      raise LD::Patch::Error.new("Operand uses unbound variable #{var.inspect}", code: 400) unless solution.bound?(var)
       var = solution[var]
 
       cut_count = 0

lib/ld/patch/algebra/delete.rb

@@ -37,12 +37,10 @@ def execute(queryable, options = {})
         case var
         when RDF::Query::Pattern
           s = var.bind(solution)
-          # FIXME 400 Bad Request
-          raise LD::Patch::Error, "Operand uses unbound pattern #{var.inspect}" if s.variable?
+          raise LD::Patch::Error.new("Operand uses unbound pattern #{var.inspect}", code: 400) if s.variable?
           s
         when RDF::Query::Variable
-          # FIXME 400 Bad Request
-          raise LD::Patch::Error, "Operand uses unbound variable #{var.inspect}" unless solution.bound?(var)
+          raise LD::Patch::Error.new("Operand uses unbound variable #{var.inspect}", code: 400) unless solution.bound?(var)
           solution[var]
         end
       end

lib/ld/patch/algebra/update_list.rb

@@ -31,8 +31,7 @@ def execute(queryable, options = {})
 
       # Bind variables to path
       if var_or_iri.variable?
-        # FIXME 400 Bad Request
-        raise LD::Patch::Error, "Operand uses unbound variable #{var_or_iri.inspect}" unless solution.bound?(var_or_iri)
+        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]
       end
 
@@ -56,8 +55,7 @@ def execute(queryable, options = {})
       else slice2.to_i
       end
 
-      # FIXME 400 Bad Request
-      raise LD::Patch::Error, "UpdateList slice indexes out of order #{start}..#{finish}}" if finish < start
+      raise LD::Patch::Error.new("UpdateList slice indexes out of order #{start}..#{finish}}", code: 400) if finish < start
 
       length = finish - start
       raise LD::Patch::Error, "UpdateList out of bounds #{start}..#{finish}}" if start + length > list.length

lib/ld/patch/parser.rb

@@ -47,7 +47,7 @@ class Parser
       begin
         input[:iri] = iri(token.value[1..-2])
       rescue ArgumentError => e
-        raise Error, e.message
+        raise ParserError, e.message
       end
     end
     terminal(:DOUBLE,               DOUBLE) do |prod, token, input|
@@ -351,7 +351,7 @@ def initialize(input = nil, options = {}, &block)
     def valid?
       parse
       true
-    rescue Error
+    rescue ParserError
       false
     end
 
@@ -416,7 +416,7 @@ def parse(prod = START)
       @result.validate! if @result && validate?
       @result
     rescue EBNF::LL1::Parser::Error, EBNF::LL1::Lexer::Error =>  e
-      raise LD::Patch::Error.new(e.message, lineno: e.lineno, token: e.token)
+      raise LD::Patch::ParserError.new(e.message, lineno: e.lineno, token: e.token)
     end
 
     ##
@@ -572,7 +572,6 @@ def iri(value)
     end
 
     def ns(prefix, suffix)
-      # FIXME 400 Bad Request
       error("pname", "undefined prefix #{prefix.inspect}") unless prefix(prefix)
       base = prefix(prefix).to_s
       suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")

spec/suite_helper.rb

@@ -78,7 +78,8 @@ module SuiteTest
         "result": {"@id": "mf:result", "@type": "@id"},
         "data": {"@id": "ldp:data", "@type": "@id"},
         "base": {"@id": "ldp:base", "@type": "@id"},
-        "patch": {"@id": "ldp:patch", "@type": "@id"}
+        "patch": {"@id": "ldp:patch", "@type": "@id"},
+        "statusCode": {"@id": "ldp:statusCode", "@type": "xsd:integer"}
       },
       "@type": "mf:Manifest",
       "entries": {

spec/suite_spec.rb

@@ -17,7 +17,7 @@
       describe m.comment do
         m.entries.each do |t|
           next if t.approval =~ /Rejected/
-          specify "#{t.id.split("/").last}: #{t.name} - #{t.comment}#{'( negative)' if t.negative_test?}" do
+          specify "#{t.name} - #{t.comment}#{'( negative)' if t.negative_test?}" do
             if %w(turtle-syntax-bad-struct-09 turtle-syntax-bad-struct-10).include?(t.name)
               pending "Multiple '.' allowed in this grammar"
             end
@@ -41,9 +41,15 @@
                 end
                 fail("Should have raised a parser error")
               end
-            rescue LD::Patch::Error
+            rescue LD::Patch::ParserError
+              unless t.syntax? && t.negative_test? || %w(turtle-eval-bad-01 turtle-eval-bad-02 turtle-eval-bad-03).include?(t.name)
+                raise
+              end
+            rescue LD::Patch::Error => e
               # Special case
-              unless t.negative_test?
+              if t.evaluate? && t.negative_test?
+                expect(e.code).to eq t.statusCode.to_i
+              else
                 raise
               end
             end