rdf 1.0.3 → 1.0.4

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjI3YmJmYTZkOGMwMTc2M2VkYTY4YWFiZGQ2YWRlN2E0NmQ5YzIxOQ==
+  data.tar.gz: !binary |-
+    NmU0NTA4ODAwNTNkNzJmMWQ1M2U3M2IyODFiNjJkYjRhM2ZiNjM2ZA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NTM5MDM3NjEzMWZhZTYwMjg1MGZjOGY5OTY4ODMyNDIxNjZjOTJiYTdiZDhk
+    YzAyZGUyYzllYjU1ZWZkMjM4NzEzMWU4NzViNGI0ZGI4YWMzZWEyZWJlZTkz
+    MzRjOTgyMzE1ZWZjN2UyYTIwZGM5ZWI4ZDRjYjhmODg0MGY5ZGM=
+  data.tar.gz: !binary |-
+    ZTA3MDBiYzUyYTBlYjJlNTk1Njg5NDYwNzI5ZTY3MGIzNjU5NmEyMjlkZTVl
+    MzQ4MTFjMmQyZTE1NDgwODc0ZTk4YThlYzRmYjJmOTBhYjdlYzQxOGFiZTg1
+    Y2MxOTQ4NDBhNzg3YzNmYjIwNWIwNjUyYTNiYzE3MzEzZTAwMzI=

data/README

@@ -115,6 +115,23 @@ A specific sub-type of Writer can also be invoked directly:
 
     graph.dump(:nquads)
 
+## Reader/Writer convenience methods
+{RDF::Enumerable} implements `to_{format}` for each available instance of {RDF::Reader}.
+For example, if `rdf/turtle` is loaded, this allows the following:
+
+    graph = RDF::Graph.new << [:hello, RDF::DC.title, "Hello, world!"]
+    graph.to_ttl
+
+Similarly, {RDF::Mutable} implements `from_{format}` for each available instance
+of {RDF::Writer}. For example:
+
+    graph = RDF::Graph.new
+    graph.from_ttl("[ a <http://www.w3.org/1999/02/22-rdf-syntax-ns#Resource>]")
+
+Note that no prefixes are loaded automatically, however they can be provided as arguments:
+
+    graph.from_ttl("[ a rdf:Resource]", :prefixes => {:rdf => RDF.to_uri})
+
 ### Querying RDF data using basic graph patterns (BGPs)
 
     require 'rdf/ntriples'
@@ -317,6 +334,7 @@ follows:
 
 * Do your best to adhere to the existing coding conventions and idioms.
 * Don't use hard tabs, and don't leave trailing whitespace on any line.
+  Before committing, run `git diff --check` to make sure of this.
 * Do document every method you add using [YARD][] annotations. Read the
   [tutorial][YARD-GS] or just look at the existing code for examples.
 * Don't touch the `.gemspec` or `VERSION` files. If you need to change them,

data/VERSION

@@ -1 +1 @@
-1.0.3
+1.0.4

data/lib/rdf/format.rb

@@ -181,29 +181,55 @@ module RDF
     end
 
     ##
-    # Returns the set of format symbols for loaded RDF::Reader subclasses.
+    # Returns the set of format symbols for available RDF::Reader subclasses.
     #
     # @example
     #
-    #     formats = RDF::Format.reader_symbols
-    #     format = RDF::Format.for(formats.first)
+    #     symbols = RDF::Format.reader_symbols
+    #     format = RDF::Format.for(symbols.first)
     #
     # @return [Array<Symbol>]
     def self.reader_symbols
-      RDF::Format.each.to_a.map(&:reader).compact.map(&:to_sym).uniq
+      @@readers.keys.compact.map(&:to_sym).uniq
     end
 
     ##
-    # Returns the set of format symbols for loaded RDF::Writer subclasses.
+    # Returns the set of content types for available RDF::Reader subclasses.
     #
     # @example
     #
-    #     formats = RDF::Format.writer_symbols
-    #     format = RDF::Format.for(formats.first)
+    #     content_types = RDF::Format.reader_types
+    #     format = RDF::Format.for(:content_type => content_types.first)
+    #
+    # @return [Array<String>]
+    def self.reader_types
+      reader_symbols.map {|s| RDF::Format.for(s).content_type}.flatten.uniq
+    end
+
+    ##
+    # Returns the set of format symbols for available RDF::Writer subclasses.
+    #
+    # @example
+    #
+    #     symbols = RDF::Format.writer_symbols
+    #     format = RDF::Format.for(symbols.first)
     #
     # @return [Array<Symbol>]
     def self.writer_symbols
-      RDF::Format.each.to_a.map(&:writer).compact.map(&:to_sym).uniq
+      @@writers.keys.compact.map(&:to_sym).uniq
+    end
+
+    ##
+    # Returns the set of content types for available RDF::Writer subclasses.
+    #
+    # @example
+    #
+    #     content_types = RDF::Format.writer_types
+    #     format = RDF::Format.for(:content_type => content_types.first)
+    #
+    # @return [Array<String>]
+    def self.writer_types
+      writer_symbols.map {|s| RDF::Format.for(s).content_type}.flatten.uniq
     end
 
     ##

data/lib/rdf/mixin/enumerable.rb

@@ -492,7 +492,7 @@ module RDF
     alias_method :enum_objects, :enum_object
 
     ##
-    # Returns all unique RDF contexts.
+    # Returns all unique RDF contexts, other than the default context.
     #
     # @param  [Hash{Symbol => Boolean}] options
     # @option options [Boolean] :unique (true)
@@ -510,14 +510,15 @@ module RDF
     ##
     # Returns `true` if `self` contains the given RDF context.
     #
-    # @param  [RDF::Resource] value
+    # @param  [RDF::Resource, false] value
+    #   Use value `false` to query for the default context
     # @return [Boolean]
     def has_context?(value)
       enum_context.include?(value)
     end
 
     ##
-    # Iterates the given block for each unique RDF context.
+    # Iterates the given block for each unique RDF context, other than the default context.
     #
     # If no block was given, returns an enumerator.
     #
@@ -664,5 +665,21 @@ module RDF
       raise RDF::WriterError, "No writer found using #{args.inspect}" unless writer
       writer.dump(self, nil, options)
     end
