rdf_context 0.4.8 → 0.5.0

data/History.txt

@@ -1,3 +1,30 @@
+=== 0.5.0
+* Support for Ruby 1.9, 1.8.7 and 1.8.6.
+  * Unicode escapes and URIRefs only work properly in Ruby 1.9
+  * Replaced some (&:meth) spells with {|c| c.meth} for Ruby 1.8.6 compatibility
+* Fully compliant N3 parser (n3-rdf level) with extnensive tests, including SWAP, CWM and Turtle test suites.
+  * Supports paths, keywords, all semantic expressions.
+  * No support yet for Formulae, variables, rules or automatic reification
+  * Allow Triple#subject to be like an object, allowing literals and graphs
+  * Allow Triple#predicate to be a BNode as well as a URIRef
+* Graph changes
+  * Graph#properties(subject) returns properties of a subject expressed as a hash to arrays of objects.
+  * Graph#seq(subject) returns ordered rdf:_n objects if subject is a rdf:Seq., or list of rdf:first/rdf:rest
+  * Graph#qname(uri) as alternative to uri.qname, has namespaces available.
+  * Graph#type_of(subject) array of RDF_TYPE objects.
+  * Graph#allow_n3 (getter/setter and option) controls if extra N3 semantics for graphs are allowed. Otherwise, calls Triple#validate_rdf to raise exception
+  * Real graph comparisons, including permutation search of triples containing BNodes (obviously, may be expensive)
+  * Add QuotedGraph and AggregateGraph
+* Literal changes
+  * Literal#== as alias to eql? Needed for sort and uniq.
+  * Normalize valid typed literals
+  * Added Literal#valid? to perform some content validations.
+* URIRef/Namespace changes
+  * Fix URI generation, performing normalizations for normal URI refs, and not for Namespace URIs.
+  * Fixed bug in URIRef#namespace & to_qname when namespace does not have a trailing / or #
+  * URIRef#short_name may return a different value after a namespace is assigned.
+* Reduce dependency on Redland when running tests
+
 === 0.4.8
 * Add Duration and support in Literal
 * Add datatype support for xs:boolean, xs:double, xs:duration and xs:time.

data/README.rdoc

@@ -7,7 +7,7 @@ A set of compliant RDF parsers:
 * RDF/XML
 * RDFa
 
-Multiple datastores may be attached to a Graph, including Memory, List and SQLite3
+Multiple data-stores may be attached to a Graph, including Memory, List and SQLite3
 
 == DESCRIPTION:
 
@@ -18,7 +18,7 @@ RdfContext parses RDF/XML, RDFa and N3-rdf into a Graph object. It also serializ
 
 * Fully compliant RDF/XML parser.
 * Fully compliant XHTML/RDFa 1.0 parser.
-* N3-rdf parser
+* Fully compliant N3-rdf parser (N3-rdf level)
 * N-Triples and RDF/XML serializer
 * RDFa tests use SPARQL for most tests due to Rasqal limitations. Other tests compare directly against N-triples.
 * Graph serializes into RDF/XML and N-Triples.
@@ -49,11 +49,24 @@ Graphs also store namespace associations, and can serialize graphs to RDF/XML or
   g.to_rdfxml
   g.to_ntriples
 
+Resource properties
+
+  graph.parse(':foo a :bar; rdfs:label "An example" .', "http://example.com/")
+  graph.resources("http://example.com/subject") =>
+  {
+   "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
+   "http://example.com/#label"                       => ["An example"]
+  }
+
 Instantiate an existing graph from a datastore
 
   s = SQLIte3Store.new(:path => "store.db")
   g = Graph.new(:store => s, :identifier => "http://example.com/context")
 
+QuotedGraph implements N3 Formulae semantics, by creating a graph within a store that is formula_aware. QuotedGraph triples are not returned in a query to a ConjunctiveGraph.
+
+AggregateGraphs allow multiple graphs from a given context_aware store to be combined into a single read-only graph.
+
 === Parsers
 Instantiate a parser and parse source, specifying type and base-URL
 
@@ -94,14 +107,9 @@ SQLite3Store:: context aware datastore using a SQLite3 database to create a pers
 
 == TODO:
 * Testing
