rdf-n3 0.2.3.2 → 0.3.0

data/lib/rdf/n3/reader/parser.rb

@@ -0,0 +1,229 @@
+
+module RDF::N3
+  module Parser
+    START = 'http://www.w3.org/2000/10/swap/grammar/n3#document'
+    R_WHITESPACE = Regexp.compile('\A\s*(?:#.*$)?')
+    R_MLSTRING = Regexp.compile("(\"\"\"[^\"\\\\]*(?:(?:\\\\.|\"(?!\"\"))[^\"\\\\]*)*\"\"\")")
+    SINGLE_CHARACTER_SELECTORS = %{\t\r\n !\"#$\%&'()*.,+/;<=>?[\\]^`{|}~}
+    NOT_QNAME_CHARS = SINGLE_CHARACTER_SELECTORS + "@"
+    NOT_NAME_CHARS = NOT_QNAME_CHARS + ":"
+    
+    def error(str)
+      raise RDF::ReaderError, "\n#{@line}\n#{'-' * @pos}^\nError on line #{@lineno} at offset #{@pos}: #{str}"
+    end
+    
+    def parse(prod)
+      todo_stack = [{:prod => prod, :terms => nil}]
+      while !todo_stack.empty?
+        pushed = false
+        if todo_stack.last[:terms].nil?
+          todo_stack.last[:terms] = []
+          tok = self.token
+          #puts "parse tok: '#{tok}', prod #{todo_stack.last[:prod]}"
+          
+          # Got an opened production
+          onStart(abbr(todo_stack.last[:prod]))
+          break if tok.nil?
+          
+          cur_prod = todo_stack.last[:prod]
+          prod_branch = @branches[cur_prod]
+          error("No branches found for '#{abbr(cur_prod)}'") if prod_branch.nil?
+          sequence = prod_branch[tok]
+          if sequence.nil?
+            dump_stack(todo_stack) if $verbose
+            expected = prod_branch.values.uniq.map {|u| u.map {|v| abbr(v).inspect}.join(",")}
+            error("Found '#{tok}' when parsing a #{abbr(cur_prod)}. expected #{expected.join(' | ')}")
+          end
+          #puts "sequence: #{sequence.inspect}"
+          todo_stack.last[:terms] += sequence
+        end
+        
+        #puts "parse: #{todo_stack.last.inspect}"
+        while !todo_stack.last[:terms].to_a.empty?
+          term = todo_stack.last[:terms].shift
+          if term.is_a?(String)
+            puts "parse term(string): #{term}" if $verbose
+            word = buffer[0, term.length]
+            if word == term
+              onToken(term, word)
+              consume(term.length)
+            elsif '@' + word.chop == term && @keywords.include?(word.chop)
+              onToken(term, word.chop)
+              consume(term.length - 1)
+            else
+              error("Found '#{buffer[0, 10]}...'; #{term} expected")
+            end
+          elsif regexp = @regexps[term]
+            if abbr(term) == 'string' && buffer[0, 3] == '"""'
+              # Read until end of multi-line comment if this is the start of a multi-line comment
+              until R_MLSTRING.match(buffer)
+                begin
+                  next_line = @input.readline
+                  @line += next_line
+                  @lineno += 1
+                rescue EOFError => e
+                  error("EOF reached searching for end of multi-line comment")
+                end
+              end
+              #puts "ml-str now #{buffer.dump}"
+            end
+            md = regexp.match(buffer)
+            error("Token(#{abbr(term)}) '#{buffer[0, 10]}...' should match #{regexp}") unless md
+            puts "parse term(#{abbr(term)}:regexp): #{term}, #{regexp}.match('#{buffer[0, 10]}...') => '#{md.inspect}'" if $verbose
+            onToken(abbr(term), md.to_s)
+            consume(md[0].length)
+          else
+            puts "parse term(push): #{term}" if $verbose
+            todo_stack << {:prod => term, :terms => nil}
+            pushed = true
+            break
+          end
+          self.token
+        end
+        
+        while !pushed && todo_stack.last[:terms].to_a.empty?
+          todo_stack.pop
+          self.onFinish
+        end
+      end
+      while !todo_stack.empty?
+        todo_stack.pop
+        self.onFinish
+      end
+    end
+
+    # Memoizer for get_token
+    def token
+      unless @memo.has_key?(@pos)
+        tok = self.get_token
+        @memo[@pos] = tok
+        puts "token: '#{tok}'('#{buffer[0, 10]}...')" if buffer && $verbose
+      end
+      @memo[@pos]
+    end
+
+    def get_token
+      whitespace
+      
+      return nil if buffer.nil?
+      
+      ch2 = buffer[0, 2]
+      return ch2 if %w(=> <= ^^).include?(ch2)
+      
+      ch = buffer[0, 1]
+      @keyword_mode = false if ch == '.' && @keyword_mode
+      
+      return ch if SINGLE_CHARACTER_SELECTORS.include?(ch)
+      return ":" if ch == ":"
+      return "0" if "+-0123456789".include?(ch)
+      
+      if ch == '@'
+        return '@' if @pos > 0 && @line[@pos-1, 1] == '"'
+
+        j = 0
+        j += 1 while buffer[j+1, 1] && !NOT_NAME_CHARS.include?(buffer[j+1, 1])
+        name = buffer[1, j]
+        if name == 'keywords'
+          @keywords = []
+          @keyword_mode = true
+        end
+        return '@' + name
+      end
+
+      j = 0
+      j += 1 while buffer[j, 1] && !NOT_QNAME_CHARS.include?(buffer[j, 1])
+      word = buffer[0, j]
+      error("Tokenizer expected qname, found #{buffer[0, 10]}") unless word
+      if @keyword_mode
+        @keywords << word
+      elsif @keywords.include?(word)
+        if word == 'keywords'
+          @keywords = []
+          @keyword_mode = true
+        end
+        return '@' + word.to_s # implicit keyword
+      end
+
+      'a'
+    end
+    
+    def whitespace
+      while buffer && md = R_WHITESPACE.match(buffer)
+        return unless md[0].length > 0
+        consume(md[0].length)
+        #puts "ws: '#{md[0]}', pos=#{@pos}"
+      end
+    end
+    
+    def readline
+      @line = @input.readline
+      @lineno += 1
+      @line.force_encoding(Encoding::UTF_8) if @line.respond_to?(:force_encoding) # for Ruby 1.9+
+      puts "readline[#{@lineno}]: '#{@line}'" if $verbose
+      @pos = 0
+      @line
+    rescue EOFError => e
+      @line, @pos = nil, 0
+    end
+    
+    # Return data from current off set to end of line
+    def buffer
+      @line[@pos, @line.length - @pos] unless @line.nil?
+    end
+    
+    # Cause n characters of line to be consumed. Read new line while line is empty or until eof
+    def consume(n)
+      @memo = {}
+      @pos += n
+      readline while @line && @line.length <= @pos
+      #puts "consume[#{n}]: '#{buffer}'" if $verbose
+    end
+    
+    def abbr(prodURI)
+      prodURI.to_s.split('#').last
+    end
+    
+    def onStart(prod)
+      $stdout.puts ' ' * @productions.length + prod
+      @productions << prod
+    end
+
+    def onFinish
+      prod = @productions.pop()
+      $stdout.puts ' ' * @productions.length + '/' + prod
+    end
+
+    def onToken(prod, tok)
+      $stdout.puts ' ' * @productions.length + "#{prod}(#{tok})"
+    end
+    
+    def dump_stack(stack)
+      STDERR.puts "\nstack trace:"
+      stack.reverse.each do |se|
+        STDERR.puts "#{se[:prod]}"
+        STDERR.puts "  " + case se[:terms]
+        when nil then "nil"
+        when [] then "empty"
+        else          se[:terms].join(",\n  ")
+        end
+      end
+    end
+    
+    def test(input, branches, regexps)
+      # FIXME: for now, read in entire doc, eventually, process as stream
+      @input = input.respond_to?(:read) ? (input.rewind; input) : StringIO.new(input.to_s)
+      @lineno = 0
+      readline  # Prime the pump
+      $stdout ||= STDOUT
+      
+      @memo = {}
+      @keyword_mode = false
+      @keywords = %w(a is of this has)
+      @productions = []
+
+      @branches = branches
+      @regexps = regexps
+      parse(START.to_sym)
+    end
+  end
+end

data/lib/rdf/n3/vocab.rb

@@ -1,3 +1,4 @@
 module RDF
   class LOG < Vocabulary("http://www.w3.org/2000/10/swap/log#"); end
+  class REI < Vocabulary("http://www.w3.org/2004/06/rei#"); end
 end

data/lib/rdf/n3/writer.rb

@@ -38,63 +38,94 @@ module RDF::N3
   #     end
   #   end
   #
+  # The writer will add prefix definitions, and use them for creating @prefix definitions, and minting QNames
+  #
+  # @example Creating @base and @prefix definitions in output
+  #   RDF::N3::Writer.buffer(:base_uri => "http://example.com/", :prefixes => {
+  #       nil => "http://example.com/ns#",
+  #       :foaf => "http://xmlns.com/foaf/0.1/"}
+  #   ) do |writer|
+  #     graph.each_statement do |statement|
+  #       writer << statement
+  #     end
+  #   end
+  #
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Writer < RDF::Writer
     format RDF::N3::Format
 
-    SUBJECT = 0
-    VERB = 1
-    OBJECT = 2
-
-    attr_accessor :graph, :base_uri
-
+    # @return [Graph] Graph of statements serialized
+    attr_accessor :graph
+    # @return [URI] Base URI used for relativizing URIs
+    attr_accessor :base_uri
+    
     ##
     # Initializes the Turtle writer instance.
     #
-    # Opitons:
-    # max_depth:: Maximum depth for recursively defining resources, defaults to 3
-    # base_uri:: Base URI of graph, used to shorting URI references
-    # default_namespace:: URI to use as default namespace
-    #
-    # @param  [IO, File]               output
+    # @param  [IO, File] output
+    #   the output stream
     # @param  [Hash{Symbol => Object}] options
-    #   @option options [Integer]       :max_depth      (nil)
-    #   @option options [String, #to_s] :base_uri (nil)
-    #   @option options [String, #to_s] :lang   (nil)
-    #   @option options [Array]         :attributes   (nil)
-    #   @option options [String]        :default_namespace
+    #   any additional options
+    # @option options [Encoding] :encoding     (Encoding::UTF_8)
+    #   the encoding to use on the output stream (Ruby 1.9+)
+    # @option options [Boolean]  :canonicalize (false)
+    #   whether to canonicalize literals when serializing
+    # @option options [Hash]     :prefixes     (Hash.new)
+    #   the prefix mappings to use (not supported by all writers)
+    # @option options [#to_s]    :base_uri     (nil)
+    #   the base URI to use when constructing relative URIs
+    # @option options [Integer]  :max_depth      (3)
+    #   Maximum depth for recursively defining resources, defaults to 3
+    # @option options [Boolean]  :standard_prefixes   (false)
+    #   Add standard prefixes to @prefixes, if necessary.
+    # @option options [String]   :default_namespace (nil)
+    #   URI to use as default namespace, same as prefixes[nil]
+    # @yield  [writer] `self`
+    # @yieldparam  [RDF::Writer] writer
+    # @yieldreturn [void]
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
     def initialize(output = $stdout, options = {}, &block)
-      @graph = RDF::Graph.new
-      @stream = output
-      super
+      super do
+        @graph = RDF::Graph.new
+        @uri_to_qname = {}
+        prefix(nil, @options[:default_namespace]) if @options[:default_namespace]
+        if block_given?
+          case block.arity
+            when 0 then instance_eval(&block)
+            else block.call(self)
+          end
+        end
+      end
     end
 
     ##
+    # Write whole graph
+    #
     # @param  [Graph] graph
     # @return [void]
-    def insert_graph(graph)
+    def write_graph(graph)
       @graph = graph
     end
 
     ##
-    # @param  [Statement] statement
+    # Addes a statement to be serialized
+    # @param  [RDF::Statement] statement
     # @return [void]
-    def insert_statement(statement)
-      @graph << statement
+    def write_statement(statement)
+      @graph.insert(statement)
     end
 
     ##
-    # Stores the RDF/XML representation of a triple.
-    #
+    # Addes a triple to be serialized
     # @param  [RDF::Resource] subject
     # @param  [RDF::URI]      predicate
     # @param  [RDF::Value]    object
     # @return [void]
-    # @see    #write_epilogue
-    def insert_triple(subject, predicate, object)
-      @graph << RDF::Statement.new(subject, predicate, object)
+    # @raise  [NotImplementedError] unless implemented in subclass
+    # @abstract
+    def write_triple(subject, predicate, object)
+      @graph.insert(Statement.new(subject, predicate, object))
     end
 
     ##
@@ -106,69 +137,285 @@ module RDF::N3
       @max_depth = @options[:max_depth] || 3
       @base_uri = @options[:base_uri]
       @debug = @options[:debug]
-      @default_namespace = @options[:default_namespace]
 
       self.reset
 
       add_debug "\nserialize: graph: #{@graph.size}"
 
-      add_namespace("", @default_namespace) if @default_namespace
-
       preprocess
       start_document
 
       order_subjects.each do |subject|
-        #puts "subj: #{subject.inspect}"
+        #STDERR.puts "subj: #{subject.inspect}"
         unless is_done?(subject)
           statement(subject)
         end
       end
     end
     
+    # Return a QName for the URI, or nil. Adds namespace of QName to defined prefixes
+    # @param [URI,#to_s] uri
+    # @return [Array<Symbol,Symbol>, nil] Prefix, Suffix pair or nil, if none found
+    def get_qname(uri)
+      uri = RDF::URI.intern(uri.to_s) unless uri.is_a?(URI)
+
+      unless @uri_to_qname.has_key?(uri)
+        # Find in defined prefixes
+        prefixes.each_pair do |prefix, vocab|
+          if uri.to_s.index(vocab.to_s) == 0
+            local_name = uri.to_s[(vocab.to_s.length)..-1]
+            add_debug "get_qname(ns): #{prefix}:#{local_name}"
+            return @uri_to_qname[uri] = [prefix, local_name.to_sym]
+          end
+        end
+        
+        # Use a default vocabulary
+        if @options[:standard_prefixes] && vocab = RDF::Vocabulary.detect {|v| uri.to_s.index(v.to_uri.to_s) == 0}
+          prefix = vocab.__name__.to_s.split('::').last.downcase
+          prefixes[prefix.to_sym] = vocab.to_uri
+          suffix = uri.to_s[vocab.to_uri.to_s.size..-1]
+          return @uri_to_qname[uri] = [prefix.to_sym, suffix.empty? ? nil : suffix.to_sym] if prefix && suffix
+        end
+        
+        @uri_to_qname[uri] = nil
+      end
+      
+      @uri_to_qname[uri]
+    rescue Addressable::URI::InvalidURIError => e
+       @uri_to_qname[uri] = nil
+    end
+    
+    # Take a hash from predicate uris to lists of values.
+    # Sort the lists of values.  Return a sorted list of properties.
+    # @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.is_a?(RDF::URI) && get_qname(a) && get_qname(a).last.to_s =~ /^_\d+$/ ? a.to_i : a.to_s
+          b_li = b.is_a?(RDF::URI) && get_qname(b) && get_qname(b).last.to_s =~ /^_\d+$/ ? b.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]
+        prop_list << prop.to_s
+      end
+      
+      properties.keys.sort.each do |prop|
+        next if prop_list.include?(prop.to_s)
+        prop_list << prop.to_s
+      end
+      
+      add_debug "sort_properties: #{prop_list.to_sentence}"
+      prop_list
+    end
+
+    ##
+    # Returns the N-Triples representation of a literal.
+    #
+    # @param  [RDF::Literal, String, #to_s] literal
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    def format_literal(literal, options = {})
+      case literal
+        when RDF::Literal
+          text = quoted(literal.value)
+          text << "@#{literal.language}" if literal.has_language?
+          text << "^^#{format_uri(literal.datatype)}" if literal.has_datatype?
+          text
+        else
+          quoted(literal.to_s)
+      end
+    end
+    
+    ##
+    # Returns the Turtle/N3 representation of a URI reference.
+    #
+    # @param  [RDF::URI] literal
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    def format_uri(uri, options = {})
+      md = relativize(uri)
+      if md && md != uri.to_s
+        "<%s>" % md
+      elsif qname = get_qname(uri)
+        qname.map(&:to_s).join(":")
+      else
+        "<%s>" % uri_for(uri)
+      end
+    end
+    
+    ##
+    # Returns the Turtle/N3 representation of a blank node.
+    #
+    # @param  [RDF::Node] node
+    # @param  [Hash{Symbol => Object}] options
+    # @return [String]
+    def format_node(node, options = {})
+      "_:%s" % node.id
+    end
+    
     protected
