rdf-rdfa 1.99.3 → 2.0.0.beta1

data/VERSION

@@ -1 +1 @@
-1.99.3
+2.0.0.beta1

data/lib/rdf/rdfa.rb

@@ -35,8 +35,5 @@ module RDF
     HTML_RDFA_CONTEXT   = "http://www.w3.org/2011/rdfa-context/html-rdfa-1.1"
     XHTML_RDFA_CONTEXT  = "http://www.w3.org/2011/rdfa-context/xhtml-rdfa-1.1"
     XML_RDFA_CONTEXT    = "http://www.w3.org/2011/rdfa-context/rdfa-1.1"
-    
-    def self.debug?; @debug; end
-    def self.debug=(value); @debug = value; end
   end
 end

data/lib/rdf/rdfa/context.rb

@@ -8,6 +8,8 @@ module RDF::RDFa
   # The class may be backed by an RDF::Repository, which will be used to retrieve a context graph
   # or to load into, if no such graph exists
   class Context
+    include RDF::Util::Logger
+
     # Prefix mappings defined in this context
     # @!attribute [r] prefixes
     # @return  [Hash{Symbol => RDF::URI}]
@@ -43,6 +45,7 @@ module RDF::RDFa
       @prefixes = options.fetch(:prefixes, {})
       @terms = options.fetch(:terms, {})
       @vocabulary = options[:vocabulary]
+      @options = options.dup
       
       yield(self) if block_given?
       self
@@ -61,7 +64,6 @@ module RDF::RDFa
     ##
     # Repository used for saving contexts
     # @return [RDF::Repository]
-    # @raise [RDF::RDFa::ContextError] if context does not support contexts
     def self.repository
       @repository ||= RDF::Repository.new(title: "RDFa Contexts")
     end
@@ -71,7 +73,13 @@ module RDF::RDFa
     # @param [RDF::Repository] repo
     # @return [RDF::Repository]
     def self.repository=(repo)
-      raise ContextError, "Context Repository must support context" unless repo.supports?(:context)
+      unless repo.supports?(:graph_name)
+        if respond_to?(:log_fatal)
+          log_fatal("Context Repository must support graph_name", exception: ContextError)
+        else
+          abort("Context Repository must support graph_name")
+        end
+      end
       @repository = repo
     end
     
@@ -87,18 +95,22 @@ module RDF::RDFa
       cache[uri] = Struct.new(:prefixes, :terms, :vocabulary).new({}, {}, nil)
       # Now do the actual load
       cache[uri] = new(uri) do |context|
-        STDERR.puts("process_context: retrieve context <#{uri}>") if RDF::RDFa.debug?
+        log_debug("process_context: retrieve context <#{uri}>") if respond_to?(:log_debug)
         Context.load(uri)
-        context.parse(repository.query(context: uri))
+        context.parse(repository.query(graph_name: uri))
       end
     rescue Exception => e
-      raise ContextError, "Context #{uri}: #{e.message}", e.backtrace
+      if respond_to?(:log_fatal)
+        log_error("Context #{uri}: #{e.message}")
+      else
+        abort("Context #{uri}: #{e.message}")
+      end
     end
 
     # Load context into repository
     def self.load(uri)
       uri = RDF::URI.intern(uri)
-      repository.load(uri.to_s, base_uri: uri, context: uri) unless repository.has_context?(uri)
+      repository.load(uri.to_s, base_uri: uri, graph_name: uri) unless repository.has_graph?(uri)
     end
     
     # @return [RDF::Repository]
@@ -146,12 +158,12 @@ module RDF::RDFa
     # @param [RDF::Enumerable, Enumerator] enumerable
     # @return [void] ignored
     def parse(enumerable)
-      STDERR.puts("process_context: parse context <#{uri}>") if RDF::RDFa.debug?
+      log_debug("process_context: parse context <#{uri}>") if respond_to?(:log_debug)
       resource_info = {}
       enumerable.each do |statement|
         res = resource_info[statement.subject] ||= {}
         next unless statement.object.is_a?(RDF::Literal)
-        STDERR.puts("process_context: statement=#{statement.inspect}") if RDF::RDFa.debug?
+        log_debug("process_context: statement=#{statement.inspect}") if respond_to?(:log_debug)
         %w(uri term prefix vocabulary).each do |term|
           res[term] ||= statement.object.value if statement.predicate == RDF::RDFA[term]
         end
@@ -164,7 +176,7 @@ module RDF::RDFa
         term = res["term"]
         prefix = res["prefix"]
         vocab = res["vocabulary"]