+
+    ##
+    # @overload #to_writer
+    #   Implements #to_writer for each available instance of {RDF::Writer},
+    #   based on the writer symbol.
+    #  
+    #   @return [String]
+    #   @see {RDF::Writer.sym}
+    def method_missing(meth, *args)
+      writer = RDF::Writer.for(meth.to_s[3..-1].to_sym) if meth.to_s[0,3] == "to_"
+      if writer
+        writer.buffer(:standard_prefixes => true) {|w| w << self}
+      else
+        super
+      end
+    end
   end # Enumerable
 end # RDF

data/lib/rdf/mixin/mutable.rb

@@ -152,6 +152,23 @@ module RDF
 
     alias_method :clear!, :clear
 
+    ##
+    # @overload #from_reader
+    #   Implements #from_reader for each available instance of {RDF::Reader},
+    #   based on the reader symbol.
+    #
+    #   Arguments are passed to Reader.new.
+    #  
+    #   @return [String]
+    #   @see {RDF::Reader.sym}
+    def method_missing(meth, *args)
+      reader = RDF::Reader.for(meth.to_s[5..-1].to_sym) if meth.to_s[0,5] == "from_"
+      if reader
+        self << reader.new(*args)
+      else
+        super
+      end
+    end
   protected
 
     ##
@@ -184,8 +201,5 @@ module RDF
     def delete_statement(statement)
       raise NotImplementedError.new("#{self.class}#delete_statement")
     end
-
-    protected :delete_statements
-    protected :delete_statement
   end
 end

data/lib/rdf/mixin/queryable.rb

@@ -147,10 +147,14 @@ module RDF
         query(pattern) do |statement|
           return statement
         end
-        return nil
+      elsif respond_to?(:each_statement)
+        each_statement do |statement|
+          return statement
+        end
       else
-        super()
+        return super()
       end
+      nil
     end
 
     ##

data/lib/rdf/model/graph.rb

@@ -31,15 +31,24 @@ module RDF
     ##
     # Returns the options passed to this graph when it was constructed.
     #
+    # @!attribute [r] options
     # @return [Hash{Symbol => Object}]
     attr_reader :options
 
     ##
+    # Name of this graph, if it is part of an {RDF::Repository}
+    # @!attribute [rw] context
     # @return [RDF::Resource]
-    # @deprecated In the next release, graphs will have no name
+    # @note In the next release, only projections from an
+    # {RDF::Enumerable} supporting contexts will have a context.
     attr_accessor :context
 
+    alias_method :name, :context
+    alias_method :name=, :context=
+
     ##
+    # {RDF::Queryable} backing this graph.
+    # @!attribute [rw] data
     # @return [RDF::Queryable]
     attr_accessor :data
 
@@ -72,9 +81,10 @@ module RDF
     #   @param  [RDF::Resource]          context
     #     The context only provides a context for loading relative documents
     #   @param  [Hash{Symbol => Object}] options
-    #   @deprecated Graph context will be removed in the next release.
-    #     This is because context relates to a Named Graph in RDF 1.1
-    #     and a default graph has no context/name.
+    #   @note contexts are only useful when used as a projection
+    #   on a `:data` which supports contexts. Otherwise, there is no
+    #   such thing as a named graph in RDF 1.1, a repository may have
+    #   graphs which are named, but the name is not a property of the graph.
     # @overload initialize(options)
     #   @param  [Hash{Symbol => Object}] options
     # @yield  [graph]
@@ -139,12 +149,12 @@ module RDF
     end
 
     ##
-    # Returns `false` to indicate that this graph is not durable
+    # A graph is durable if it's underlying data model is durable
     #
     # @return [Boolean]
     # @see    RDF::Durable#durable?
     def durable?
-      false
+      @data.durable?
     end
 
     ##
@@ -156,10 +166,9 @@ module RDF
     end
 
     ##
-    # Returns the URI representation of this graph.
+    # Returns the {RDF::Resource} representation of this graph.
     #
-    # @return [RDF::URI]
-    # @note The next release, graphs will not be named, this will return nil
+    # @return [RDF::Resource]
     def to_uri
       context
     end
@@ -169,7 +178,7 @@ module RDF
     #
     # @return [String]
     def to_s
-      named? ? context.to_s : "<>"
+      named? ? context.to_s : "default"
     end
 
     ##
@@ -178,7 +187,7 @@ module RDF
     # @return [Boolean]
     # @see    RDF::Enumerable#empty?
     def empty?
-      @data.empty?
+      !@data.has_context?(context || false)
     end
 
     ##
@@ -196,7 +205,7 @@ module RDF
     # @return [Integer]
     # @see    RDF::Enumerable#count
     def count
-      @data.query(:context => context).count
+      @data.query(:context => context || false).count
     end
 
     ##
@@ -207,7 +216,7 @@ module RDF
     # @see    RDF::Enumerable#has_statement?
     def has_statement?(statement)
       statement = statement.dup
-      statement.context = context # TODO: going away
+      statement.context = context
       @data.has_statement?(statement)
     end
 
@@ -219,7 +228,27 @@ module RDF
     # @return [Enumerator]
     # @see    RDF::Enumerable#each_statement
     def each(&block)
-      @data.query(:context => context).each(&block)
+      if @data.respond_to?(:query)
+        @data.query(:context => context || false, &block)
+      elsif @data.respond_to?(:each)
+        @data.each(&block)
+      else
+        @data.to_a.each(&block)
+      end
+    end
+
+    ##
+    # Graph equivalence based on the contents of each graph being _exactly_
+    # the same. To determine if the have the same _meaning_, consider
+    # [rdf-isomorphic](http://rubygems.org/gems/rdf-isomorphic).
+    #
+    # @param [RDF::Graph] other
+    # @return [Boolean]
+    # @see http://rubygems.org/gems/rdf-isomorphic
+    def ==(other)
+      other.is_a?(RDF::Graph) &&
+      context == other.context &&
+      statements.to_a == other.statements.to_a
     end
 
     ##
@@ -227,7 +256,7 @@ module RDF
     # @see RDF::Queryable#query
     def query_pattern(pattern, &block)
       pattern = pattern.dup
-      pattern.context = context
+      pattern.context = context || false
       @data.query(pattern, &block)
     end
 
@@ -253,7 +282,7 @@ module RDF
     # @private
     # @see RDF::Mutable#clear
     def clear_statements
-      @data.delete(:context => context)
+      @data.delete(:context => context || false)
     end
 
     protected :query_pattern

data/lib/rdf/model/literal.rb