+    # Output @base and @prefix definitions
     def start_document
       @started = true
       
-      write("#{indent}@base <#{@base_uri}> .\n") if @base_uri
+      @output.write("#{indent}@base <#{@base_uri}> .\n") if @base_uri
+      
+      add_debug("start_document: #{prefixes.inspect}")
+      prefixes.keys.sort_by(&:to_s).each do |prefix|
+        @output.write("#{indent}@prefix #{prefix}: <#{prefixes[prefix]}> .\n")
+      end
+    end
+    
+    # If @base_uri is defined, use it to try to make uri relative
+    # @param [#to_s] uri
+    # @return [String]
+    def relativize(uri)
+      uri = uri.to_s
+      @base_uri ? uri.sub(@base_uri.to_s, "") : uri
+    end
+
+    # Defines rdf:type of subjects to be emitted at the beginning of the graph. Defaults to rdfs:Class
+    # @return [Array<URI>]
+    def top_classes; [RDF::RDFS.Class]; end
+
+    # Defines order of predicates to to emit at begninning of a resource description. Defaults to
+    # [rdf:type, rdfs:label, dc:title]
+    # @return [Array<URI>]
+    def predicate_order; [RDF.type, RDF::RDFS.label, RDF::DC.title]; end
+    
+    # Order subjects for output. Override this to output subjects in another order.
+    #
+    # Uses top_classes
+    # @return [Array<Resource>] Ordered list of subjects
+    def order_subjects
+      seen = {}
+      subjects = []
       
