rdf 1.0.10.2 → 1.1.0.p0

data/lib/rdf/format.rb

@@ -13,18 +13,18 @@ module RDF
   #   RDF::Format.for("etc/doap.nt")
   #   RDF::Format.for(:file_name => "etc/doap.nt")
   #   RDF::Format.for(:file_extension => "nt")
-  #   RDF::Format.for(:content_type => "application/n-triples")
+  #   RDF::Format.for(:content_type => "text/plain")
   #
   # @example Obtaining serialization format MIME types
-  #   RDF::Format.content_types      #=> {"application/n-triples" => [RDF::NTriples::Format]}
+  #   RDF::Format.content_types      #=> {"text/plain" => [RDF::NTriples::Format]}
   #
   # @example Obtaining serialization format file extension mappings
   #   RDF::Format.file_extensions    #=> {:nt => [RDF::NTriples::Format]}
   #
   # @example Defining a new RDF serialization format class
   #   class RDF::NTriples::Format < RDF::Format
-  #     content_type     'application/n-triples', :extension => :nt
-  #     content_encoding 'utf-8'
+  #     content_type     'text/plain', :extension => :nt
+  #     content_encoding 'ascii'
   #     
   #     reader RDF::NTriples::Reader
   #     writer RDF::NTriples::Writer
@@ -142,14 +142,12 @@ module RDF
 
       # If we have a sample, use that for format detection
       if sample = (options[:sample] if options.is_a?(Hash)) || (yield if block_given?)
-        sample = sample.dup.to_s
-        sample.force_encoding(Encoding::US_ASCII) if sample.respond_to?(:force_encoding)
         # Given a sample, perform format detection across the appropriate formats, choosing
         # the first that matches
         format ||= @@subclasses
 
         # Return first format that has a positive detection
-        format.detect {|f| f.detect(sample)} || format.first
+        format.detect {|f| f.detect(sample.to_s)} || format.first
       elsif format.is_a?(Array)
         # Otherwise, just return the first matching format
         format.first
@@ -251,7 +249,7 @@ module RDF
     #
     # @example
     #
-    #     RDF::NTriples::Format.name => "N-Triples"
+    #     RDF::NTriples::Format.name => "NTriples"
     #
     # @return [Symbol]
     def self.name
@@ -357,7 +355,7 @@ module RDF
     # match cannot be unambigiously found otherwise.
     #
     # @example
-    #     RDF::NTriples::Format.detect("<a> <b> <c> .") #=> true
+    #     RDF::NTriples::Format.detect("<a> <b> <c> .") => true
     #
     # @param [String] sample Beginning several bytes (~ 1K) of input.
     # @return [Boolean]
@@ -403,21 +401,14 @@ module RDF
           |ct, cl| (cl.include?(self) && ct != @@content_type[self]) ?  ct : nil }].flatten.compact
       else
         @@content_type[self] = type
-        @@content_types[type] ||= []
-        @@content_types[type] << self unless @@content_types[type].include?(self)
+        (@@content_types[type] ||= []) << self
 
         if extensions = (options[:extension] || options[:extensions])
-          extensions = Array(extensions).map(&:to_sym)
-          extensions.each do |ext|
-            @@file_extensions[ext] ||= []
-            @@file_extensions[ext] << self unless @@file_extensions[ext].include?(self)
-          end
+          extensions = [extensions].flatten.map(&:to_sym)
+          extensions.each { |ext| (@@file_extensions[ext] ||= []) << self }
         end
         if aliases = (options[:alias] || options[:aliases])
-          aliases = Array(aliases).each do |a|
-            @@content_types[a] ||= []
-            @@content_types[a] << self unless @@content_types[a].include?(self)
-          end
+          aliases = [aliases].flatten.each { |a| (@@content_types[a] ||= []) << self }
         end
       end
     end

data/lib/rdf/mixin/countable.rb

@@ -9,8 +9,9 @@ module RDF
     #
     # @return [Boolean]
     def empty?
