RubyGems - rdf-turtle - Versions diffs - 0.1.0 → 0.1.1 - Mend

rdf-turtle 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

data/History +4 -0
data/README.markdown +2 -2
data/VERSION +1 -1
data/lib/rdf/ll1/lexer.rb +19 -4
data/lib/rdf/ll1/parser.rb +126 -75
data/lib/rdf/turtle.rb +0 -2
data/lib/rdf/turtle/format.rb +3 -2
data/lib/rdf/turtle/meta.rb +553 -126
data/lib/rdf/turtle/reader.rb +26 -26
data/lib/rdf/turtle/terminals.rb +20 -10
data/lib/rdf/turtle/writer.rb +41 -36
metadata +41 -19
data/lib/rdf/turtle/patches.rb +0 -38

data/History CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

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

data/lib/rdf/ll1/lexer.rb CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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 CHANGED

@@ -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" => [
       "(",
       "[",