-      add_debug("start_document: #{@namespaces.inspect}")
-      @namespaces.keys.sort.each do |prefix|
-        write("#{indent}@prefix #{prefix}: <#{@namespaces[prefix]}> .\n")
+      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}"
+          subjects << subject
+          seen[subject] = @top_levels[subject] = true
+        end
       end
+      
+      # Sort subjects by resources over bnodes, ref_counts and the subject URI itself
+      recursable = @subjects.keys.
+        select {|s| !seen.include?(s)}.
+        map {|r| [r.is_a?(RDF::Node) ? 1 : 0, ref_count(r), r]}.
+        sort
+      
+      subjects += recursable.map{|r| r.last}
+    end
+    
+    # Perform any preprocessing of statements required
+    def preprocess
+      @graph.each {|statement| preprocess_statement(statement)}
     end
     
-    def end_document
-      write("\n")
+    # Perform any statement preprocessing required. This is used to perform reference counts and determine required
+    # prefixes.
+    # @param [Statement] statement
+    def preprocess_statement(statement)
+      #add_debug "preprocess: #{statement.inspect}"
+      references = ref_count(statement.object) + 1
+      @references[statement.object] = references
+      @subjects[statement.subject] = true
+      
+      # Pre-fetch qnames, to fill prefixes
+      get_qname(statement.subject)
+      get_qname(statement.predicate)
+      get_qname(statement.object)
+
+      @references[statement.predicate] = ref_count(statement.predicate) + 1
+    end
+    
+    # Return the number of times this node has been referenced in the object position
+    # @return [Integer]
+    def ref_count(node)
+      @references.fetch(node, 0)
+    end
+
+    # Returns indent string multiplied by the depth
+    # @param [Integer] modifier Increase depth by specified amount
+    # @return [String] A number of spaces, depending on current depth
+    def indent(modifier = 0)
+      " " * (@depth + modifier)
+    end
+
+    # Reset internal helper instance variables
+    def reset
+      @depth = 0
+      @lists = {}
+      @namespaces = {}
+      @references = {}
+      @serialized = {}
+      @subjects = {}
+      @top_levels = {}
+      @shortNames = {}
+      @started = false
+    end
+
+    ##
+    # Use single- or multi-line quotes. If literal contains \t, \n, or \r, use a multiline quote,
+    # otherwise, use a single-line
+    # @param  [String] string
+    # @return [String]
+    def quoted(string)
+      if string.to_s.match(/[\t\n\r]/)
+        string = string.gsub('\\', '\\\\').gsub('"""', '\\"""')
+        %("""#{string}""")
+      else
+        "\"#{escaped(string)}\""
+      end
     end
