rdf-turtle 0.0.4 → 0.0.5

data/History

@@ -1,3 +1,12 @@
+### 0.0.5
+* Update turtle and writer specs to use latest version of Turtle specs.
+* Use Spira Manifest w/list to order tests.
+* Change debug to use blocks to reduce computation overhead when not doing debugging, results in a reasonable performance boost.
+
+### 0.0.4
+* Make an un-defined empty prefix an error, rather than treating it as <>.
+* Replace remaining uses of SPARQL with RDF::Turtle or RDF::LL1
+
 ### 0.0.3
  * Completed RDF 1.1 Turtle based on http://www.w3.org/TR/2011/WD-turtle-20110809/
     * Reader

data/README.markdown

@@ -130,6 +130,7 @@ see <http://unlicense.org/> or the accompanying {file:UNLICENSE} file.
 [PDD]:          http://lists.w3.org/Archives/Public/public-rdf-ruby/2010May/0013.html
 [RDF.rb]:       http://rdf.rubyforge.org/
 [Backports]:    http://rubygems.org/gems/backports
+[N-Triples]:    http://www.w3.org/TR/rdf-testcases/#ntriples
 [Turtle]:       http://www.w3.org/TR/2011/WD-turtle-20110809/
 [Turtle doc]:   http://rubydoc.info/github/gkellogg/rdf-turtle/master/file/README.markdown
 [Turtle EBNF]:  http://www.w3.org/2000/10/swap/grammar/turtle.bnf

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/rdf/ll1/parser.rb

@@ -75,7 +75,7 @@ module RDF::LL1
         @patterns ||= []
         @patterns << [term, regexp]  # Passed in order to define evaulation sequence
         @terminal_handlers ||= {}
-        @terminal_handlers[term] = block
+        @terminal_handlers[term] = block if block_given?
         @unescape_terms ||= []
         @unescape_terms << term if options[:unescape]
       end
@@ -187,10 +187,11 @@ module RDF::LL1
             token = @lexer.recover
           end
           @lineno = token.lineno if token
-          debug("parse(production)",
-                "#{token ? token.representation.inspect : 'nil'}, " + 
-                "prod #{todo_stack.last[:prod].inspect}, " + 
-                "depth #{depth}")
+          debug("parse(production)") do
+            "#{token ? token.representation.inspect : 'nil'}, " + 
+            "prod #{todo_stack.last[:prod].inspect}, " + 
+            "depth #{depth}"
+          end
           
           # Got an opened production
           cur_prod = todo_stack.last[:prod]
@@ -200,14 +201,15 @@ module RDF::LL1
           
           if prod_branch = @branch[cur_prod]
             sequence = prod_branch[token.representation]
-            debug("parse(production)",
-                  "#{token.representation.inspect} " +
-                  "prod #{cur_prod.inspect}, " + 
-                  "prod_branch #{prod_branch.keys.inspect}, " +
-                  "sequence #{sequence.inspect}")
+            debug("parse(production)") do
+              "#{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")
+                debug("parse(production)") {"empty sequence for ebnf:empty"}
               else
                 expected = prod_branch.keys.map {|v| v.inspect}.join(", ")
                 error("parse", "expected one of #{expected}",
@@ -227,13 +229,13 @@ module RDF::LL1
           end
         end
         
-        debug("parse(terms)", "todo #{todo_stack.last.inspect}, depth #{depth}")
+        debug("parse(terms)") {"todo #{todo_stack.last.inspect}, depth #{depth}"}
         while !todo_stack.last[:terms].to_a.empty?
           begin
             # Get the next term in this sequence
             term = todo_stack.last[:terms].shift
             if token = accept(term)
-              debug("parse(token)", "#{token.inspect}, term #{term.inspect}")
+              debug("parse(token)") {"#{token.inspect}, term #{term.inspect}"}
               @lineno = token.lineno if token
               onToken(term, token)
             elsif terminals.include?(term)
@@ -245,7 +247,7 @@ module RDF::LL1
             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}
-              debug("parse(push)", "term #{term.inspect}, depth #{depth}")
+              debug("parse(push)") {"term #{term.inspect}, depth #{depth}"}
               pushed = true
               break
             end