-      each {return false}
-      true
+      empty = true
+      each { empty = false; break }
+      empty
     end
 
     ##
@@ -31,16 +32,8 @@ module RDF
     # @see    Object#enum_for
     def enum_for(method = :each, *args)
       # Ensure that enumerators support the `#empty?` and `#count` methods:
-      this = self
-      Countable::Enumerator.new do |yielder|
-        this.send(method, *args) {|y| yielder << y}
-      end
+      super.extend(RDF::Countable)
     end
     alias_method :to_enum, :enum_for
-
-    # Extends Enumerator with {Countable}, which is used by {Countable#enum_for}
-    class Enumerator < ::Enumerator
-      include Countable
-    end
   end # Countable
 end # RDF

data/lib/rdf/mixin/enumerable.rb

@@ -17,10 +17,10 @@ module RDF
   #   enumerable.has_quad?([subject, predicate, object, context])
   #
   # @example Checking whether a specific value exists
-  #   enumerable.has_subject?(RDF::URI("http://rubygems.org/gems/rdf"))
+  #   enumerable.has_subject?(RDF::URI("http://rdf.rubyforge.org/"))
   #   enumerable.has_predicate?(RDF::DC.creator)
-  #   enumerable.has_object?(RDF::Literal("A Ruby library for working with Resource Description Framework (RDF) data.", :language => :en))
-  #   enumerable.has_context?(RDF::URI("http://ar.to/#self"))
+  #   enumerable.has_object?(RDF::Literal("Hello!", :language => :en))
+  #   enumerable.has_context?(RDF::URI("http://rubyforge.org/"))
   #
   # @example Enumerating all statements
   #   enumerable.each_statement do |statement|
@@ -162,11 +162,7 @@ module RDF
     # @return [Enumerator]
     # @see    #each_statement
     def enum_statement
-      # Ensure that statements are queryable, countable and enumerable
-      this = self
-      Queryable::Enumerator.new do |yielder|
-        this.send(:each_statement) {|y| yielder << y}
-      end
+      enum_for(:each_statement).extend(RDF::Queryable, RDF::Enumerable)
     end
     alias_method :enum_statements, :enum_statement
 

data/lib/rdf/mixin/mutable.rb

@@ -106,9 +106,6 @@ module RDF
 
     ##
     # Deletes RDF statements from `self`.
-    # If any statement contains a {Query::Variable}, it is
-    # considered to be a pattern, and used to query
-    # self to find matching statements to delete.
     #
     # @param  [Enumerable<RDF::Statement>] statements
     # @raise  [TypeError] if `self` is immutable
@@ -121,7 +118,7 @@ module RDF
           when value.respond_to?(:each_statement)
             delete_statements(value)
             nil
-          when (statement = Statement.from(value)).constant?
+          when (statement = Statement.from(value)).valid?
             statement
           else
             delete_statements(query(value))

data/lib/rdf/mixin/queryable.rb

@@ -17,29 +17,18 @@ module RDF
     # This method delegates to the protected {RDF::Queryable#query_pattern} method for the
     # actual lower-level query pattern matching implementation.
     #
-    # @example Querying for statements having a given predicate
+    # @example
     #     queryable.query([nil, RDF::DOAP.developer, nil])
-    #     queryable.query(:predicate => RDF::DOAP.developer) do |statement|
-    #       puts statement.inspect
-    #     end
-    #
-    # @example Querying for solutions from a BGP
-    #     query = RDF::Query.new {pattern [:s, :p, :o]}
-    #     queryable.query(query) do |solution|
-    #       puts solution.inspect
-    #     end
+    #     queryable.query(:predicate => RDF::DOAP.developer)
     #
     # @param  [RDF::Query, RDF::Statement, Array(RDF::Term), Hash] pattern
-    # @param  [Hash{Symbol => Object}] options ({})
-    #   Any other options passed to {#query_pattern} or {#query_execute}
     # @yield  [statement]
     #   each matching statement