+
+    private
     
+    # Add debug event to debug array, if specified
+    #
+    # @param [String] message::
+    def add_debug(message)
+      STDERR.puts message if ::RDF::N3::debug?
+      @debug << message if @debug.is_a?(Array)
+    end
+
     # Checks if l is a valid RDF list, i.e. no nodes have other properties.
     def is_valid_list(l)
       props = @graph.properties(l)
-      #puts "is_valid_list: #{props.inspect}" if ::RDF::N3::debug?
+      #STDERR.puts "is_valid_list: #{props.inspect}" if ::RDF::N3::debug?
       return false unless props.has_key?(RDF.first.to_s) || l == RDF.nil
       while l && l != RDF.nil do
-        #puts "is_valid_list(length): #{props.length}" if ::RDF::N3::debug?
+        #STDERR.puts "is_valid_list(length): #{props.length}" if ::RDF::N3::debug?
         return false unless props.has_key?(RDF.first.to_s) && props.has_key?(RDF.rest.to_s)
         n = props[RDF.rest.to_s]
-        #puts "is_valid_list(n): #{n.inspect}" if ::RDF::N3::debug?
+        #STDERR.puts "is_valid_list(n): #{n.inspect}" if ::RDF::N3::debug?
         return false unless n.is_a?(Array) && n.length == 1
         l = n.first
         props = @graph.properties(l)
       end
