rdf-turtle 1.1.7 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56d0d3cc2cf4292f416aa291e67d4d058cd332d7
-  data.tar.gz: d39c9e316044e0ebea6e8d1780a9ccf136a39e2e
+  metadata.gz: 3eb247803e3c16fd5a6338c2175664deaeeea53c
+  data.tar.gz: cf0ea0c919bfc0421e91eb0dbd7337fd61dfe881
 SHA512:
-  metadata.gz: 15d74683135486f8c3f107c71f422d27f1b9e8d13c55decb6a75d629a0d923c804e9ece23a0c0ffb339ff42baea972f8f7e6adf9831bea4d556e808b63abcb7c
-  data.tar.gz: 2733ddfba4a8a54c84f997a31c37df08a3b2c820829c8c9f55899d2b67af769a4e2d36bd289b79f2077e6bc5f0138bb236600f49508d30b3f645ca3836b08f8c
+  metadata.gz: 0a461d97b2f6c0fb5a8e63cf0f07f427cbea96dbf38952b0da5dac2064464ff999237067a53d7ac18ddeaaff809a74db273f93095c6007b7d2a13f0e826a15e4
+  data.tar.gz: d145feb24bbda56cbdb7992becc7fe68c501efebac7e020bdcb6e87015e09189951f77b0516e2ad8db84f7197e4a055b4fb7564b603b5da1809eb7cffb1b0f7d

data/README.md