-    # @yieldparam  [RDF::Statement, RDF::Query::Solution] statement
-    #   Statement or Solution
+    # @yieldparam  [RDF::Statement] statement
     # @yieldreturn [void] ignored
     # @return [Enumerator]
     # @see    RDF::Queryable#query_pattern
-    def query(pattern, options = {}, &block)
+    def query(pattern, &block)
       raise TypeError, "#{self} is not readable" if respond_to?(:readable?) && !readable?
 
       case pattern
@@ -47,11 +36,7 @@ module RDF
         when Query
           if block_given?
             before_query(pattern) if respond_to?(:before_query)
-            if method(:query_execute).arity == 1
-              query_execute(pattern, &block)
-            else
-              query_execute(pattern, options, &block)
-            end
+            query_execute(pattern, &block)
             after_query(pattern) if respond_to?(:after_query)
           end
           enum_for(:query_execute, pattern)
@@ -78,16 +63,14 @@ module RDF
 
             # Otherwise, we delegate to `#query_pattern`:
             else # pattern.variable?
-              if block_given?
-                if self.method(:query_pattern).arity == 1
-                  query_pattern(pattern, &block)
-                else
-                  query_pattern(pattern, options, &block)
-                end
-              end
+              query_pattern(pattern, &block) if block_given?
               enum_for(:query_pattern, pattern)
           end
           after_query(pattern) if block_given? && respond_to?(:after_query)
+          enum.extend(RDF::Queryable, RDF::Enumerable, RDF::Countable)
+          def enum.to_a
+            super.extend(RDF::Queryable, RDF::Enumerable, RDF::Countable)
+          end
           enum
       end
     end
@@ -102,8 +85,6 @@ module RDF
     #
     # @param  [RDF::Query] query
     #   the query to execute
-    # @param  [Hash{Symbol => Object}] options ({})
-    #   Any other options passed to `query.execute`
     # @yield  [solution]
     # @yieldparam  [RDF::Query::Solution] solution
     # @yieldreturn [void] ignored
@@ -111,12 +92,12 @@ module RDF
     # @see    RDF::Queryable#query
     # @see    RDF::Query#execute
     # @since  0.3.0
-    def query_execute(query, options = {}, &block)
+    def query_execute(query, &block)
       # By default, we let RDF.rb's built-in `RDF::Query#execute` handle BGP
       # query execution by breaking down the query into its constituent
       # triple patterns and invoking `RDF::Query::Pattern#execute` on each
       # pattern.
-      query.execute(self, options).each(&block)
+      query.execute(self).each(&block)
     end
     protected :query_execute
 
@@ -130,8 +111,6 @@ module RDF
     #
     # @param  [RDF::Query::Pattern] pattern
     #   the query pattern to match
-    # @param  [Hash{Symbol => Object}] options ({})
-    #   Any other options
     # @yield  [statement]
     # @yieldparam  [RDF::Statement] statement
     # @yieldreturn [void] ignored
@@ -139,7 +118,7 @@ module RDF
     # @see    RDF::Queryable#query
     # @see    RDF::Query::Pattern#execute
     # @since  0.2.0
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, &block)
       # By default, we let Ruby's built-in `Enumerable#grep` handle the
       # matching of statements by iterating over all statements and calling
       # `RDF::Query::Pattern#===` on each statement.
@@ -286,31 +265,5 @@ module RDF
     def first_value(pattern = nil)
       (literal = first_literal(pattern)) ? literal.value : nil
     end