-        STDERR.puts("process_context: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}, vocabulary=#{vocab.inspect}") if RDF::RDFa.debug?
+        log_debug("process_context: uri=#{uri.inspect}, term=#{term.inspect}, prefix=#{prefix.inspect}, vocabulary=#{vocab.inspect}") if respond_to?(:log_debug)
 
         @vocabulary = vocab if vocab
         

data/lib/rdf/rdfa/context/xml.rb

@@ -7,6 +7,7 @@ class RDF::RDFa::Context
       @_rdfa_1_1_prof ||= RDF::RDFa::Context.new(RDF::URI("http://www.w3.org/2011/rdfa-context/rdfa-1.1"), {
         prefixes: {
           cc:      "http://creativecommons.org/ns#",
+          csvw:    "http://www.w3.org/ns/csvw#",
           ctag:    "http://commontag.org/ns#",
           dc:      "http://purl.org/dc/terms/",
           dc11:    "http://purl.org/dc/elements/1.1/",

data/lib/rdf/rdfa/format.rb

@@ -19,7 +19,9 @@ module RDF::RDFa
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
     content_encoding 'utf-8'
-    content_type     'text/html', extension: :html
+    content_type     'text/html',
+      aliases: %w(application/xhtml+xml image/svg+xml),
+      extensions: [:html, :xhtml, :svg]
     reader { RDF::RDFa::Reader }
     writer { RDF::RDFa::Writer }
 
@@ -37,65 +39,9 @@ module RDF::RDFa
        sample.match(/<[^>]*DOCTYPE\s+html[^>]*>.*xmlns:/im)
       ) && !sample.match(/<(\w+:)?(RDF)/)
     end
-  end
-
-  # Aliases for RDFa::Format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an HTML format class
-  #   RDF::Format.for(:lite)         # RDF::RDFa::Lite
-  #   RDF::Format.for(:lite).reader  # RDF::RDFa::Reader
-  #   RDF::Format.for(:lite).writer  # RDF::RDFa::Writer
-  class Lite < RDF::Format
-    content_encoding 'utf-8'
-    content_type     'text/html', extension: :html
-    reader { RDF::RDFa::Reader }
-    writer { RDF::RDFa::Writer }
-  end
-
-  # Aliases for RDFa::Format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an HTML format class
-  #   RDF::Format.for(:html)         # RDF::RDFa::HTML
-  #   RDF::Format.for(:html).reader  # RDF::RDFa::Reader
-  #   RDF::Format.for(:html).writer  # RDF::RDFa::Writer
-  class HTML < RDF::Format
-    content_encoding 'utf-8'
-    content_type     'text/html', extension: :html
-    reader { RDF::RDFa::Reader }
-    writer { RDF::RDFa::Writer }
-  end
-
-  # Aliases for RDFa::Format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an HTML format class
-  #   RDF::Format.for(:xhtml)         # RDF::RDFa::XHTML
-  #   RDF::Format.for(:xhtml).reader  # RDF::RDFa::Reader
-  #   RDF::Format.for(:xhtml).writer  # RDF::RDFa::Writer
-  class XHTML < RDF::Format
-    content_encoding 'utf-8'
-    content_type     'application/xhtml+xml', extension: :xhtml
-    reader { RDF::RDFa::Reader }
-    writer { RDF::RDFa::Writer }
-  end
 
-  # Aliases for RDFa::Format
-  #
-  # This allows the following:
-  #
-  # @example Obtaining an HTML format class
-  #   RDF::Format.for(:svg)         # RDF::RDFa::SVG
-  #   RDF::Format.for(:svg).reader  # RDF::RDFa::Reader
-  #   RDF::Format.for(:svg).writer  # RDF::RDFa::Writer
-  class SVG < RDF::Format
-    content_encoding 'utf-8'
-    content_type     'image/svg+xml', extension: :svg
-    reader { RDF::RDFa::Reader }
-    writer { RDF::RDFa::Writer }
+    def self.symbols
+      [:rdfa, :lite, :html, :xhtml, :svg]
+    end
   end
 end

data/lib/rdf/rdfa/reader.rb

@@ -1,6 +1,6 @@
 begin
   require 'nokogiri'
-rescue LoadError => e
+rescue LoadError
   :rexml
 end
 require 'rdf/ntriples'
@@ -28,6 +28,7 @@ module RDF::RDFa
   class Reader < RDF::Reader
     format Format
     include Expansion
+    include RDF::Util::Logger
 
     XHTML = "http://www.w3.org/1999/xhtml"
     
@@ -99,16 +100,6 @@ module RDF::RDFa
     # @return [Module]
     attr_reader :implementation
 
-    ##
-    # Warnings found during processing
-    # @return [Array<String>]
-    attr_reader :warnings
-
-    ##
-    # Accumulated errors found during processing
-    # @return [Array<String>]
-    attr_reader :errors
-
     # The Recursive Baggage
     # @private
     class EvaluationContext # :nodoc:
@@ -252,6 +243,31 @@ module RDF::RDFa
       end
     end
 
+    ##
+    # RDFa Reader options
+    # @see http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Reader#options-class_method
+    def self.options
+      super + [
+        RDF::CLI::Option.new(
+          symbol: :vocab_expansion,
+          datatype: TrueClass,
+          on: ["--vocab-expansion"],
+          description: "Perform OWL2 expansion on the resulting graph.") {true},
+        RDF::CLI::Option.new(
+          symbol: :host_language,
+          datatype: %w(xml xhtml1 xhtml5 html4 svg),
+          on: ["--host-language HOSTLANG", %w(xml xhtml1 xhtml5 html4 svg)],
+          description: "Host Language. One of xml, xhtml1, xhtml5, html4, or svg") do |arg|
+            arg.to_sym
+        end,
+        RDF::CLI::Option.new(
+          symbol: :rdfagraph,
+          datatype: %w(output processor both),
+          on: ["--rdfagraph RDFAGRAPH", %w(output processor both)],
+          description: "Used to indicate if either or both of the :output or :processor graphs are output.") {|arg| arg.to_sym},
+      ]
+    end
+
     ##
     # Initializes the RDFa reader instance.
     #
@@ -276,12 +292,6 @@ module RDF::RDFa
     #   Value is an array containing on or both of :output or :processor.
     # @option options [Repository] :vocab_repository (nil)
     #   Repository to save loaded vocabularies.
-    # @option options [Array] :errors
-    #   array for placing errors found when parsing
-    # @option options [Array] :warnings
-    #   array for placing warnings found when parsing
-    # @option options [Array] :debug
-    #   Array to place debug messages
     # @return [reader]
     # @yield  [reader] `self`
     # @yieldparam  [RDF::Reader] reader
@@ -289,13 +299,11 @@ module RDF::RDFa
     # @raise [RDF::ReaderError] if _validate_
     def initialize(input = $stdin, options = {}, &block)
       super do
-        @errors = @options[:errors]
-        @warnings = @options[:warnings]
-        @debug = @options[:debug]
         @options = {reference_folding: true}.merge(@options)
         @repository = RDF::Repository.new
 
         @options[:rdfagraph] = case @options[:rdfagraph]
+        when 'all' then [:output, :processor]
         when String, Symbol then @options[:rdfagraph].to_s.split(',').map(&:strip).map(&:to_sym)
         when Array then @options[:rdfagraph].map {|o| o.to_s.to_sym}
         else  []
@@ -396,9 +404,13 @@ module RDF::RDFa
 
             if reader = RDF::Reader.for(content_type: type.to_s)
               add_debug(el, "=> reader #{reader.to_sym}")
-              # Wrap input in a RemoteDocument with appropriate content-type
+              # Wrap input in a RemoteDocument with appropriate content-type and base
               doc = if input.is_a?(String)
-                RDF::Util::File::RemoteDocument.new(input, options.merge(content_type: type.to_s))
+                RDF::Util::File::RemoteDocument.new(input,
+                                                    options.merge(
+                                                      content_type: type.to_s,
+                                                      base_uri: base_uri
+                                                    ))
               else
                 input
               end
@@ -457,6 +469,10 @@ module RDF::RDFa
             yield RDF::Statement.new(*statement.to_triple) if @options[:rdfagraph].include?(:processor)
           end
         end
+
+        if validate? && log_statistics[:error]
+          raise RDF::ReaderError, "Errors found during processing"
+        end
       end
       enum_for(:each_statement)
     end
@@ -496,30 +512,30 @@ module RDF::RDFa
     # @param [#display_path, #to_s] node XML Node or string for showing context
     # @param [String] message
     # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
-    def add_debug(node, message = "")
-      return unless ::RDF::RDFa.debug? || @debug
-      message = message + yield if block_given?
-      add_processor_message(node, message, RDF::RDFA.Info)
+    def add_debug(node, message = "", &block)
+      add_processor_message(node, message, nil, &block)
     end
 
-    def add_info(node, message, process_class = RDF::RDFA.Info)
-      add_processor_message(node, message, process_class)
+    def add_info(node, message, process_class = RDF::RDFA.Info, &block)
+      add_processor_message(node, message, process_class, &block)
     end
     
     def add_warning(node, message, process_class = RDF::RDFA.Warning)
-      @warnings << "#{node_path(node)}: #{message}" if @warnings
       add_processor_message(node, message, process_class)
     end
     
     def add_error(node, message, process_class = RDF::RDFA.Error)
-      @errors << "#{node_path(node)}: #{message}" if @errors
       add_processor_message(node, message, process_class)
-      raise RDF::ReaderError, message if validate?
     end
     
-    def add_processor_message(node, message, process_class)
-      puts "#{node_path(node)}: #{message}" if ::RDF::RDFa.debug?
-      @debug << "#{node_path(node)}: #{message}" if @debug.is_a?(Array)
+    def add_processor_message(node, message, process_class, &block)
+      case process_class
+      when RDF::RDFA.Error    then log_error(node_path(node), message, &block)
+      when RDF::RDFA.Warning  then log_warn(node_path(node), message, &block)
+      when RDF::RDFA.Info     then log_info(node_path(node), message, &block)
+      else                         log_debug(node_path(node), message, &block)
+      end
+      process_class ||= RDF::RDFA.Info
       if @options[:processor_callback] || @options[:rdfagraph].include?(:processor)
         n = RDF::Node.new
         processor_statements = [
@@ -605,10 +621,10 @@ module RDF::RDFa
             next
           end
 
-          old_debug = RDF::RDFa.debug?
+          old_logger = @options[:logger]
           begin
             add_info(root, "load_initial_contexts: load #{uri.to_base}")
-            RDF::RDFa.debug = false
+            @options[:logger] = false
             context = Context.find(uri)
 
             # Add URI Mappings to prefixes
@@ -619,11 +635,11 @@ module RDF::RDFa
             yield :term_mappings, context.terms unless context.terms.empty?
             yield :default_vocabulary, context.vocabulary if context.vocabulary
           rescue Exception => e
-            RDF::RDFa.debug = old_debug
+            options[:logger] = old_logger
             add_error(root, e.message)
             raise # In case we're not in strict mode, we need to be sure processing stops
           ensure
-            RDF::RDFa.debug = old_debug
+            @options[:logger] = old_logger
           end
         end
     end
@@ -1174,7 +1190,7 @@ module RDF::RDFa
               add_debug(element, "[Step 11] value literal (#{attrs[:value]})")
               v = attrs[:value].to_s
               # Figure it out by parsing
-              dt_lit = %w(Integer Float Double).map {|t| RDF::Literal.const_get(t)}.detect do |dt|
+              dt_lit = %w(Integer Decimal Double).map {|t| RDF::Literal.const_get(t)}.detect do |dt|
                 v.match(dt::GRAMMAR)
               end || RDF::Literal
               dt_lit.new(v)

data/lib/rdf/rdfa/reader/nokogiri.rb

@@ -280,7 +280,7 @@ module RDF::RDFa
       # Document errors
       def doc_errors
         # FIXME: Nokogiri version 1.5.5 thinks many HTML5 elements are invalid
-        @doc.errors.reject {|e| e.to_s =~ /(Tag (?:article|aside|audio|canvas|command|data|datalist|details|embed|figure|footer|header|hgroup|keygen|main|mark|meter|nav|output|progress|ruby|section|source|time|track|video|wbr) invalid|Missing attribute name)/}
+        @doc.errors.reject {|e| e.to_s =~ /(Tag (?:article|aside|audio|canvas|command|datalist|details|embed|figcaption|figure|footer|header|hgroup|keygen|main|mark|meter|nav|output|progress|ruby|section|time|video|wbr) invalid|Missing attribute name)/}
       end
       
       ##

data/lib/rdf/rdfa/writer.rb

@@ -49,6 +49,7 @@ module RDF::RDFa
   # @author [Gregg Kellogg](http://kellogg-assoc.com/)
   class Writer < RDF::Writer
     format RDF::RDFa::Format
+    include RDF::Util::Logger
 
     # Defines rdf:type of subjects to be emitted at the beginning of the document.
     # @return [Array<URI>]
@@ -62,8 +63,9 @@ module RDF::RDFa
     # @return [Array<URI>]
     attr :heading_predicates
 
-    # to preserve whitespace without using entities
-    HAML_OPTIONS = Gem.loaded_specs['haml'].version < Gem::Version.create('5.0') ? { ugly: false } : {}
+    HAML_OPTIONS = {
+      ugly: false, # to preserve whitespace without using entities
+    }
 
     # @return [Graph] Graph of statements serialized
     attr_accessor :graph
@@ -71,6 +73,19 @@ module RDF::RDFa
     # @return [RDF::URI] Base URI used for relativizing URIs
     attr_accessor :base_uri
 
+    ##
+    # RDFa Writer options
+    # @see http://www.rubydoc.info/github/ruby-rdf/rdf/RDF/Writer#options-class_method
+    def self.options
+      super + [
+        RDF::CLI::Option.new(
+          symbol: :lang,
+          datatype: String,
+          on: ["--lang"],
+          description: "Output as root @lang attribute, and avoid generation _@lang_ where possible."),
+      ]
+    end
+
     ##
     # Initializes the RDFa writer instance.
     #
@@ -124,25 +139,6 @@ module RDF::RDFa
       end
     end
 
-    ##
-    # Write whole graph
-    #
-    # @param  [Graph] graph
-    # @return [void]
-    def write_graph(graph)
-      @graph = graph
-    end
-
-    ##
-    # Addes a statement to be serialized
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @raise [RDF::WriterError] if validating and attempting to write an invalid {RDF::Term}.
-    def write_statement(statement)
-      raise RDF::WriterError, "Statement #{statement.inspect} is invalid" if validate? && statement.invalid?
-      @graph.insert(statement)
-    end
-
     ##
     # Addes a triple to be serialized
     # @param  [RDF::Resource] subject
@@ -153,7 +149,7 @@ module RDF::RDFa
     # @abstract
     # @raise [RDF::WriterError] if validating and attempting to write an invalid {RDF::Term}.
     def write_triple(subject, predicate, object)
-      write_statement Statement.new(subject, predicate, object)
+      @graph.insert(RDF::Statement(subject, predicate, object))
     end
 
     ##
@@ -163,16 +159,15 @@ module RDF::RDFa
     def write_epilogue
       @base_uri = RDF::URI(@options[:base_uri]) if @options[:base_uri]
       @lang = @options[:lang]
-      @debug = @options[:debug]
       self.reset
 
-      add_debug {"\nserialize: graph size: #{@graph.size}"}
+      log_debug {"\nserialize: graph size: #{@graph.size}"}
 
       preprocess
 
       # Prefixes
       prefix = prefixes.keys.map {|pk| "#{pk}: #{prefixes[pk]}"}.sort.join(" ") unless prefixes.empty?
-      add_debug {"\nserialize: prefixes: #{prefix.inspect}"}
+      log_debug {"\nserialize: prefixes: #{prefix.inspect}"}
 
       subjects = order_subjects
 
@@ -196,6 +191,8 @@ module RDF::RDFa
         subject(s)
       end
       @output.write(doc)
+
+      super
     end
 
     protected
@@ -307,7 +304,7 @@ module RDF::RDFa
     # @return String
     #   The rendered document is returned as a string
     def render_property(predicate, objects, options = {}, &block)
-      add_debug {"render_property(#{predicate}): #{objects.inspect}, #{options.inspect}"}
+      log_debug {"render_property(#{predicate}): #{objects.inspect}, #{options.inspect}"}
       # If there are multiple objects, and no :property_values is defined, call recursively with
       # each object
 
@@ -317,19 +314,19 @@ module RDF::RDFa
       # Separate out the objects which are lists and render separately
       list_objects = objects.reject do |o|
         o == RDF.nil ||
-        (l = RDF::List.new(o, @graph)).invalid?
+        (l = RDF::List.new(subject: o, graph: @graph)).invalid?
       end
       unless list_objects.empty?
         # Render non-list objects
-        add_debug {"properties with lists: #{list_objects} non-lists: #{objects - list_objects}"}
-        nl = depth {render_property(predicate, objects - list_objects, options, &block)} unless objects == list_objects
+        log_debug {"properties with lists: #{list_objects} non-lists: #{objects - list_objects}"}
+        nl = log_depth {render_property(predicate, objects - list_objects, options, &block)} unless objects == list_objects
         return nl.to_s + list_objects.map do |object|
           # Render each list as multiple properties and set :inlist to true
-          list = RDF::List.new(object, @graph)
+          list = RDF::List.new(subject: object, graph: @graph)
           list.each_statement {|st| subject_done(st.subject)}
 
-          add_debug {"list: #{list.inspect} #{list.to_a}"}
-          depth do
+          log_debug {"list: #{list.inspect} #{list.to_a}"}
+          log_depth do
             render_property(predicate, list.to_a, options.merge(inlist: "true")) do |object|
               yield(object, true) if block_given?
             end
@@ -340,10 +337,10 @@ module RDF::RDFa
       if objects.length > 1 && template.nil?
         # If there is no property_values template, render each property using property_value template
         objects.map do |object|
-          depth {render_property(predicate, [object], options, &block)}
+          log_depth {render_property(predicate, [object], options, &block)}
         end.join(" ")
       else
-        raise RDF::WriterError, "Missing property template" if template.nil?
+        log_fatal("Missing property template", exception: RDF::WriterError) if template.nil?
 
         template = options[:haml] || (
           objects.to_a.length > 1 &&
@@ -410,7 +407,7 @@ module RDF::RDFa
       select {|s| !seen.include?(s)}.
       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}"}
+          #log_debug {"order_subjects: #{subject.inspect}"}
           subjects << subject
           seen[subject] = true
         end
@@ -422,7 +419,7 @@ module RDF::RDFa
         map {|r| [r.is_a?(RDF::Node) ? 1 : 0, ref_count(r), r]}.
         sort
 
-      add_debug {"order_subjects: #{recursable.inspect}"}
+      log_debug {"order_subjects: #{recursable.inspect}"}
 
       subjects += recursable.map{|r| r.last}
     end
@@ -446,7 +443,7 @@ module RDF::RDFa
         prop_list << prop.to_s
       end
 
-      add_debug {"order_properties: #{prop_list.join(', ')}"}
+      log_debug {"order_properties: #{prop_list.join(', ')}"}
       prop_list
     end
 
@@ -454,7 +451,7 @@ module RDF::RDFa
     # @param [RDF::Statement] statement
     # @return [ignored]
     def preprocess_statement(statement)
-      #add_debug {"preprocess: #{statement.inspect}"}
+      #log_debug {"preprocess: #{statement.inspect}"}
       bump_reference(statement.object)
       @subjects[statement.subject] = true
       get_curie(statement.subject)
@@ -465,7 +462,7 @@ module RDF::RDFa
 
     # Reset parser to run again
     def reset
-      @depth = 0
+      @options[:log_depth] = 0
       prefixes = {}
       @references = {}
       @serialized = {}
@@ -502,7 +499,7 @@ module RDF::RDFa
       typeof = type_of(properties.delete(RDF.type.to_s), subject)
       prop_list = order_properties(properties)
 
-      add_debug {"props: #{prop_list.inspect}"}
+      log_debug {"props: #{prop_list.inspect}"}
 
       render_opts = {typeof: typeof, property_values: properties}.merge(options)
 
@@ -539,7 +536,7 @@ module RDF::RDFa
       # Nodes without a curie need a blank @typeof to generate a subject
       typeof ||= "" unless curie
 
-      add_debug {"subject: #{curie.inspect}, typeof: #{typeof.inspect}" }
+      log_debug {"subject: #{curie.inspect}, typeof: #{typeof.inspect}" }
 
       typeof.freeze
     end
@@ -552,17 +549,17 @@ module RDF::RDFa
       # See if there's a template based on the sorted concatenation of all types of this subject
       # or any type of this subject
       tmpl = find_template(subject)
-      add_debug {"subject: found template #{tmpl[:identifier] || tmpl.inspect}"} if tmpl
+      log_debug {"subject: found template #{tmpl[:identifier] || tmpl.inspect}"} if tmpl
 
       # Render this subject
       # If :rel is specified and :typeof is nil, use @resource instead of @about.
       # Pass other options from calling context
       with_template(tmpl) do
         render_subject(subject, prop_list, render_opts) do |pred|
-          depth do
+          log_depth do
             pred = RDF::URI(pred) if pred.is_a?(String)
             values = render_opts[:property_values][pred.to_s]
-            add_debug {"subject: #{get_curie(subject)}, pred: #{get_curie(pred)}, values: #{values.inspect}"}
+            log_debug {"subject: #{get_curie(subject)}, pred: #{get_curie(pred)}, values: #{values.inspect}"}
             predicate(pred, values)
           end
         end
@@ -578,15 +575,15 @@ module RDF::RDFa
     #   Objects to serialize
     # @return [String]
     def predicate(predicate, objects)
-      add_debug {"predicate: #{predicate.inspect}, objects: #{objects}"}
+      log_debug {"predicate: #{predicate.inspect}, objects: #{objects}"}
 
       return if objects.to_a.empty?
 
-      add_debug {"predicate: #{get_curie(predicate)}"}
+      log_debug {"predicate: #{get_curie(predicate)}"}
       render_property(predicate, objects) do |o, inlist=nil|
         # Yields each object, for potential recursive definition.
         # If nil is returned, a leaf is produced
-        depth {subject(o, rel: get_curie(predicate), inlist: inlist, element: (:li if objects.length > 1 || inlist))} if !is_done?(o) && @subjects.include?(o)
+        log_depth {subject(o, rel: get_curie(predicate), inlist: inlist, element: (:li if objects.length > 1 || inlist))} if !is_done?(o) && @subjects.include?(o)
       end
     end
 
@@ -596,8 +593,12 @@ module RDF::RDFa
     # @return [String, nil]
     # @raise [RDF::WriterError]
     def get_dt_curie(literal)
-      raise RDF::WriterError, "Getting datatype CURIE for #{literal.inspect}, which must be a literal" unless literal.is_a?(RDF::Literal)
-      get_curie(literal.datatype) if literal.literal? && literal.datatype?
+      if literal.is_a?(RDF::Literal)
+        get_curie(literal.datatype) if literal.literal? && literal.datatype?
+      else
+        log_error("Getting datatype CURIE for #{literal.inspect}, which must be a literal")
+        nil
+      end
     end
 
     # Haml rendering helper. Return language for plain literal, if there is no language, or it is the same as the document, return nil
@@ -606,8 +607,12 @@ module RDF::RDFa
     # @return [Symbol, nil]
     # @raise [RDF::WriterError]
     def get_lang(literal)
-      raise RDF::WriterError, "Getting datatype CURIE for #{literal.inspect}, which must be a literal" unless literal.is_a?(RDF::Literal)
-      literal.language if literal.literal? && literal.language && literal.language.to_s != @lang.to_s
+      if literal.is_a?(RDF::Literal)
+        literal.language if literal.literal? && literal.language && literal.language.to_s != @lang.to_s
+      else
+        log_error("Getting language for #{literal.inspect}, which must be a literal")
+        nil
+      end
     end
 
     # Haml rendering helper. Data to be added to a @content value, for specific datatypes
@@ -616,21 +621,28 @@ module RDF::RDFa
     # @return [String, nil]
     # @raise [RDF::WriterError]
     def get_content(literal)
-      raise RDF::WriterError, "Getting content for #{literal.inspect}, which must be a literal" unless literal.is_a?(RDF::Literal)
       case literal
       when RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime, RDF::Literal::Duration
         literal.to_s
+      when RDF::Literal then nil
+      else
+        log_error("Getting content for #{literal.inspect}, which must be a literal")
+        nil
       end
     end
 
-    # Haml rendering helper. Display value for object, may be humanized into a non-canonical form
+    # Haml rendering helper. Display value for object, may be humanized into a non-canonical form 
     #
     # @param [RDF::Literal] literal
     # @return [String]
     # @raise [RDF::WriterError]
     def get_value(literal)
-      raise RDF::WriterError, "Getting value for #{literal.inspect}, which must be a literal" unless literal.is_a?(RDF::Literal)
-      literal.humanize
+      if literal.is_a?(RDF::Literal)
+        literal.humanize
+      else
+        log_error("Getting value for #{literal.inspect}, which must be a literal")
+        nil
+      end
     end
 
     # Haml rendering helper. Return an appropriate label for a resource.
@@ -639,8 +651,12 @@ module RDF::RDFa
     # @return [String]
     # @raise [RDF::WriterError]
     def get_predicate_name(resource)
-      raise RDF::WriterError, "Getting predicate name for #{resource.inspect}, which must be a resource" unless resource.is_a?(RDF::Resource)
-      get_curie(resource)
+      if resource.is_a?(RDF::URI)
+        get_curie(resource)
+      else
+        log_error("Getting predicate name for #{resource.inspect}, which must be a URI")
+        nil
+      end
     end
 
     # Haml rendering helper. Return appropriate, term, CURIE or URI for the given resource.
@@ -649,42 +665,50 @@ module RDF::RDFa
     # @return [String] value to use to identify URI
     # @raise [RDF::WriterError]
     def get_curie(resource)
-      raise RDF::WriterError, "Getting CURIE for #{resource.inspect}, which must be an RDF value" unless resource.is_a?(RDF::Value)
-      return resource.to_s unless resource.uri?
+      case resource
+      when RDF::URI
+        begin
+          uri = resource.to_s
+
+          curie = case
+          when @uri_to_term_or_curie.has_key?(uri)
+            log_debug {"get_curie(#{uri}): uri_to_term_or_curie #{@uri_to_term_or_curie[uri].inspect}"}
+            return @uri_to_term_or_curie[uri]
+          when base_uri && uri.index(base_uri.to_s) == 0
+            log_debug {"get_curie(#{uri}): base_uri (#{uri.sub(base_uri.to_s, "")})"}
+            uri.sub(base_uri.to_s, "")
+          when @vocabulary && uri.index(@vocabulary) == 0
+            log_debug {"get_curie(#{uri}): vocabulary"}
+            uri.sub(@vocabulary, "")
+          when u = @uri_to_prefix.keys.detect {|u| uri.index(u.to_s) == 0}
+            log_debug {"get_curie(#{uri}): uri_to_prefix"}
+            # Use a defined prefix
+            prefix = @uri_to_prefix[u]
+            prefix(prefix, u)  # Define for output
+            uri.sub(u.to_s, "#{prefix}:")
+          when @options[:standard_prefixes] && vocab = RDF::Vocabulary.detect {|v| uri.index(v.to_uri.to_s) == 0}
+            log_debug {"get_curie(#{uri}): standard_prefixes"}
+            prefix = vocab.__name__.to_s.split('::').last.downcase
+            prefix(prefix, vocab.to_uri) # Define for output
+            uri.sub(vocab.to_uri.to_s, "#{prefix}:")
+          else
+            log_debug {"get_curie(#{uri}): none"}
+            uri
+          end
 
-      uri = resource.to_s
+          #log_debug {"get_curie(#{resource}) => #{curie}"}
 
-      curie = case
-      when @uri_to_term_or_curie.has_key?(uri)
-        add_debug {"get_curie(#{uri}): uri_to_term_or_curie #{@uri_to_term_or_curie[uri].inspect}"}
-        return @uri_to_term_or_curie[uri]
-      when base_uri && uri.index(base_uri.to_s) == 0
-        add_debug {"get_curie(#{uri}): base_uri (#{uri.sub(base_uri.to_s, "")})"}
-        uri.sub(base_uri.to_s, "")
-      when @vocabulary && uri.index(@vocabulary) == 0
-        add_debug {"get_curie(#{uri}): vocabulary"}
-        uri.sub(@vocabulary, "")
-      when u = @uri_to_prefix.keys.detect {|u| uri.index(u.to_s) == 0}
-        add_debug {"get_curie(#{uri}): uri_to_prefix"}
-        # Use a defined prefix
-        prefix = @uri_to_prefix[u]
-        prefix(prefix, u)  # Define for output
-        uri.sub(u.to_s, "#{prefix}:")
-      when @options[:standard_prefixes] && vocab = RDF::Vocabulary.detect {|v| uri.index(v.to_uri.to_s) == 0}
-        add_debug {"get_curie(#{uri}): standard_prefixes"}
-        prefix = vocab.__name__.to_s.split('::').last.downcase
-        prefix(prefix, vocab.to_uri) # Define for output
-        uri.sub(vocab.to_uri.to_s, "#{prefix}:")
+          @uri_to_term_or_curie[uri] = curie
+        rescue ArgumentError => e
+          log_error("Invalid URI #{uri.inspect}: #{e.message}")
+          nil
+        end
+      when RDF::Node then resource.to_s
+      when RDF::Literal then nil
       else
-        add_debug {"get_curie(#{uri}): none"}
-        uri
+        log_error("Getting CURIE for #{resource.inspect}, which must be a resource")
+        nil
       end
-
-      #add_debug {"get_curie(#{resource}) => #{curie}"}
-
-      @uri_to_term_or_curie[uri] = curie
-    rescue ArgumentError => e
-      raise RDF::WriterError, "Invalid URI #{uri.inspect}: #{e.message}"
     end
     private
 
@@ -700,18 +724,6 @@ module RDF::RDFa
       CGI.escapeHTML(str).gsub(/[\n\r]/) {|c| '&#x' + c.unpack('h').first + ';'}
     end
 
-    # Increase depth around a method invocation
-    # @yield
-    #   Yields with no arguments
-    # @yieldreturn [Object] returns the result of yielding
-    # @return [Object]
-    def depth
-      @depth += 1
-      ret = yield
-      @depth -= 1
-      ret
-    end
-
     # Set the template to use within block
     # @param [Hash{Symbol => String}] templ template to use for block evaluation; merged in with the existing template.
     # @yield
@@ -743,20 +755,22 @@ module RDF::RDFa
     # @return [String]
     # @raise [RDF::WriterError]
     def hamlify(template, locals = {})
-      add_debug {"hamlify template: #{template}"}
+      log_debug {"hamlify template: #{template}"}
       template = haml_template[template] if template.is_a?(Symbol)
 
       template = template.align_left
-      add_debug {"hamlify locals: #{locals.inspect}"}
+      log_debug {"hamlify locals: #{locals.inspect}"}
 
       Haml::Engine.new(template, @options[:haml_options] || HAML_OPTIONS).render(self, locals) do |*args|
         yield(*args) if block_given?
       end
     rescue Haml::Error => e
-      raise RDF::WriterError, "#{e.inspect}\n" +
+      log_fatal("#{e.inspect}\n" +
         "rendering #{template}\n" +
         "with options #{(@options[:haml_options] || HAML_OPTIONS).inspect}\n" +
-        "and locals #{locals.inspect}"
+        "and locals #{locals.inspect}",
+        exception: RDF::WriterError
+      )
     end
 
     ##
@@ -794,18 +808,6 @@ module RDF::RDFa
     def ref_count(node)
       @references.fetch(node, 0)
     end
-
-    # Add debug event to debug array, if specified
-    #
-    # @param [String] message
-    # @yieldreturn [String] appended to message, to allow for lazy-evaulation of message
-    def add_debug(message = "")
-      return unless ::RDF::RDFa.debug? || @debug
-      message = message + yield if block_given?
-      msg = "#{'  ' * @depth}#{message}"
-      STDERR.puts msg if ::RDF::RDFa.debug?
-      @debug << msg.force_encoding("utf-8") if @debug.is_a?(Array)
-    end
   end
 end