@@ -343,6 +343,17 @@ module RDF
       self
     end
 
+    ##
+    # Returns the base representation of this URI.
+    #
+    # @return [Sring]
+    def to_base
+      text = %("#{escape(value)}")
+      text << "@#{language}" if has_language?
+      text << "^^#{datatype.to_base}" if has_datatype?
+      text
+    end
+
     ##
     # Returns the value as a string.
     #

data/lib/rdf/model/node.rb

@@ -137,6 +137,14 @@ module RDF
     end
     alias_method :===, :==
 
+    ##
+    # Returns the base representation of this URI.
+    #
+    # @return [Sring]
+    def to_base
+      to_s
+    end
+
     ##
     # Returns a string representation of this blank node.
     #

data/lib/rdf/model/statement.rb

@@ -57,6 +57,7 @@ module RDF
     #   @option options [RDF::URI]       :predicate (nil)
     #   @option options [RDF::Term]      :object    (nil)
     #   @option options [RDF::Resource]  :context   (nil)
+    #     Note, in RDF 1.1, a context MUST be an IRI.
     #
     # @overload initialize(subject, predicate, object, options = {})
     #   @param  [RDF::Resource]          subject
@@ -259,25 +260,9 @@ module RDF
     #
     # @return [String]
     def to_s
-      StringIO.open do |buffer|
-        buffer << case subject
-          when RDF::Node    then subject.to_s
-          when RDF::URI     then "<#{subject}>"
-          else subject.inspect
-        end
-        buffer << " <#{predicate}> "
-        buffer << case object
-          when RDF::Literal then object.to_s
-          when RDF::Node    then object.to_s
-          when RDF::URI     then "<#{object}>"
-          else object.inspect
-        end
-        buffer << case context
-          when nil then " ."
-          else " <#{context}> ."
-        end
-        buffer.string
-      end
+      (context ? to_quad : to_triple).map do |term|
+        term.respond_to?(:to_base) ? term.to_base : term.inspect
+      end.join(" ") + " ."
     end
 
     ##

data/lib/rdf/model/term.rb

@@ -66,12 +66,36 @@ module RDF
     end
 
     ##
-    # Returns `true` if this term is variable.
+    # Returns a base representation of `self`.
     #
-    # @return [Boolean] `true` or `false`
-    # @see    #constant?
-    def variable?
-      false
+    # @return [RDF::Value]
+    def to_base
+      self
+    end
+
+    ##
+    # Returns `true` if `self` is a {RDF::Term}.
+    #
+    # @return [Boolean]
+    def term?
+      true
     end
+
+    protected
+    ##
+    # Escape a term using standard character escapes
+    #
+    # @param  [String] string
+    # @return [String]
+    def escape(string)
+      string.gsub('\\', '\\\\').
+             gsub("\b", '\\b').
+             gsub("\f", '\\f').
+             gsub("\t", '\\t').
+             gsub("\n", '\\n').
+             gsub("\r", '\\r').
+             gsub('"', '\\"')
+    end
+
   end # Term
 end # RDF

data/lib/rdf/model/uri.rb

@@ -19,6 +19,7 @@ module RDF
   # @example Getting the string representation of a URI
   #   uri.to_s #=> "http://rdf.rubyforge.org/"
   #
+  # http://en.wikipedia.org/wiki/Internationalized_Resource_Identifier
   # @see http://en.wikipedia.org/wiki/Uniform_Resource_Identifier
   # @see http://www.ietf.org/rfc/rfc3986.txt
   # @see http://www.ietf.org/rfc/rfc3987.txt
@@ -41,54 +42,54 @@ module RDF
         [\\u{A0000}-\\u{AFFFD}]|[\\u{B0000}-\\u{BFFFD}]|[\\u{C0000}-\\u{CFFFD}]|
         [\\u{D0000}-\\u{DFFFD}]|[\\u{E0000}-\\u{EFFFD}]
       EOS
-      IPRIVATE = Regexp.compile("[\\uE000-\\uF8FF]|[\\u{F0000}-\\u{FFFFD}]|[\\u100000-\\u10FFFD]")
+      IPRIVATE = Regexp.compile("[\\uE000-\\uF8FF]|[\\u{F0000}-\\u{FFFFD}]|[\\u100000-\\u10FFFD]").freeze
     end
 
-    SCHEME = Regexp.compile("[A-za-z](?:[A-Za-z0-9+-\.])*")
-    PORT = Regexp.compile("[0-9]*")
-    IP_literal = Regexp.compile("\\[[0-9A-Fa-f:\\.]*\\]")  # Simplified, no IPvFuture
-    PCT_ENCODED = Regexp.compile("%[0-9A-Fa-f]{2}")
-    GEN_DELIMS = Regexp.compile("[:/\\?\\#\\[\\]@]")
-    SUB_DELIMS = Regexp.compile("[!\\$&'\\(\\)\\*\\+,;=]")
-    RESERVED = Regexp.compile("(?:#{GEN_DELIMS}|#{SUB_DELIMS})")
-    UNRESERVED = Regexp.compile("[A-Za-z0-9]|-|\\.|_|~")
+    SCHEME = Regexp.compile("[A-za-z](?:[A-Za-z0-9+-\.])*").freeze
+    PORT = Regexp.compile("[0-9]*").freeze
+    IP_literal = Regexp.compile("\\[[0-9A-Fa-f:\\.]*\\]").freeze  # Simplified, no IPvFuture
+    PCT_ENCODED = Regexp.compile("%[0-9A-Fa-f]{2}").freeze
+    GEN_DELIMS = Regexp.compile("[:/\\?\\#\\[\\]@]").freeze
+    SUB_DELIMS = Regexp.compile("[!\\$&'\\(\\)\\*\\+,;=]").freeze
+    RESERVED = Regexp.compile("(?:#{GEN_DELIMS}|#{SUB_DELIMS})").freeze
+    UNRESERVED = Regexp.compile("[A-Za-z0-9]|-|\\.|_|~").freeze
 
     if RUBY_VERSION >= '1.9'
-      IUNRESERVED = Regexp.compile("[A-Za-z0-9]|-|\\.|_|~|#{UCSCHAR}")
+      IUNRESERVED = Regexp.compile("[A-Za-z0-9]|-|\\.|_|~|#{UCSCHAR}").freeze
     else