-      #puts "is_valid_list: valid" if ::RDF::N3::debug?
+      #STDERR.puts "is_valid_list: valid" if ::RDF::N3::debug?
       true
     end
     
     def do_list(l)
-      puts "do_list: #{l.inspect}" if ::RDF::N3::debug?
-      position = SUBJECT
+      STDERR.puts "do_list: #{l.inspect}" if ::RDF::N3::debug?
+      position = :subject
       while l do
         p = @graph.properties(l)
         item = p.fetch(RDF.first.to_s, []).first
         if item
           path(item, position)
           subject_done(l)
-          position = OBJECT
+          position = :object
         end
         l = p.fetch(RDF.rest.to_s, []).first
       end
@@ -176,13 +423,13 @@ module RDF::N3
     
     def p_list(node, position)
       return false if !is_valid_list(node)
-      #puts "p_list: #{node.inspect}, #{position}" if ::RDF::N3::debug?
+      #STDERR.puts "p_list: #{node.inspect}, #{position}" if ::RDF::N3::debug?
 
-      write(position == SUBJECT ? "(" : " (")
+      @output.write(position == :subject ? "(" : " (")
       @depth += 2
       do_list(node)
       @depth -= 2
-      write(')')
+      @output.write(')')
     end
     
     def p_squared?(node, position)
