rdf-trig 1.1.4 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e14c37b1f090059ce8dd6b279a15e968c2c6f99f
-  data.tar.gz: cd3c7fe9e89ae3a13ce38a83c31c7553b59bcc78
+  metadata.gz: d00d578b68a875bc5125f9aa774126ccc243033b
+  data.tar.gz: 1009f36d61ec685e87c38bfb5bef15a0af419bd3
 SHA512:
-  metadata.gz: 4777a92570a042a8ad45f3f01938744b0a76531fa5355ec7ebb62506a27c804050c2c00d18740e55c7cd50b4a6fdf086b5e8b45b506909319efd61f8c71e5072
-  data.tar.gz: 6ab8ff3b7a65feda9a6636978e4dcf0b2214e0f2bb94757182196f53d577652fe6331c82a0f59a64979c18e9568f398fb21c0a7f09e3b8bd08197b08e4372763
+  metadata.gz: 35af56aa261c892dd3b46a6662f9f5bb21f7e58e4dba381a60b1059d81ad46c8d176fba227438b74fa8a93d18438dc67651e839e68e0f5eddd59186957da14df
+  data.tar.gz: ac9cd12228fbb1051186d82255c18b9c53052accc5029c2078c3611bf54879e4179964956a6414239eb84724eb523376f927427746951a008cbf2a8a88286341

data/README.md