@@ -264,7 +266,7 @@ module RDF::LL1
               !todo_stack.empty? &&
               ( todo_stack.last[:terms].to_a.empty? ||
                 (@recovering && @follow[todo_stack.last[:term]].nil?))
-          debug("parse(pop)", "todo #{todo_stack.last.inspect}, depth #{depth}, recovering? #{@recovering.inspect}")
+          debug("parse(pop)") {"todo #{todo_stack.last.inspect}, depth #{depth}, recovering? #{@recovering.inspect}"}
           prod = todo_stack.last[:prod]
           @recovering = false if @follow[prod] # Stop recovering when we might have a match
           todo_stack.pop
@@ -276,7 +278,7 @@ module RDF::LL1
 
       # Continue popping contexts off of the stack
       while !todo_stack.empty?
-        debug("parse(eof)", "stack #{todo_stack.last.inspect}, depth #{depth}")
+        debug("parse(eof)") {"stack #{todo_stack.last.inspect}, depth #{depth}"}
         todo_stack.pop
         onFinish
       end
@@ -297,7 +299,7 @@ module RDF::LL1
       if handler
         # Create a new production data element, potentially allowing handler
         # to customize before pushing on the @prod_data stack
-        progress("#{prod}(:start):#{@prod_data.length}", @prod_data.last)
+        progress("#{prod}(:start):#{@prod_data.length}") {@prod_data.last}
         data = {}
         handler.call(self, :start, @prod_data.last, data, @parse_callback)
         @prod_data << data
@@ -315,7 +317,7 @@ module RDF::LL1
         # Pop production data element from stack, potentially allowing handler to use it
         data = @prod_data.pop
         handler.call(self, :finish, @prod_data.last, data, @parse_callback)
-        progress("#{prod}(:finish):#{@prod_data.length}", @prod_data.last)
+        progress("#{prod}(:finish):#{@prod_data.length}") {@prod_data.last}
       else
         progress("#{prod}(:finish)", '')
       end
@@ -330,9 +332,9 @@ module RDF::LL1
         handler ||= self.class.terminal_handlers[nil] if prod.is_a?(String) # Allows catch-all for simple string terminals
         if handler
           handler.call(self, parentProd, token, @prod_data.last)
-          progress("#{prod}(:token)", "#{token}: #{@prod_data.last}", :depth => (depth + 1))
+          progress("#{prod}(:token)", "", :depth => (depth + 1)) {"#{token}: #{@prod_data.last}"}
         else
-          progress("#{prod}(:token)", token.to_s, :depth => (depth + 1))
+          progress("#{prod}(:token)", "", :depth => (depth + 1)) {token.to_s}
         end
       else
         error("#{parentProd}(:token)", "Token has no parent production", :production => prod)
@@ -343,16 +345,16 @@ module RDF::LL1
     def skip_until_follow(todo_stack)
       debug("recovery", "stack follows:")
       todo_stack.each do |todo|
-        debug("recovery", "  #{todo[:prod]}: #{@follow[todo[:prod]].inspect}")
+        debug("recovery") {"  #{todo[:prod]}: #{@follow[todo[:prod]].inspect}"}
       end
       follows = todo_stack.inject([]) do |follow, todo|
         prod = todo[:prod]
         follow += @follow[prod] || []
       end.uniq
-      progress("recovery", "first #{@lexer.first.inspect}, follows: #{follows.inspect}")
+      progress("recovery") {"first #{@lexer.first.inspect}, follows: #{follows.inspect}"}
       while (token = @lexer.first) && follows.none? {|t| token === t}
         skipped = @lexer.shift
-        progress("recovery", "skip #{skipped.inspect}")
+        progress("recovery") {"skip #{skipped.inspect}"}
       end
     end
 
@@ -375,11 +377,17 @@ module RDF::LL1
 
     ##
     # Progress output when parsing
-    # @param [String] str
-    def progress(node, message, options = {})
+    # @param [String] node Relevant location associated with message
+    # @param [String] message ("")
+    # @param [Hash] options
+    # @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]
       depth = options[:depth] || self.depth
