rdf-rdfxml 0.3.4 → 0.3.5

data/{History.rdoc → History.markdown}

@@ -1,29 +1,33 @@
-=== 0.3.4
+### 0.3.5
+* RDF.rb 0.3.4 compatibility.
+* Added format detection.
+
+### 0.3.4
 * Decode XML Entity declarations when parsing.
 
-=== 0.3.3.1
+### 0.3.3.1
 * JRuby/FFI compatibility updates.
 * Simplify property value ordering in writer; this was causing unnecessary prefixes to be generated.
 
-=== 0.3.3
+### 0.3.3
 * Change licensing to UNLICENSE.
 * Only generate prefix definitions for prefixes actually used within a serialization.
 * Make sure that only valid QNames are generated in writer.
 
-=== 0.3.2.1
+### 0.3.2.1
 * Fix collection serialization bug
 * Assert :xml as a format type (by creating RDF::RDFXML::XML as a sub-class of Format that uses RDFXML::Reader/Writer)
 
-=== 0.3.2
+### 0.3.2
 * Refactor rdfcore tests using Spira and open-uri-cached.
 * Improve detection and reporting of attempts to write illegal values.
 
-=== 0.3.1
+### 0.3.1
 * In writer
   * fix bug where a serialized subject is output again, when it appears in a collection.
   * Fix subject ordering.
 
-=== 0.3.0
+### 0.3.0
 * RDF.rb 0.3.0 compatibility updates
   * Remove literal_normalization and qname_hacks, add back uri_hacks (until 0.3.0)
   * Use nil for default namespace
@@ -44,15 +48,15 @@
   * Add all in-scope namespaces, not just those that seem to be used.
 * RSpec 2 compatibility
 
-=== 0.2.3
+### 0.2.3
 * Fixed QName generation in Writer based on RDF/XML Processing recommendations
 
-=== 0.2.2.1
+### 0.2.2.1
 * Ruby 1.9.2 support.
 * Added script/tc to run test cases
 * Mark failing XMLLiteral tests as pending
 
-=== 0.2.2
+### 0.2.2
 * Fix bug creating datatyped literal where datatype is a string, not an RDF::URI
 * Added more XMLLiteral tests (fail, until full canonicalization working)
 * Added RDF_Reader and RDF_Writer behavior expectations