-
-    ##
-    # @private
-    # @param  [Symbol, #to_sym] method
-    # @return [Enumerator]
-    # @see    Object#enum_for
-    def enum_for(method = :each, *args)
-      # Ensure that enumerators are, themselves, queryable
-      this = self
-      Queryable::Enumerator.new do |yielder|
-        this.send(method, *args) {|y| yielder << y}
-      end
-    end
-    alias_method :to_enum, :enum_for
-
-
-    # Extends Enumerator with {Queryable} and {Enumerable}, which is used by {Enumerable#each_statement} and {Queryable#enum_for}
-    class Enumerator < ::Enumerator
-      include Queryable
-      include Enumerable
-
-      # Make sure returned arrays are also queryable
-      def to_a
-        return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
-      end
-    end
   end # Queryable
 end # RDF

data/lib/rdf/model/graph.rb

@@ -2,26 +2,31 @@ module RDF
   ##
   # An RDF graph.
   #
-  # @example Creating an empty unnamed graph
-  #   graph = Graph.new
+  # An {RDF::Graph} contains a unique set of {RDF::Statement}. It is
+  # based on an underlying data object, which may be specified when the
+  # graph is initialized, and will default to a {RDF::Repository} without
+  # support for contexts otherwise.
   #
-  # @example Creating an empty named graph
-  #   graph = Graph.new("http://rubygems.org/")
+  # Note that in RDF 1.1, graphs are not named, but are associated with
+  # a name in the context of a Dataset, as a pair of <name, graph>.
+  # This class allows a name to be associated with a graph when it is
+  # a projection of an underlying {RDF::Repository} supporting contexts.
   #
-  # @example Loading graph data from a URL (1)
-  #   require 'rdf/rdfxml'  # for RDF/XML support
-  #   
-  #   graph = RDF::Graph.new("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
-  #   graph.load!
+  # @example Creating an empty graph
+  #   graph = Graph.new
   #
-  # @example Loading graph data from a URL (2)
+  # @example Loading graph data from a URL
   #   require 'rdf/rdfxml'  # for RDF/XML support
   #   
   #   graph = RDF::Graph.load("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
   #
+  # @example Accessing a specific named graph within a {RDF::Repository}
+  #   require 'rdf/trig'  # for TriG support
+  #
+  #   repository = RDF::Repository.load("https://raw.github.com/ruby-rdf/rdf-trig/master/etc/doap.trig")
+  #   graph = RDF::Graph.new(:data => repository, :context => RDF::URI("http://greggkellogg.net/foaf#me"))
   class Graph
-    include RDF::Resource
-
+    include RDF::Value
     include RDF::Countable
     include RDF::Durable
     include RDF::Enumerable
@@ -39,8 +44,7 @@ module RDF
     # Name of this graph, if it is part of an {RDF::Repository}
     # @!attribute [rw] context
     # @return [RDF::Resource]
-    # @note In the next release, only projections from an
-    # {RDF::Enumerable} supporting contexts will have a context.
+    # @since 1.1.0
     attr_accessor :context
 
     alias_method :name, :context
@@ -64,8 +68,8 @@ module RDF
     # @return [Graph]
     # @since  0.1.7
     def self.load(url, options = {}, &block)
-      self.new(url, options) do |graph|
-        graph.load! unless graph.unnamed?
+      self.new(options) do |graph|
+        graph.load(url, options)
 
         if block_given?
           case block.arity
@@ -79,18 +83,24 @@ module RDF
     ##
     # @overload initialize(context, options)
     #   @param  [RDF::Resource]          context
-    #     The context only provides a context for loading relative documents
+    #     The context from the associated {RDF::Queryable} associated
+    #     with this graph as provided with the `:data` option
+    #     (only for {RDF::Queryable} instances supporting
+    #     named contexts).
     #   @param  [Hash{Symbol => Object}] options
+    #   @option options [RDF::Queryable] :data (RDF::Repository.new)
+    #     Storage behind this graph.
+    #   @raise [ArgumentError] if a `data` does not support contexts.
     #   @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
+    #   @option options [RDF::Queryable] :data (RDF::Repository.new)
+    #     Storage behind this graph.
     # @yield  [graph]
     # @yieldparam [Graph]
