rdf-turtle 0.1.0 → 0.1.1

data/History

@@ -1,3 +1,7 @@
+### 0.1.1
+* Improvements to allow reader & writer to be sub-classed for rdf-trig.
+* Improved error recovery when parsing.
+
 ### 0.1.0
 * Updates for RDF.rb 0.3.4.
 * Format detection.

data/README.markdown

@@ -74,7 +74,7 @@ Using SWAP utilities, this is done as follows:
     python http://www.w3.org/2000/10/swap/grammar/ebnf2turtle.py \
       etc/turtle.bnf \
       ttl language \
-      'http://www.w3.org/2000/10/swap/grammar/turtle#' > |
+      'http://www.w3.org/ns/formats/Turtle#' > |
     sed -e 's/^  ".*"$/  g:seq (&)/'  > etc/turtle.n3
       
     python http://www.w3.org/2000/10/swap/cwm.py etc/turtle.n3 \
@@ -84,7 +84,7 @@ Using SWAP utilities, this is done as follows:
     
     script/gramLL1 \
       --grammar etc/turtle-ll1.n3 \
-      --lang 'http://www.w3.org/2000/10/swap/grammar/turtle#language' \
+      --lang 'http://www.w3.org/ns/formats/Turtle#language' \
       --output lib/rdf/turtle/meta.rb
     
       

data/VERSION

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

data/lib/rdf/ll1/lexer.rb