-      IUNRESERVED = Regexp.compile("[A-Za-z0-9]|-|\\.|_|~")
+      IUNRESERVED = Regexp.compile("[A-Za-z0-9]|-|\\.|_|~").freeze
     end
 
-    IPCHAR = Regexp.compile("(?:#{IUNRESERVED}|#{PCT_ENCODED}|#{SUB_DELIMS}|:|@)")
+    IPCHAR = Regexp.compile("(?:#{IUNRESERVED}|#{PCT_ENCODED}|#{SUB_DELIMS}|:|@)").freeze
 
     if RUBY_VERSION >= '1.9'
-      IQUERY = Regexp.compile("(?:#{IPCHAR}|#{IPRIVATE}|/|\\?)*")
+      IQUERY = Regexp.compile("(?:#{IPCHAR}|#{IPRIVATE}|/|\\?)*").freeze
     else
-      IQUERY = Regexp.compile("(?:#{IPCHAR}|/|\\?)*")
+      IQUERY = Regexp.compile("(?:#{IPCHAR}|/|\\?)*").freeze
     end
 
-    IFRAGMENT = Regexp.compile("(?:#{IPCHAR}|/|\\?)*")
+    IFRAGMENT = Regexp.compile("(?:#{IPCHAR}|/|\\?)*").freeze.freeze
 
-    ISEGMENT = Regexp.compile("(?:#{IPCHAR})*")
-    ISEGMENT_NZ = Regexp.compile("(?:#{IPCHAR})+")
-    ISEGMENT_NZ_NC = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|@)+")
+    ISEGMENT = Regexp.compile("(?:#{IPCHAR})*").freeze
+    ISEGMENT_NZ = Regexp.compile("(?:#{IPCHAR})+").freeze
+    ISEGMENT_NZ_NC = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|@)+").freeze
 
-    IPATH_ABEMPTY = Regexp.compile("(?:/#{ISEGMENT})*")
-    IPATH_ABSOLUTE = Regexp.compile("/(?:(?:#{ISEGMENT_NZ})(/#{ISEGMENT})*)?")
-    IPATH_NOSCHEME = Regexp.compile("(?:#{ISEGMENT_NZ_NC})(?:/#{ISEGMENT})*")
-    IPATH_ROOTLESS = Regexp.compile("(?:#{ISEGMENT_NZ})(?:/#{ISEGMENT})*")
-    IPATH_EMPTY = Regexp.compile("")
+    IPATH_ABEMPTY = Regexp.compile("(?:/#{ISEGMENT})*").freeze
+    IPATH_ABSOLUTE = Regexp.compile("/(?:(?:#{ISEGMENT_NZ})(/#{ISEGMENT})*)?").freeze
+    IPATH_NOSCHEME = Regexp.compile("(?:#{ISEGMENT_NZ_NC})(?:/#{ISEGMENT})*").freeze
+    IPATH_ROOTLESS = Regexp.compile("(?:#{ISEGMENT_NZ})(?:/#{ISEGMENT})*").freeze
+    IPATH_EMPTY = Regexp.compile("").freeze
 
-    IREG_NAME   = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS}))*")
-    IHOST = Regexp.compile("(?:#{IP_literal})|(?:#{IREG_NAME})")
-    IUSERINFO = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|:)*")
-    IAUTHORITY = Regexp.compile("(?:#{IUSERINFO}@)?#{IHOST}(?::#{PORT})?")
+    IREG_NAME   = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS}))*").freeze
+    IHOST = Regexp.compile("(?:#{IP_literal})|(?:#{IREG_NAME})").freeze
+    IUSERINFO = Regexp.compile("(?:(?:#{IUNRESERVED})|(?:#{PCT_ENCODED})|(?:#{SUB_DELIMS})|:)*").freeze
+    IAUTHORITY = Regexp.compile("(?:#{IUSERINFO}@)?#{IHOST}(?::#{PORT})?").freeze
     
-    IRELATIVE_PART = Regexp.compile("(?:(?://#{IAUTHORITY}(?:#{IPATH_ABEMPTY}))|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_NOSCHEME})|(?:#{IPATH_EMPTY}))")
-    IRELATIVE_REF = Regexp.compile("^#{IRELATIVE_PART}(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$")
+    IRELATIVE_PART = Regexp.compile("(?:(?://#{IAUTHORITY}(?:#{IPATH_ABEMPTY}))|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_NOSCHEME})|(?:#{IPATH_EMPTY}))").freeze
+    IRELATIVE_REF = Regexp.compile("^#{IRELATIVE_PART}(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$").freeze
 
-    IHIER_PART = Regexp.compile("(?:(?://#{IAUTHORITY}#{IPATH_ABEMPTY})|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_ROOTLESS})|(?:#{IPATH_EMPTY}))")
-    IRI = Regexp.compile("^#{SCHEME}:(?:#{IHIER_PART})(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$")
+    IHIER_PART = Regexp.compile("(?:(?://#{IAUTHORITY}#{IPATH_ABEMPTY})|(?:#{IPATH_ABSOLUTE})|(?:#{IPATH_ROOTLESS})|(?:#{IPATH_EMPTY}))").freeze
+    IRI = Regexp.compile("^#{SCHEME}:(?:#{IHIER_PART})(?:\\?#{IQUERY})?(?:\\##{IFRAGMENT})?$").freeze
     
     ##
     # @return [RDF::Util::Cache]
@@ -148,14 +149,6 @@ module RDF
       end
     end
 
-    ##
-    # Returns `false`.
-    #
-    # @return [Boolean] `true` or `false`
-    def anonymous?
-      false
-    end
-
     ##
     # Returns `true`.
     #
@@ -592,6 +585,14 @@ module RDF
       self
     end
 
+    ##
+    # Returns the base representation of this URI.
+    #
+    # @return [Sring]
+    def to_base
+      "<#{escape(@uri.to_s)}>"
+    end
+
     ##
     # Returns the string representation of this URI.
     #
@@ -641,4 +642,7 @@ module RDF
       end
     end
   end # URI
+
+  # RDF::IRI is a synonym for RDF::URI
+  IRI = URI
 end # RDF

data/lib/rdf/model/value.rb

@@ -4,7 +4,8 @@ module RDF
   #
   # This is the basis for the RDF.rb class hierarchy. Anything that can be a
   # term of {RDF::Statement RDF statements} should directly or indirectly