-  * Integrate ntriples tests in spec/ntriples/test.nt
-  * Turtle tests from http://www.w3.org/2000/10/swap/test/n3/turtle-manifest.n3 (if can find .ttl and .out files)
-  * N3-RDF tests from http://www.w3.org/2000/10/swap/test/n3/n3-rdf.tests
-  * N3-Full tests from http://www.w3.org/2000/10/swap/test/n3/n3-full.tests
-  * N3 grammar tests?
   * RDFa updates for new tests and non XHTML representations.
 * Graphs
-  * n3 serialization
+  * n3/turtle serialization
 * Reasoner/inference engine
 * SPARQL
 * RDFS logic and RDF entailment tests
@@ -109,11 +117,16 @@ SQLite3Store:: context aware datastore using a SQLite3 database to create a pers
   * ActiveRDF-like class support
   * Integrate with RDFObjects (http://github.com/rsinger/RDFObjects)
 
+== Resources:
+* Distiller[http://kellogg-assoc/distiller]
+* RDoc[http://rdoc.info/projects/gkellogg/rdf_context]
+* History[http://github.com/gkellogg/rdf_context/blob/master/History.txt]
+
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2009 Gregg Kellogg
+Copyright (c) 2009-2010 Gregg Kellogg
 
 Copyright (c) 2008 Tom Morris and contributors
 

data/Rakefile

@@ -50,28 +50,33 @@ Spec::Rake::SpecTask.new(:spec) do |spec|
 end
 
 desc "Run specs through RCov"
-Spec::Rake::SpecTask.new(:rcov) do |spec|
+Spec::Rake::SpecTask.new("spec:rcov") do |spec|
   spec.libs << 'lib' << 'spec'
   spec.pattern = 'spec/*_spec.rb'
   spec.rcov = true
 end
 
+desc "Generate HTML report specs"
+Spec::Rake::SpecTask.new("doc:spec") do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/*_spec.rb']
+  spec.spec_opts = ["--format", "html:doc/spec.html"]
+end
+
 task :spec => :check_dependencies
 
 task :default => :spec
 
 require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
+Rake::RDocTask.new("doc:rdoc") do |rdoc|
   if File.exist?('VERSION')
     version = File.read('VERSION')
   else
-    version = RdfaParser::VERSION
+    version = RdfContext::VERSION
   end
 
-  rdoc.rdoc_dir = 'rdoc'
+  rdoc.rdoc_dir = 'doc/rdoc'
   rdoc.title = "rdf_context #{version}"
   rdoc.rdoc_files.include('README*', "History.txt")
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-# vim: syntax=Ruby

data/VERSION

@@ -1 +1 @@
-0.4.8
+0.5.0

data/bin/rdf_context

@@ -9,7 +9,7 @@ class Parse
     graph_opts = {:identifier => base_uri}
     graph_opts[:store] = store if store
     parser = Parser.new(:graph => Graph.new(graph_opts))
-    parser.parse(File.read(file), base_uri, :strict => true)
+    parser.parse(file.respond_to?(:read) ? file : File.open(file), base_uri, :strict => true)
     output = case $format
     when "xml"
       parser.graph.to_rdfxml
@@ -30,9 +30,12 @@ class Parse
   end
 end
 
+mode = ARGV.shift
+raise "Mode must be one of 'parse'" unless mode == "parse"
+
 $verbose = false
 base_uri  = "http://example.com"
-store     = :list_store
+store = :list_store
 opts = GetoptLong.new(
   ["--verbose", GetoptLong::NO_ARGUMENT],
   ["--quiet", GetoptLong::NO_ARGUMENT],
@@ -62,7 +65,12 @@ opts.each do |opt, arg|
 end
 
 x = Parse.new
-ARGV.each do |test_file|
-  x.parse(test_file, base_uri, store)
+if ARGV.empty?
+  s = $stdin.read
+  x.parse(StringIO.new(s), base_uri, store)
+else
+  ARGV.each do |test_file|
+    x.parse(test_file, base_uri, store)
+  end
 end
 

data/lib/rdf_context.rb

@@ -43,7 +43,7 @@ module RdfContext
        | \\\\u[0-9a-fA-F]
       )
       (  [0-9a-zA-Z_\.-]
-       | \\\\u([0-9a-fA-F]{4})  # \u followed by a sequence of four hex digits
+       | \\\\u([0-9a-fA-F]{4})
       )*
     $},
     Regexp::EXTENDED)
@@ -51,6 +51,8 @@ module RdfContext
   RDF_TYPE    = URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
   XML_LITERAL = Literal::Encoding.xmlliteral
 
+  OWL_NS      = Namespace.new("http://www.w3.org/2002/07/owl#", "owl")
+  LOG_NS      = Namespace.new("http://www.w3.org/2000/10/swap/log#", "log")
   RDF_NS      = Namespace.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#", "rdf")
   RDFS_NS     = Namespace.new("http://www.w3.org/2000/01/rdf-schema#", "rdfs")
   XHV_NS      = Namespace.new("http://www.w3.org/1999/xhtml/vocab#", "xhv")

data/lib/rdf_context/aggregate_graph.rb

@@ -0,0 +1,86 @@
+require File.join(File.dirname(__FILE__), "graph")
+
+module RdfContext
+  # AggregateGraph - A read-only graph composed of multiple other graphs.
+  #
+  # Essentially a ConjunctiveGraph over an explicit subset of the entire store.
+  class AggregateGraph < Graph
+    attr_reader :graphs
+    
+    # List of graphs to aggregate
+    def initialize(*graph)
+      @graphs = graph
+    end
+    
+    def destroy(configuration = nil); raise ReadOnlyGraphException; end
+    def commit; raise ReadOnlyGraphException; end
+    def rollback; raise ReadOnlyGraphException; end
+    def add; raise ReadOnlyGraphException; end
+    def remove; raise ReadOnlyGraphException; end
+    def bind(namespace); raise ReadOnlyGraphException; end
+    def parse(stream, uri, options = {}); raise ReadOnlyGraphException; end
+    def n3; raise ReadOnlyGraphException; end
+    
+    # Open the graphs
+    def open(configuration = {})
+      @graphs.each {|g| g.open(configuration)}
+    end
+    
+    # Close the graphs
+    def close(configuration = {})
+      @graphs.each {|g| g.close(configuration)}
+    end
+
+    # Number of Triples in the graph
+    def size
+      @graphs.inject(0) {|memo, g| memo += g.size}
+    end
+
+    # List of distinct subjects in graph
+    def subjects
+      @graphs.inject([]) {|memo, g| memo += g.subjects}
+    end
+    
+    # List of distinct predicates in graph
+    def predicates
+      @graphs.inject([]) {|memo, g| memo += g.predicates}
+    end
+    
+    # List of distinct objects in graph
+    def objects
+      @graphs.inject([]) {|memo, g| memo += g.objects}
+    end
+
+    # Triples from graph, optionally matching subject, predicate, or object.
+    # Delegates to Store#triples.
+    #
+    # @param [Triple, nil] triple:: Triple to match, may be a pattern triple or nil
+    # @return [Array]:: List of matched triples
+    def triples(triple = Triple.new(nil, nil, nil), &block) # :yields: triple, context
+      @graphs.inject([]) {|memo, g| memo += g.triples(triple, &block)}
+    end
+
+    # Check to see if this graph contains the specified triple
+    def contains?(triple)
+      @graphs.any? {|g| g.contains?(triple) }
+    end
+    
+    # Get all BNodes with usage count used within graph
+    def bnodes
+      @graphs.inject([]) {|memo, g| memo += g.bnodes}
+    end
+    
+    # Only compares to another AggregateGraph. Compares each sub-graph
+    def eql?(other)
+      other.is_a?(AggregateGraph) ? super : false
+    end
+    
+    def nsbinding
+      @graphs.inject({}) {|memo, g| memo.merge(g.nsbinding)}
+    end
+    
+    def uri_binding
+      @graphs.inject({}) {|memo, g| memo.merge(g.uri_binding)}
+    end
+  end
+end

data/lib/rdf_context/array_hacks.rb

@@ -0,0 +1,53 @@
+class Array
+  # http://wiki.rubygarden.org/Ruby/page/show/ArrayPermute
+  # Permute an array, and call a block for each permutation
+  # Author: Paul Battley
+  def permute(prefixed=[])
+    if (length < 2)
+      # there are no elements left to permute
+      yield(prefixed + self)
+    else
+      # recursively permute the remaining elements
+      each_with_index do |e, i|
+        (self[0,i]+self[(i+1)..-1]).permute(prefixed+[e]) { |a| yield a }
+      end
+    end
+  end
+  
+  # Converts the array to a comma-separated sentence where the last element is joined by the connector word. Options:
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements in arrays with two or more elements (default: ", ")
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements in arrays with two elements (default: " and ")
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element in arrays with three or more elements (default: ", and ")
+  def to_sentence(options = {})
+    default_words_connector     = ", "
+    default_two_words_connector = " and "
+    default_last_word_connector = ", and "
+
+    # Try to emulate to_senteces previous to 2.3
+    if options.has_key?(:connector) || options.has_key?(:skip_last_comma)
+      ::ActiveSupport::Deprecation.warn(":connector has been deprecated. Use :words_connector instead", caller) if options.has_key? :connector
+      ::ActiveSupport::Deprecation.warn(":skip_last_comma has been deprecated. Use :last_word_connector instead", caller) if options.has_key? :skip_last_comma
+
+      skip_last_comma = options.delete :skip_last_comma
+      if connector = options.delete(:connector)
+        options[:last_word_connector] ||= skip_last_comma ? connector : ", #{connector}"
+      else
+        options[:last_word_connector] ||= skip_last_comma ? default_two_words_connector : default_last_word_connector
+      end
+    end
+
+#    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector, :locale)
+    options = {:words_connector => default_words_connector, :two_words_connector => default_two_words_connector, :last_word_connector => default_last_word_connector}.merge(options)
+
+    case length
+      when 0
+        ""
+      when 1
+        self[0].to_s
+      when 2
+        "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+      else
+        "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end
+end

data/lib/rdf_context/conjunctive_graph.rb

@@ -36,7 +36,7 @@ module RdfContext
     # Triples across all contexts in store, optionally matching subject, predicate, or object.
     # Delegates to Store#triples.
     #
-    # @param [Triple, nil] triple:: Triple to match, may be a patern triple or nil
+    # @param [Triple, nil] triple:: Triple to match, may be a pattern triple or nil
     # @return [Array]:: List of matched triples
     def triples(triple = Triple.new(nil, nil, nil), &block) # :yields: triple, context
       @store.triples(triple, nil, &block) || []

data/lib/rdf_context/exceptions.rb

@@ -1,11 +1,13 @@
 module RdfContext
-  class RdfException < RuntimeError; end
+  class RdfException    < RuntimeError; end
+
   class ParserException < RdfException; end
-  class GraphException < RdfException; end
-  class StoreException < RdfException; end
-  class BNodeException < RdfException; end
-  class TypeError < RdfException; end
+  class GraphException  < RdfException; end
+  class StoreException  < RdfException; end
+  class BNodeException  < RdfException; end
+  class TypeError       < RdfException; end
+  class InvalidNode     < RdfException; end
   class InvalidPredicate < RdfException; end
-  class InvalidSubject < RdfException; end
-  class InvalidObject < RdfException; end
+
+  class ReadOnlyGraphException < GraphException; end
 end

data/lib/rdf_context/graph.rb

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), 'namespace')
 require File.join(File.dirname(__FILE__), 'triple')
+require File.join(File.dirname(__FILE__), 'array_hacks')
 require File.join(File.dirname(__FILE__), 'store', 'list_store')
 require File.join(File.dirname(__FILE__), 'store', 'memory_store')
 
@@ -12,6 +13,7 @@ module RdfContext
     attr_reader :nsbinding
     attr_reader :identifier
     attr_reader :store
+    attr_accessor :allow_n3
 
     # Create a Graph with the given store and identifier.
     #
@@ -30,6 +32,7 @@ module RdfContext
     # @param [Hash] options:: Options
     # <em>options[:store]</em>:: storage, defaults to a new ListStore instance. May be symbol :list_store or :memory_store
     # <em>options[:identifier]</em>:: Identifier for this graph, BNode or URIRef
+    # <em>options[:allow_n3]</em>:: Allow N3-specific triples: Literals as subject, BNodes as predicate
     def initialize(options = {})
       @nsbinding = {}
 
@@ -41,7 +44,9 @@ module RdfContext
       else                     ListStore.new
       end
       
-      @identifier = Triple.coerce_subject(options[:identifier]) || BNode.new
+      @allow_n3 = options[:allow_n3]
+      
+      @identifier = Triple.coerce_node(options[:identifier]) || BNode.new
     end
 
     def inspect
@@ -53,7 +58,7 @@ module RdfContext
       [self.class.to_s, self.identifier].hash
     end
     
-    def context_aware?; @context_aware; end
+    def context_aware?; @store.context_aware?; end
     
     # Data Store interface
     def nsbinding; @store.nsbinding; end
@@ -136,7 +141,8 @@ module RdfContext
       # Add bindings for predicates not already having bindings
       tmp_ns = "ns0"
       predicates.each do |p|
-        unless uri_bindings.has_key?(p.base)
+        raise "Attempt to serialize graph containing non-strict RDF compiant BNode as predicate" unless p.is_a?(URIRef)
+        if !p.namespace(uri_bindings)
           uri_bindings[p.base] = Namespace.new(p.base, tmp_ns)
           rdf_attrs["xmlns:#{tmp_ns}"] = p.base
           tmp_ns = tmp_ns.succ
@@ -188,6 +194,11 @@ module RdfContext
     # Hash of uri => Namespace bindings
     def uri_binding; @store.uri_binding; end
     
+    # QName for a URI
+    def qname(uri)
+      uri.to_qname(self.uri_binding)
+    end
+    
     # Namespace for prefix
     def namespace(prefix); @store.namespace(prefix); end
 
@@ -235,6 +246,7 @@ module RdfContext
     # @param [Triple] t:: the triple to be added to the graph
     # @return [Graph]:: Returns the graph
     def << (triple)
+      triple.validate_rdf unless @allow_n3 # Only add triples if n3-mode is set
       @store.add(triple, self)
       self
     end
@@ -254,7 +266,10 @@ module RdfContext
     def add(*triples)
       options = triples.last.is_a?(Hash) ? triples.pop : {}
       ctx = options[:context] || @default_context || self
-      triples.each {|t| @store.add(t, ctx)}
+      triples.each do |t|
+        t.validate_rdf unless @allow_n3 # Only add triples if n3-mode is set
+        @store.add(t, ctx)
+      end
       self
     end
     
@@ -265,19 +280,73 @@ module RdfContext
     # Triples from graph, optionally matching subject, predicate, or object.
     # Delegates to Store#triples.
     #
-    # @param [Triple, nil] triple:: Triple to match, may be a patern triple or nil
+    # @param [Triple, nil] triple:: Triple to match, may be a pattern triple or nil
     # @return [Array]:: List of matched triples
     def triples(triple = Triple.new(nil, nil, nil), &block) # :yields: triple, context
       @store.triples(triple, self, &block) || []
     end
     alias_method :find, :triples
+    
+    # Returns ordered rdf:_n objects or rdf:first, rdf:rest for a given subject
+    def seq(subject)
+      props = properties(subject)
+      rdf_type = props[RDF_TYPE.to_s] || []
+
+      if rdf_type.include?(RDF_NS.Seq)
+        props.keys.select {|k| k.match(/#{RDF_NS.uri}_(\d)$/)}.
+          sort_by {|i| i.sub(RDF_NS._.to_s, "").to_i}.
+          map {|key| props[key]}.
+          flatten
+      elsif self.triples(Triple.new(subject, RDF_NS.first, nil))
+        # N3-style first/rest chain
+        list = []
+        while subject != RDF_NS.nil
+          props = properties(subject)
+          list += props[RDF_NS.first.to_s]
+          subject = props[RDF_NS.rest.to_s].first
+        end
+        list
+      else
+        []
+      end
+    end
+
+    # Resource properties
+    #
+    # Properties arranged as a hash with the predicate Term as index to an array of resources or literals
+    #
+    # Example:
+    #   graph.parse(':foo a :bar; rdfs:label "An example" .', "http://example.com/")
+    #   graph.resources("http://example.com/subject") =>
+    #   {
+    #     "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
+    #     "http://example.com/#label"                       => ["An example"]
+    #   }
+    def properties(subject)
+      @properties ||= {}
+      @properties[subject.to_s] ||= begin
+        hash = Hash.new
+        self.triples(Triple.new(subject, nil, nil)).map do |t, ctx|
+          pred = t.predicate.to_s
+
+          hash[pred] ||= []
+          hash[pred] << t.object
+        end
+        hash
+      end
+    end
+    
+    # Return an n3 identifier for the Graph
+    def n3
+      "[#{self.identifier.to_n3}]"
+    end
 
     # Detect the presence of a BNode in the graph, either as a subject or an object
     #
     # @param [BNode] bn:: BNode to find
     #
     def has_bnode_identifier?(bn)
-      triples do |triple, context|
+      self.triples do |triple, context|
         return true if triple.subject.eql?(bn) || triple.object.eql?(bn)
       end
       false
@@ -300,6 +369,11 @@ module RdfContext
       triples(Triple.new(nil, RDF_TYPE, object)).map {|t, ctx| t.subject}
     end
     
+    # Get type(s) of subject, returns a list of symbols
+    def type_of(subject)
+      triples(Triple.new(subject, RDF_TYPE, nil)).map {|t, ctx| t.object}
+    end
+    
     # Merge a graph into this graph
     def merge!(graph)
       raise GraphException.new("merge without a graph") unless graph.is_a?(Graph)
@@ -310,9 +384,10 @@ module RdfContext
       
       graph.triples do |triple, context|
         # If triple contains bnodes, remap to new values
-        if triple.subject.is_a?(BNode) || triple.object.is_a?(BNode)
+        if triple.subject.is_a?(BNode) || triple.predicate.is_a?(BNode) || triple.object.is_a?(BNode)
           triple = triple.clone
           triple.subject = bn[triple.subject] if triple.subject.is_a?(BNode)
+          triple.predicate = bn[triple.predicate] if triple.predicate.is_a?(BNode)
           triple.object = bn[triple.object] if triple.object.is_a?(BNode)
         end
         self << triple
@@ -326,26 +401,53 @@ module RdfContext
     #
     # We just follow Python RDFlib's lead and do a simple comparison
     def eql?(other)
-      #puts "eql? size #{self.size} vs #{other.size}"
+      puts "eql? size #{self.size} vs #{other.size}" if $DEBUG
       return false if !other.is_a?(Graph) || self.size != other.size
-      return false unless other.identifier.to_s == identifier.to_s
+      return false unless other.identifier.to_s == identifier.to_s unless other.identifier.is_a?(BNode) && identifier.is_a?(BNode)
       
       bn_self = bnodes.values.sort
       bn_other = other.bnodes.values.sort
-      #puts "eql? bnodes '#{bn_self.to_sentence}' vs '#{bn_other.to_sentence}'"
+      puts "eql? bnodes '#{bn_self.to_sentence}' vs '#{bn_other.to_sentence}'" if $DEBUG
       return false unless bn_self == bn_other
       
       # Check each triple to see if it's contained in the other graph
       triples do |t, ctx|
-        next if t.subject.is_a?(BNode) || t.object.is_a?(BNode)
-        #puts "eql? contains '#{t.to_ntriples}'"
+        next if t.subject.is_a?(BNode) || t.predicate.is_a?(BNode) || t.object.is_a?(BNode)
+        puts "eql? contains '#{t.to_ntriples}: #{other.contains?(t)}'" if $DEBUG
         return false unless other.contains?(t)
       end
-      true
+      
+      # For each BNode, check permutations of similar bnodes in other graph
+      bnode_permutations(bnodes, other.bnodes) do |bn_map|
+        puts "bnode permutations: #{bn_map.inspect}" if $DEBUG
+        # bn_map contains 1-1 mapping of bnodes from self to other
+        catch :next_perm do
+          triples do |t, ctx|
+            next unless t.subject.is_a?(BNode) || t.predicate.is_a?(BNode) || t.object.is_a?(BNode)
+            subject, predicate, object = t.subject, t.predicate, t.object
+            subject = bn_map[subject] if bn_map.has_key?(subject)
+            predicate = bn_map[predicate] if bn_map.has_key?(predicate)
+            object = bn_map[object] if bn_map.has_key?(object)
+            tn = Triple.new(subject, predicate, object)
+            puts "  eql? contains '#{tn.inspect}': #{other.contains?(tn)}" if $DEBUG
+            next if other.contains?(tn)
+          
+            puts "  no, next permutation" if $DEBUG
+            # Not a match, try next permutation
+            throw :next_perm
+          end
+          
+          # If we matched all triples in the graph using this permutation, we're done
+          return true
+        end
+      end
+      
+      # Exhausted all permutations, unless there were no bnodes
+      bn_self.length == 0
     end
 
     alias_method :==, :eql?
-  
+    
     # Parse source into Graph.
     #
     # Merges results into a common Graph
@@ -356,9 +458,66 @@ module RdfContext
     # <em>options[:debug]</em>:: Array to place debug messages
     # <em>options[:type]</em>:: One of _rdfxml_, _html_, or _n3_
     # <em>options[:strict]</em>:: Raise Error if true, continue with lax parsing, otherwise
+    # <em>options[:allow_n3]</em>:: Allow N3-specific triples: Literals as subject, BNodes as predicate
     # @return [Graph]:: Returns the graph containing parsed triples
-    def parse(stream, uri, options = {}, &block) # :yields: triple
+    def parse(stream, uri = nil, options = {}, &block) # :yields: triple
+      @allow_n3 ||= options[:allow_n3]
       Parser.parse(stream, uri, options.merge(:graph => self), &block)
     end
   end
+  
+  protected
+
+    # Permutations of two BNode lists
+    #
+    # Take source keys and run permutations mapping to other keys, if the permutation
+    # maps to the same counts for each
+    def bnode_permutations(bn_source, bn_other)
+      puts "compare #{bn_source.inspect}\n   with #{bn_other.inspect}" if $DEBUG
+
+      source_keys = bn_source.keys
+      other_keys = bn_other.keys
+      values = bn_source.values.uniq
+
+      # Break key lists into groups based on sharing equivalent usage counts
+      case values.length
+      when 0
+        {}
+      when 1
+        # All keys have equivalent counts, yield permutations
+        if source_keys.length == 1
+          puts "yield #{{source_keys.first => other_keys.first}.inspect}" if $DEBUG
+          yield({source_keys.first => other_keys.first})
+        else
+          (0..(source_keys.length-1)).to_a.permute do |indicies|
+            puts "indicies #{indicies.inspect}" if $DEBUG
+            ok = other_keys.dup
+            map = indicies.inject({}) { |hash, i| hash[source_keys[i]] = ok.shift; hash}
+            puts "yield #{map.inspect}" if $DEBUG
+            yield(map)
+          end
+        end
+      else
+        # Break bnodes into 2 arrays sharing a common usage count and permute each separately
+        max = values.max
+        bn_source_min = bn_source.clone
+        bn_other_min = bn_other.clone
+        bn_source_max = {}
+        bn_other_max = {}
+        bn_source.each_pair do |bn, v|
+          bn_source_max[bn] = bn_source_min.delete(bn) if v == max
+        end
+        bn_other.each_pair do |bn, v|
+          bn_other_max[bn] = bn_other_min.delete(bn) if v == max
+        end
+
+        puts "yield permutations of multiple with max #{bn_source_max.inspect}\n  and #{bn_other_max.inspect}" if $DEBUG
+        # Yield for each permutation of max joined with permutations of min
+        bnode_permutations(bn_source_max, bn_other_max) do |bn_perm_max|
+          bnode_permutations(bn_source_min, bn_other_min) do |bn_perm_min|
+            yield bn_perm_max.merge(bn_perm_min)
+          end
+        end
+      end
+    end
 end