@@ -200,12 +200,20 @@ module RDF::LL1
 
         if token.nil?
           lexme = (scanner.rest.split(/#{@whitespace}|#{@comment}/).first rescue nil) || scanner.rest
-          raise Error.new("Invalid token #{lexme.inspect} on line #{lineno + 1}",
+          raise Error.new("Invalid token #{lexme[0..100].inspect}",
             :input => scanner.rest[0..100], :token => lexme, :lineno => lineno)
         end
 
         token
       end
+    rescue ArgumentError, Encoding::CompatibilityError => e
+      raise Error.new("#{e.message} on line #{lineno + 1}",
+        :input => (scanner.rest[0..100] rescue '??'), :token => lexme, :lineno => lineno)
+    rescue Error
+      raise
+    rescue
+      STDERR.puts "Expected ArgumentError, got #{$!.class}"
+      raise
     end
 
     ##
@@ -223,13 +231,13 @@ module RDF::LL1
     #
     # @return [Token]
     def recover
-      scanner.skip(/./)
       until scanner.eos? do
         begin
+          shift
           return first
-        rescue Error
+        rescue Error, ArgumentError
           # Ignore errors until something scans, or EOS.
-          scanner.skip(/./)
+          scanner.pos = scanner.pos + 1
         end
       end
     end
@@ -454,5 +462,12 @@ module RDF::LL1
         super(message.to_s)
       end
     end # class Error
+    
+    unless "".respond_to?(:force_encoding)
+      # Compatibility with 1.9 Encoding
+      module Encoding
+        class CompatibilityError < StandardError; end
+      end
+    end
   end # class Lexer
 end # module RDF::Turtle

data/lib/rdf/ll1/parser.rb

@@ -13,11 +13,12 @@ module RDF::LL1
       base.extend(ClassMethods)
     end
 
+    # DSL for creating terminals and productions
     module ClassMethods
-      def production_handlers; @production_handlers || {}; end
-      def terminal_handlers; @terminal_handlers || {}; end
-      def patterns; @patterns || []; end
-      def unescape_terms; @unescape_terms || []; end
+      def production_handlers; @@production_handlers || {}; end
+      def terminal_handlers; @@terminal_handlers || {}; end
+      def patterns; @@patterns || []; end
+      def unescape_terms; @@unescape_terms || []; end
 
       ##
       # Defines a production called during different phases of parsing
@@ -42,8 +43,8 @@ module RDF::LL1
       #   Should conform to the yield specs for #initialize
       # Yield to generate a triple
       def production(term, &block)
-        @production_handlers ||= {}
-        @production_handlers[term] = block
+        @@production_handlers ||= {}
+        @@production_handlers[term] = block
       end
 
       ##
@@ -72,12 +73,12 @@ module RDF::LL1
       #   Block passed to initialization for yielding to calling reader.
       #   Should conform to the yield specs for #initialize
       def terminal(term, regexp, options = {}, &block)
-        @patterns ||= []
-        @patterns << [term, regexp]  # Passed in order to define evaulation sequence
-        @terminal_handlers ||= {}
-        @terminal_handlers[term] = block if block_given?
-        @unescape_terms ||= []
-        @unescape_terms << term if options[:unescape]
+        @@patterns ||= []
+        @@patterns << [term, regexp]  # Passed in order to define evaulation sequence
+        @@terminal_handlers ||= {}
+        @@terminal_handlers[term] = block if block_given?
+        @@unescape_terms ||= []
+        @@unescape_terms << term if options[:unescape]
       end
     end
 
@@ -136,6 +137,8 @@ module RDF::LL1
     # @param  [Hash{Symbol => Object}] options
     # @option options [Hash{Symbol,String => Hash{Symbol,String => Array<Symbol,String>}}] :branch
     #   LL1 branch table.
+    # @option options [HHash{Symbol,String => Array<Symbol,String>}] :first ({})
+    #   Lists valid terminals that can precede each production (for error recovery).
     # @option options [HHash{Symbol,String => Array<Symbol,String>}] :follow ({})
     #   Lists valid terminals that can follow each production (for error recovery).
     # @option options [Boolean]  :validate     (false)
@@ -156,11 +159,13 @@ module RDF::LL1
     def parse(input = nil, prod = nil, options = {}, &block)
       @options = options.dup
       @branch  = options[:branch]
+      @first  = options[:first] ||= {}
       @follow  = options[:follow] ||= {}
       @lexer   = input.is_a?(Lexer) ? input : Lexer.new(input, self.class.patterns, @options.merge(:unescape_terms => self.class.unescape_terms))
       @productions = []
       @parse_callback = block
       @recovering = false
+      @error_log = []
       terminals = self.class.patterns.map(&:first)  # Get defined terminals to help with branching
 
       # Unrecoverable errors
@@ -175,57 +180,49 @@ module RDF::LL1
         pushed = false
         if todo_stack.last[:terms].nil?
           todo_stack.last[:terms] = []
-          begin
-            token = @lexer.first
-          rescue RDF::LL1::Lexer::Error => e
-            # Recover from lexer error
-            @lineno = e.lineno
-            error("parse(production)", "With input '#{e.input}': #{e.message}",
-                  :production => @productions.last)
+          cur_prod = todo_stack.last[:prod]
 
-            # Retrieve next valid token
-            token = @lexer.recover
-          end
-          @lineno = token.lineno if token
+          # Get this first valid token appropriate for the stacked productions,
+          # skipping invalid tokens until either a valid token is found (from @first),
+          # or a token appearing in @follow appears.
+          token = skip_until_valid(todo_stack)
+          
+          # At this point, token is either nil, in the first set of the production,
+          # or in the follow set of this production or any previous production
           debug("parse(production)") do
-            "#{token ? token.representation.inspect : 'nil'}, " + 
-            "prod #{todo_stack.last[:prod].inspect}, " + 
+            "token #{token ? token.representation.inspect : 'nil'}, " + 
+            "prod #{cur_prod.inspect}, " + 
             "depth #{depth}"
           end
           
-          # Got an opened production
-          cur_prod = todo_stack.last[:prod]
           # Got an opened production
           onStart(cur_prod)
           break if token.nil?
           
           if prod_branch = @branch[cur_prod]
+            @recovering = false
             sequence = prod_branch[token.representation]
             debug("parse(production)") do
-              "#{token.representation.inspect} " +
+              "token #{token.representation.inspect} " +
               "prod #{cur_prod.inspect}, " + 
               "prod_branch #{prod_branch.keys.inspect}, " +
               "sequence #{sequence.inspect}"
             end
+
             if sequence.nil?
               if prod_branch.has_key?(:"ebnf:empty")
                 debug("parse(production)") {"empty sequence for ebnf:empty"}
               else
-                expected = prod_branch.keys.map {|v| v.inspect}.join(", ")
-                error("parse", "expected one of #{expected}",
-                  :production => cur_prod, :token => token)
-
-                # Skip input until we find something that can follow the current production
-                skip_until_follow(todo_stack)
-                todo_stack.last[:terms] = []
+                # If there is no sequence for this production, we're
+                # in error recovery, and _token_ has been advanced to
+                # the point where it can reasonably follow this production
               end
             end
-            @recovering = false
             todo_stack.last[:terms] += sequence if sequence
           else
-            error("parse", "No branches found for #{cur_prod.inspect}",
+            # Is this a fatal error?
+            error("parse(fatal?)", "No branches found for #{cur_prod.inspect}",
               :production => cur_prod, :token => token)
-            todo_stack.last[:terms] = []
           end
         end
         
@@ -234,16 +231,15 @@ module RDF::LL1
           begin
             # Get the next term in this sequence
             term = todo_stack.last[:terms].shift
+            debug("parse(token)") {"accept #{term.inspect}"}
             if token = accept(term)
-              debug("parse(token)") {"#{token.inspect}, term #{term.inspect}"}
-              @lineno = token.lineno if token
+              @recovering = false
+              debug("parse(token)") {"token #{token.inspect}, term #{term.inspect}"}
               onToken(term, token)
             elsif terminals.include?(term)
-              error("parse", "#{term.inspect} expected",
-                :production => todo_stack.last[:prod], :token => @lexer.first)
-            
-              # Recover until we find something that can follow this term
-              skip_until_follow(todo_stack)
+              # If term is a terminal, then it is an error of token does not
+              # match it
+              skip_until_valid(todo_stack)
             else
               # If it's not a string (a symbol), it is a non-terminal and we push the new state
               todo_stack << {:prod => term, :terms => nil}
@@ -251,11 +247,6 @@ module RDF::LL1
               pushed = true
               break
             end
-          rescue RDF::LL1::Lexer::Error => e
-            # Skip forward for acceptable lexer input
-            error("parse", "#{term.inspect} expected: #{e.message}",
-              :production => todo_stack.last[:prod])
-            @lexer.recover
           end
         end
         
@@ -282,11 +273,11 @@ module RDF::LL1
         todo_stack.pop
         onFinish
       end
-
-    rescue RDF::LL1::Lexer::Error => e
-      @lineno = e.lineno
-      error("parse", "With input '#{e.input}': #{e.message}",
-            :production => @productions.last)
+      
+      # When all is said and done, raise the error log
+      unless @error_log.empty?
+        raise Error, @error_log.join("\n\t") 
+      end
     end
 
     def depth; (@productions || []).length; end
@@ -341,21 +332,55 @@ module RDF::LL1
       end
     end
     
-    # Skip throught the input stream until something is found that follows the last production with a list of follows
-    def skip_until_follow(todo_stack)
+    # Skip through the input stream until something is found that
+    # is either valid based on the content of the production stack,
+    # or can follow a production in the stack.
+    #
+    # @return [Token]
+    def skip_until_valid(todo_stack)
+      cur_prod = todo_stack.last[:prod]
+      token = get_token
+      first = @first[cur_prod] || []
+      
+      # If this token can be used by the top production, return it
+      # Otherwise, if the banch table allows empty, also return the token
+      return token if !@recovering && (
+        (@branch[cur_prod] && @branch[cur_prod].has_key?(:"ebnf:empty")) ||
+        first.any? {|t| token === t})
+      
+      # Otherwise, it's an error condition, and skip either until
+      # we find a valid token for this production, or until we find
+      # something that can follow this production
+      expected = first.map {|v| v.inspect}.join(", ")
+      error("skip_until_valid", "expected one of #{expected}",
+        :production => cur_prod, :token => token)
+
       debug("recovery", "stack follows:")
-      todo_stack.each do |todo|
+      todo_stack.reverse.each do |todo|
         debug("recovery") {"  #{todo[:prod]}: #{@follow[todo[:prod]].inspect}"}
       end
+
+      # Find all follows to the top of the stack
       follows = todo_stack.inject([]) do |follow, todo|
         prod = todo[:prod]
         follow += @follow[prod] || []
       end.uniq
-      progress("recovery") {"first #{@lexer.first.inspect}, follows: #{follows.inspect}"}
-      while (token = @lexer.first) && follows.none? {|t| token === t}
+      debug("recovery") {"follows: #{follows.inspect}"}
+
+      # Skip tokens until one is found in first or follows
+      while (token = get_token) && (first + follows).none? {|t| token === t}
         skipped = @lexer.shift
         progress("recovery") {"skip #{skipped.inspect}"}
       end
+      debug("recovery") {"found #{token.inspect}"}
+      
+      # If the token is a first, just return it. Otherwise, it is a follow
+      # and we need to skip to the end of the production
+      unless first.any? {|t| token == t} || todo_stack.last[:terms].empty?
+        debug("recovery") {"token in follows, skip past #{todo_stack.last[:terms].inspect}"}
+        todo_stack.last[:terms] = [] 
+      end
+      token
     end
 
     # @param [String] str Error string
@@ -363,16 +388,34 @@ module RDF::LL1
     # @option options [URI, #to_s] :production
     # @option options [Token] :token
     def error(node, message, options = {})
-      return if @recovering
-      @recovering = true
       message += ", found #{options[:token].representation.inspect}" if options[:token]
       message += " at line #{@lineno}" if @lineno
-      message += ", production = #{options[:production].inspect}" if options[:production] && options[:debug]
-      if !@options[:validate] && !options[:fatal]
-        debug(node, message, options)
-      else
-        raise Error, message
+      message += ", production = #{options[:production].inspect}" if options[:production] && @options[:debug]
+      @error_log << message unless @recovering
+      @recovering = true
+      debug(node, message, options)
+    end
+
+    ##
+    # Return the next token, entering error recovery if the token is invalid
+    #
+    # @return [Token]
+    def get_token
+      token = begin
+        @lexer.first
+      rescue RDF::LL1::Lexer::Error => e
+        # Recover from lexer error
+        @lineno = e.lineno
+        error("get_token", "With input '#{e.input}': #{e.message}",
+              :production => @productions.last)
+
+        # Retrieve next valid token
+        t = @lexer.recover
+        debug("get_token") {"skipped to #{t.inspect}"}
+        t
       end
+      @lineno = token.lineno if token
+      token
     end
 
     ##
@@ -383,13 +426,18 @@ module RDF::LL1
     # @option options [Integer] :depth
     #   Recursion depth for indenting output
     # @yieldreturn [String] added to message
-    def progress(node, message = "", options = {})
-      return debug(node, message, options) if @options[:debug]
-      return unless @options[:progress]
+    def progress(node, *args)
+      return unless @options[:progress] || @options[:debug]
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      message = args.join(",")
       depth = options[:depth] || self.depth
-      message += yield if block_given?
-      str = "[#{@lineno}]#{' ' * depth}#{node}: #{message}"
-      $stderr.puts("[#{@lineno}]#{' ' * depth}#{node}: #{message}")
+      message += yield.to_s if block_given?
+      if @options[:debug]
+        return debug(node, message, options)
+      else
+        str = "[#{@lineno}]#{' ' * depth}#{node}: #{message}"
+        $stderr.puts("[#{@lineno}]#{' ' * depth}#{node}: #{message}")
+      end
     end
 
     ##
@@ -416,11 +464,14 @@ module RDF::LL1
     end
 
     ##
+    # Accept the first token in the input stream if it matches
+    # _type\_or\_value_. Return nil otherwise.
+    #
     # @param  [Symbol, String] type_or_value
     # @return [Token]
     def accept(type_or_value)
-      if (token = @lexer.first) && token === type_or_value
-        debug("accept") {"#{token.inspect} === #{type_or_value}.inspect"}
+      if (token = get_token) && token === type_or_value
+        debug("accept") {"#{token.inspect} === #{type_or_value.inspect}"}
         @lexer.shift
       end
     end

data/lib/rdf/turtle.rb

@@ -20,8 +20,6 @@ module RDF
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   module Turtle
     require  'rdf/turtle/format'
-    require  'rdf/turtle/patches'
-    autoload :Lexer,      'rdf/turtle/lexer'
     autoload :Reader,     'rdf/turtle/reader'
     autoload :Terminals,  'rdf/turtle/terminals'
     autoload :VERSION,    'rdf/turtle/version'

data/lib/rdf/turtle/format.rb

@@ -36,7 +36,7 @@ module RDF::Turtle
     # @return [Boolean]
     def self.detect(sample)
       !!sample.match(%r(
-        (?:@(base|prefix|keywords)) |                                   # N3 keywords
+        (?:@(base|prefix)) |                                            # Turtle keywords
         ["']{3} |                                                       # STRING_LITERAL_LONG1/2
         "[^"]*"^^ | "[^"]*"@ |                                          # Typed/Language literals
         (?:
@@ -44,7 +44,8 @@ module RDF::Turtle
           (?:\s*(?:(?:<[^>]*>) | (?:\w*:\w+) | (?:"[^"]*"))){3}
         )
       )mx) && !(
-        sample.match(%r(@keywords|=>|\{)) ||                             # N3
+        sample.match(%r([{}])) ||                                       # TriG
+        sample.match(%r(@keywords|=>|\{)) ||                            # N3
         sample.match(%r(<(?:\/|html|rdf))i) ||                          # HTML, RDF/XML
         sample.match(%r(^(?:\s*<[^>]*>){4}.*\.\s*$)) ||                 # N-Quads
         sample.match(%r("@(context|subject|iri)"))                      # JSON-LD

data/lib/rdf/turtle/meta.rb

@@ -5,7 +5,7 @@ module RDF::Turtle::Meta
 
   BRANCH = {
     :"_:_g0" => {
-      ";" => [:"_:g2164861540"],
+      ";" => [:"_:g2156954680"],
       :"ebnf:empty" => [],
     },
     :"_:_g1" => {
@@ -27,7 +27,7 @@ module RDF::Turtle::Meta
       :PNAME_NS => [:verb, :objectList],
     },
     :"_:_g4" => {
-      "," => [:"_:g2152509620"],
+      "," => [:"_:g2153337920"],
       ";" => [],
       :"ebnf:empty" => [],
     },
@@ -35,29 +35,29 @@ module RDF::Turtle::Meta
       "," => [",", :object],
     },
     :"_:_g6" => {
-      "(" => [:"_:g2169738260"],
-      "[" => [:"_:g2169738260"],
-      "false" => [:"_:g2169738260"],
+      "(" => [:"_:g2152877000"],
+      "[" => [:"_:g2152877000"],
+      "false" => [:"_:g2152877000"],
       :"ebnf:empty" => [],
-      :ANON => [:"_:g2169738260"],
-      :BLANK_NODE_LABEL => [:"_:g2169738260"],
-      :DECIMAL => [:"_:g2169738260"],
-      :DECIMAL_NEGATIVE => [:"_:g2169738260"],
-      :DECIMAL_POSITIVE => [:"_:g2169738260"],
-      :DOUBLE => [:"_:g2169738260"],
-      :DOUBLE_NEGATIVE => [:"_:g2169738260"],
-      :DOUBLE_POSITIVE => [:"_:g2169738260"],
-      :INTEGER => [:"_:g2169738260"],
-      :INTEGER_NEGATIVE => [:"_:g2169738260"],
-      :INTEGER_POSITIVE => [:"_:g2169738260"],
-      :IRI_REF => [:"_:g2169738260"],
-      :PNAME_LN => [:"_:g2169738260"],
-      :PNAME_NS => [:"_:g2169738260"],
-      :STRING_LITERAL1 => [:"_:g2169738260"],
-      :STRING_LITERAL2 => [:"_:g2169738260"],
-      :STRING_LITERAL_LONG1 => [:"_:g2169738260"],
-      :STRING_LITERAL_LONG2 => [:"_:g2169738260"],
-      "true" => [:"_:g2169738260"],
+      :ANON => [:"_:g2152877000"],
+      :BLANK_NODE_LABEL => [:"_:g2152877000"],
+      :DECIMAL => [:"_:g2152877000"],
+      :DECIMAL_NEGATIVE => [:"_:g2152877000"],
+      :DECIMAL_POSITIVE => [:"_:g2152877000"],
+      :DOUBLE => [:"_:g2152877000"],
+      :DOUBLE_NEGATIVE => [:"_:g2152877000"],
+      :DOUBLE_POSITIVE => [:"_:g2152877000"],
+      :INTEGER => [:"_:g2152877000"],
+      :INTEGER_NEGATIVE => [:"_:g2152877000"],
+      :INTEGER_POSITIVE => [:"_:g2152877000"],
+      :IRI_REF => [:"_:g2152877000"],
+      :PNAME_LN => [:"_:g2152877000"],
+      :PNAME_NS => [:"_:g2152877000"],
+      :STRING_LITERAL1 => [:"_:g2152877000"],
+      :STRING_LITERAL2 => [:"_:g2152877000"],
+      :STRING_LITERAL_LONG1 => [:"_:g2152877000"],
+      :STRING_LITERAL_LONG2 => [:"_:g2152877000"],
+      "true" => [:"_:g2152877000"],
     },
     :"_:_g7" => {
       "(" => [],
@@ -91,7 +91,7 @@ module RDF::Turtle::Meta
       "(" => [],
       "," => [],
       "[" => [],
-      "^^" => [:"_:g2153021180"],
+      "^^" => [:"_:g2165812760"],
       "false" => [],
       :ANON => [],
       :BLANK_NODE_LABEL => [],
@@ -114,37 +114,7 @@ module RDF::Turtle::Meta
       :STRING_LITERAL_LONG2 => [],
       "true" => [],
     },
-    :"_:g2152509620" => {
-      "," => [:"_:_g5", :"_:_g4"],
-      ";" => [],
-    },
-    :"_:g2153021180" => {
-      "(" => [],
-      "," => [],
-      "[" => [],
-      "^^" => ["^^", :IRIref],
-      "false" => [],
-      :ANON => [],
-      :BLANK_NODE_LABEL => [],
-      :DECIMAL => [],
-      :DECIMAL_NEGATIVE => [],
-      :DECIMAL_POSITIVE => [],
-      :DOUBLE => [],
-      :DOUBLE_NEGATIVE => [],
-      :DOUBLE_POSITIVE => [],
-      :INTEGER => [],
-      :INTEGER_NEGATIVE => [],
-      :INTEGER_POSITIVE => [],
-      :IRI_REF => [],
-      :PNAME_LN => [],
-      :PNAME_NS => [],
-      :STRING_LITERAL1 => [],
-      :STRING_LITERAL2 => [],
-      :STRING_LITERAL_LONG1 => [],
-      :STRING_LITERAL_LONG2 => [],
-      "true" => [],
-    },
-    :"_:g2156281440" => {
+    :"_:g2152809700" => {
       "(" => [:triples, "."],
       "@base" => [],
       "@prefix" => [],
@@ -155,33 +125,7 @@ module RDF::Turtle::Meta
       :PNAME_LN => [:triples, "."],
       :PNAME_NS => [:triples, "."],
     },
-    :"_:g2164861540" => {
-      ";" => [:"_:_g1", :"_:_g0"],
-    },
-    :"_:g2165342840" => {
-      "(" => [],
-      "@base" => [:directive, "."],
-      "@prefix" => [:directive, "."],
-      "[" => [],
-      :ANON => [],
-      :BLANK_NODE_LABEL => [],
-      :IRI_REF => [],
-      :PNAME_LN => [],
-      :PNAME_NS => [],
-    },
-    :"_:g2169711200" => {
-      "(" => [:statement, :turtleDoc],
-      "@base" => [:statement, :turtleDoc],
-      "@prefix" => [:statement, :turtleDoc],
-      "[" => [:statement, :turtleDoc],
-      :"ebnf:eof" => [],
-      :ANON => [:statement, :turtleDoc],
-      :BLANK_NODE_LABEL => [:statement, :turtleDoc],
-      :IRI_REF => [:statement, :turtleDoc],
-      :PNAME_LN => [:statement, :turtleDoc],
-      :PNAME_NS => [:statement, :turtleDoc],
-    },
-    :"_:g2169738260" => {
+    :"_:g2152877000" => {
       "(" => [:object, :"_:_g6"],
       "[" => [:object, :"_:_g6"],
       "false" => [:object, :"_:_g6"],
@@ -205,6 +149,62 @@ module RDF::Turtle::Meta
       :STRING_LITERAL_LONG2 => [:object, :"_:_g6"],
       "true" => [:object, :"_:_g6"],
     },
+    :"_:g2153010700" => {
+      "(" => [],
+      "@base" => [:directive, "."],
+      "@prefix" => [:directive, "."],
+      "[" => [],
+      :ANON => [],
+      :BLANK_NODE_LABEL => [],
+      :IRI_REF => [],
+      :PNAME_LN => [],
+      :PNAME_NS => [],
+    },
+    :"_:g2153337920" => {
+      "," => [:"_:_g5", :"_:_g4"],
+      ";" => [],
+    },
+    :"_:g2156954680" => {
+      ";" => [:"_:_g1", :"_:_g0"],
+    },
+    :"_:g2165682600" => {
+      "(" => [:statement, :turtleDoc],
+      "@base" => [:statement, :turtleDoc],
+      "@prefix" => [:statement, :turtleDoc],
+      "[" => [:statement, :turtleDoc],
+      :"ebnf:eof" => [],
+      :ANON => [:statement, :turtleDoc],
+      :BLANK_NODE_LABEL => [:statement, :turtleDoc],
+      :IRI_REF => [:statement, :turtleDoc],
+      :PNAME_LN => [:statement, :turtleDoc],
+      :PNAME_NS => [:statement, :turtleDoc],
+    },
+    :"_:g2165812760" => {
+      "(" => [],
+      "," => [],
+      "[" => [],
+      "^^" => ["^^", :IRIref],
+      "false" => [],
+      :ANON => [],
+      :BLANK_NODE_LABEL => [],
+      :DECIMAL => [],
+      :DECIMAL_NEGATIVE => [],
+      :DECIMAL_POSITIVE => [],
+      :DOUBLE => [],
+      :DOUBLE_NEGATIVE => [],
+      :DOUBLE_POSITIVE => [],
+      :INTEGER => [],
+      :INTEGER_NEGATIVE => [],
+      :INTEGER_POSITIVE => [],
+      :IRI_REF => [],
+      :PNAME_LN => [],
+      :PNAME_NS => [],
+      :STRING_LITERAL1 => [],
+      :STRING_LITERAL2 => [],
+      :STRING_LITERAL_LONG1 => [],
+      :STRING_LITERAL_LONG2 => [],
+      "true" => [],
+    },
     :BASE => {
       "@base" => ["@base"],
     },
@@ -641,15 +641,15 @@ module RDF::Turtle::Meta
       "@prefix" => [:PREFIX, :PNAME_NS, :IRI_REF],
     },
     :statement => {
-      "(" => [:"_:g2156281440"],
-      "@base" => [:"_:g2165342840"],
-      "@prefix" => [:"_:g2165342840"],
-      "[" => [:"_:g2156281440"],
-      :ANON => [:"_:g2156281440"],
-      :BLANK_NODE_LABEL => [:"_:g2156281440"],
-      :IRI_REF => [:"_:g2156281440"],
-      :PNAME_LN => [:"_:g2156281440"],
-      :PNAME_NS => [:"_:g2156281440"],
+      "(" => [:"_:g2152809700"],
+      "@base" => [:"_:g2153010700"],
+      "@prefix" => [:"_:g2153010700"],
+      "[" => [:"_:g2152809700"],
+      :ANON => [:"_:g2152809700"],
+      :BLANK_NODE_LABEL => [:"_:g2152809700"],
+      :IRI_REF => [:"_:g2152809700"],
+      :PNAME_LN => [:"_:g2152809700"],
+      :PNAME_NS => [:"_:g2152809700"],
     },
     :subject => {
       "(" => [:blank],
@@ -671,17 +671,17 @@ module RDF::Turtle::Meta
       :PNAME_NS => [:subject, :predicateObjectList],
     },
     :turtleDoc => {
-      "(" => [:"_:g2169711200"],
-      "@base" => [:"_:g2169711200"],
-      "@prefix" => [:"_:g2169711200"],
-      "[" => [:"_:g2169711200"],
+      "(" => [:"_:g2165682600"],
+      "@base" => [:"_:g2165682600"],
+      "@prefix" => [:"_:g2165682600"],
+      "[" => [:"_:g2165682600"],
       :"ebnf:empty" => [],
       :"ebnf:eof" => [],
-      :ANON => [:"_:g2169711200"],
-      :BLANK_NODE_LABEL => [:"_:g2169711200"],
-      :IRI_REF => [:"_:g2169711200"],
-      :PNAME_LN => [:"_:g2169711200"],
-      :PNAME_NS => [:"_:g2169711200"],
+      :ANON => [:"_:g2165682600"],
+      :BLANK_NODE_LABEL => [:"_:g2165682600"],
+      :IRI_REF => [:"_:g2165682600"],
+      :PNAME_LN => [:"_:g2165682600"],
+      :PNAME_NS => [:"_:g2165682600"],
     },
     :verb => {
       "(" => [],
@@ -743,30 +743,27 @@ module RDF::Turtle::Meta
     :STRING_LITERAL_LONG2,
     "true"
   ].freeze
-  FOLLOW = {
-    "." => [
-      "(",
-      "@base",
-      "@prefix",
-      "[",
-      :ANON,
-      :BLANK_NODE_LABEL,
-      :IRI_REF,
-      :PNAME_LN,
-      :PNAME_NS],
+  FIRST = {
+    :"_:_g0" => [
+      ";"],
     :"_:_g1" => [
       ";"],
     :"_:_g2" => [
-      ";"],
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
     :"_:_g3" => [
-      ";"],
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
     :"_:_g4" => [
-      ";"],
+      ","],
     :"_:_g5" => [
       ","],
-    :"_:_g7" => [
+    :"_:_g6" => [
       "(",
-      ",",
       "[",
       "false",
       "true",
@@ -788,9 +785,19 @@ module RDF::Turtle::Meta
       :STRING_LITERAL2,
       :STRING_LITERAL_LONG1,
       :STRING_LITERAL_LONG2],
+    :"_:_g7" => [
+      "^^",
+      :LANGTAG],
     :"_:_g8" => [
+      "^^",
+      :LANGTAG],
+    :"_:g2152346260" => [
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2152446700" => [
       "(",
-      ",",
       "[",
       "false",
       "true",
@@ -812,11 +819,130 @@ module RDF::Turtle::Meta
       :STRING_LITERAL2,
       :STRING_LITERAL_LONG1,
       :STRING_LITERAL_LONG2],
-    :"_:g2152509620" => [
-      ";"],
-    :"_:g2153021180" => [
+    :"_:g2152796420" => [
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2152809700" => [
+      "(",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2152877000" => [
+      "(",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :"_:g2152903680" => [
+      "(",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :"_:g2153010700" => [
+      "@base",
+      "@prefix"],
+    :"_:g2153124700" => [
+      "(",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :"_:g2153337920" => [
+      ","],
+    :"_:g2153346700" => [
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2153658980" => [
+      "(",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :"_:g2156398800" => [
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2156472020" => [
+      "^^",
+      :LANGTAG],
+    :"_:g2156771960" => [
       "(",
-      ",",
       "[",
       "false",
       "true",
@@ -838,7 +964,13 @@ module RDF::Turtle::Meta
       :STRING_LITERAL2,
       :STRING_LITERAL_LONG1,
       :STRING_LITERAL_LONG2],
-    :"_:g2156281440" => [
+    :"_:g2156954680" => [
+      ";"],
+    :"_:g2164414260" => [
+      ","],
+    :"_:g2164800240" => [
+      ";"],
+    :"_:g2165021300" => [
       "(",
       "@base",
       "@prefix",
@@ -848,7 +980,7 @@ module RDF::Turtle::Meta
       :IRI_REF,
       :PNAME_LN,
       :PNAME_NS],
-    :"_:g2165342840" => [
+    :"_:g2165682600" => [
       "(",
       "@base",
       "@prefix",
@@ -858,8 +990,303 @@ module RDF::Turtle::Meta
       :IRI_REF,
       :PNAME_LN,
       :PNAME_NS],
-    :"_:g2169711200" => [
-      :"ebnf:eof"],
+    :"_:g2165812760" => [
+      "^^"],
+    :BASE => [
+      "@base"],
+    :BlankNode => [
+      :ANON,
+      :BLANK_NODE_LABEL],
+    :BooleanLiteral => [
+      "false",
+      "true"],
+    :IRIref => [
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :NumericLiteral => [
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE],
+    :NumericLiteralNegative => [
+      :DECIMAL_NEGATIVE,
+      :DOUBLE_NEGATIVE,
+      :INTEGER_NEGATIVE],
+    :NumericLiteralPositive => [
+      :DECIMAL_POSITIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER_POSITIVE],
+    :NumericLiteralUnsigned => [
+      :DECIMAL,
+      :DOUBLE,
+      :INTEGER],
+    :PREFIX => [
+      "@prefix"],
+    :PrefixedName => [
+      :PNAME_LN,
+      :PNAME_NS],
+    :RDFLiteral => [
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :String => [
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :base => [
+      "@base"],
+    :blank => [
+      "(",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL],
+    :blankNodePropertyList => [
+      "["],
+    :collection => [
+      "("],
+    :directive => [
+      "@base",
+      "@prefix"],
+    :literal => [
+      "false",
+      "true",
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :object => [
+      "(",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :objectList => [
+      "(",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :predicate => [
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :predicateObjectList => [
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :prefixID => [
+      "@prefix"],
+    :statement => [
+      "(",
+      "@base",
+      "@prefix",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :subject => [
+      "(",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :triples => [
+      "(",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :turtleDoc => [
+      "(",
+      "@base",
+      "@prefix",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :verb => [
+      "a",
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+  }.freeze
+  FOLLOW = {
+    "." => [
+      "(",
+      "@base",
+      "@prefix",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:_g1" => [
+      ";"],
+    :"_:_g2" => [
+      ";"],
+    :"_:_g3" => [
+      ";"],
+    :"_:_g4" => [
+      ";"],
+    :"_:_g5" => [
+      ","],
+    :"_:_g7" => [
+      "(",
+      ",",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :"_:_g8" => [
+      "(",
+      ",",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
+    :"_:g2152809700" => [
+      "(",
+      "@base",
+      "@prefix",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2153010700" => [
+      "(",
+      "@base",
+      "@prefix",
+      "[",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS],
+    :"_:g2153337920" => [
+      ";"],
+    :"_:g2165682600" => [
+      :"ebnf:eof"],
+    :"_:g2165812760" => [
+      "(",
+      ",",
+      "[",
+      "false",
+      "true",
+      :ANON,
+      :BLANK_NODE_LABEL,
+      :DECIMAL,
+      :DECIMAL_NEGATIVE,
+      :DECIMAL_POSITIVE,
+      :DOUBLE,
+      :DOUBLE_NEGATIVE,
+      :DOUBLE_POSITIVE,
+      :INTEGER,
+      :INTEGER_NEGATIVE,
+      :INTEGER_POSITIVE,
+      :IRI_REF,
+      :PNAME_LN,
+      :PNAME_NS,
+      :STRING_LITERAL1,
+      :STRING_LITERAL2,
+      :STRING_LITERAL_LONG1,
+      :STRING_LITERAL_LONG2],
     "a" => [
       "(",
       "[",