-    # @note Currently, context makes this a named garph;
-    # in the next release it will not
     def initialize(*args, &block)
       context = args.shift unless args.first.is_a?(Hash)
       options = args.first || {}
@@ -101,7 +111,10 @@ module RDF
       end
 
       @options = options.dup
-      @data    = @options.delete(:data) || RDF::Repository.new
+      @data    = @options.delete(:data) || RDF::Repository.new(:with_context => false)
+
+      raise ArgumentError, "Can't apply context unless initialized with `data` supporting contexts" if
+        @context && !@data.supports?(:context)
 
       if block_given?
         case block.arity
@@ -112,12 +125,14 @@ module RDF
     end
 
     ##
+    # (re)loads the graph from the specified location, or from the location associated with the graph context, if any
     # @return [void]
-    # @note The next release, graphs will not be named
+    # @see    RDF::Mutable#load
     def load!(*args)
       case
         when args.empty?
-          load(context.to_s, context ? {:base_uri => context}.merge(@options) : @options)
+          raise ArgumentError, "Can't reload graph with no context" unless context.is_a?(RDF::URI)
+          load(context.to_s, {:base_uri => context}.merge(@options))
         else super
       end
     end
@@ -181,6 +196,15 @@ module RDF
       named? ? context.to_s : "default"
     end
 
+    ##
+    # Returns `true` if this graph contains no RDF statements.
+    #
+    # @return [Boolean]
+    # @see    RDF::Enumerable#empty?
+    def empty?
+      !@data.has_context?(context || false)
+    end
+
     ##
     # Returns `true` if this graph has an anonymous context, `false` otherwise.
     #

data/lib/rdf/model/list.rb

@@ -8,7 +8,8 @@ module RDF
   # @since 0.2.3
   class RDF::List
     include RDF::Enumerable
-    include RDF::Resource
+    include RDF::Value
+    include Comparable
 
     ##
     # Constructs a new list from the given `values`.
@@ -38,12 +39,10 @@ module RDF
     # @yield  [list]
     # @yieldparam [RDF::List] list
     def initialize(subject = nil, graph = nil, values = nil, &block)
-      @subject = subject || RDF.nil
+      @subject = subject || RDF::Node.new
       @graph   = graph   || RDF::Graph.new
 
-      unless values.to_a.empty?
-        values.reverse_each {|value| self.unshift(value)}
-      end
+      values.each { |value| self << value } unless values.nil? || values.empty?
 
       if block_given?
         case block.arity
@@ -61,9 +60,10 @@ module RDF
     ##
     # Validate the list ensuring that
     # * rdf:rest values are all BNodes are nil
-    # * rdf:type, if it exists, is rdf:List
-    # * each subject has no properties other than single-valued rdf:first, rdf:rest
-    #   other than for the first node in the list
+    # * each subject has exactly one value for `rdf:first` and
+    #   `rdf:rest`.
+    # * The value of `rdf:rest` must be either a BNode or `rdf:nil`.
+    # * All other properties are ignored.
     # @return [Boolean]
     def valid?
       li = subject
@@ -71,19 +71,13 @@ module RDF
         rest = nil
         firsts = rests = 0
         @graph.query(:subject => li) do |st|
-          return false unless st.subject.node?
           case st.predicate
-          when RDF.type
-            # Be tollerant about rdf:type entries, as some OWL vocabularies use it excessively
           when RDF.first
             firsts += 1
           when RDF.rest
             rest = st.object
             return false unless rest.node? || rest == RDF.nil
             rests += 1
-          else
-            # First node may have other properties
-            return false unless li == subject
           end
         end
         return false unless firsts == 1 && rests == 1
@@ -199,7 +193,7 @@ module RDF
     # Returns the element at `index`.
     #
     # @example
-    #   RDF::List[1, 2, 3][0]                   #=> RDF::Literal(1)
+    #   RDF::List[1, 2, 3][0]                   #=> 1
     #
     # @param  [Integer] index
     # @return [RDF::Term]