-  # include this module.
+  # include this module, but it does not define classes that can be included
+  # within a {RDF::Statement}, for this see {RDF::Term}.
   #
   # @example Checking if a value is a resource (blank node or URI reference)
   #   value.resource?
@@ -19,15 +20,16 @@ module RDF
   # @example Checking if a value is a literal
   #   value.literal?
   #
-  # @see RDF::Graph
   # @see RDF::Literal
   # @see RDF::Node
   # @see RDF::Resource
-  # @see RDF::Statement
   # @see RDF::URI
+  # @see RDF::Graph
+  # @see RDF::List
+  # @see RDF::Statement
   module Value
     ##
-    # Returns `true` if `self` is a graph.
+    # Returns `true` if `self` is a {RDF::Graph}.
     #
     # @return [Boolean]
     def graph?
@@ -35,23 +37,31 @@ module RDF
     end
 
     ##
-    # Returns `true` if `self` is a literal.
+    # Returns `true` if `self` is a {RDF::Statement}.
     #
     # @return [Boolean]
-    def literal?
+    def statement?
       false
     end
 
     ##
-    # Returns `true` if `self` is a blank node.
+    # Returns `true` if `self` is a {RDF::List}.
     #
     # @return [Boolean]
-    def node?
+    def list?
       false
     end
 
     ##
-    # Returns `true` if `self` is a resource.
+    # Returns `true` if `self` is a {RDF::Term}.
+    #
+    # @return [Boolean]
+    def term?
+      false
+    end
+
+    ##
+    # Returns `true` if `self` is a {RDF::Resource}.
     #
     # @return [Boolean]
     def resource?
@@ -59,10 +69,18 @@ module RDF
     end
 
     ##
-    # Returns `true` if `self` is a statement.
+    # Returns `true` if `self` is a {RDF::Literal}.
     #
     # @return [Boolean]
-    def statement?
+    def literal?
+      false
+    end
+
+    ##
+    # Returns `true` if `self` is a {RDF::Node}.
+    #
+    # @return [Boolean]
+    def node?
       false
     end
 
@@ -77,7 +95,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if `self` is a URI reference.
+    # Returns `true` if `self` is a {RDF::URI}.
     #
     # @return [Boolean]
     def uri?
@@ -85,7 +103,7 @@ module RDF
     end
 
     ##
-    # Returns `true` if `self` is a query variable.
+    # Returns `true` if `self` is a {RDF::Query::Variable}.
     #
     # @return [Boolean]
     # @since  0.1.7
@@ -93,6 +111,14 @@ module RDF
       false
     end
 
+    ##
+    # Is this an anonymous value?
+    #
+    # @return [Boolean] `true` or `false`
+    def anonymous?
+      false
+    end
+
     ##
     # Returns `true` if the value has a valid representation
     #

data/lib/rdf/nquads.rb

@@ -14,12 +14,13 @@ module RDF
     #   RDF::Format.for("etc/doap.nq")
     #   RDF::Format.for(:file_name      => "etc/doap.nq")
     #   RDF::Format.for(:file_extension => "nq")
+    #   RDF::Format.for(:content_type   => "application/n-quads")
     #   RDF::Format.for(:content_type   => "text/x-nquads")
     #
     # @see http://sw.deri.org/2008/07/n-quads/#mediatype
     # @since  0.4.0
     class Format < RDF::Format
-      content_type     'text/x-nquads', :extension => :nq
+      content_type     'application/n-quads', :extension => :nq, :alias => ['text/x-nquads']
       content_encoding 'utf-8'
 
       reader { RDF::NQuads::Reader }
@@ -78,6 +79,9 @@ module RDF
               predicate = read_uriref(:intern => true) || fail_predicate
               object    = read_uriref || read_node || read_literal || fail_object
               context    = read_uriref || read_node || read_literal
+              if validate? && !read_eos
+                raise RDF::ReaderError, "expected end of statement in line #{lineno}: #{current_line.inspect}"
+              end
               return [subject, predicate, object, {:context => context}]
             end
           rescue RDF::ReaderError => e

data/lib/rdf/ntriples/reader.rb

@@ -28,20 +28,6 @@ module RDF::NTriples
   class Reader < RDF::Reader
     format RDF::NTriples::Format
 
