rdf_context 0.5.0 → 0.5.1

data/History.txt

@@ -1,3 +1,18 @@
+=== 0.5.1
+* Avoid stack-overflow when checking graph size (if $DEBUG == true)
+* Refactor serializers to be based on AbstractSerializer
+* Graph
+  * Add Graph#serialize taking a serializer or symbol identifing a serialzer and a base URI
+  * Add Graph#add_seq to add the list of Resources as to an RDF Container (i.e., rdf:first/rdf:rest)
+  * Add Graph#sync_properties to write properties cached from Graph#properties back to the store.
+* Add TurtleSerializer, along with AbstractSerializer, RecusiveSerializer, NTSerializer and XMLSerializer
+* Update XmlSerializer, and Graph#to_xml to do more intelligent generation of RDF/XML
+  * Control depth of recursive node generation with :max_depth
+  * Serialize rdf:type and untyped literals as attributes with :attributes => :untyped
+  * Serialize typed literals as attributes with :attributes => :typed
+* Added Literal#typed? and Literal#untyped? in addition to Literal#xmlliteral?
+* BNode.new("") is not a named identifier, it's equivalent to an anonymous BNode
+
 === 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

data/README.rdoc

@@ -19,7 +19,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.
 * Fully compliant N3-rdf parser (N3-rdf level)
-* N-Triples and RDF/XML serializer
+* Turtle, 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.
 * ConjunctiveGraph, named Graphs and contextual storage modules.
@@ -40,7 +40,7 @@ a :store (defaults to :list_store)
 
   g.add(Triple.new(subject, predicate, object))
   
-Graphs also store namespace associations, and can serialize graphs to RDF/XML or N-triples
+Graphs also store namespace associations, and can serialize graphs to Turtle, RDF/XML, N-triples or a custom serializer
 
   g.bind(Namespace.new("http://example.com", "ex"))
   g.namespace("ex")
@@ -48,6 +48,12 @@ Graphs also store namespace associations, and can serialize graphs to RDF/XML or
   
   g.to_rdfxml
   g.to_ntriples
+  g.serialize(:format => :xml, :io => StringIO.new, :base => "http://base.example.com/") => IO Object, or string if none specified
+
+or, pass an instantiated Serializer object
+
+  ser = TurtleSerializer.new(g)
+  g.serialize(:format => ser, :io => StringIO.new, :base => "http://base.example.com/")
 
 Resource properties
 
@@ -63,9 +69,47 @@ 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.
+==== Named Graphs / Conjunctive Graphs
+RdfContext defines the following kinds of Graphs:
+Graph:: Basic graph, associated with a Store and an identifier
+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.
+ConjunctiveGraph:: A Conjunctive Graph is the most relevant collection of graphs that are considered to be the boundary for closed world assumptions. This boundary is equivalent to that of the store instance (which is itself uniquely identified and distinct from other instances of Store that signify other Conjunctive Graphs). It is equivalent to all the named graphs within it and associated with a _default_ graph which is automatically assigned a BNode for an identifier - if one isn't given.
+AggregateGraph:: allow multiple graphs from a given context_aware store to be combined into a single read-only graph.
+
+=== Terminology
+_Context_: A named, unordered set of statements. Also could be called a sub-graph. The named graphs literature and ontology are relevant to this concept. A context could be thought of as only the relationship between an RDF triple and a sub-graph (this is how the term context is used in the Notation 3 Design Issues page) in which it is found or the sub-graph itself.
+
+It's worth noting that the concept of logically grouping triples within an addressable 'set' or 'subgraph' is just barely beyond the scope of the RDF model. The RDF model defines a graph as an arbitrary collection of triples and the semantics of these triples, but doesn't give guidance on how to consistently address such arbitrary collections. Though a collection of triples can be thought of as a resource itself, the association between a triple and the collection it is a part of is not covered.
+
+<em>Conjunctive Graph</em>: This refers to the 'top-level' Graph. It is the aggregation of all the contexts within it and is also the appropriate, absolute boundary for closed world assumptions / models. This distinction is the low-hanging fruit of RDF along the path to the semantic web and most of its value is in (corporate/enterprise) real-world problems:
+
+For the sake of persistence, Conjunctive Graphs must be distinguished by identifiers (that may not necessarily be RDF identifiers or may be an RDF identifier normalized - SHA1/MD5 perhaps - for database naming purposes ) which could be referenced to indicate conjunctive queries (queries made across the entire conjunctive graph) or appear as nodes in asserted statements. In this latter case, such statements could be interpreted as being made about the entire 'known' universe. For example:
+
+  <urn:uuid:conjunctive-graph-foo> rdf:type :ConjunctiveGraph
+  <urn:uuid:conjunctive-graph-foo> rdf:type log:Truth
+  <urn:uuid:conjunctive-graph-foo> :persistedBy :MySQL
+
+_Terms_: Terms are the kinds of objects that can appear in a quoted/asserted triple. This includes those that are core to RDF:
+
+* Blank Nodes
+* URI References
+* Literals (which consist of a literal value, datatype and language tag)
+
+_Nodes_: Nodes are a subset of the Terms that the underlying store actually persists. The set of such Terms depends on whether or not the store is formula-aware. Stores that aren't formula-aware would only persist those terms core to the RDF Model, and those that are formula-aware would be able to persist the N3 extensions as well. However, utility terms that only serve the purpose for matching nodes by term-patterns probably will only be terms and not nodes.
+
+The set of nodes of an RDF graph is the set of subjects and objects of triples in the graph.
+
+<em>Context-aware</em>: An RDF store capable of storing statements within contexts is considered context-aware. Essentially, such a store is able to partition the RDF model it represents into individual, named, and addressable sub-graphs.
+
+<em>Formula-aware</em>: An RDF store capable of distinguishing between statements that are asserted and statements that are quoted is considered formula-aware.
+
+Such a store is responsible for maintaining this separation and ensuring that queries against the entire model (the aggregation of all the contexts - specified by not limiting a 'query' to a specifically name context) do not include quoted statements. Also, it is responsible for distinguishing universal quantifiers (variables).
 