@@ -208,71 +202,6 @@ module RDF
       at(index)
     end
 
-    ##
-    # Appends an element to the head of this list. Existing references are not updated, as the list subject changes as a side-effect.
-    #
-    # @example
-    #   RDF::List[].unshift(1).unshift(2).unshift(3) #=> RDF::List[3, 2, 1]
-    #
-    # @param  [RDF::Term] value
-    # @return [RDF::List]
-    # @see    http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-unshift
-    #
-    def unshift(value)
-      value = case value
-        when nil         then RDF.nil
-        when RDF::Value  then value
-        when Array       then RDF::List.new(nil, graph, value)
-        else value
-      end
-
-      new_subject, old_subject = RDF::Node.new, subject
-
-      graph.insert([new_subject, RDF.type, RDF.List])
-      graph.insert([new_subject, RDF.first, value.is_a?(RDF::List) ? value.subject : value])
-      graph.insert([new_subject, RDF.rest, old_subject])
-
-      @subject = new_subject
-
-      return self
-    end
-
-    ##
-    # Removes and returns the element at the head of this list.
-    #
-    # @example
-    #   RDF::List[1,2,3].shift              #=> 1
-    #
-    # @return [RDF::Term]
-    # @see    http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-shift
-    def shift
-      return nil if empty?
-
-      value = first
-      old_subject, new_subject = subject, rest_subject
-      graph.delete([old_subject, RDF.type, RDF.List])
-      graph.delete([old_subject, RDF.first, value])
-      graph.delete([old_subject, RDF.rest, new_subject])
-
-      @subject = new_subject
-      return value
-    end
-
-    ##
-    # Empties this list
-    #
-    # @example
-    #   RDF::List[1, 2, 2, 3].clear    #=> RDF::List[]
-    #
-    # @return [RDF::List]
-    # @see    http://ruby-doc.org/core-1.9.3/classes/Array.html#method-i-clear
-    def clear
-      until empty?
-        shift
-      end
-      return self
-    end
-
     ##
     # Appends an element to the tail of this list.
     #
@@ -291,14 +220,13 @@ module RDF
       end
 
       if empty?
-        @subject = new_subject = RDF::Node.new
+        new_subject = subject
       else
         old_subject, new_subject = last_subject, RDF::Node.new
         graph.delete([old_subject, RDF.rest, RDF.nil])
         graph.insert([old_subject, RDF.rest, new_subject])
       end
 
-      graph.insert([new_subject, RDF.type, RDF.List])
       graph.insert([new_subject, RDF.first, value.is_a?(RDF::List) ? value.subject : value])
       graph.insert([new_subject, RDF.rest, RDF.nil])
 
@@ -367,12 +295,10 @@ module RDF
     end
 
     ##
-    # Returns a slice of a list.
+    # Returns the element at `index`.
     #
     # @example
-    #     RDF::List[1, 2, 3].slice(0)    #=> RDF::Literal(1),
-    #     RDF::List[1, 2, 3].slice(0, 2) #=> RDF::List[1, 2],
-    #     RDF::List[1, 2, 3].slice(0..2) #=> RDF::List[1, 2, 3]
+    #   RDF::List[1, 2, 3].at(0)                #=> 1
     #
     # @return [RDF::Term]
     # @see    http://ruby-doc.org/core-1.9/classes/Array.html#M000462
@@ -401,10 +327,10 @@ module RDF
     protected :slice_with_range
 
     ##
-    # Returns element at `index` with default.
+    # Returns the element at `index`.
     #
     # @example
-    #   RDF::List[1, 2, 3].fetch(0)             #=> RDF::Literal(1)
+    #   RDF::List[1, 2, 3].fetch(0)             #=> 1
     #   RDF::List[1, 2, 3].fetch(4)             #=> IndexError
     #   RDF::List[1, 2, 3].fetch(4, nil)        #=> nil
     #   RDF::List[1, 2, 3].fetch(4) { |n| n*n } #=> 16