+      message += yield if block_given?
       str = "[#{@lineno}]#{' ' * depth}#{node}: #{message}"
       $stderr.puts("[#{@lineno}]#{' ' * depth}#{node}: #{message}")
     end
@@ -387,12 +395,15 @@ module RDF::LL1
     ##
     # Progress output when debugging
     # @param [String] node Relevant location associated with message
-    # @param [String] message
+    # @param [String] message ("")
     # @param [Hash] options
     # @option options [Integer] :depth
     #   Recursion depth for indenting output
-    def debug(node, message, options = {})
+    # @yieldreturn [String] added to message
+    def debug(node, message = "", options = {})
+      return unless @options[:debug]
       depth = options[:depth] || self.depth
+      message += yield if block_given?
       str = "[#{@lineno}]#{' ' * depth}#{node}: #{message}"
       case @options[:debug]
       when Array
@@ -400,7 +411,7 @@ module RDF::LL1
       when TrueClass
         $stderr.puts str
       when :yield
-        @parse_callback.call(:debug, node, message, options)
+        @parse_callback.call(:trace, node, message, options)
       end
     end
 
@@ -409,7 +420,7 @@ module RDF::LL1
     # @return [Token]
     def accept(type_or_value)
       if (token = @lexer.first) && token === type_or_value
-        debug("accept", "#{token.inspect} === #{type_or_value}.inspect")
+        debug("accept") {"#{token.inspect} === #{type_or_value}.inspect"}
         @lexer.shift
       end
     end

data/lib/rdf/turtle.rb

@@ -7,7 +7,7 @@ module RDF
   # @example Requiring the `RDF::Turtle` module
   #   require 'rdf/turtle'
   #
-  # @example Parsing RDF statements from an N3 file
+  # @example Parsing RDF statements from an Turtle file
   #   RDF::Turtle::Reader.open("etc/foaf.ttl") do |reader|
   #     reader.each_statement do |statement|
   #       puts statement.inspect

data/lib/rdf/turtle/format.rb

@@ -2,14 +2,14 @@ module RDF::Turtle
   ##
   # RDFa format specification.
   #
-  # @example Obtaining an Notation3 format class
+  # @example Obtaining an Turtle format class
   #     RDF::Format.for("etc/foaf.ttl")
   #     RDF::Format.for(:file_name      => "etc/foaf.ttl")
   #     RDF::Format.for(:file_extension => "ttl")
   #     RDF::Format.for(:content_type   => "text/turtle")
   #
   # @example Obtaining serialization format MIME types
-  #     RDF::Format.content_types      #=> {"text/turtle" => [RDF::N3::Format]}
+  #     RDF::Format.content_types      #=> {"text/turtle" => [RDF::Turtle::Format]}
   #
   # @example Obtaining serialization format file extension mappings
   #     RDF::Format.file_extensions    #=> {:ttl => "text/turtle"}
@@ -31,9 +31,9 @@ module RDF::Turtle
   # This allows the following:
   #
   # @example Obtaining an TTL format class
-  #     RDF::Format.for(:ttl)         # RDF::N3::TTL
-  #     RDF::Format.for(:ttl).reader  # RDF::N3::Reader
-  #     RDF::Format.for(:ttl).writer  # RDF::N3::Writer
+  #     RDF::Format.for(:ttl)         # RDF::Turtle::TTL
+  #     RDF::Format.for(:ttl).reader  # RDF::Turtle::Reader
+  #     RDF::Format.for(:ttl).writer  # RDF::Turtle::Writer
   class TTL < RDF::Format
     reader { RDF::Turtle::Reader }
     writer { RDF::Turtle::Writer }

data/lib/rdf/turtle/reader.rb

@@ -180,7 +180,7 @@ module RDF::Turtle
     end
 
     ##
-    # Initializes a new parser instance.
+    # Initializes a new reader instance.
     #
     # @param  [String, #to_s]          input
     # @param  [Hash{Symbol => Object}] options
@@ -206,11 +206,11 @@ module RDF::Turtle
       super do
         @options = {:anon_base => "b0", :validate => false}.merge(options)
 