-AggregateGraphs allow multiple graphs from a given context_aware store to be combined into a single read-only graph.
+These 2 additional concepts (formulae and variables) must be thought of as core extensions and distinguishable from the other terms of a triple (for the sake of the persistence roundtrip - at the very least). It's worth noting that the 'scope' of universal quantifiers (variables) and existential quantifiers (BNodes) is the formula (or context - to be specific) in which their statements reside. Beyond this, a Formula-aware store behaves the same as a Context-aware store.
+
+<em>Conjunctive Query</em>: Any query that doesn't limit the store to search within a named context only. Such a query expects a context-aware store to search the entire asserted universe (the conjunctive graph). A formula-aware store is expected not to include quoted statements when matching such a query.
+
+<em>Transactional Store</em>: An RDF store capable of providing transactional integrity to the RDF operations performed on it.
 
 === Parsers
 Instantiate a parser and parse source, specifying type and base-URL
@@ -84,11 +128,46 @@ or, parse directly into a graph
   g = Graph.new(:identifier => "http://example.com", :store => :sqlite3_store)
   g.parse(input, "http://example.com", :type => :rdfxml)
 
+=== Serializers
+AbstractSerializer class for XML, N-Triples and Turtle serializers. Turtle based on RecursiveSerializer.
+May be called from Graph via Graph#serialize, or instantiated and run separately:
+
+  g = Graph.new
+  s = TurtleSerializer.new(g)
+  stream = StringIO.new
+  s.serialize(stream, , "http://base.example.com/")
+
 === Data Stores
+RdfContext defines three datastores:
+
 ListStore:: simple non-context aware datastore based on Array
 MemoryStore:: context aware datastore using multiple hashes to optimize triple lookkup
 SQLite3Store:: context aware datastore using a SQLite3 database to create a persistent storage model
 
+Additional stores may be created by sub-classing _AbstractStore_ or _AbstractSQLStore_.
+
+==== Database/Transactional stores
+An RDF store should provide standard interfaces for the management of database connections. Such interfaces are standard to most database management systems (Oracle, MySQL, Berkeley DB, Postgres, etc..) The following methods are defined to provide this capability:
+
+*open*:: Opens the store specified by the options. If :create is true a store will be created if it does not already exist. If *create* is false and a store does not already exist an exception is raised. An exception is also raised if a store exists, but there is insufficient permissions to open the store.
+*close*:: This closes the database connection. The commit_pending_transaction parameter specifies whether to commit all pending transactions before closing (if the store is transactional).
+*destroy*:: This destroys the instance of the store identified by the options.
+
+The configuration hash is understood by the store implementation and represents all the necessary parameters needed to locate an individual instance of a store. The open function needs to fail intelligently in order to clearly express that a store (identified by the given configuration string) already exists or that there is no store (at the location specified by the configuration string) depending on the value of create.
+
+==== Triple Interfaces
+An RDF store could provide a standard set of interfaces for the manipulation, management, and/or retrieval of its contained triples (asserted or quoted):
+
+*add*:: Adds the given statement to a specific context or to the model. The quoted argument is interpreted by formula-aware stores to indicate this statement is quoted/hypothetical. It should be an error to not specify a context and have the quoted argument be True. It should also be an error for the quoted argument to be True when the store is not formula-aware.
+*remove*:: Remove a triple, or pattern from a specific or all contexts.
+*triples*:: Returns an closure over all the triples (within the conjunctive graph or just the given context) matching the given pattern or an array of triples. The pattern is specified by providing explicit statement terms (which are used to match against nodes in the underlying store), or nil - which indicates a wildcard. This function can be thought of as the primary mechanism for producing triples with nodes that match the corresponding terms and term pattern provided. A conjunctive query can be indicated by either providing a value of nil for context or the identifier associated with the Conjunctive Graph.
+*size*:: Number of statements in the store. This should only account for non-quoted (asserted) statements if the context is not specified, otherwise it should return the number of statements in the formula or context given.
+
+==== Formula / Context Interfaces
+
+These interfaces work on contexts and formulae (for stores that are formula-aware) interchangeably.
+*contexts*:: Closure or list over all contexts in the graph. If triple is specified, it returns all contexts the triple is in.
+
 == Dependencies:
 
 * Addressable