@@ -428,7 +354,6 @@ module RDF
     #
     # @example
     #   RDF::List[1, 2, 3].at(0)                #=> 1
-    #   RDF::List[1, 2, 3].at(4)                #=> nil
     #
     # @return [RDF::Term]
     # @see    http://ruby-doc.org/core-1.9/classes/Array.html#M000419
@@ -445,7 +370,7 @@ module RDF
     # Returns the first element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].first               #=> RDF::Literal(1)
+    #   RDF::List[*(1..10)].first               #=> 1
     #
     # @return [RDF::Term]
     def first
@@ -456,7 +381,7 @@ module RDF
     # Returns the second element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].second              #=> RDF::Literal(2)
+    #   RDF::List[*(1..10)].second              #=> 2
     #
     # @return [RDF::Term]
     def second
@@ -467,7 +392,7 @@ module RDF
     # Returns the third element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].third               #=> RDF::Literal(4)
+    #   RDF::List[*(1..10)].third               #=> 3
     #
     # @return [RDF::Term]
     def third
@@ -478,7 +403,7 @@ module RDF
     # Returns the fourth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].fourth              #=> RDF::Literal(4)
+    #   RDF::List[*(1..10)].fourth              #=> 4
     #
     # @return [RDF::Term]
     def fourth
@@ -489,7 +414,7 @@ module RDF
     # Returns the fifth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].fifth               #=> RDF::Literal(5)
+    #   RDF::List[*(1..10)].fifth               #=> 5
     #
     # @return [RDF::Term]
     def fifth
@@ -500,7 +425,7 @@ module RDF
     # Returns the sixth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].sixth               #=> RDF::Literal(6)
+    #   RDF::List[*(1..10)].sixth               #=> 6
     #
     # @return [RDF::Term]
     def sixth
@@ -511,7 +436,7 @@ module RDF
     # Returns the seventh element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].seventh             #=> RDF::Literal(7)
+    #   RDF::List[*(1..10)].seventh             #=> 7
     #
     # @return [RDF::Term]
     def seventh
@@ -522,7 +447,7 @@ module RDF
     # Returns the eighth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].eighth              #=> RDF::Literal(8)
+    #   RDF::List[*(1..10)].eighth              #=> 8
     #
     # @return [RDF::Term]
     def eighth
@@ -533,7 +458,7 @@ module RDF
     # Returns the ninth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].ninth               #=> RDF::Literal(9)
+    #   RDF::List[*(1..10)].ninth               #=> 9
     #
     # @return [RDF::Term]
     def ninth
@@ -544,7 +469,7 @@ module RDF
     # Returns the tenth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].tenth               #=> RDF::Literal(10)
+    #   RDF::List[*(1..10)].tenth               #=> 10
     #
     # @return [RDF::Term]
     def tenth
@@ -555,7 +480,7 @@ module RDF
     # Returns the last element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].last                 #=> RDF::Literal(10)
+    #   RDF::List[1, 2, 3].last                 #=> 3
     #
     # @return [RDF::Term]
     # @see    http://ruby-doc.org/core-1.9/classes/Array.html#M000422
@@ -747,7 +672,7 @@ module RDF
     #
     # @example
     #   RDF::List[].to_a                        #=> []
-    #   RDF::List[1, 2, 3].to_a                 #=> [RDF::Literal(1), RDF::Literal(2), RDF::Literal(3)]
+    #   RDF::List[1, 2, 3].to_a                 #=> [1, 2, 3]
     #
     # @return [Array]
     def to_a
@@ -758,7 +683,7 @@ module RDF
     # Returns the elements in this list as a set.
     #
     # @example
-    #   RDF::List[1, 2, 3].to_set               #=> Set[RDF::Literal(1), RDF::Literal(2), RDF::Literal(3)]
+    #   RDF::List[1, 2, 3].to_set               #=> Set[1, 2, 3]
     #
     # @return [Set]
     def to_set