@@ -194,57 +441,62 @@ module RDF::N3
     def p_squared(node, position)
       return false unless p_squared?(node, position)
 
-      #puts "p_squared: #{node.inspect}, #{position}" if ::RDF::N3::debug?
+      #STDERR.puts "p_squared: #{node.inspect}, #{position}" if ::RDF::N3::debug?
       subject_done(node)
-      write(position == SUBJECT ? '[' : ' [')
+      @output.write(position == :subject ? '[' : ' [')
       @depth += 2
       predicate_list(node)
       @depth -= 2
-      write(']')
+      @output.write(']')
       
       true
     end
     
     def p_default(node, position)
-      #puts "p_default: #{node.inspect}, #{position}" if ::RDF::N3::debug?
-      l = (position == SUBJECT ? "" : " ") + format_value(node)
-      write(l)
+      #STDERR.puts "p_default: #{node.inspect}, #{position}" if ::RDF::N3::debug?
+      l = (position == :subject ? "" : " ") + format_value(node)
+      @output.write(l)
     end
     
     def path(node, position)
-      puts "path: #{node.inspect}, pos: #{position}, []: #{is_valid_list(node)}, p2?: #{p_squared?(node, position)}, rc: #{ref_count(node)}" if ::RDF::N3::debug?
+      STDERR.puts "path: #{node.inspect}, pos: #{position}, []: #{is_valid_list(node)}, p2?: #{p_squared?(node, position)}, rc: #{ref_count(node)}" if ::RDF::N3::debug?
       raise RDF::WriterError, "Cannot serialize node '#{node}'" unless p_list(node, position) || p_squared(node, position) || p_default(node, position)
     end
     
     def verb(node)
-      puts "verb: #{node.inspect}" if ::RDF::N3::debug?
+      STDERR.puts "verb: #{node.inspect}" if ::RDF::N3::debug?
       if node == RDF.type
-        write(" a")
+        @output.write(" a")
       else
-        path(node, VERB)
+        path(node, :predicate)
       end
     end
     
     def object_list(objects)