@@ -65,18 +69,18 @@
 * Handle XMLLiteral when value is a Nokogiri node set.
 * Ensure URIs are properly RDF Escaped (patch to RDF::NTriples::Writer#format_uri)
 
-=== 0.2.1
+### 0.2.1
 * Update for RDF 0.2.1
 * Writer bug fixes:
   * RDF::Node#identifier => RDF::Node#id
   * Vocabulary.new(uri) => Vocabulary(uri)
 
-=== 0.2.0
+### 0.2.0
 * Updates for RDF 0.2.0
   * Use URI#intern instead of URI#new
   * Change use of Graph#predicates and Graph#objects to use as enumerables
 
-=== 0.0.3
+### 0.0.3
 * Added patches for the following:
   * RDF::Graph#properties
   * RDF::Graph#seq (Output rdf:Seq elements in order)
@@ -96,12 +100,12 @@
     * should create <http://foo/bar> from <http://foo/bar#> and ''
   * Writer test needs Turtle reader
 
-=== 0.0.2
+### 0.0.2
 * Added specs from RdfContext
 * Added array_hacks, nokogiri_hacks, and rdf_escape
 * Fixed most bugs that are not related to the underlying framework.
   * Specific failing testcases for rdf-isomorphic, RDF::Literaland others need to be constructed and added as issues against those gems.
 * Removed interal graph in Reader and implement each_triple & each_statement to perform parsing
 
-=== 0.0.1
+### 0.0.1
 * First port from RdfContext version 0.5.4

data/{README → README.markdown}

@@ -23,11 +23,11 @@ Instantiate a parser and parse source, specifying type and base-URL
     end
 
 ## Dependencies
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.1)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.3.4)
 * [Nokogiri](http://rubygems.org/gems/nokogiri) (>= 1.4.4)
 
 ## Documentation
-Full documentation available on [RubyForge](http://rdf.rubyforge.org/rdfxml)
+Full documentation available on [RubyForge](http://rubydoc.info/github/gkellogg/rdf-rdfxml/master/frames)
 
 ### Principle Classes
 * {RDF::RDFXML}

data/VERSION

@@ -1 +1 @@
-0.3.4
+0.3.5

data/lib/rdf/rdfxml/format.rb

@@ -26,6 +26,19 @@ module RDF::RDFXML
 
     reader { RDF::RDFXML::Reader }
     writer { RDF::RDFXML::Writer }
+
+    ##
+    # Sample detection to see if it matches RDF/XML (not Microdata or RDFa)
+    #
+    # Use a text sample to detect the format of an input file. Sub-classes implement
+    # a matcher sufficient to detect probably format matches, including disambiguating
+    # between other similar formats.
+    #
+    # @param [String] sample Beginning several bytes (~ 1K) of input.
+    # @return [Boolean]
+    def self.detect(sample)
+      sample.match(/<(\w+:)?(RDF)/)
+    end
   end
   
   # Aliases for this format

data/lib/rdf/rdfxml/reader.rb

@@ -137,7 +137,6 @@ module RDF::RDFXML
         else
           Nokogiri::XML.parse(input, @base_uri.to_s) do |config|
             config.noent
-            config.strict if options[:validate]
           end
         end
         
@@ -229,9 +228,12 @@ module RDF::RDFXML
     
     # Add debug event to debug array, if specified
     #
-    # @param [XML Node, any] node:: XML Node or string for showing context
+    # @param [Nokogiri::XML::Node, #to_s] node:: XML Node or string for showing context
     # @param [String] message::
-    def add_debug(node, message)
+    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
+    def add_debug(node, message = "")
+      return unless ::RDF::RDFXML.debug? || @debug
+      message = message + yield if block_given?
       puts "#{node_path(node)}: #{message}" if ::RDF::RDFXML::debug?
       @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
     end
@@ -246,7 +248,7 @@ module RDF::RDFXML
     # @raise [RDF::ReaderError]:: Checks parameter types and raises if they are incorrect if validating.
     def add_triple(node, subject, predicate, object)
       statement = RDF::Statement.new(subject, predicate, object)
-      add_debug(node, "statement: #{statement}")
+      add_debug(node) {"statement: #{statement}"}
       @callback.call(statement)
     end
 
@@ -260,9 +262,9 @@ module RDF::RDFXML
       # subject
       subject = ec.subject || parse_subject(el, ec)
       
-      add_debug(el, "nodeElement, ec: #{ec.inspect}")
-      add_debug(el, "nodeElement, el: #{el.uri}")
-      add_debug(el, "nodeElement, subject: #{subject.nil? ? 'nil' : subject.to_s}")
+      add_debug(el) {"nodeElement, ec: #{ec.inspect}"}
+      add_debug(el) {"nodeElement, el: #{el.uri}"}
+      add_debug(el) {"nodeElement, subject: #{subject.nil? ? 'nil' : subject.to_s}"}
 
       unless el.uri.to_s == RDF.Description.to_s
         add_triple(el, subject, RDF.type, el.uri)
@@ -270,7 +272,7 @@ module RDF::RDFXML
 
       # produce triples for attributes
       el.attribute_nodes.each do |attr|
-        add_debug(el, "propertyAttr: #{attr.uri}='#{attr.value}'")
+        add_debug(el) {"propertyAttr: #{attr.uri}='#{attr.value}'"}
         if attr.uri.to_s == RDF.type.to_s
           # If there is an attribute a in propertyAttr with a.URI == rdf:type
           # then u:=uri(identifier:=resolve(a.string-value))
@@ -293,16 +295,16 @@ module RDF::RDFXML
           prefix(prefix, value)
         end
         predicate = child.uri
-        add_debug(child, "propertyElt, predicate: #{predicate}")
+        add_debug(child) {"propertyElt, predicate: #{predicate}"}
         propertyElementURI_check(child)
         
         # Determine the content type of this property element
         text_nodes = child.children.select {|e| e.text? && !e.blank?}
         element_nodes = child.children.select {|c| c.element? }
-        add_debug(child, "#{text_nodes.length} text nodes, #{element_nodes.length} element nodes")
+        add_debug(child) {"#{text_nodes.length} text nodes, #{element_nodes.length} element nodes"}
         if element_nodes.length > 1
           element_nodes.each do |node|
-            add_debug(child, "  node: #{node.to_s}")
+            add_debug(child) {"  node: #{node.to_s}"}
           end
         end
 
@@ -326,7 +328,7 @@ module RDF::RDFXML
             # RDF/XML documents specified in [RDF-MS] to remain valid;
             # new documents SHOULD NOT use these unqualified attributes and applications
             # MAY choose to warn when the unqualified form is seen in a document.
-            add_debug(el, "Unqualified attribute '#{attr}'")
+            add_debug(el) {"Unqualified attribute '#{attr}'"}
             #attrs[attr.to_s] = attr.value unless attr.to_s.match?(/^xml/)
           elsif attr.namespace.href == RDF::XML.to_s
             # No production. Lang and base elements already extracted
@@ -354,12 +356,12 @@ module RDF::RDFXML
         resourceAttr = RDF::NTriples.unescape(resourceAttr) if resourceAttr
         nodeID = nodeID_check(el, RDF::NTriples.unescape(nodeID)) if nodeID
 
-        add_debug(child, "attrs: #{attrs.inspect}")
-        add_debug(child, "datatype: #{datatype}") if datatype
-        add_debug(child, "parseType: #{parseType}") if parseType
-        add_debug(child, "resource: #{resourceAttr}") if resourceAttr
-        add_debug(child, "nodeID: #{nodeID}") if nodeID
-        add_debug(child, "id: #{id}") if id
+        add_debug(child) {"attrs: #{attrs.inspect}"}
+        add_debug(child) {"datatype: #{datatype}"} if datatype
+        add_debug(child) {"parseType: #{parseType}"} if parseType
+        add_debug(child) {"resource: #{resourceAttr}"} if resourceAttr
+        add_debug(child) {"nodeID: #{nodeID}"} if nodeID
+        add_debug(child) {"id: #{id}"} if id
         
         if attrs.empty? && datatype.nil? && parseType.nil? && element_nodes.length == 1
           # Production resourcePropertyElt
@@ -368,7 +370,7 @@ module RDF::RDFXML
             prefix(prefix, value)
           end
           new_node_element = element_nodes.first
-          add_debug(child, "resourcePropertyElt: #{node_path(new_node_element)}")
+          add_debug(child) {"resourcePropertyElt: #{node_path(new_node_element)}"}
           new_subject = nodeElement(new_node_element, new_ec)
           add_triple(child, subject, predicate, new_subject)
         elsif attrs.empty? && parseType.nil? && element_nodes.length == 0 && text_nodes.length > 0
@@ -487,7 +489,7 @@ module RDF::RDFXML
 
             # produce triples for attributes
             attrs.each_pair do |attr, val|
-              add_debug(el, "attr: #{attr.name}='#{val}'")
+              add_debug(el) {"attr: #{attr.name}='#{val}'"}
               
               if attr.uri.to_s == RDF.type.to_s
                 add_triple(child, resource, RDF.type, val)
@@ -542,16 +544,16 @@ module RDF::RDFXML
 
       case
       when id
-        add_debug(el, "parse_subject, id: '#{RDF::NTriples.unescape(id.value)}'")
+        add_debug(el) {"parse_subject, id: #{RDF::NTriples.unescape(id.value).inspect}"}
         id_check(el, RDF::NTriples.unescape(id.value), ec.base) # Returns URI
       when nodeID
         # The value of rdf:nodeID must match the XML Name production
         nodeID = nodeID_check(el, RDF::NTriples.unescape(nodeID.value))
-        add_debug(el, "parse_subject, nodeID: '#{nodeID}")
+        add_debug(el) {"parse_subject, nodeID: #{nodeID.inspect}"}
         bnode(nodeID)
       when about
         about = RDF::NTriples.unescape(about.value)
-        add_debug(el, "parse_subject, about: '#{about}'")
+        add_debug(el) {"parse_subject, about: #{about.inspect}"}
         ec.base.join(about)
       else
         add_debug(el, "parse_subject, BNode")
@@ -627,7 +629,7 @@ module RDF::RDFXML
     def old_property_check(el)
       el.attribute_nodes.each do |attr|
         if OLD_TERMS.include?(attr.uri.to_s)
-          add_debug(el, "Obsolete attribute '#{attr.uri}'")
+          add_debug(el) {"Obsolete attribute '#{attr.uri}'"}
           raise RDF::ReaderError.new("Obsolete attribute '#{attr.uri}'") if validate?
         end
       end

data/lib/rdf/rdfxml/writer.rb

@@ -138,23 +138,23 @@ module RDF::RDFXML
 
       doc = Nokogiri::XML::Document.new
 
-      add_debug "\nserialize: graph of size #{@graph.size}"
-      add_debug "options: #{@options.inspect}"
+      add_debug {"\nserialize: graph of size #{@graph.size}"}
+      add_debug {"options: #{@options.inspect}"}
 
       preprocess
 
       prefix(:rdf, RDF.to_uri)
-      prefix(:xml, RDF::XML) if @base_uri || @lang
+      prefix(:xml, RDF::XML) if base_uri || @lang
       
-      add_debug "\nserialize: graph namespaces: #{prefixes.inspect}"
+      add_debug {"\nserialize: graph namespaces: #{prefixes.inspect}"}
       
       doc.root = Nokogiri::XML::Element.new("rdf:RDF", doc)
       doc.root["xml:lang"] = @lang if @lang
-      doc.root["xml:base"] = @base_uri if @base_uri
+      doc.root["xml:base"] = base_uri if base_uri
       
       # Add statements for each subject
       order_subjects.each do |subject|
-        #add_debug "subj: #{subject.inspect}"
+        #add_debug "{subj: #{subject.inspect}"}
         subject(subject, doc.root)
       end
 
@@ -166,7 +166,7 @@ module RDF::RDFXML
         end
       end
 
-      add_debug "doc:\n #{doc.to_xml(:encoding => "UTF-8", :indent => 2)}"
+      add_debug {"doc:\n #{doc.to_xml(:encoding => "UTF-8", :indent => 2)}"}
       doc.write_xml_to(@output, :encoding => "UTF-8", :indent => 2)
     end
     
@@ -178,22 +178,22 @@ module RDF::RDFXML
     def get_qname(resource, options = {})
       case resource
       when RDF::Node
-        add_debug "qname(#{resource.inspect}): #{resource}"
+        add_debug {"qname(#{resource.inspect}): #{resource}"}
         return resource.to_s
       when RDF::URI
         uri = resource.to_s
       else
-        add_debug "qname(#{resource.inspect}): nil"
+        add_debug {"qname(#{resource.inspect}): nil"}
         return nil
       end
 
       qname = case
       when options[:with_default] && prefix(nil) && uri.index(prefix(nil)) == 0
         # Don't cache
-        add_debug "qname(#{resource.inspect}): #{uri.sub(prefix(nil), '').inspect} (default)"
+        add_debug {"qname(#{resource.inspect}): #{uri.sub(prefix(nil), '').inspect} (default)"}
         return uri.sub(prefix(nil), '')
       when @uri_to_qname.has_key?(uri)
-        add_debug "qname(#{resource.inspect}): #{@uri_to_qname[uri].inspect} (cached)"
+        add_debug {"qname(#{resource.inspect}): #{@uri_to_qname[uri].inspect} (cached)"}
         return @uri_to_qname[uri]
       when u = @uri_to_prefix.keys.detect {|u| uri.index(u.to_s) == 0 && NC_REGEXP.match(uri[u.to_s.length..-1])}
         # Use a defined prefix
@@ -225,19 +225,19 @@ module RDF::RDFXML
         "#{@gen_prefix}:#{suffix}"
       end
       
-      add_debug "qname(#{resource.inspect}): #{qname.inspect}"
+      add_debug {"qname(#{resource.inspect}): #{qname.inspect}"}
       @uri_to_qname[uri] = qname
     rescue Addressable::URI::InvalidURIError => e
       raise RDF::WriterError, "Invalid URI #{uri.inspect}: #{e.message}"
     end
     
     protected
-    # If @base_uri is defined, use it to try to make uri relative
+    # 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
+      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 none
@@ -259,7 +259,7 @@ module RDF::RDFXML
       
       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}"
+          #add_debug "{order_subjects: #{subject.inspect}"}
           subjects << subject
           seen[subject] = @top_levels[subject] = true
         end
@@ -285,7 +285,7 @@ module RDF::RDFXML
       @options[:prefixes] = {}  # Will define actual used when matched
 
       if default_namespace
-        add_debug("preprocess: default_namespace: #{default_namespace}")
+        add_debug {"preprocess: default_namespace: #{default_namespace}"}
         prefix(nil, default_namespace) 
       end
 
@@ -296,7 +296,7 @@ module RDF::RDFXML
     # prefixes.
     # @param [Statement] statement
     def preprocess_statement(statement)
-      #add_debug "preprocess: #{statement.inspect}"
+      #add_debug {"preprocess: #{statement.inspect}"}
       references = ref_count(statement.object) + 1
       @references[statement.object] = references
       @subjects[statement.subject] = true
@@ -328,7 +328,7 @@ module RDF::RDFXML
       if !is_done?(subject)
         subject_done(subject)
         properties = @graph.properties(subject)
-        add_debug "subject: #{subject.inspect}, props: #{properties.inspect}"
+        add_debug {"subject: #{subject.inspect}, props: #{properties.inspect}"}
 
         @graph.query(:subject => subject).each do |st|
           raise RDF::WriterError, "Illegal use of predicate #{st.predicate.inspect}, not supported in RDF/XML" unless st.predicate.uri?
@@ -345,7 +345,7 @@ module RDF::RDFXML
           properties[RDF.type.to_s] = [rest].flatten.compact
         end
         prop_list = order_properties(properties)
-        add_debug "=> property order: #{prop_list.to_sentence}"
+        add_debug {"=> property order: #{prop_list.to_sentence}"}
 
         if qname
           rdf_type = nil
@@ -381,7 +381,7 @@ module RDF::RDFXML
           end
         end
       elsif @force_RDF_about.include?(subject)
-        add_debug "subject: #{subject.inspect}, force about"
+        add_debug {"subject: #{subject.inspect}, force about"}
         node = Nokogiri::XML::Element.new("rdf:Description", parent_node.document)
         if subject.is_a?(RDF::Node)
           node["rdf:nodeID"] = subject.id
@@ -403,7 +403,13 @@ module RDF::RDFXML
       qname = get_qname(prop, :with_default => !as_attr)
       raise RDF::WriterError, "No qname generated for <#{prop}>" unless qname
 
-      add_debug "predicate: #{qname}, as_attr: #{as_attr}, object: #{object.inspect}, done: #{is_done?(object)}, subject: #{@subjects.include?(object)}"
+      add_debug do
+        "predicate: #{qname}, " +
+        "as_attr: #{as_attr}, " +
+        "object: #{object.inspect}, " +
+        "done: #{is_done?(object)}, " +
+        "subject: #{@subjects.include?(object)}"
+      end
       #qname = "rdf:li" if qname.match(/rdf:_\d+/)
       pred_node = Nokogiri::XML::Element.new(qname, node.document)
       
@@ -416,7 +422,7 @@ module RDF::RDFXML
 
       # Check to see if it can be serialized as a collection
       if conformant_list
-        add_debug("=> as collection: [#{col.map(&:to_s).join(", ")}]")
+        add_debug {"=> as collection: [#{col.map(&:to_s).join(", ")}]"}
         # Serialize list as parseType="Collection"
         pred_node.add_child(Nokogiri::XML::Comment.new(node.document, "Serialization for #{object}")) if RDF::RDFXML::debug?
         pred_node["rdf:parseType"] = "Collection"
@@ -426,7 +432,7 @@ module RDF::RDFXML
           item = o_props[RDF.first.to_s].first
           object = o_props[RDF.rest.to_s].first
           o_props = @graph.properties(object)
-          add_debug("=> li first: #{item}, rest: #{object}")
+          add_debug {"=> li first: #{item}, rest: #{object}"}
           @force_RDF_about[item] = true
           subject(item, pred_node)
         end
@@ -435,16 +441,16 @@ module RDF::RDFXML
         pred_node.unlink
         pred_node = nil
         node[qname] = object.is_a?(RDF::URI) ? relativize(object) : object.value
-        add_debug("=> as attribute: node[#{qname}]=#{node[qname]}, #{object.class}")
+        add_debug {"=> as attribute: node[#{qname}]=#{node[qname]}, #{object.class}"}
       elsif object.literal?
         # Serialize as element
-        add_debug("predicate as element: #{attrs.inspect}")
+        add_debug {"predicate as element: #{attrs.inspect}"}
         attrs.each_pair do |a, av|
           next if a.to_s == "xml:lang" && av.to_s == @lang # Lang already specified, don't repeat
-          add_debug "=> elt attr #{a}=#{av}"
+          add_debug {"=> elt attr #{a}=#{av}"}
           pred_node[a] = av.to_s
         end
-        add_debug "=> elt #{'xmllit ' if object.literal? && object.datatype == RDF.XMLLiteral}content=#{args.first}" if !args.empty?
+        add_debug {"=> elt #{'xmllit ' if object.literal? && object.datatype == RDF.XMLLiteral}content=#{args.first}"} if !args.empty?
         if object.datatype == RDF.XMLLiteral
           pred_node.inner_html = args.first.to_s
         elsif args.first
@@ -468,7 +474,7 @@ module RDF::RDFXML
 
     # Mark a subject as done.
     def subject_done(subject)
-      add_debug("subject_done: #{subject}")
+      add_debug {"subject_done: #{subject}"}
       @serialized[subject] = true
     end
     
@@ -478,7 +484,7 @@ module RDF::RDFXML
     end
 
     def is_done?(subject)
-      #add_debug("is_done?(#{subject}): #{@serialized.include?(subject)}")
+      #add_debug {"is_done?(#{subject}): #{@serialized.include?(subject)}"}
       @serialized.include?(subject)
     end
     
@@ -544,9 +550,12 @@ module RDF::RDFXML
     
     # Add debug event to debug array, if specified
     #
-    # @param [String] message::
-    def add_debug(message)
-      msg = "#{indent}#{message}"
+    # @param [String] message
+    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
+    def add_debug(message = "")
+      return unless ::RDF::RDFXML.debug? || @debug
+      message = message + yield if block_given?
+      msg = "#{'  ' * @depth}#{message}"
       STDERR.puts msg if ::RDF::RDFXML.debug?
       @debug << msg if @debug.is_a?(Array)
     end