@@ -4,6 +4,8 @@
 
 [![Gem Version](https://badge.fury.io/rb/rdf-trig.png)](http://badge.fury.io/rb/rdf-trig)
 [![Build Status](https://travis-ci.org/ruby-rdf/rdf-trig.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf-trig)
+[![Coverage Status](https://coveralls.io/repos/ruby-rdf/rdf-trig/badge.svg)](https://coveralls.io/r/ruby-rdf/rdf-trig)
+[![Dependency Status](https://gemnasium.com/ruby-rdf/rdf-trig.png)](https://gemnasium.com/ruby-rdf/rdf-trig)
 
 ## Description
 This is a [Ruby][] implementation of a [TriG][] reader and writer for [RDF.rb][].
@@ -46,8 +48,9 @@ Full documentation available on [Rubydoc.info][TriG doc].
 
 
 ## Implementation Notes
-The reader uses the [Turtle][Turtle doc] parser, which is based on the LL1::Parser with minor updates for the TriG grammar.
-The writer also is based on the Turtle writer.
+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.
+
+The reader uses the [Turtle][Turtle doc] parser. The writer also is based on the Turtle writer.
 
 The syntax is compatible with placing default triples within `{}`, but the writer does not use this for writing triples in the default graph.
 
@@ -55,9 +58,9 @@ There is a new `:stream` option to {RDF::TriG::Writer} which is more efficient f
       
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0)
-* [rdf-turtle](http://rubygems.org/gems/rdf-turtle) (>= 1.0)
+* [Ruby](http://ruby-lang.org/) (>= 1.9.3)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 1.1)
+* [rdf-turtle](http://rubygems.org/gems/rdf-turtle) (~> 1.1, >= 1.1.8)
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-1.1.4
+1.1.5

data/lib/rdf/trig.rb

@@ -1,5 +1,5 @@
 require 'rdf'
-require 'ebnf'
+require 'rdf/turtle'
 
 module RDF
   ##

data/lib/rdf/trig/reader.rb

@@ -1,5 +1,4 @@
 require 'rdf/turtle'
-require 'rdf/trig/meta'
 
 module RDF::TriG
   ##
@@ -8,224 +7,28 @@ module RDF::TriG
   # Leverages the Turtle reader
   class Reader < RDF::Turtle::Reader
     format Format
-    include RDF::TriG::Meta
 
     # 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([\{\}\(\),.;\[\]a]|\^\^|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 '.'                then input[:terminated] = true
-      else                         input[:string] = token.value
-      end
-    end
-
-    terminal(:GRAPH,      /graph/i) do |prod, token, input|
-      input[:string_value] = token.value
-    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
-
-    # Productions
-    # [2g] block defines the basic creation of context
-    start_production(:block) do |input, current, callback|
-      callback.call(:context, "graph", nil)
-    end
-    production(:block) do |input, current, callback|
-      callback.call(:context, "graph", nil)
-    end
-
-    # [7g] labelOrSubject
-    # Sets the context for triples defined within that graph
-    production(:labelOrSubject) do |input, current, callback|
-      # If input contains set_graph_iri, use the returned value to set @context
-      debug(":labelOrSubject") {"Set graph context to #{current[:resource]}"}
-      callback.call(:context, "labelOrSubject", current[:resource])
-      input[:resource] = current[:resource]
-    end
-
-    # _triplesOrGraph_2 ::= predicateObjectList '.'
-    start_production(:_triplesOrGraph_2) do |input, current, callback|
-      # Default graph after all
-      callback.call(:context, "graph", nil)
-      debug("_triplesOrGraph_2") {"subject: #{current[:resource]}"}
-      current[:subject] = input[:resource]
-    end
-
-    # 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
+    terminal(nil,                               %r([\{\}\(\),.;\[\]a]|\^\^|true|false))
 
-    # [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
-
-    # [52s]  triplesBlock
-    start_production(:triplesBlock) do |input, current, callback|
-      # Note production as triples for blankNodePropertyList
-      # to set :subject instead of :resource
-      current[:triples] = true
-    end
-    production(:triplesBlock) do |input, current, callback|
-      # Note production as triples for blankNodePropertyList
-      # to set :subject instead of :resource
-      current[:triples] = true
-    end
-
-    # [9] verb ::= predicate | "a"
-    production(:verb) do |input, current, callback|
-      input[:predicate] = current[:resource]
-    end
-
-    # [10] subject ::= iri | blank
-    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
-
-      # 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
+    terminal(:GRAPH,                            /graph/i)
+    terminal(:PREFIX,                           PREFIX)
+    terminal(:BASE,                             BASE)
+    terminal(:LANGTAG,                          LANGTAG)
 
     ##
     # Iterates the given block for each RDF statement in the input.
@@ -235,63 +38,28 @@ module RDF::TriG
     # @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 :context
-            @context = data[1]
-          when :statement
-            data << @context if @context
-            debug("each_statement") {"data: #{data.inspect}, context: #{@context.inspect}"}
-            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_trigDoc
           end
+        rescue EBNF::LL1::Lexer::Error, SyntaxError, EOFError, Recovery
+          # Terminate loop if EOF found while recovering
         end
-      end
-      enum_for(:each_statement)
-    rescue EBNF::LL1::Parser::Error, EBNF::LL1::Lexer::Error => e
-      if validate?
-        raise RDF::ReaderError, e.message
-      else
-        $stderr.puts e.message
-      end
-    end
 
-    ##
-    # Iterates the given block for each RDF quad in the input.
-    # This results in flattening each quad into a triple.
-    #
-    # @yield  [subject, predicate, object]
-    # @yieldparam [RDF::Resource] subject
-    # @yieldparam [RDF::URI]      predicate
-    # @yieldparam [RDF::Value]    object
-    # @return [void]
-    def each_triple(&block)
-      if block_given?
-        each_statement do |statement|
-          block.call(*statement.to_triple)
+        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_quad)
+      enum_for(:each_statement)
     end
 
     ##
@@ -311,5 +79,156 @@ module RDF::TriG
       end
       enum_for(:each_quad)
     end
+
+    # add a statement, object can be literal or URI or bnode
+    #
+    # @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(production, statement)
+      error("Statement is invalid: #{statement.inspect.inspect}", production: produciton) if validate? && statement.invalid?
+      statement.context = @graph_name if @graph_name
+      @callback.call(statement) if statement.subject &&
+                                   statement.predicate &&
+                                   statement.object &&
+                                   (validate? ? statement.valid? : true)
+    end
+
+  protected
+    # @return [Object]
+    def read_trigDoc
+      prod(:trigDoc, %(} .)) do
+        read_directive || read_block
+      end
+    end
+
+    # @return [Object]
+    def read_block
+      prod(:block, %(})) do
+        @graph_name = nil
+        token = @lexer.first
+        case token && (token.type || token.value)
+        when :GRAPH
+          @lexer.shift
+          @graph_name = read_labelOrSubject || error("Expected label or subject", production: :block, token: @lexer.first)
+          read_wrappedGraph || error("Expected wrappedGraph", production: :block, token: @lexer.first)
+          @graph_name = nil
+        when :IRIREF, :BLANK_NODE_LABEL, :ANON, :PNAME_LN, :PNAME_NS
+          read_triplesOrGraph || error("Expected triplesOrGraph", production: :block, token: @lexer.first)
+        when '{'
+          read_wrappedGraph || error("Expected wrappedGraph", production: :block, token: @lexer.first)
+        when '(', '['
+          read_triples2 || error("Expected collection or blankNodePropertyList", production: :block, token: @lexer.first)
+        when nil
+          # End of input
+        else
+          error("Unexpected token", production: :block, token: @lexer.first)
+        end
+      end
+    end
+
+    # @return [Object]
+    def read_triplesOrGraph
+      while name = read_labelOrSubject
+        prod(:triplesOrGraph, %(} .)) do
+          token = @lexer.first
+          case token && token.value
+          when '{'
+            @graph_name = name
+            read_wrappedGraph || error("Expected wrappedGraph", production: :triplesOrGraph, token: @lexer.first)
+            @graph_name = nil
+            true
+          else
+            read_predicateObjectList(name) || error("Expected predicateObjectList", production: :triplesOrGraph, token: @lexer.first)
+            unless @recovering
+              # If recovering, we will have eaten the closing '.'
+              token = @lexer.shift
+              unless token && token.value == '.'
+                error("Expected '.' following triple", production: :triplesOrGraph, token: token)
+              end
+            end
+          end
+        end
+      end
+      true
+    end
+
+    # @return [Object]
+    def read_triples2
+      token = @lexer.first
+      case token && token.value
+      when '['
+        prod(:triples2) do
+          # blankNodePropertyList predicateObjectList? 
+          subject = read_blankNodePropertyList || error("Failed to parse blankNodePropertyList", production: :triples2, token: @lexer.first)
+          read_predicateObjectList(subject)
+          if !@recovering || @lexer.first === '.'
+            # If recovering, we will have eaten the closing '.'
+            token = @lexer.shift
+            unless token && token.value == '.'
+              error("Expected '.' following triple", production: :triples2, token: token)
+            end
+          end
+          true
+        end
+      when '('
+        prod(:triples2) do
+          subject = read_collection || error("Failed to parse read_collection", production: :triples2, token: @lexer.first)
+          token = @lexer.first
+          case token && (token.type || token.value)
+          when 'a', :IRIREF, :PNAME_LN, :PNAME_NS then read_predicateObjectList(subject)
+          else error("Expected predicateObjectList after collection subject", production: :triples2, token: token)
+          end
+          if !@recovering || @lexer.first === '.'
+            # If recovering, we will have eaten the closing '.'
+            token = @lexer.shift
+            unless token && token.value == '.'
+              error("Expected '.' following triple", production: :triples2, token: token)
+            end
+          end
+          true
+        end
+      end
+    end
+
+    # @return [Object]
+    def read_wrappedGraph
+      token = @lexer.first
+      if token && token.value == '{'
+        prod(:wrappedGraph, %w(})) do
+          @lexer.shift
+          while read_triplesBlock
+            # Read until nothing found
+          end
+          if !@recovering || @lexer.first === '}'
+            # If recovering, we will have eaten the closing '}'
+            token = @lexer.shift
+            unless token && token.value == '}'
+              error("Expected '}' following triple", production: :wrappedGraph, token: token)
+            end
+          end
+          true
+        end
+      end
+    end
+
+    # @return [Object]
+    def read_triplesBlock
+      prod(:triplesBlock, %w(.)) do
+        while (token = @lexer.first) && token.value != '}' && read_triples
+          break unless @lexer.first === '.'
+          @lexer.shift
+        end
+      end
+    end
+
+    # @return [RDF::Resource]
+    def read_labelOrSubject
+      prod(:labelOrSubject) do
+        read_iri || read_BlankNode
+      end
+    end
+
   end # class Reader
 end # module RDF::Turtle