-    # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar
-    COMMENT               = /^#\s*(.*)$/.freeze
-    NODEID                = /^_:([A-Za-z][A-Za-z0-9\-_]*)/.freeze
-    URIREF                = /^<([^>]+)>/.freeze
-    LITERAL_PLAIN         = /^"((?:\\"|[^"])*)"/.freeze
-    LITERAL_WITH_LANGUAGE = /^"((?:\\"|[^"])*)"@([a-z]+[\-A-Za-z0-9]*)/.freeze
-    LITERAL_WITH_DATATYPE = /^"((?:\\"|[^"])*)"\^\^<([^>]+)>/.freeze
-    LANGUAGE_TAG          = /^@([a-z]+[\-A-Za-z0-9]*)/.freeze
-    DATATYPE_URI          = /^\^\^<([^>]+)>/.freeze
-    LITERAL               = Regexp.union(LITERAL_WITH_LANGUAGE, LITERAL_WITH_DATATYPE, LITERAL_PLAIN).freeze
-    SUBJECT               = Regexp.union(URIREF, NODEID).freeze
-    PREDICATE             = Regexp.union(URIREF).freeze
-    OBJECT                = Regexp.union(URIREF, NODEID, LITERAL).freeze
-
     # @see http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     ESCAPE_CHARS          = ["\b", "\f", "\t", "\n", "\r", "\"", "\\"].freeze
     ESCAPE_CHAR4          = /\\u([0-9A-Fa-f]{4,4})/.freeze
@@ -51,6 +37,97 @@ module RDF::NTriples
     ESCAPE_SURROGATE1     = (0xD800..0xDBFF).freeze
     ESCAPE_SURROGATE2     = (0xDC00..0xDFFF).freeze
 
+
+    # Terminals from rdf-turtle.
+    #
+    # @see http://www.w3.org/TR/n-triples/
+    # @see http://www.w3.org/TR/turtle/
+    if RUBY_VERSION >= '1.9'
+      ##
+      # Unicode regular expressions for Ruby 1.9+ with the Oniguruma engine.
+      U_CHARS1         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
+                           [\\u00C0-\\u00D6]|[\\u00D8-\\u00F6]|[\\u00F8-\\u02FF]|
+                           [\\u0370-\\u037D]|[\\u037F-\\u1FFF]|[\\u200C-\\u200D]|
+                           [\\u2070-\\u218F]|[\\u2C00-\\u2FEF]|[\\u3001-\\uD7FF]|
+                           [\\uF900-\\uFDCF]|[\\uFDF0-\\uFFFD]|[\\u{10000}-\\u{EFFFF}]
+                         EOS
+      U_CHARS2         = Regexp.compile("\\u00B7|[\\u0300-\\u036F]|[\\u203F-\\u2040]").freeze
+      IRI_RANGE        = Regexp.compile("[[^<>\"{}|^`\\\\]&&[^\\x00-\\x20]]").freeze
+    else
+      ##
+      # UTF-8 regular expressions for Ruby 1.8.x.
+      U_CHARS1         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
+                           \\xC3[\\x80-\\x96]|                                (?# [\\u00C0-\\u00D6]|)
+                           \\xC3[\\x98-\\xB6]|                                (?# [\\u00D8-\\u00F6]|)
+                           \\xC3[\\xB8-\\xBF]|[\\xC4-\\xCB][\\x80-\\xBF]|     (?# [\\u00F8-\\u02FF]|)
+                           \\xCD[\\xB0-\\xBD]|                                (?# [\\u0370-\\u037D]|)
+                           \\xCD\\xBF|[\\xCE-\\xDF][\\x80-\\xBF]|             (?# [\\u037F-\\u1FFF]|)
+                           \\xE0[\\xA0-\\xBF][\\x80-\\xBF]|                   (?# ...)
+                           \\xE1[\\x80-\\xBF][\\x80-\\xBF]|                   (?# ...)
+                           \\xE2\\x80[\\x8C-\\x8D]|                           (?# [\\u200C-\\u200D]|)
+                           \\xE2\\x81[\\xB0-\\xBF]|                           (?# [\\u2070-\\u218F]|)
+                           \\xE2[\\x82-\\x85][\\x80-\\xBF]|                   (?# ...)
+                           \\xE2\\x86[\\x80-\\x8F]|                           (?# ...)
+                           \\xE2[\\xB0-\\xBE][\\x80-\\xBF]|                   (?# [\\u2C00-\\u2FEF]|)
+                           \\xE2\\xBF[\\x80-\\xAF]|                           (?# ...)
+                           \\xE3\\x80[\\x81-\\xBF]|                           (?# [\\u3001-\\uD7FF]|)
+                           \\xE3[\\x81-\\xBF][\\x80-\\xBF]|                   (?# ...)
+                           [\\xE4-\\xEC][\\x80-\\xBF][\\x80-\\xBF]|           (?# ...)
+                           \\xED[\\x80-\\x9F][\\x80-\\xBF]|                   (?# ...)
+                           \\xEF[\\xA4-\\xB6][\\x80-\\xBF]|                   (?# [\\uF900-\\uFDCF]|)
+                           \\xEF\\xB7[\\x80-\\x8F]|                           (?# ...)
+                           \\xEF\\xB7[\\xB0-\\xBF]|                           (?# [\\uFDF0-\\uFFFD]|)
+                           \\xEF[\\xB8-\\xBE][\\x80-\\xBF]|                   (?# ...)
+                           \\xEF\\xBF[\\x80-\\xBD]|                           (?# ...)
+                           \\xF0[\\x90-\\xBF][\\x80-\\xBF][\\x80-\\xBF]|      (?# [\\u{10000}-\\u{EFFFF}])
+                           [\\xF1-\\xF2][\\x80-\\xBF][\\x80-\\xBF][\\x80-\\xBF]|
+                           \\xF3[\\x80-\\xAF][\\x80-\\xBF][\\x80-\\xBF]       (?# ...)
+                         EOS
+      U_CHARS2         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
+                           \\xC2\\xB7|                                        (?# \\u00B7|)
+                           \\xCC[\\x80-\\xBF]|\\xCD[\\x80-\\xAF]|             (?# [\\u0300-\\u036F]|)
+                           \\xE2\\x80\\xBF|\\xE2\\x81\\x80                    (?# [\\u203F-\\u2040])
+                         EOS
+      IRI_RANGE        = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
+                           \\x21|                                             (?# ")
+                           [\\x23-\\x3b]|\\x3d|                               (?# < & >)
+                           [\\x3f-\\x5b]|\\x5d|\\x5f|                         (?# \ ^ `)
+                           [\\x61-\\x7a]|                                     (?# { } |)
+                           [\\x7e-\\xff]
+                         EOS
+    end
+
+    # 163s
+    PN_CHARS_BASE        = /[A-Z]|[a-z]|#{U_CHARS1}/.freeze
+    # 164s
+    PN_CHARS_U           = /_|#{PN_CHARS_BASE}/.freeze
+    # 166s
+    PN_CHARS             = /-|[0-9]|#{PN_CHARS_U}|#{U_CHARS2}/.freeze
+    # 159s
+    ECHAR                = /\\[tbnrf\\"']/.freeze
+    # 18
+    IRIREF               = /<((?:#{IRI_RANGE}|#{ESCAPE_CHAR})*)>/.freeze
+    # 141s
+    BLANK_NODE_LABEL     = /_:((?:[0-9]|#{PN_CHARS_U})(?:(?:#{PN_CHARS}|\.)*#{PN_CHARS})?)/.freeze
+    # 144s
+    LANGTAG              = /@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)/.freeze
+    # 22
+    STRING_LITERAL_QUOTE = /"((?:[^\"\\\n\r]|#{ECHAR}|#{ESCAPE_CHAR})*)"/.freeze
+
+    # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar
+    COMMENT               = /^#\s*(.*)$/.freeze
+    NODEID                = /^#{BLANK_NODE_LABEL}/.freeze
+    URIREF                = /^#{IRIREF}/.freeze
+    LITERAL_PLAIN         = /^#{STRING_LITERAL_QUOTE}/.freeze
+    LITERAL_WITH_LANGUAGE = /^#{STRING_LITERAL_QUOTE}#{LANGTAG}/.freeze
+    LITERAL_WITH_DATATYPE = /^#{STRING_LITERAL_QUOTE}\^\^#{IRIREF}/.freeze
+    DATATYPE_URI          = /^\^\^#{IRIREF}/.freeze
+    LITERAL               = Regexp.union(LITERAL_WITH_LANGUAGE, LITERAL_WITH_DATATYPE, LITERAL_PLAIN).freeze
+    SUBJECT               = Regexp.union(URIREF, NODEID).freeze
+    PREDICATE             = Regexp.union(URIREF).freeze
+    OBJECT                = Regexp.union(URIREF, NODEID, LITERAL).freeze
+    END_OF_STATEMENT      = /^\s*\.\s*$/.freeze
+
     ##
     # Reconstructs an RDF value from its serialized N-Triples
     # representation.
@@ -124,6 +201,7 @@ module RDF::NTriples
     # @see    http://blog.grayproductions.net/articles/understanding_m17n
     # @see    http://yehudakatz.com/2010/05/17/encodings-unabridged/
     def self.unescape(string)
+      string = string.to_s
       string = string.dup.force_encoding(Encoding::ASCII_8BIT) if string.respond_to?(:force_encoding)
 
       # Decode \t|\n|\r|\"|\\ character escapes:
@@ -135,8 +213,10 @@ module RDF::NTriples
           if ESCAPE_SURROGATE1.include?($1.hex) && ESCAPE_SURROGATE2.include?($2.hex)
             s = [$1, $2].pack('H*H*')
             s = s.respond_to?(:force_encoding) ?
-              s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8) : # for Ruby 1.9+
-              Iconv.conv('UTF-8', 'UTF-16BE', s)                              # for Ruby 1.8.x
+              # for Ruby 1.9+
+              s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8) :
+              # for Ruby 1.8.x
+              Iconv.conv('UTF-8', 'UTF-16BE', s)
           else
             s = [$1.hex].pack('U*') << '\u' << $2
           end
@@ -159,7 +239,7 @@ module RDF::NTriples
     def read_value
       begin
         read_statement
-      rescue RDF::ReaderError => e
+      rescue RDF::ReaderError
         read_uriref || read_node || read_literal
       end
     end
@@ -177,6 +257,9 @@ module RDF::NTriples
             subject   = read_uriref || read_node || fail_subject
             predicate = read_uriref(:intern => true) || fail_predicate
             object    = read_uriref || read_node || read_literal || fail_object
+            if validate? && !read_eos
+              raise RDF::ReaderError, "expected end of statement in line #{lineno}: #{current_line.inspect}"
+            end
             return [subject, predicate, object]
           end
         rescue RDF::ReaderError => e
@@ -201,6 +284,7 @@ module RDF::NTriples
         uri_str = self.class.unescape(uri_str)
         uri = RDF::URI.send(intern? && options[:intern] ? :intern : :new, uri_str)
         uri.validate!     if validate?
+        raise RDF::ReaderError, "uri not absolute" if validate? && !uri.absolute?
         uri.canonicalize! if canonicalize?
         uri
       end
@@ -210,7 +294,7 @@ module RDF::NTriples
     # @return [RDF::Node]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (nodeID)
     def read_node
-      if node_id = match(NODEID)
+       if node_id = match(NODEID)
         @nodes ||= {}
         @nodes[node_id] ||= RDF::Node.new(node_id)
       end
@@ -223,7 +307,7 @@ module RDF::NTriples
       if literal_str = match(LITERAL_PLAIN)
         literal_str = self.class.unescape(literal_str)
         literal = case
-          when language = match(LANGUAGE_TAG)
+          when language = match(LANGTAG)
             RDF::Literal.new(literal_str, :language => language)
           when datatype = match(/^(\^\^)/) # FIXME
             RDF::Literal.new(literal_str, :datatype => read_uriref || fail_object)
@@ -235,5 +319,12 @@ module RDF::NTriples
         literal
       end
     end
+
+    ##
+    # @return [Boolean]
+    # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar (triple)
+    def read_eos
+      match(END_OF_STATEMENT)
+    end
   end # Reader
 end # RDF::NTriples

data/lib/rdf/ntriples/writer.rb

@@ -209,7 +209,7 @@ module RDF::NTriples
     # @param  [Hash{Symbol => Object}] options
     # @return [String]
     def format_node(node, options = {})
-      "_:%s" % node.id
+      node.to_base
     end
 
     ##
@@ -219,7 +219,7 @@ module RDF::NTriples
     # @param  [Hash{Symbol => Object}] options
     # @return [String]
     def format_uri(uri, options = {})
-      "<%s>" % escaped(uri_for(uri))
+      uri.to_base
     end
 
     ##
@@ -231,6 +231,7 @@ module RDF::NTriples
     def format_literal(literal, options = {})
       case literal
         when RDF::Literal
+          # Note, escaping here is more robust than in Term
           text = quoted(escaped(literal.value))
           text << "@#{literal.language}" if literal.has_language?
           text << "^^<#{uri_for(literal.datatype)}>" if literal.has_datatype?

data/lib/rdf/query.rb

@@ -129,10 +129,12 @@ module RDF
     #   @option options [RDF::Resource, RDF::Query::Variable, false] :context (nil)
     #     Default context for matching against queryable.
     #     Named queries either match against a specifically named
-    #     contexts if the name is an {RDF::Resource} or bound {RDF::Query::Variable}.
-    #     Names that are against unbound variables match either detault
-    #     or named contexts.
+    #     graphs if the name is an {RDF::Resource} or bound {RDF::Query::Variable}.
+    #     Names that are against unbound variables match either default
+    #     or named graphs.
     #     The name of `false` will only match against the default context.
+    #   @option options [RDF::Resource, RDF::Query::Variable, false] :name (nil)
+    #     Alias for `:context`.
     #   @yield  [query]
     #   @yieldparam  [RDF::Query] query
     #   @yieldreturn [void] ignored
@@ -146,9 +148,11 @@ module RDF
     #   @option options [RDF::Resource, RDF::Query::Variable, false] :context (nil)
     #     Default context for matching against queryable.
     #     Named queries either match against a specifically named
-    #     contexts if the name is an {RDF::Resource} or bound {RDF::Query::Variable}.
-    #     Names that are against unbound variables match either detault
-    #     or named contexts.
+    #     graphs if the name is an {RDF::Resource} or bound {RDF::Query::Variable}.
+    #     Names that are against unbound variables match either default
+    #     or named graphs.
+    #   @option options [RDF::Resource, RDF::Query::Variable, false] :name (nil)
+    #     Alias for `:context`.
     #   @yield  [query]
     #   @yieldparam  [RDF::Query] query
     #   @yieldreturn [void] ignored
@@ -157,7 +161,9 @@ module RDF
       patterns << @options if patterns.empty?
       @variables = {}
       @solutions = @options.delete(:solutions) || Solutions.new
-      context = @options.delete(:context)
+      context = @options.fetch(:context, @options.fetch(:name, nil))
+      @options.delete(:context)
+      @options.delete(:name)
 
       @patterns  = case patterns.first
         when Hash  then compile_hash_patterns(HashPatternNormalizer.normalize!(patterns.first.dup, @options))
@@ -246,6 +252,8 @@ module RDF
     # @option options [RDF::Resource, RDF::Query::Variable, false] context (nil)
     #   Specific context for matching against queryable;
     #   overrides default context defined on query.
+    # @option options [RDF::Resource, RDF::Query::Variable, false] name (nil)
+    #   Alias for `:context`.
     # @option options [Hash{Symbol => RDF::Term}] solutions
     #   optional initial solutions for chained queries
     # @return [RDF::Query::Solutions]
@@ -264,7 +272,7 @@ module RDF
       @solutions = options[:solutions] || (Solutions.new << RDF::Query::Solution.new({}))
 
       patterns = @patterns
-      context = options.fetch(:context, self.context)
+      context = options.fetch(:context, options.fetch(:name, self.context))
 
       # Add context to pattern, if necessary
       unless context.nil?
@@ -349,27 +357,34 @@ module RDF
       Query.new(self.patterns + other.patterns)
     end
     
-    # Is this is a named query?
+    # Is this query scoped to a named graph?
     # @return [Boolean]
     def named?
       !!options[:context]
     end
     
-    # Is this is an unamed query?
+    # Is this query scoped to the default graph?
+    # @return [Boolean]
+    def default?
+      options[:context] == false
+    end
+    
+    # Is this query unscoped? This indicates that it can return results from
+    # either a named graph or the default graph.
     # @return [Boolean]
     def unnamed?
-      !named?
+      options[:context].nil?
     end
     
-    # Add name to query
-    # @param [RDF::Value] value
-    # @return [RDF::Value]
+    # Scope the query to named graphs matching value
+    # @param [RDF::IRI, RDF::Query::Variable] value
+    # @return [RDF::IRI, RDF::Query::Variable]
     def context=(value)
       options[:context] = value
     end
     
-    # Name of this query, if any
-    # @return [RDF::Value]
+    # Scope of this query, if any
+    # @return [RDF::IRI, RDF::Query::Variable]
     def context
       options[:context]
     end

data/lib/rdf/query/solution.rb

@@ -22,9 +22,11 @@ class RDF::Query
   #
   class Solution
     # Undefine all superfluous instance methods:
-    undef_method(*(instance_methods.map(&:to_sym) - [:__id__, :__send__, :__class__, :__eval__,
-      :object_id, :dup, :instance_eval, :inspect, :to_s,
-      :class, :is_a?, :respond_to?, :respond_to_missing?]))
+    undef_method(*instance_methods.
+                  map(&:to_s).
+                  select {|m| m =~ /^\w+$/}.
+                  reject {|m| %w(object_id dup instance_eval inspect to_s class).include?(m) || m[0,2] == '__'}.
+                  map(&:to_sym))
 
     include Enumerable
 

data/lib/rdf/util/file.rb

@@ -29,17 +29,17 @@ module RDF; module Util
     #   to override this implementation to provide more control over HTTP
     #   headers and redirect following.
     # @option options [Array, String] :headers
-    #   HTTP Request headers, passed to Kernel.open.
+    #   HTTP Request headers, passed to Kernel.open. (Ruby >= 1.9 only)
     # @return [IO] File stream
     # @yield [IO] File stream
     # @note HTTP headers not passed to `Kernel.open` for Ruby versions < 1.9.
     def self.open_file(filename_or_url, options = {}, &block)
       filename_or_url = $1 if filename_or_url.to_s.match(/^file:(.*)$/)
-      options[:headers] ||= {}
-      options[:headers]['Accept'] ||= RDF::Reader.map {|r| r.format.content_type}.uniq.join(", ")
       if RUBY_VERSION < "1.9"
         Kernel.open(filename_or_url.to_s, &block)
       else
+        options[:headers] ||= {}
+        options[:headers]['Accept'] ||= (RDF::Format.reader_types + %w(*/*;q=0.1)).join(", ")
         Kernel.open(filename_or_url.to_s, options[:headers], &block)
       end
     end

data/lib/rdf/vocab.rb

@@ -129,7 +129,11 @@ module RDF
     end
 
     # Undefine all superfluous instance methods:
-    undef_method(*(instance_methods.map(&:to_sym) - [:__id__, :__send__, :__class__, :__eval__, :object_id, :instance_eval, :inspect, :class, :is_a?]))
+    undef_method(*instance_methods.
+                  map(&:to_s).
+                  select {|m| m =~ /^\w+$/}.
+                  reject {|m| %w(object_id dup instance_eval inspect to_s class).include?(m) || m[0,2] == '__'}.
+                  map(&:to_sym))
 
     ##
     # @param  [RDF::URI, String, #to_s] uri

data/lib/rdf/writer.rb

@@ -466,8 +466,13 @@ module RDF
     # @param  [String] string
     # @return [String]
     def escaped(string)
-      string.gsub('\\', '\\\\').gsub("\t", '\\t').
-        gsub("\n", '\\n').gsub("\r", '\\r').gsub('"', '\\"')
+      string.gsub('\\', '\\\\').
+             gsub("\b", '\\b').
+             gsub("\f", '\\f').
+             gsub("\t", '\\t').
+             gsub("\n", '\\n').
+             gsub("\r", '\\r').
+             gsub('"', '\\"')
     end
 
     ##

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 1.0.3
-  prerelease: 
+  version: 1.0.4
 platform: ruby
 authors:
 - Arto Bendiken
@@ -11,12 +10,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-26 00:00:00.000000000 Z
+date: 2013-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -24,7 +22,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -32,7 +29,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -40,7 +36,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -48,7 +43,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -56,7 +50,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -64,7 +57,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -72,7 +64,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -170,30 +161,26 @@ files:
 homepage: http://ruby-rdf.github.com/
 licenses:
 - Public Domain
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.8.1
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2150851322746438702
 requirements: []
 rubyforge_project: rdf
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.
 test_files: []
 has_rdoc: false