-      puts "object_list: #{objects.inspect}" if ::RDF::N3::debug?
+      STDERR.puts "object_list: #{objects.inspect}" if ::RDF::N3::debug?
       return if objects.empty?
 
       objects.each_with_index do |obj, i|
-        write(",\n#{indent(2)}") if i > 0
-        path(obj, OBJECT)
+        @output.write(",\n#{indent(2)}") if i > 0
+        path(obj, :object)
       end
     end
     
     def predicate_list(subject)
       properties = @graph.properties(subject)
       prop_list = sort_properties(properties) - [RDF.first.to_s, RDF.rest.to_s]
-      puts "predicate_list: #{prop_list.inspect}" if ::RDF::N3::debug?
+      STDERR.puts "predicate_list: #{prop_list.inspect}" if ::RDF::N3::debug?
       return if prop_list.empty?
 
       prop_list.each_with_index do |prop, i|
-        write(";\n#{indent(2)}") if i > 0
-        verb(RDF::URI.new(prop))
-        object_list(properties[prop])
+        begin
+          @output.write(";\n#{indent(2)}") if i > 0
+          prop[0, 2] == "_:"
+          verb(prop[0, 2] == "_:" ? RDF::Node.new(prop.split(':').last) : RDF::URI.intern(prop))
+          object_list(properties[prop])
+        rescue Addressable::URI::InvalidURIError => e
+          STDERR.puts "Predicate #{prop.inspect} is an invalid URI: #{e.message}"
+        end
       end
     end
     
@@ -255,39 +507,28 @@ module RDF::N3
     def s_squared(subject)
       return false unless s_squared?(subject)
       
-      write("\n#{indent} [")
+      @output.write("\n#{indent} [")
       @depth += 1
       predicate_list(subject)
       @depth -= 1
-      write("] .")
+      @output.write("] .")
       true
     end
     
     def s_default(subject)
-      write("\n#{indent}")
-      path(subject, SUBJECT)
+      @output.write("\n#{indent}")
+      path(subject, :subject)
       predicate_list(subject)
-      write(" .")
+      @output.write(" .")
       true
     end
     
-    def relativize(uri)
-      uri = uri.to_s
-      @base_uri ? uri.sub(@base_uri.to_s, "") : uri
-    end
-
     def statement(subject)
-      puts "statement: #{subject.inspect}, s2?: #{s_squared(subject)}" if ::RDF::N3::debug?
+      STDERR.puts "statement: #{subject.inspect}, s2?: #{s_squared(subject)}" if ::RDF::N3::debug?
       subject_done(subject)
       s_squared(subject) || s_default(subject)
     end
     
-    MAX_DEPTH = 10
-    INDENT_STRING = " "
-    
-    def top_classes; [RDF::RDFS.Class]; end
-    def predicate_order; [RDF.type, RDF::RDFS.label, RDF::DC.title]; end
-    
     def is_done?(subject)
       @serialized.include?(subject)
     end
@@ -296,187 +537,5 @@ module RDF::N3
     def subject_done(subject)
       @serialized[subject] = true
     end