@@ -109,13 +188,10 @@ SQLite3Store:: context aware datastore using a SQLite3 database to create a pers
 * Testing
   * RDFa updates for new tests and non XHTML representations.
 * Graphs
-  * n3/turtle serialization
+  * n3 semantics including variables and formulae
 * Reasoner/inference engine
 * SPARQL
 * RDFS logic and RDF entailment tests
-* Ruby objects
-  * ActiveRDF-like class support
-  * Integrate with RDFObjects (http://github.com/rsinger/RDFObjects)
 
 == Resources:
 * Distiller[http://kellogg-assoc/distiller]

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/bin/rdf_context

@@ -10,12 +10,7 @@ class Parse
     graph_opts[:store] = store if store
     parser = Parser.new(:graph => Graph.new(graph_opts))
     parser.parse(file.respond_to?(:read) ? file : File.open(file), base_uri, :strict => true)
-    output = case $format
-    when "xml"
-      parser.graph.to_rdfxml
-    else
-      parser.graph.to_ntriples
-    end
+    output = parser.graph.serialize(:format => $format.to_sym, :base => base_uri)
     puts output unless $quiet
 
     puts parser.debug.join("\n\t") if $verbose
@@ -34,6 +29,7 @@ mode = ARGV.shift
 raise "Mode must be one of 'parse'" unless mode == "parse"
 
 $verbose = false
+$format = "ttl"
 base_uri  = "http://example.com"
 store = :list_store
 opts = GetoptLong.new(

data/lib/rdf_context.rb

@@ -15,10 +15,19 @@ rescue LoadError
   require 'treetop'
 end
 
-Dir.glob(File.join(File.dirname(__FILE__), 'rdf_context/**.rb')).sort.each { |f| require f }
+Dir.glob(File.join(File.dirname(__FILE__), 'rdf_context/*.rb')).sort.each { |f| require f }
 
 # Include Storage types, but be tollerant of failure to load as dependencies might not be available
-Dir.glob(File.join(File.dirname(__FILE__), "rdf_context/store/**.rb")).each do |f|
+Dir.glob(File.join(File.dirname(__FILE__), "rdf_context/store/*.rb")).each do |f|
+  begin
+    require f
+  rescue LoadError
+    puts "Error loading #{f}: #{$!}"
+  end
+end
+
+# Include Serializer types, but be tollerant of failure to load as dependencies might not be available
+Dir.glob(File.join(File.dirname(__FILE__), "rdf_context/serializer/*.rb")).each do |f|
   begin
     require f
   rescue LoadError
@@ -51,6 +60,7 @@ module RdfContext
   RDF_TYPE    = URIRef.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#type")
   XML_LITERAL = Literal::Encoding.xmlliteral
 
+  DC_NS       = Namespace.new("http://purl.org/dc/elements/1.1/", "dc")
   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")

data/lib/rdf_context/bnode.rb

@@ -16,7 +16,7 @@ module RdfContext
     # @param [String] identifier:: Legal NCName or nil for a named BNode
     # @param [Hash] context:: Context used to store named BNodes
     def initialize(identifier = nil, context = {})
-      if identifier.nil?
+      if identifier.to_s.empty?
         @identifier = generate_bn_identifier
       elsif identifier.match(/n?bn\d+[a-z]+(N\w+)?$/)
         @identifier = context[identifier] || identifier
@@ -70,6 +70,10 @@ module RdfContext
     end
     alias_method :==, :eql?
     
+    def <=>(other)
+      self.to_s <=> other.to_s
+    end
+  
     # Needed for uniq
     def hash; self.to_s.hash; end
     

data/lib/rdf_context/graph.rb

@@ -3,6 +3,9 @@ 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')
+require File.join(File.dirname(__FILE__), 'serializer', 'nt_serializer')
+require File.join(File.dirname(__FILE__), 'serializer', 'turtle_serializer')
+require File.join(File.dirname(__FILE__), 'serializer', 'xml_serializer')
 
 module RdfContext
   # A simple graph to hold triples.
@@ -10,7 +13,6 @@ module RdfContext
   # Graphs store triples, and the namespaces associated with those triples, where defined
   class Graph
     attr_reader :triples
-    attr_reader :nsbinding
     attr_reader :identifier
     attr_reader :store
     attr_accessor :allow_n3
@@ -34,8 +36,6 @@ module RdfContext
     # <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 = {}
-
       # Instantiate triple store
       @store = case options[:store]
       when AbstractStore  then options[:store]
@@ -60,9 +60,6 @@ module RdfContext
     
     def context_aware?; @store.context_aware?; end
     
-    # Data Store interface
-    def nsbinding; @store.nsbinding; end
-
     # Destroy the store identified by _configuration_ if supported
     # If configuration is nil, remove the graph context
     def destroy(configuration = nil)
@@ -94,9 +91,34 @@ module RdfContext
     # Might be necessary for stores that require closing a connection to a
     # database or releasing some resource.
     def close(commit_pending_transaction=false)
-      @store.open(commit_pending_transaction)
+      @store.close(commit_pending_transaction)
     end
 
+    # Serialize graph using specified serializer class.
+    #
+    # @param [Hash] options:: Options
+    # <em>options[:format]</em>:: serializer, defaults to a new NTSerializer instance. Otherwise may be a symbol from :nt, :turtle, :xml
+    # <em>options[:io]</em>:: IO (or StringIO) object, otherwise serializes to a string
+    # <em>options[:base]</em>:: Base URI for output
+    #
+    # Other options are parser specific.
+    #
+    # @returns [IO, String]:: Passed IO/StringIO object or a string
+    def serialize(options)
+      serializer = case options[:format].to_sym
+      when AbstractSerializer   then options[:serializer]
+      when :nt, :ntriples       then NTSerializer.new(self)
+      when :ttl, :turtle, :n3   then TurtleSerializer.new(self)
+      when :rdf, :xml, :rdfxml  then XmlSerializer.new(self)
+      else                           NTSerializer.new(self)
+      end
+      
+      io = options[:io] || StringIO.new
+      
+      serializer.serialize(io, options)
+      options[:io] ? io : (io.rewind; io.read)
+    end
+    
     ## 
     # Exports the graph to RDF in N-Triples form.
     #
@@ -107,9 +129,7 @@ module RdfContext
     #
     # @author Tom Morris
     def to_ntriples
-      triples.collect do |t|
-        t.to_ntriples
-      end * "\n" + "\n"
+      serialize(:format => :nt)
     end
     
     # Output graph using to_ntriples
@@ -120,59 +140,7 @@ module RdfContext
     #
     # @return [String]:: The RDF/XML graph
     def to_rdfxml
-      replace_text = {}
-      rdfxml = ""
-      xml = builder = Builder::XmlMarkup.new(:target => rdfxml, :indent => 2)
-
-      extended_bindings = nsbinding.merge(
-        "rdf"   => RDF_NS,
-        "rdfs"  => RDFS_NS,
-        "xhv"   => XHV_NS,
-        "xml"   => XML_NS
-      )
-      rdf_attrs = extended_bindings.values.inject({}) { |hash, ns| hash.merge(ns.xmlns_attr => ns.uri.to_s)}
-      uri_bindings = self.uri_binding.merge(
-        RDF_NS.uri.to_s => RDF_NS,
-        RDFS_NS.uri.to_s => RDFS_NS,
-        XHV_NS.uri.to_s => XHV_NS,
-        XML_NS.uri.to_s => XML_NS
-      )
-      
-      # Add bindings for predicates not already having bindings
-      tmp_ns = "ns0"
-      predicates.each do |p|
-        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
-        end
-      end
-
-      xml.instruct!
-      xml.rdf(:RDF, rdf_attrs) do
-        # Add statements for each subject
-        subjects.each do |s|
-          xml.rdf(:Description, (s.is_a?(BNode) ? "rdf:nodeID" : "rdf:about") => s) do
-            triples(Triple.new(s, nil, nil)) do |triple, context|
-              xml_args = triple.object.xml_args
-              qname = triple.predicate.to_qname(uri_bindings)
-              if triple.object.is_a?(Literal) && triple.object.xmlliteral?
-                replace_text["__replace_with_#{triple.object.object_id}__"] = xml_args[0]
-                xml_args[0] = "__replace_with_#{triple.object.object_id}__"
-              end
-              xml.tag!(qname, *xml_args)
-            end
-          end
-        end
-      end
-
-      # Perform literal substitutions
-      replace_text.each_pair do |match, value|
-        rdfxml.sub!(match, value)
-      end
-      
-      rdfxml
+      serialize(:format => :rdfxml)
     end
     
     ## 
@@ -268,11 +236,45 @@ module RdfContext
       ctx = options[:context] || @default_context || self
       triples.each do |t|
         t.validate_rdf unless @allow_n3 # Only add triples if n3-mode is set
+        #puts "Add #{t.inspect}, ctx: #{ctx.identifier}" if $verbose
         @store.add(t, ctx)
       end
       self
     end
     
+    ##
+    # Adds a list of resources as an RDF list by creating bnodes and first/rest triples
+    # @param [URIRef, BNode] subject:: the subject of the triple
+    # @param [URIRef] predicate:: the predicate of the triple
+    # @param [Array] objects:: List of objects to serialize
+    # @return [Graph]:: Returns the graph
+    # @raise [Error]:: Checks parameter types and raises if they are incorrect.
+    def add_seq(subject, predicate, objects)
+      if objects.empty?
+        add_triple(subject, predicate, RDF_NS.nil)
+        return self
+      end
+      
+      if RDF_NS.first != predicate
+        bn = BNode.new
+        add_triple(subject, predicate, bn)
+        subject = bn
+      end
+
+      last = objects.pop
+      
+      objects.each do |o|
+        add_triple(subject, RDF_NS.first, o)
+        bn = BNode.new
+        add_triple(subject, RDF_NS.rest, bn)
+        subject = bn
+      end
+
+      # Last item in list
+      add_triple(subject, RDF_NS.first, last)
+      add_triple(subject, RDF_NS.rest, RDF_NS.nil)
+    end
+    
     # Remove a triple from the graph. Delegates to store.
     # Nil matches all triples and thus empties the graph
     def remove(triple); @store.remove(triple, self); end
@@ -290,20 +292,26 @@ module RdfContext
     # 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] || []
+      rdf_type = (props[RDF_TYPE.to_s] || []).map {|t| t.to_s}
 
-      if rdf_type.include?(RDF_NS.Seq)
+      #puts "seq; #{rdf_type} #{rdf_type - [RDF_NS.Seq, RDF_NS.Bag, RDF_NS.Alt]}"
+      if !(rdf_type - [RDF_NS.Seq, RDF_NS.Bag, RDF_NS.Alt]).empty?
         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))
+      elsif !self.triples(Triple.new(subject, RDF_NS.first, nil)).empty?
         # 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
+          f = props[RDF_NS.first.to_s]
+          if f.to_s.empty? || f.first == RDF_NS.nil
+            subject = RDF_NS.nil
+          else
+            list += f
+            subject = props[RDF_NS.rest.to_s].first
+          end
         end
         list
       else
@@ -322,8 +330,9 @@ module RdfContext
     #     "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" => [<http://example.com/#bar>],
     #     "http://example.com/#label"                       => ["An example"]
     #   }
-    def properties(subject)
+    def properties(subject, recalc = false)
       @properties ||= {}
+      @properties.delete(subject.to_s) if recalc
       @properties[subject.to_s] ||= begin
         hash = Hash.new
         self.triples(Triple.new(subject, nil, nil)).map do |t, ctx|
@@ -336,6 +345,24 @@ module RdfContext
       end
     end
     
+    
+    # Synchronize properties to graph
+    def sync_properties(subject)
+      props = properties(subject)
+      
+      # First remove all properties for subject
+      remove(Triple.new(subject, nil, nil))
+      
+      # Iterate through and add properties to graph
+      props.each_pair do |pred, list|
+        predicate = URIRef.new(pred)
+        [list].flatten.compact.each do |object|
+          add(Triple.new(subject, predicate, object))
+        end
+      end
+      @properties.delete(subject.to_s) # Read back in from graph
+    end
+    
     # Return an n3 identifier for the Graph
     def n3
       "[#{self.identifier.to_n3}]"
@@ -401,7 +428,7 @@ 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}" if $DEBUG
+      #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 unless other.identifier.is_a?(BNode) && identifier.is_a?(BNode)