-        debug("def prefix", "#{base_uri.inspect}")
+        debug("def prefix") {base_uri.inspect}
         
-        debug("validate", "#{validate?.inspect}")
-        debug("canonicalize", "#{canonicalize?.inspect}")
-        debug("intern", "#{intern?.inspect}")
+        debug("validate") {validate?.inspect}
+        debug("canonicalize") {canonicalize?.inspect}
+        debug("intern") {intern?.inspect}
 
         if block_given?
           case block.arity
@@ -271,7 +271,7 @@ module RDF::Turtle
     def add_triple(node, subject, predicate, object)
       statement = RDF::Statement.new(subject, predicate, object)
       if statement.valid?
-        debug(node, "generate statement: #{statement}")
+        debug(node) {"generate statement: #{statement}"}
         @callback.call(statement)
       else
         error(node, "Statement is invalid: #{statement.inspect}")
@@ -297,7 +297,12 @@ module RDF::Turtle
       options = options.dup
       # Internal representation is to not use xsd:string, although it could arguably go the other way.
       options.delete(:datatype) if options[:datatype] == RDF::XSD.string
-      debug("literal", "value: #{value.inspect}, options: #{options.inspect}, validate: #{validate?.inspect}, c14n?: #{canonicalize?.inspect}")
+      debug("literal") do
+        "value: #{value.inspect}, " +
+        "options: #{options.inspect}, " +
+        "validate: #{validate?.inspect}, " +
+        "c14n?: #{canonicalize?.inspect}"
+      end
       RDF::Literal.new(value, options.merge(:validate => validate?, :canonicalize => canonicalize?))
     end
 