@@ -4,6 +4,8 @@
 
 [![Gem Version](https://badge.fury.io/rb/rdf-turtle.png)](http://badge.fury.io/rb/rdf-turtle)
 [![Build Status](https://travis-ci.org/ruby-rdf/rdf-turtle.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-turtle)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf-turtle/badge.svg)](https://coveralls.io/r/ruby-rdf/rdf-turtle)
+[![Dependency Status](https://gemnasium.com/ruby-rdf/rdf-turtle.png)](https://gemnasium.com/ruby-rdf/rdf-turtle)
 
 ## Description
 This is a [Ruby][] implementation of a [Turtle][] parser for [RDF.rb][].
@@ -46,10 +48,7 @@ Full documentation available on [Rubydoc.info][Turtle doc]
 ### Variations from the spec
 In some cases, the specification is unclear on certain issues:
 
-* The LC version of the [Turtle][] specification separates rules for `@base` and `@prefix` with
-  closing '.' from the
-  SPARQL-like `BASE` and `PREFIX` without closing '.'. This version implements a more flexible
-  syntax where the `@` and closing `.` are optional and `base/prefix` are matched case independently.
+* The LC version of the [Turtle][] specification separates rules for `@base` and `@prefix` with closing '.' from the SPARQL-like `BASE` and `PREFIX` without closing '.'. This version implements a more flexible syntax where the `@` and closing `.` are optional and `base/prefix` are matched case independently.
 * Additionally, both `a` and `A` match `rdf:type`.
 
 ### Freebase-specific Reader
@@ -83,19 +82,13 @@ An example of reading Freebase dumps:
       r.each_statement {|stmt| puts stmt.to_ntriples}
     end
 ## 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 Turtle parser.
-
-The parser takes branch and follow tables generated from the original [Turtle
-EBNF Grammar][Turtle EBNF] described in the [specification][Turtle]. Branch and
-Follow tables are specified in {RDF::Turtle::Meta}, which is in turn generated
-using the [EBNF][] gem.
+This version uses a hand-written parser using the Lexer from the [EBNF][] gem instead of a general [EBNF][] LL(1) parser for faster performance.
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.1)
-* [EBNF][] (>= 0.3.0)
+* [Ruby](http://ruby-lang.org/) (>= 1.9.3)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 1.1)
+* [EBNF][] (~> 0.3)
 
 ## Installation
 
@@ -136,7 +129,7 @@ A copy of the [Turtle EBNF][] and derived parser files are included in the repos
 [YARD]:         http://yardoc.org/
 [YARD-GS]:      http://rubydoc.info/docs/yard/file/docs/GettingStarted.md
 [PDD]:          http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
-[RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf/master/frames
+[RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf
 [EBNF]:         http://rubygems.org/gems/ebnf
 [Backports]:    http://rubygems.org/gems/backports
 [N-Triples]:    http://www.w3.org/TR/rdf-testcases/#ntriples

data/VERSION

@@ -1 +1 @@
-1.1.7
+1.1.8

data/lib/rdf/turtle/reader.rb

@@ -1,203 +1,44 @@
-require 'rdf/turtle/meta'
-require 'ebnf/ll1/parser'
+# coding: utf-8
+require 'ebnf/ll1/lexer'
 
 module RDF::Turtle
   ##
   # A parser for the Turtle 2
   class Reader < RDF::Reader
     format Format
-    include RDF::Turtle::Meta
     include EBNF::LL1::Parser
     include RDF::Turtle::Terminals
 
     # Terminals passed to lexer. Order matters!
-    terminal(:ANON,                 ANON) do |prod, token, input|
-      input[:resource] = self.bnode
-    end
-    terminal(:BLANK_NODE_LABEL,     BLANK_NODE_LABEL) do |prod, token, input|
-      input[:resource] = self.bnode(token.value[2..-1])
-    end
-    terminal(:IRIREF,               IRIREF, unescape:  true) do |prod, token, input|
-      input[:resource] = process_iri(token.value[1..-2])
-    end
-    terminal(:DOUBLE,               DOUBLE) do |prod, token, input|
-      # Note that a Turtle Double may begin with a '.[eE]', so tack on a leading
-      # zero if necessary
-      value = token.value.sub(/\.([eE])/, '.0\1')
-      input[:resource] = literal(value, datatype:  RDF::XSD.double)
-    end
-    terminal(:DECIMAL,              DECIMAL) do |prod, token, input|
-      # Note that a Turtle Decimal may begin with a '.', so tack on a leading
-      # zero if necessary
-      value = token.value
-      value = "0#{token.value}" if token.value[0,1] == "."
-      input[:resource] = literal(value, datatype:  RDF::XSD.decimal)
-    end
-    terminal(:INTEGER,              INTEGER) do |prod, token, input|
-      input[:resource] = literal(token.value, datatype:  RDF::XSD.integer)
-    end
-    # Spec confusion: spec says : "Literals , prefixed names and IRIs may also contain escape sequences"
-    terminal(:PNAME_LN,             PNAME_LN, unescape:  true) do |prod, token, input|
-      prefix, suffix = token.value.split(":", 2)
-      input[:resource] = pname(prefix, suffix)
-    end
-    # Spec confusion: spec says : "Literals , prefixed names and IRIs may also contain escape sequences"
-    terminal(:PNAME_NS,             PNAME_NS) do |prod, token, input|
-      prefix = token.value[0..-2]
-      
-      # Two contexts, one when prefix is being defined, the other when being used
-      case prod
-      when :prefixID, :sparqlPrefix
-        input[:prefix] = prefix
-      else
-        input[:resource] = pname(prefix, '')
-      end
-    end
-    terminal(:STRING_LITERAL_LONG_SINGLE_QUOTE, STRING_LITERAL_LONG_SINGLE_QUOTE, unescape:  true) do |prod, token, input|
-      input[:string_value] = token.value[3..-4]
-    end
-    terminal(:STRING_LITERAL_LONG_QUOTE, STRING_LITERAL_LONG_QUOTE, unescape:  true) do |prod, token, input|
-      input[:string_value] = token.value[3..-4]
-    end
-    terminal(:STRING_LITERAL_QUOTE,      STRING_LITERAL_QUOTE, unescape:  true) do |prod, token, input|
-      input[:string_value] = token.value[1..-2]
-    end
-    terminal(:STRING_LITERAL_SINGLE_QUOTE,      STRING_LITERAL_SINGLE_QUOTE, unescape:  true) do |prod, token, input|
-      input[:string_value] = token.value[1..-2]
-    end
+    terminal(:ANON,                             ANON)
+    terminal(:BLANK_NODE_LABEL,                 BLANK_NODE_LABEL)
+    terminal(:IRIREF,                           IRIREF, unescape:  true)
+    terminal(:DOUBLE,                           DOUBLE)
+    terminal(:DECIMAL,                          DECIMAL)
+    terminal(:INTEGER,                          INTEGER)
+    terminal(:PNAME_LN,                         PNAME_LN, unescape:  true)
+    terminal(:PNAME_NS,                         PNAME_NS)
+    terminal(:STRING_LITERAL_LONG_SINGLE_QUOTE, STRING_LITERAL_LONG_SINGLE_QUOTE, unescape:  true)
+    terminal(:STRING_LITERAL_LONG_QUOTE,        STRING_LITERAL_LONG_QUOTE,        unescape:  true)
+    terminal(:STRING_LITERAL_QUOTE,             STRING_LITERAL_QUOTE,             unescape:  true)
+    terminal(:STRING_LITERAL_SINGLE_QUOTE,      STRING_LITERAL_SINGLE_QUOTE,      unescape:  true)
     
     # String terminals
-    terminal(nil,                  %r([\(\),.;\[\]Aa]|\^\^|true|false)) do |prod, token, input|
-      case token.value
-      when 'A', 'a'           then input[:resource] = RDF.type
-      when 'true', 'false'    then input[:resource] = RDF::Literal::Boolean.new(token.value)
-      when '@base', '@prefix' then input[:lang] = token.value[1..-1]
-      when '.'                then input[:terminated] = true
-      else                         input[:string] = token.value
-      end
-    end
-
-    terminal(:PREFIX,      PREFIX) do |prod, token, input|
-      input[:string_value] = token.value
-    end
-    terminal(:BASE,      BASE) do |prod, token, input|
-      input[:string_value] = token.value
-    end
-
-    terminal(:LANGTAG,              LANGTAG) do |prod, token, input|
-      input[:lang] = token.value[1..-1]
-    end
+    terminal(nil,                               %r([\(\),.;\[\]Aa]|\^\^|true|false))
 
-    # Productions
-    # [4] prefixID defines a prefix mapping
-    production(:prefixID) do |input, current, callback|
-      prefix = current[:prefix]
-      iri = current[:resource]
-      lexical = current[:string_value]
-      terminated = current[:terminated]
-      debug("prefixID") {"Defined prefix #{prefix.inspect} mapping to #{iri.inspect}"}
-      if lexical.start_with?('@') && lexical != '@prefix'
-        error(:prefixID, "should be downcased")
-      elsif lexical == '@prefix'
-        error(:prefixID, "directive not terminated") unless terminated
-      else
-        error(:prefixID, "directive should not be terminated") if terminated
-      end
-      prefix(prefix, iri)
-    end
-    
-    # [5] base set base_uri
-    production(:base) do |input, current, callback|
-      iri = current[:resource]
-      lexical = current[:string_value]
-      terminated = current[:terminated]
-      debug("base") {"Defined base as #{iri}"}
-      if lexical.start_with?('@') && lexical != '@base'
-        error(:base, "should be downcased")
-      elsif lexical == '@base'
-        error(:base, "directive not terminated") unless terminated
-      else
-        error(:base, "directive should not be terminated") if terminated
-      end
-      options[:base_uri] = iri
-    end
-    
-    # [6] triples
-    start_production(:triples) do |input, current, callback|
-      # Note production as triples for blankNodePropertyList
-      # to set :subject instead of :resource
-      current[:triples] = true
-    end
-    production(:triples) do |input, current, callback|
-      # Note production as triples for blankNodePropertyList
-      # to set :subject instead of :resource
-      current[:triples] = true
-    end
+    terminal(:PREFIX,                           PREFIX)
+    terminal(:BASE,                             BASE)
+    terminal(:LANGTAG,                          LANGTAG)
 
-    # [9] verb ::= predicate | "a"
-    production(:verb) do |input, current, callback|
-      input[:predicate] = current[:resource]
-    end
-
-    # [10] subject ::= IRIref | BlankNode | collection
-    start_production(:subject) do |input, current, callback|
-      current[:triples] = nil
-    end
-
-    production(:subject) do |input, current, callback|
-      input[:subject] = current[:resource]
-    end
-
-    # [12] object ::= iri | BlankNode | collection | blankNodePropertyList | literal
-    production(:object) do |input, current, callback|
-      if input[:object_list]
-        # Part of an rdf:List collection
-        input[:object_list] << current[:resource]
-      else
-        debug("object") {"current: #{current.inspect}"}
-        callback.call(:statement, "object", input[:subject], input[:predicate], current[:resource])
-      end
-    end
-
-    # [14] blankNodePropertyList ::= "[" predicateObjectList "]"
-    start_production(:blankNodePropertyList) do |input, current, callback|
-      current[:subject] = self.bnode
-    end
-    
-    production(:blankNodePropertyList) do |input, current, callback|
-      if input[:triples]
-        input[:subject] = current[:subject]
-      else
-        input[:resource] = current[:subject]
-      end
-    end
-    
-    # [15] collection ::= "(" object* ")"
-    start_production(:collection) do |input, current, callback|
-      # Tells the object production to collect and not generate statements
-      current[:object_list] = []
-    end
-    
-    production(:collection) do |input, current, callback|
-      # Create an RDF list
-      objects = current[:object_list]
-      list = RDF::List[*objects]
-      list.each_statement do |statement|
-        next if statement.predicate == RDF.type && statement.object == RDF.List
-        callback.call(:statement, "collection", statement.subject, statement.predicate, statement.object)
-      end
+    ##
+    # Accumulated errors found during processing
+    # @return [Array<String>]
+    attr_reader :errors
 
-      # Return bnode as resource
-      input[:resource] = list.subject
-    end
-    
-    # [16] RDFLiteral ::= String ( LanguageTag | ( "^^" IRIref ) )? 
-    production(:RDFLiteral) do |input, current, callback|
-      opts = {}
-      opts[:datatype] = current[:resource] if current[:resource]
-      opts[:language] = current[:lang] if current[:lang]
-      input[:resource] = literal(current[:string_value], opts)
-    end
+    ##
+    # Accumulated warnings found during processing
+    # @return [Array<String>]
+    attr_reader :warnings
 
     ##
     # Redirect for Freebase Reader
@@ -229,13 +70,13 @@ module RDF::Turtle
     #   the base URI to use when resolving relative URIs (for acessing intermediate parser productions)
     # @option options [#to_s]    :anon_base     ("b0")
     #   Basis for generating anonymous Nodes
-    # @option options [Boolean] :resolve_uris (false)
-    #   Resolve prefix and relative IRIs, otherwise, when serializing the parsed SSE
-    #   as S-Expressions, use the original prefixed and relative URIs along with `base` and `prefix`
-    #   definitions.
     # @option options [Boolean]  :validate     (false)
     #   whether to validate the parsed statements and values. If not validating,
     #   the parser will attempt to recover from errors.
+    # @option options [Array] :errors
+    #   array for placing errors found when parsing
+    # @option options [Array] :warnings
+    #   array for placing warnings found when parsing
     # @option options [Boolean] :progress
     #   Show progress of parser productions
     # @option options [Boolean, Integer, Array] :debug
@@ -255,6 +96,11 @@ module RDF::Turtle
           whitespace:  WS,
         }.merge(options)
         @options = {prefixes:  {nil => ""}}.merge(@options) unless @options[:validate]
+        @errors = @options[:errors] || []
+        @warnings = @options[:warnings] || []
+        @depth = 0
+        @prod_stack = []
+
         @options[:debug] ||= case
         when RDF::Turtle.debug? then true
         when @options[:progress] then 2
@@ -268,6 +114,8 @@ module RDF::Turtle
         debug("canonicalize") {canonicalize?.inspect}
         debug("intern") {intern?.inspect}
 
+        @lexer = EBNF::LL1::Lexer.new(input, self.class.patterns, @options)
+
         if block_given?
           case block.arity
             when 0 then instance_eval(&block)
@@ -289,41 +137,28 @@ module RDF::Turtle
     # @return [void]
     def each_statement(&block)
       if block_given?
+        @recovering = false
         @callback = block
 
-        parse(@input, START.to_sym, @options.merge(branch:  BRANCH,
-                                                   first:  FIRST,
-                                                   follow:  FOLLOW,
-                                                   reset_on_start:  true)
-        ) do |context, *data|
-          case context
-          when :statement
-            loc = data.shift
-            s = RDF::Statement.from(data, lineno:  lineno)
-            add_statement(loc, s) unless !s.valid? && validate?
-          when :trace
-            level, lineno, depth, *args = data
-            message = "#{args.join(': ')}"
-            d_str = depth > 100 ? ' ' * 100 + '+' : ' ' * depth
-            str = "[#{lineno}](#{level})#{d_str}#{message}"
-            case @options[:debug]
-            when Array
-              @options[:debug] << str
-            when TrueClass
-              $stderr.puts str
-            when Integer
-              $stderr.puts(str) if level <= @options[:debug]
-            end
+        begin
+          while (@lexer.first rescue true)
+            read_statement
+          end
+        rescue EBNF::LL1::Lexer::Error, SyntaxError, EOFError, Recovery
+          # Terminate loop if EOF found while recovering
+        end
+
+        if validate?
+          if !warnings.empty? && !@options[:warnings]
+            $stderr.puts "Warnings: #{warnings.join("\n")}"
+          end
+          if !errors.empty?
+            $stderr.puts "Errors: #{errors.join("\n")}" unless @options[:errors]
+            raise RDF::ReaderError, "Errors found during processing"
           end
         end
       end
       enum_for(:each_statement)
-    rescue EBNF::LL1::Parser::Error, EBNF::LL1::Lexer::Error =>  e
-      if validate?
-        raise RDF::ReaderError.new(e.message, lineno: e.lineno, token: e.token)
-      else
-        $stderr.puts e.message
-      end
     end
     
     ##
@@ -345,13 +180,12 @@ module RDF::Turtle
 
     # add a statement, object can be literal or URI or bnode
     #
-    # @param [Nokogiri::XML::Node, any] node XML Node or string for showing context
+    # @param [Symbol] production
     # @param [RDF::Statement] statement the subject of the statement
     # @return [RDF::Statement] Added statement
     # @raise [RDF::ReaderError] Checks parameter types and raises if they are incorrect if parsing mode is _validate_.
-    def add_statement(node, statement)
-      error(node, "Statement is invalid: #{statement.inspect.inspect}") if validate? && statement.invalid?
-      progress(node) {"generate statement: #{statement.to_ntriples}"}
+    def add_statement(production, statement)
+      error("Statement is invalid: #{statement.inspect.inspect}", production: produciton) if validate? && statement.invalid?
       @callback.call(statement) if statement.subject &&
                                    statement.predicate &&
                                    statement.object &&
@@ -360,11 +194,15 @@ module RDF::Turtle
 
     # Process a URI against base
     def process_iri(iri)
-      value = base_uri.join(iri)
+      iri = iri.value[1..-2] if iri === :IRIREF
+      value = RDF::URI(iri)
+      value = base_uri.join(value) if value.relative?
       value.validate! if validate?
       value.canonicalize! if canonicalize?
       value = RDF::URI.intern(value) if intern?
       value
+    rescue ArgumentError => e
+      error("process_iri", e)
     end
     
     # Create a literal
@@ -376,6 +214,8 @@ module RDF::Turtle
         "c14n?: #{canonicalize?.inspect}"
       end
       RDF::Literal.new(value, options.merge(validate:  validate?, canonicalize:  canonicalize?))
+    rescue ArgumentError => e
+      error("Argument Error #{e.message}", production: :literal, token: @lexer.first)
     end
 
     ##
@@ -397,7 +237,7 @@ module RDF::Turtle
       if prefix(prefix)
         base = prefix(prefix).to_s
       elsif !prefix(prefix)
-        error("pname", "undefined prefix #{prefix.inspect}")
+        error("undefined prefix", production: :pname, token: prefix)
         base = ''
       end
       suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")
@@ -411,5 +251,443 @@ module RDF::Turtle
       @bnode_cache ||= {}
       @bnode_cache[value.to_s] ||= RDF::Node.new(value)
     end
+
+  protected
+    # @return [void]
+    def read_statement
+      prod(:statement, %w{.}) do
+        error("read_statement", "Unexpected end of file") unless token = @lexer.first
+        case token.type
+        when :BASE, :PREFIX
+          read_directive || error("Failed to parse directive", production: :directive, token: token)
+        else
+          read_triples || error("Expected token", production: :statement, token: token)
+          if !@recovering || @lexer.first === '.'
+            # If recovering, we will have eaten the closing '.'
+            token = @lexer.shift
+            unless token && token.value == '.'
+              error("Expected '.' following triple", production: :statement, token: token)
+            end
+          end
+        end
+      end
+    end
+
+    # @return [void]
+    def read_directive
+      prod(:directive, %w{.}) do
+        token = @lexer.first
+        case token.type
+        when :BASE
+          prod(:base) do
+            @lexer.shift
+            terminated = token.value == '@base'
+            iri = @lexer.shift
+            error("Expected IRIREF", :production => :base, token: iri) unless iri === :IRIREF
+            @options[:base_uri] = process_iri(iri)
+            error("base", "#{token} should be downcased") if token.value.start_with?('@') && token.value != '@base'
+
+            if terminated
+              error("base", "Expected #{token} to be terminated") unless @lexer.first === '.'
+              @lexer.shift
+            elsif @lexer.first === '.'
+              error("base", "Expected #{token} not to be terminated") 
+            else
+              true
+            end
+          end
+        when :PREFIX
+          prod(:prefixID, %w{.}) do
+            @lexer.shift
+            pfx, iri = @lexer.shift, @lexer.shift
+            terminated = token.value == '@prefix'
+            error("Expected PNAME_NS", :production => :prefix, token: pfx) unless pfx === :PNAME_NS
+            error("Expected IRIREF", :production => :prefix, token: iri) unless iri === :IRIREF
+            debug("prefixID") {"Defined prefix #{pfx.inspect} mapping to #{iri.inspect}"}
+            prefix(pfx.value[0..-2], process_iri(iri))
+            error("prefixId", "#{token} should be downcased") if token.value.start_with?('@') && token.value != '@prefix'
+
+            if terminated
+              error("prefixID", "Expected #{token} to be terminated") unless @lexer.first === '.'
+              @lexer.shift
+            elsif @lexer.first === '.'
+              error("prefixID", "Expected #{token} not to be terminated") 
+            else
+              true
+            end
+          end
+        end
+      end
+    end
+
+    # @return [Object] returns the last verb matched, or subject BNode on predicateObjectList?
+    def read_triples
+      prod(:triples, %w{.}) do
+        error("read_triples", "Unexpected end of file") unless token = @lexer.first
+        case token.type || token.value
+        when '['
+          # blankNodePropertyList predicateObjectList? 
+          subject = read_blankNodePropertyList || error("Failed to parse blankNodePropertyList", production: :triples, token: @lexer.first)
+          read_predicateObjectList(subject) || subject
+        else
+          # subject predicateObjectList
+          subject = read_subject || error("Failed to parse subject", production: :triples, token: @lexer.first)
+          read_predicateObjectList(subject) || error("Expected predicateObjectList", production: :triples, token: @lexer.first)
+        end
+      end
+    end
+
+    # @param [RDF::Resource] subject
+    # @return [RDF::URI] the last matched verb
+    def read_predicateObjectList(subject)
+      prod(:predicateObjectList, %{;}) do
+        last_verb = nil
+        while verb = read_verb
+          last_verb = verb
+          prod(:_predicateObjectList_5) do
+            read_objectList(subject, verb) || error("Expected objectList", production: :predicateObjectList, token: @lexer.first)
+          end
+          break unless @lexer.first === ';'
+          @lexer.shift while @lexer.first === ';'
+        end
+        last_verb
+      end
+    end
+
+    # @return [RDF::Term] the last matched subject
+    def read_objectList(subject, predicate)
+      prod(:objectList, %{,}) do
+        last_object = nil
+        while object = prod(:_objectList_2) {read_object(subject, predicate)}
+          last_object = object
+          break unless @lexer.first === ','
+          @lexer.shift while @lexer.first === ','
+        end
+        last_object
+      end
+    end
+
+    # @return [RDF::URI]
+    def read_verb
+      error("read_verb", "Unexpected end of file") unless token = @lexer.first
+      case token.type || token.value
+      when 'a' then prod(:verb) {@lexer.shift && RDF.type}
+      else prod(:verb) {read_iri}
+      end
+    end
+
+    # @return [RDF::Resource]
+    def read_subject
+      prod(:subject) do
+        read_iri ||
+        read_BlankNode ||
+        read_collection ||
+        error( "Expected subject", production: :subject, token: @lexer.first)
+      end
+    end
+
+    # @return [void]
+    def read_object(subject = nil, predicate = nil)
+      prod(:object) do
+        if object = read_iri ||
+          read_BlankNode ||
+          read_collection ||
+          read_blankNodePropertyList ||
+          read_literal
+
+          add_statement(:object, RDF::Statement(subject, predicate, object)) if subject && predicate
+          object
+        end
+      end
+    end
+
+    # @return [RDF::Literal]
+    def read_literal
+      error("Unexpected end of file", production: :literal) unless token = @lexer.first
+      case token.type || token.value
+      when :INTEGER then prod(:literal) {literal(@lexer.shift.value, datatype:  RDF::XSD.integer)}
+      when :DECIMAL
+        prod(:litearl) do
+          value = @lexer.shift.value
+          value = "0#{value}" if value.start_with?(".")
+          literal(value, datatype:  RDF::XSD.decimal)
+        end
+      when :DOUBLE then prod(:literal) {literal(@lexer.shift.value.sub(/\.([eE])/, '.0\1'), datatype:  RDF::XSD.double)}
+      when "true", "false" then prod(:literal) {literal(@lexer.shift.value, datatype: RDF::XSD.boolean)}
+      when :STRING_LITERAL_QUOTE, :STRING_LITERAL_SINGLE_QUOTE
+        prod(:literal) do
+          value = @lexer.shift.value[1..-2]
+          error("read_literal", "Unexpected end of file") unless token = @lexer.first
+          case token.type || token.value
+          when :LANGTAG
+            literal(value, language: @lexer.shift.value[1..-1].to_sym)
+          when '^^'
+            @lexer.shift
+            literal(value, datatype: read_iri)
+          else
+            literal(value)
+          end
+        end
+      when :STRING_LITERAL_LONG_QUOTE, :STRING_LITERAL_LONG_SINGLE_QUOTE
+        prod(:literal) do
+          value = @lexer.shift.value[3..-4]
+          error("read_literal", "Unexpected end of file") unless token = @lexer.first
+          case token.type || token.value
+          when :LANGTAG
+            literal(value, language: @lexer.shift.value[1..-1].to_sym)
+          when '^^'
+            @lexer.shift
+            literal(value, datatype: read_iri)
+          else
+            literal(value)
+          end
+        end
+      end
+    end
+
+    # @return [RDF::Node]
+    def read_blankNodePropertyList
+      token = @lexer.first
+      if token === '['
+        prod(:blankNodePropertyList, %{]}) do
+          @lexer.shift
+          progress("blankNodePropertyList") {"token: #{token.inspect}"}
+          node = bnode
+          read_predicateObjectList(node)
+          error("blankNodePropertyList", "Expected closing ']'") unless @lexer.first === ']'
+          @lexer.shift
+          node
+        end
+      end
+    end
+
+    # @return [RDF::Node]
+    def read_collection
+      if @lexer.first === '('
+        prod(:collection, %{)}) do
+          @lexer.shift
+          token = @lexer.first
+          progress("collection") {"token: #{token.inspect}"}
+          objects = []
+          while object = read_object
+            objects << object
+          end
+          list = RDF::List.new(nil, nil, objects)
+          list.each_statement do |statement|
+            add_statement("collection", statement)
+          end
+          error("collection", "Expected closing ')'") unless @lexer.first === ')'
+          @lexer.shift
+          list.subject
+        end
+      end
+    end
+
+    # @return [RDF::URI]
+    def read_iri
+      token = @lexer.first
+      case token && token.type
+      when :IRIREF then prod(:iri)  {process_iri(@lexer.shift)}
+      when :PNAME_LN, :PNAME_NS then prod(:iri) {pname(*@lexer.shift.value.split(':', 2))}
+      end
+    end
+
+    # @return [RDF::Node]
+    def read_BlankNode
+      token = @lexer.first
+      case token && token.type
+      when :BLANK_NODE_LABEL then prod(:BlankNode) {bnode(@lexer.shift.value[2..-1])}
+      when :ANON then @lexer.shift && prod(:BlankNode) {bnode}
+      end
+    end
+
+    def prod(production, recover_to = [])
+      @prod_stack << {prod: production, recover_to: recover_to}
+      @depth += 1
+      @recovering = false
+      progress("#{production}(start)") {"token: #{@lexer.first.inspect}"}
+      yield
+    rescue EBNF::LL1::Lexer::Error, SyntaxError, Recovery =>  e
+      # Lexer encountered an illegal token or the parser encountered
+      # a terminal which is inappropriate for the current production.
+      # Perform error recovery to find a reasonable terminal based
+      # on the follow sets of the relevant productions. This includes
+      # remaining terms from the current production and the stacked
+      # productions
+      case e
+      when EBNF::LL1::Lexer::Error
+        @lexer.recover
+        begin
+          error("Lexer error", "With input '#{e.input}': #{e.message}",
+            production: production,
+            token: e.token)
+        rescue SyntaxError
+        end
+      end
+      raise EOFError, "End of input found when recovering" if @lexer.first.nil?
+      debug("recovery", "current token: #{@lexer.first.inspect}", :level => 4)
+
+      unless e.is_a?(Recovery)
+        # Get the list of follows for this sequence, this production and the stacked productions.
+        debug("recovery", "stack follows:", :level => 4)
+        @prod_stack.reverse.each do |prod|
+          debug("recovery", :level => 4) {"  #{prod[:prod]}: #{prod[:recover_to].inspect}"}
+        end
+      end
+
+      # Find all follows to the top of the stack
+      follows = @prod_stack.map {|prod| Array(prod[:recover_to])}.flatten.compact.uniq
+
+      # Skip tokens until one is found in follows
+      while (token = (@lexer.first rescue @lexer.recover)) && follows.none? {|t| token === t}
+        skipped = @lexer.shift
+        progress("recovery") {"skip #{skipped.inspect}"}
+      end
+      debug("recovery") {"found #{token.inspect} in follows"}
+
+      # Re-raise the error unless token is a follows of this production
+      raise Recovery unless Array(recover_to).any? {|t| token === t}
+
+      # Skip that token to get something reasonable to start the next production with
+      @lexer.shift
+    ensure
+      progress("#{production}(finish)")
+      @depth -= 1
+      @prod_stack.pop
+    end
+
+    ##
+    # Warning information, used as level `1` debug messages.
+    #
+    # @param [String] node Relevant location associated with message
+    # @param [String] message Error string
+    # @param [Hash] options
+    # @option options [URI, #to_s] :production
+    # @option options [Token] :token
+    # @see {#debug}
+    def warn(node, message, options = {})
+      m = "WARNING "
+      m += "[line: #{@lineno}] " if @lineno
+      m += message
+      m += " (found #{options[:token].inspect})" if options[:token]
+      m += ", production = #{options[:production].inspect}" if options[:production]
+      @warnings << m unless @recovering
+      debug(node, m, options.merge(:level => 1))
+    end
+
+    ##
+    # Error information, used as level `0` debug messages.
+    #
+    # @overload debug(node, message, options)
+    #   @param [String] node Relevant location associated with message
+    #   @param [String] message Error string
+    #   @param [Hash] options
+    #   @option options [URI, #to_s] :production
+    #   @option options [Token] :token
+    #   @see {#debug}
+    def error(*args)
+      return if @recovering
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      lineno = @lineno || (options[:token].lineno if options[:token].respond_to?(:lineno))
+      message = "#{args.join(': ')}"
+      m = "ERROR "
+      m += "[line: #{lineno}] " if lineno
+      m += message
+      m += " (found #{options[:token].inspect})" if options[:token]
+      m += ", production = #{options[:production].inspect}" if options[:production]
+      @recovering = true
+      @errors << m
+      debug(m, options.merge(level: 0))
+      raise SyntaxError.new(m, lineno: lineno, token: options[:token], production: options[:production])
+    end
+
+    ##
+    # Progress output when debugging.
+    #
+    # The call is ignored, unless `@options[:debug]` is set, in which
+    # case it records tracing information as indicated. Additionally,
+    # if `@options[:debug]` is an Integer, the call is aborted if the
+    # `:level` option is less than than `:level`.
+    #
+    # @overload debug(node, message, options)
+    #   @param [Array<String>] args Relevant location associated with message
+    #   @param [Hash] options
+    #   @option options [Integer] :depth
+    #     Recursion depth for indenting output
+    #   @option options [Integer] :level
+    #     Level assigned to message, by convention, level `0` is for
+    #     errors, level `1` is for warnings, level `2` is for parser
+    #     progress information, and anything higher is for various levels
+    #     of debug information.
+    #
+    # @yieldparam [:trace] trace
+    # @yieldparam [Integer] level
+    # @yieldparam [Integer] lineno
+    # @yieldparam [Integer] depth Recursive depth of productions
+    # @yieldparam [Array<String>] args
+    # @yieldreturn [String] added to message
+    def debug(*args)
+      return unless @options[:debug]
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      debug_level = options.fetch(:level, 3)
+      return if @options[:debug].is_a?(Integer) && debug_level > @options[:debug]
+
+      depth = options[:depth] || @depth
+      args << yield if block_given?
+
+      message = "#{args.join(': ')}"
+      d_str = depth > 100 ? ' ' * 100 + '+' : ' ' * depth
+      str = "[#{lineno}](#{debug_level})#{d_str}#{message}"
+      case @options[:debug]
+      when Array
+        @options[:debug] << str
+      when TrueClass
+        $stderr.puts str
+      when Integer
+        case debug_level
+        when 0 then return if @options[:errors]
+        when 1 then return if @options[:warnings]
+        end
+        $stderr.puts(str) if debug_level <= @options[:debug]
+      end
+    end
+
+    # Used for internal error recovery
+    class Recovery < StandardError; end
+
+    class SyntaxError < RDF::ReaderError
+      ##
+      # The current production.
+      #
+      # @return [Symbol]
+      attr_reader :production
+
+      ##
+      # The invalid token which triggered the error.
+      #
+      # @return [String]
+      attr_reader :token
+
+      ##
+      # The line number where the error occurred.
+      #
+      # @return [Integer]
+      attr_reader :lineno
+
+      ##
+      # Initializes a new syntax error instance.
+      #
+      # @param  [String, #to_s]          message
+      # @param  [Hash{Symbol => Object}] options
+      # @option options [Symbol]         :production  (nil)
+      # @option options [String]         :token  (nil)
+      # @option options [Integer]        :lineno (nil)
+      def initialize(message, options = {})
+        @production = options[:production]
+        @token      = options[:token]
+        @lineno     = options[:lineno] || (@token.lineno if @token.respond_to?(:lineno))
+        super(message.to_s)
+      end
+    end
   end # class Reader
 end # module RDF::Turtle