-    
-    def order_subjects
-      seen = {}
-      subjects = []
-      
-      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}"
-          subjects << subject
-          seen[subject] = @top_levels[subject] = true
-        end
-      end
-      
-      # Sort subjects by resources over bnodes, ref_counts and the subject URI itself
-      recursable = @subjects.keys.
-        select {|s| !seen.include?(s)}.
-        map {|r| [r.is_a?(RDF::Node) ? 1 : 0, ref_count(r), r]}.
-        sort
-      
-      subjects += recursable.map{|r| r.last}
-    end
-    
-    def preprocess
-      @graph.each {|statement| preprocess_statement(statement)}
-    end
-    
-    def preprocess_statement(statement)
-      #add_debug "preprocess: #{statement.inspect}"
-      references = ref_count(statement.object) + 1
-      @references[statement.object] = references
-      @subjects[statement.subject] = true
-      
-      # Pre-fetch qnames, to fill namespaces
-      get_qname(statement.subject)
-      get_qname(statement.predicate)
-      get_qname(statement.object)
-
-      @references[statement.predicate] = ref_count(statement.predicate) + 1
-    end
-    
-    # Return the number of times this node has been referenced in the object position
-    def ref_count(node)
-      @references.fetch(node, 0)
-    end
-
-    # Return a QName for the URI, or nil. Adds namespace of QName to defined namespaces
-    def get_qname(uri)
-      if uri.is_a?(RDF::URI)
-        md = relativize(uri)
-        return "<#{md}>" unless md == uri.to_s
-
-        # Duplicate logic from URI#qname to remember namespace assigned
-
-        if uri.qname
-          return ":#{uri.qname.last}" if uri.vocab == @default_namespace
-          add_namespace(uri.qname.first, uri.vocab)
-          add_debug "get_qname(uri.qname): #{uri.qname.join(':')}"
-          return uri.qname.join(":") 
-        end
-        
-        # No vocabulary assigned, find one from cache of created namespace URIs
-        @namespaces.each_pair do |prefix, vocab|
-          if uri.to_s.index(vocab.to_s) == 0
-            uri.vocab = vocab
-            local_name = uri.to_s[(vocab.to_s.length)..-1]
-            if vocab == @default_namespace
-              add_debug "get_qname(ns): :#{local_name}"
-              return ":#{local_name}"
-            else
-              add_debug "get_qname(ns): #{prefix}:#{local_name}"
-              return "#{prefix}:#{local_name}"
-            end
-          end
-        end
-        
-        nil
-      end
-    end
-    
-    def add_namespace(prefix, ns)
-      return if @namespaces.has_key?(prefix.to_s)
-      uri = (ns.respond_to?(:to_uri) ? ns.to_uri : ns).to_s
-      add_debug "add_namespace: '#{prefix}', <#{uri}>"
-      @namespaces[prefix.to_s] = uri
-    end
-
-    def reset
-      @depth = 0
-      @lists = {}
-      @namespaces = {}
-      @references = {}
-      @serialized = {}
-      @subjects = {}
-      @top_levels = {}
-      @shortNames = {}
-      @started = false
-    end
-
-    # Take a hash from predicate uris to lists of values.
-    # Sort the lists of values.  Return a sorted list of properties.
-    def sort_properties(properties)
-      properties.keys.each do |k|
-        properties[k] = properties[k].sort do |a, b|
-          a_li = a.is_a?(RDF::URI) && a.qname && a.qname.last =~ /^_\d+$/ ? a.to_i : a.to_s
-          b_li = b.is_a?(RDF::URI) && b.qname && b.qname.last =~ /^_\d+$/ ? b.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]
-        prop_list << prop.to_s
-      end
-      
-      properties.keys.sort.each do |prop|
-        next if prop_list.include?(prop.to_s)
-        prop_list << prop.to_s
-      end
-      
-      add_debug "sort_properties: #{prop_list.to_sentence}"
-      prop_list
-    end
-
-    # Add debug event to debug array, if specified
-    #
-    # @param [String] message::
-    def add_debug(message)
-      STDERR.puts message if ::RDF::N3::debug?
-      @debug << message if @debug.is_a?(Array)
-    end
-
-    # Returns indent string multiplied by the depth
-    def indent(modifier = 0)
-      INDENT_STRING * (@depth + modifier)
-    end
-
-    # Write text
-    def write(text)
-      @stream.write(text)
-    end
-    
-    ##
-    # Returns the N-Triples representation of a literal.
-    #
-    # @param  [RDF::Literal, String, #to_s] literal
-    # @param  [Hash{Symbol => Object}] options
-    # @return [String]
-    def format_literal(literal, options = {})
-      case literal
-        when RDF::Literal
-          text = quoted(literal.value)
-          text << "@#{literal.language}" if literal.has_language?
-          text << "^^#{format_uri(literal.datatype)}" if literal.has_datatype?
-          text
-        else
-          quoted(literal.to_s)
-      end
-    end
-    
-    ##
-    # Returns the Turtle/N3 representation of a URI reference.
-    #
-    # @param  [RDF::URI] literal
-    # @param  [Hash{Symbol => Object}] options
-    # @return [String]
-    def format_uri(uri, options = {})
-      get_qname(uri) || "<%s>" % uri_for(uri)
-    end
-    
-    ##
-    # Returns the Turtle/N3 representation of a blank node.
-    #
-    # @param  [RDF::Node] node
-    # @param  [Hash{Symbol => Object}] options
-    # @return [String]
-    def format_node(node, options = {})
-      "_:%s" % node.id
-    end
   end
 end