@@ -324,7 +329,7 @@ module RDF::Turtle
         base = ''
       end
       suffix = suffix.to_s.sub(/^\#/, "") if base.index("#")
-      debug("pname", "base: '#{base}', suffix: '#{suffix}'")
+      debug("pname") {"base: '#{base}', suffix: '#{suffix}'"}
       process_iri(base + suffix.to_s)
     end
     
@@ -349,9 +354,13 @@ module RDF::Turtle
 
     ##
     # Progress output when debugging
-    # @param [String] str
-    def debug(node, message, options = {})
+    # @param [String] node relative location in input
+    # @param [String] message ("")
+    # @yieldreturn [String] added to message
+    def debug(node, message = "", options = {})
+      return unless @options[:debug] || RDF::Turtle.debug?
       depth = options[:depth] || self.depth
+      message += yield if block_given?
       str = "[#{@lineno}]#{' ' * depth}#{node}: #{message}"
       @options[:debug] << str if @options[:debug].is_a?(Array)
       $stderr.puts(str) if RDF::Turtle.debug?

data/lib/rdf/turtle/version.rb

@@ -0,0 +1,18 @@
+module RDF::Turtle::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
+end

data/lib/rdf/turtle/writer.rb

@@ -9,23 +9,19 @@ module RDF::Turtle
   # and then serialize the graph.
   #
   # @example Obtaining a Turtle writer class
-  #   RDF::Writer.for(:n3)         #=> RDF::Turtle::Writer
-  #   RDF::Writer.for("etc/test.n3")
+  #   RDF::Writer.for(:ttl)         #=> RDF::Turtle::Writer
   #   RDF::Writer.for("etc/test.ttl")
-  #   RDF::Writer.for(:file_name      => "etc/test.n3")
   #   RDF::Writer.for(:file_name      => "etc/test.ttl")
-  #   RDF::Writer.for(:file_extension => "n3")
   #   RDF::Writer.for(:file_extension => "ttl")
-  #   RDF::Writer.for(:content_type   => "text/n3")
   #   RDF::Writer.for(:content_type   => "text/turtle")
   #
   # @example Serializing RDF graph into an Turtle file
-  #   RDF::Turtle::Writer.open("etc/test.n3") do |writer|
+  #   RDF::Turtle::Writer.open("etc/test.ttl") do |writer|
   #     writer << graph
   #   end
   #
   # @example Serializing RDF statements into an Turtle file
-  #   RDF::Turtle::Writer.open("etc/test.n3") do |writer|
+  #   RDF::Turtle::Writer.open("etc/test.ttl") do |writer|
   #     graph.each_statement do |statement|
   #       writer << statement
   #     end
@@ -136,11 +132,10 @@ module RDF::Turtle
     def write_epilogue
       @max_depth = @options[:max_depth] || 3
       @base_uri = RDF::URI(@options[:base_uri])
-      @debug = @options[:debug]
 
       self.reset
 
-      add_debug "\nserialize: graph: #{@graph.size}"
+      debug {"\nserialize: graph: #{@graph.size}"}
 
       preprocess
       start_document
@@ -172,13 +167,13 @@ module RDF::Turtle
         # Use a defined prefix
         prefix = @uri_to_prefix[u]
         prefix(prefix, u) unless u.to_s.empty? # Define for output
-        add_debug "get_pname: add prefix #{prefix.inspect} => #{u}"
+        debug {"get_pname: add prefix #{prefix.inspect} => #{u}"}
         uri.sub(u.to_s, "#{prefix}:")
       when @options[:standard_prefixes] && vocab = RDF::Vocabulary.each.to_a.detect {|v| uri.index(v.to_uri.to_s) == 0}
         prefix = vocab.__name__.to_s.split('::').last.downcase
         @uri_to_prefix[vocab.to_uri.to_s] = prefix
         prefix(prefix, vocab.to_uri) # Define for output
-        add_debug "get_pname: add standard prefix #{prefix.inspect} => #{vocab.to_uri}"
+        debug {"get_pname: add standard prefix #{prefix.inspect} => #{vocab.to_uri}"}
         uri.sub(vocab.to_uri.to_s, "#{prefix}:")
       else
         nil
@@ -200,20 +195,11 @@ module RDF::Turtle
     # @param [Hash{String => Array<Resource>}] properties A hash of Property to Resource mappings
     # @return [Array<String>}] Ordered list of properties. Uses predicate_order.
     def sort_properties(properties)
-      properties.keys.each do |k|
-        properties[k] = properties[k].sort do |a, b|
-          a_li = a.to_s.index(RDF._.to_s) == 0 ? a.to_s.match(/\d+$/).to_s.to_i : a.to_s
-          b_li = b.to_s.index(RDF._.to_s) == 0 ? b.to_s.match(/\d+$/).to_s.to_i : b.to_s
-          
-          a_li <=> b_li
-        end
-      end
-      
       # Make sorted list of properties
       prop_list = []
       
       predicate_order.each do |prop|
-        next unless properties[prop]
+        next unless properties[prop.to_s]
         prop_list << prop.to_s
       end
       
@@ -222,7 +208,7 @@ module RDF::Turtle
         prop_list << prop.to_s
       end
       
-      add_debug "sort_properties: #{prop_list.join(', ')}"
+      debug {"sort_properties: #{prop_list.join(', ')}"}
       prop_list
     end
 
@@ -260,7 +246,7 @@ module RDF::Turtle
     # @return [String]
     def format_uri(uri, options = {})
       md = relativize(uri)
-      add_debug("relativize(#{uri.inspect}) => #{md.inspect}") if md != uri.to_s
+      debug {"relativize(#{uri.inspect}) => #{md.inspect}"} if md != uri.to_s
       md != uri.to_s ? "<#{md}>" : (get_pname(uri) || "<#{uri}>")
     end
     
@@ -281,7 +267,7 @@ module RDF::Turtle
       
       @output.write("#{indent}@base <#{@base_uri}> .\n") unless @base_uri.to_s.empty?
       
-      add_debug("start_document: #{prefixes.inspect}")
+      debug {"start_document: #{prefixes.inspect}"}
       prefixes.keys.sort_by(&:to_s).each do |prefix|
         @output.write("#{indent}@prefix #{prefix}: <#{prefixes[prefix]}> .\n")
       end
@@ -321,7 +307,7 @@ module RDF::Turtle
       # Add distinguished classes
       top_classes.each do |class_uri|
         graph.query(:predicate => RDF.type, :object => class_uri).map {|st| st.subject}.sort.uniq.each do |subject|
-          add_debug "order_subjects: #{subject.inspect}"
+          debug {"order_subjects: #{subject.inspect}"}
           subjects << subject
           seen[subject] = true
         end
@@ -353,7 +339,7 @@ module RDF::Turtle
     # prefixes.
     # @param [Statement] statement
     def preprocess_statement(statement)
-      #add_debug "preprocess: #{statement.inspect}"
+      #debug {"preprocess: #{statement.inspect}"}
       references = ref_count(statement.object) + 1
       @references[statement.object] = references
       @subjects[statement.subject] = true
@@ -408,27 +394,30 @@ module RDF::Turtle
 
     private
     
+    ##
     # Add debug event to debug array, if specified
-    #
-    # @param [String] message::
-    def add_debug(message)
-      STDERR.puts message if ::RDF::Turtle::debug?
-      @debug << message if @debug.is_a?(Array)
+    # @param [String] message ("")
+    # @yieldreturn [String] added to message
+    def debug(message = "", options = {})
+      return unless @options[:debug] || RDF::Turtle.debug?
+      message += yield if block_given?
+      @options[:debug] << message if @options[:debug].is_a?(Array)
+      $stderr.puts(message) if RDF::Turtle.debug?
     end
 
     # Checks if l is a valid RDF list, i.e. no nodes have other properties.
     def is_valid_list(l)
-      #add_debug "is_valid_list: #{l.inspect}"
+      #debug {"is_valid_list: #{l.inspect}"}
       return RDF::List.new(l, @graph).valid?
     end
     
     def do_list(l)
       list = RDF::List.new(l, @graph)
-      add_debug "do_list: #{list.inspect}"
+      debug {"do_list: #{list.inspect}"}
       position = :subject
       list.each_statement do |st|
         next unless st.predicate == RDF.first
-        add_debug " list this: #{st.subject} first: #{st.object}[#{position}]"
+        debug {" list this: #{st.subject} first: #{st.object}[#{position}]"}
         path(st.object, position)
         subject_done(st.subject)
         position = :object
@@ -437,7 +426,7 @@ module RDF::Turtle
     
     def p_list(node, position)
       return false if !is_valid_list(node)
-      #add_debug "p_list: #{node.inspect}, #{position}"
+      #debug {"p_list: #{node.inspect}, #{position}"}
 
       @output.write(position == :subject ? "(" : " (")
       @depth += 2
@@ -455,7 +444,7 @@ module RDF::Turtle
     def p_squared(node, position)
       return false unless p_squared?(node, position)
 
-      #add_debug "p_squared: #{node.inspect}, #{position}"
+      #debug {"p_squared: #{node.inspect}, #{position}"}
       subject_done(node)
       @output.write(position == :subject ? '[' : ' [')
       @depth += 2
@@ -467,18 +456,24 @@ module RDF::Turtle
     end
     
     def p_default(node, position)
-      #add_debug "p_default: #{node.inspect}, #{position}"
+      #debug {"p_default: #{node.inspect}, #{position}"}
       l = (position == :subject ? "" : " ") + format_value(node)
       @output.write(l)
     end
     
     def path(node, position)
-      add_debug "path: #{node.inspect}, pos: #{position}, []: #{is_valid_list(node)}, p2?: #{p_squared?(node, position)}, rc: #{ref_count(node)}"
+      debug do
+        "path: #{node.inspect}, " +
+        "pos: #{position}, " +
+        "[]: #{is_valid_list(node)}, " +
+        "p2?: #{p_squared?(node, position)}, " +
+        "rc: #{ref_count(node)}"
+      end
       raise RDF::WriterError, "Cannot serialize node '#{node}'" unless p_list(node, position) || p_squared(node, position) || p_default(node, position)
     end
     
     def verb(node)
-      add_debug "verb: #{node.inspect}"
+      debug {"verb: #{node.inspect}"}
       if node == RDF.type
         @output.write(" a")
       else
@@ -487,7 +482,7 @@ module RDF::Turtle
     end
     
     def object_list(objects)
-      add_debug "object_list: #{objects.inspect}"
+      debug {"object_list: #{objects.inspect}"}
       return if objects.empty?
 
       objects.each_with_index do |obj, i|
@@ -504,7 +499,7 @@ module RDF::Turtle
       end
 
       prop_list = sort_properties(properties) - [RDF.first.to_s, RDF.rest.to_s]
-      add_debug "predicate_list: #{prop_list.inspect}"
+      debug {"predicate_list: #{prop_list.inspect}"}
       return if prop_list.empty?
 
       prop_list.each_with_index do |prop, i|
@@ -514,7 +509,7 @@ module RDF::Turtle
           verb(prop[0, 2] == "_:" ? RDF::Node.new(prop.split(':').last) : RDF::URI.intern(prop))
           object_list(properties[prop])
         rescue Addressable::URI::InvalidURIError => e
-          add_debug "Predicate #{prop.inspect} is an invalid URI: #{e.message}"
+          debug {"Predicate #{prop.inspect} is an invalid URI: #{e.message}"}
         end
       end
     end
@@ -526,7 +521,7 @@ module RDF::Turtle
     def s_squared(subject)
       return false unless s_squared?(subject)
       
-      add_debug "s_squared: #{subject.inspect}"
+      debug {"s_squared: #{subject.inspect}"}
       @output.write("\n#{indent} [")
       @depth += 1
       predicate_list(subject)
@@ -544,7 +539,7 @@ module RDF::Turtle
     end
     
     def statement(subject)
-      add_debug "statement: #{subject.inspect}, s2?: #{s_squared?(subject)}"
+      debug {"statement: #{subject.inspect}, s2?: #{s_squared?(subject)}"}
       subject_done(subject)
       s_squared(subject) || s_default(subject)
       @output.puts

metadata

@@ -1,77 +1,127 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: rdf-turtle
-version: !ruby/object:Gem::Version
-  version: 0.0.4
+version: !ruby/object:Gem::Version 
+  hash: 21
   prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 5
+  version: 0.0.5
 platform: ruby
-authors:
+authors: 
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-29 00:00:00.000000000Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2011-09-04 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: rdf
-  requirement: &2168942220 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 0
+        - 3
+        - 3
         version: 0.3.3
   type: :runtime
-  prerelease: false
-  version_requirements: *2168942220
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: yard
-  requirement: &2168941620 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 0
+        - 6
+        - 0
         version: 0.6.0
   type: :development
-  prerelease: false
-  version_requirements: *2168941620
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &2168941080 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 2
+        - 5
+        - 0
         version: 2.5.0
   type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdf-n3
   prerelease: false
-  version_requirements: *2168941080
-- !ruby/object:Gem::Dependency
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 25
+        segments: 
+        - 0
+        - 3
+        - 5
+        version: 0.3.5
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: rdf-spec
-  requirement: &2168940600 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 3
+        - 2
         version: 0.3.2
   type: :development
-  prerelease: false
-  version_requirements: *2168940600
-- !ruby/object:Gem::Dependency
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
   name: rdf-isomorphic
-  requirement: &2168940140 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 27
+        segments: 
+        - 0
+        - 3
+        - 4
         version: 0.3.4
   type: :development
-  prerelease: false
-  version_requirements: *2168940140
+  version_requirements: *id006
 description: Turtle reader/writer for Ruby.
 email: public-rdf-ruby@w3.org
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - AUTHORS
 - README.markdown
 - History
@@ -85,31 +135,43 @@ files:
 - lib/rdf/turtle/patches.rb
 - lib/rdf/turtle/reader.rb
 - lib/rdf/turtle/terminals.rb
+- lib/rdf/turtle/version.rb
 - lib/rdf/turtle/writer.rb
 - lib/rdf/turtle.rb
 homepage: http://github.com/gkellogg/rdf-turtle
-licenses:
+licenses: 
 - Public Domain
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 53
+      segments: 
+      - 1
+      - 8
+      - 1
       version: 1.8.1
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: rdf-turtle
 rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Turtle reader/writer for Ruby.
 test_files: []
+