rdf 1.0.5 → 1.0.6

data/README

@@ -1,5 +1,4 @@
 # RDF.rb: Linked Data for Ruby
-[![Build Status](https://secure.travis-ci.org/ruby-rdf/rdf.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf)
 
 This is a pure-Ruby library for working with [Resource Description Framework
 (RDF)][RDF] data.
@@ -10,6 +9,9 @@ This is a pure-Ruby library for working with [Resource Description Framework
 * <http://blog.datagraph.org/2010/04/parsing-rdf-with-ruby>
 * <http://blog.datagraph.org/2010/04/rdf-repository-howto>
 
+[![Gem Version](https://badge.fury.io/rb/rdf.png)](http://badge.fury.io/rb/rdf)
+[![Build Status](https://travis-ci.org/ruby-rdf/rdf.png?branch=master)](http://travis-ci.org/ruby-rdf/rdf)
+
 ## Features
 
 * 100% pure Ruby with minimal dependencies and no bloat.

data/VERSION

@@ -1 +1 @@
-1.0.5
+1.0.6

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 => "text/plain")
+  #   RDF::Format.for(:content_type => "application/n-triples")
   #
   # @example Obtaining serialization format MIME types
-  #   RDF::Format.content_types      #=> {"text/plain" => [RDF::NTriples::Format]}
+  #   RDF::Format.content_types      #=> {"application/n-triples" => [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     'text/plain', :extension => :nt
-  #     content_encoding 'ascii'
+  #     content_type     'application/n-triples', :extension => :nt
+  #     content_encoding 'utf-8'
   #     
   #     reader RDF::NTriples::Reader
   #     writer RDF::NTriples::Writer
@@ -249,7 +249,7 @@ module RDF
     #
     # @example
     #
-    #     RDF::NTriples::Format.name => "NTriples"
+    #     RDF::NTriples::Format.name => "N-Triples"
     #
     # @return [Symbol]
     def self.name
@@ -355,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]
@@ -401,14 +401,21 @@ module RDF
           |ct, cl| (cl.include?(self) && ct != @@content_type[self]) ?  ct : nil }].flatten.compact
       else
         @@content_type[self] = type
-        (@@content_types[type] ||= []) << self
+        @@content_types[type] ||= []
+        @@content_types[type] << self unless @@content_types[type].include?(self)
 
         if extensions = (options[:extension] || options[:extensions])
           extensions = [extensions].flatten.map(&:to_sym)
-          extensions.each { |ext| (@@file_extensions[ext] ||= []) << self }
+          extensions.each do |ext|
+            @@file_extensions[ext] ||= []
+            @@file_extensions[ext] << self unless @@file_extensions[ext].include?(self)
+          end
         end
         if aliases = (options[:alias] || options[:aliases])
-          aliases = [aliases].flatten.each { |a| (@@content_types[a] ||= []) << self }
+          aliases = [aliases].flatten.each do |a|
+            @@content_types[a] ||= []
+            @@content_types[a] << self unless @@content_types[a].include?(self)
+          end
         end
       end
     end

data/lib/rdf/mixin/countable.rb

@@ -9,9 +9,8 @@ module RDF
     #
     # @return [Boolean]
     def empty?
-      empty = true
-      each { empty = false; break }
-      empty
+      each {return false}
+      true
     end
 
     ##

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://rdf.rubyforge.org/"))
+  #   enumerable.has_subject?(RDF::URI("http://rubygems.org/gems/rdf"))
   #   enumerable.has_predicate?(RDF::DC.creator)
-  #   enumerable.has_object?(RDF::Literal("Hello!", :language => :en))
-  #   enumerable.has_context?(RDF::URI("http://rubyforge.org/"))
+  #   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"))
   #
   # @example Enumerating all statements
   #   enumerable.each_statement do |statement|

data/lib/rdf/mixin/queryable.rb

@@ -17,7 +17,7 @@ module RDF
     # This method delegates to the protected {RDF::Queryable#query_pattern} method for the
     # actual lower-level query pattern matching implementation.
     #
-    # @example
+    # @example Querying for statements having a given predicate
     #     queryable.query([nil, RDF::DOAP.developer, nil])
     #     queryable.query(:predicate => RDF::DOAP.developer)
     #

data/lib/rdf/model/graph.rb

@@ -9,13 +9,13 @@ module RDF
   #   graph = Graph.new("http://rubygems.org/")
   #
   # @example Loading graph data from a URL (1)
-  #   require 'rdf/raptor'  # for RDF/XML support
+  #   require 'rdf/rdfxml'  # for RDF/XML support
   #   
   #   graph = RDF::Graph.new("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
   #   graph.load!
   #
   # @example Loading graph data from a URL (2)
-  #   require 'rdf/raptor'  # for RDF/XML support
+  #   require 'rdf/rdfxml'  # for RDF/XML support
   #   
   #   graph = RDF::Graph.load("http://www.bbc.co.uk/programmes/b0081dq5.rdf")
   #
@@ -181,15 +181,6 @@ 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

@@ -196,7 +196,7 @@ module RDF
     # Returns the element at `index`.
     #
     # @example
-    #   RDF::List[1, 2, 3][0]                   #=> 1
+    #   RDF::List[1, 2, 3][0]                   #=> RDF::Literal(1)
     #
     # @param  [Integer] index
     # @return [RDF::Term]
@@ -299,10 +299,12 @@ module RDF
     end
 
     ##
-    # Returns the element at `index`.
+    # Returns a slice of a list.
     #
     # @example
-    #   RDF::List[1, 2, 3].at(0)                #=> 1
+    #     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]
     #
     # @return [RDF::Term]
     # @see    http://ruby-doc.org/core-1.9/classes/Array.html#M000462
@@ -331,10 +333,10 @@ module RDF
     protected :slice_with_range
 
     ##
-    # Returns the element at `index`.
+    # Returns element at `index` with default.
     #
     # @example
-    #   RDF::List[1, 2, 3].fetch(0)             #=> 1
+    #   RDF::List[1, 2, 3].fetch(0)             #=> RDF::Literal(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
@@ -358,6 +360,7 @@ 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
@@ -374,7 +377,7 @@ module RDF
     # Returns the first element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].first               #=> 1
+    #   RDF::List[*(1..10)].first               #=> RDF::Literal(1)
     #
     # @return [RDF::Term]
     def first
@@ -385,7 +388,7 @@ module RDF
     # Returns the second element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].second              #=> 2
+    #   RDF::List[*(1..10)].second              #=> RDF::Literal(2)
     #
     # @return [RDF::Term]
     def second
@@ -396,7 +399,7 @@ module RDF
     # Returns the third element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].third               #=> 3
+    #   RDF::List[*(1..10)].third               #=> RDF::Literal(4)
     #
     # @return [RDF::Term]
     def third
@@ -407,7 +410,7 @@ module RDF
     # Returns the fourth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].fourth              #=> 4
+    #   RDF::List[*(1..10)].fourth              #=> RDF::Literal(4)
     #
     # @return [RDF::Term]
     def fourth
@@ -418,7 +421,7 @@ module RDF
     # Returns the fifth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].fifth               #=> 5
+    #   RDF::List[*(1..10)].fifth               #=> RDF::Literal(5)
     #
     # @return [RDF::Term]
     def fifth
@@ -429,7 +432,7 @@ module RDF
     # Returns the sixth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].sixth               #=> 6
+    #   RDF::List[*(1..10)].sixth               #=> RDF::Literal(6)
     #
     # @return [RDF::Term]
     def sixth
@@ -440,7 +443,7 @@ module RDF
     # Returns the seventh element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].seventh             #=> 7
+    #   RDF::List[*(1..10)].seventh             #=> RDF::Literal(7)
     #
     # @return [RDF::Term]
     def seventh
@@ -451,7 +454,7 @@ module RDF
     # Returns the eighth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].eighth              #=> 8
+    #   RDF::List[*(1..10)].eighth              #=> RDF::Literal(8)
     #
     # @return [RDF::Term]
     def eighth
@@ -462,7 +465,7 @@ module RDF
     # Returns the ninth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].ninth               #=> 9
+    #   RDF::List[*(1..10)].ninth               #=> RDF::Literal(9)
     #
     # @return [RDF::Term]
     def ninth
@@ -473,7 +476,7 @@ module RDF
     # Returns the tenth element in this list.
     #
     # @example
-    #   RDF::List[*(1..10)].tenth               #=> 10
+    #   RDF::List[*(1..10)].tenth               #=> RDF::Literal(10)
     #
     # @return [RDF::Term]
     def tenth
@@ -484,7 +487,7 @@ module RDF
     # Returns the last element in this list.
     #
     # @example
-    #   RDF::List[1, 2, 3].last                 #=> 3
+    #   RDF::List[*(1..10)].last                 #=> RDF::Literal(10)
     #
     # @return [RDF::Term]
     # @see    http://ruby-doc.org/core-1.9/classes/Array.html#M000422
@@ -676,7 +679,7 @@ module RDF
     #
     # @example
     #   RDF::List[].to_a                        #=> []
-    #   RDF::List[1, 2, 3].to_a                 #=> [1, 2, 3]
+    #   RDF::List[1, 2, 3].to_a                 #=> [RDF::Literal(1), RDF::Literal(2), RDF::Literal(3)]
     #
     # @return [Array]
     def to_a
@@ -687,7 +690,7 @@ module RDF
     # Returns the elements in this list as a set.
     #
     # @example
-    #   RDF::List[1, 2, 3].to_set               #=> Set[1, 2, 3]
+    #   RDF::List[1, 2, 3].to_set               #=> Set[RDF::Literal(1), RDF::Literal(2), RDF::Literal(3)]
     #
     # @return [Set]
     def to_set

data/lib/rdf/model/literal/datetime.rb

@@ -15,6 +15,9 @@ module RDF; class Literal
       @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
       @string   = options[:lexical] if options.has_key?(:lexical)
       @string   ||= value if value.is_a?(String)
+      @has_timezone = @string.nil? || if md = @string.match(GRAMMAR)
+        !!md[2] # If lexical value contains timezone
+      end
       @object   = case
         when value.is_a?(::DateTime)         then value
         when value.respond_to?(:to_datetime) then value.to_datetime # Ruby 1.9+
@@ -33,6 +36,35 @@ module RDF; class Literal
       self
     end
 
+    ##
+    # Returns the timezone part of arg as a simple literal. Returns the empty string if there is no timezone.
+    #
+    # @return [RDF::Literal]
+    # @see http://www.w3.org/TR/sparql11-query/#func-tz
+    def tz
+      zone =  @has_timezone ? object.zone : ""
+      zone = "Z" if zone == "+00:00"
+      RDF::Literal(zone)
+    end
+
+    ##
+    # Returns the timezone part of arg as an xsd:dayTimeDuration, or `nil`
+    # if lexical form of literal does not include a timezone.
+    #
+    # @return [RDF::Literal]
+    def timezone
+      if tz == 'Z'
+        RDF::Literal("PT0S", :datatype => RDF::XSD.dayTimeDuration)
+      elsif md = tz.to_s.match(/^([+-])?(\d+):(\d+)?$/)
+        plus_minus, hour, min = md[1,3]
+        plus_minus = nil unless plus_minus == "-"
+        hour = hour.to_i
+        min = min.to_i
+        res = "#{plus_minus}PT#{hour}H#{"#{min}M" if min > 0}"
+        RDF::Literal(res, :datatype => RDF::XSD.dayTimeDuration)
+      end
+    end
+
     ##
     # Returns `true` if the value adheres to the defined grammar of the
     # datatype.
@@ -45,6 +77,8 @@ module RDF; class Literal
       super && object && value !~ %r(\A0000)
     end
 
+    ##
+    # Returns the `timezone` of the literal. If the
     ##
     # Returns the value as a string.
     #

data/lib/rdf/model/literal/decimal.rb

@@ -56,6 +56,36 @@ module RDF; class Literal
       (d = to_d) && d > 0 ? self : RDF::Literal(d.abs)
     end
 
+    ##
+    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
+    #
+    # @return [RDF::Literal]
+    def round
+      self.class.new(to_d.round)
+    end
+
+    ##
+    # Returns the smallest integer greater than or equal to `self`.
+    #
+    # @example
+    #   RDF::Literal(1).ceil            #=> RDF::Literal(1)
+    #
+    # @return [RDF::Literal]
+    def ceil
+      self.class.new(to_d.ceil)
+    end
+
+    ##
+    # Returns the largest integer less than or equal to `self`.
+    #
+    # @example
+    #   RDF::Literal(1).floor            #=> RDF::Literal(1)
+    #
+    # @return [RDF::Literal]
+    def floor
+      self.class.new(to_d.floor)
+    end
+
     ##
     # Returns `true` if the value is zero.
     #

data/lib/rdf/model/literal/double.rb

@@ -118,7 +118,7 @@ module RDF; class Literal
     end
 
     ##
-    # Returns the smallest integer greater than or equal to `self`.
+    # Returns the smallest number greater than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).ceil            #=> RDF::Literal(2)
@@ -129,11 +129,11 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def ceil
-      RDF::Literal(to_f.ceil)
+      self.class.new(to_f.ceil)
     end
 
     ##
-    # Returns the largest integer less than or equal to `self`.
+    # Returns the largest number less than or equal to `self`.
     #
     # @example
     #   RDF::Literal(1.2).floor           #=> RDF::Literal(1)
@@ -144,7 +144,7 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def floor
-      RDF::Literal(to_f.floor)
+      self.class.new(to_f.floor)
     end
 
     ##
@@ -153,7 +153,15 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def abs
-      (f = to_f) && f > 0 ? self : RDF::Literal(f.abs)
+      (f = to_f) && f > 0 ? self : self.class.new(f.abs)
+    end
+
+    ##
+    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
+    #
+    # @return [RDF::Literal]
+    def round
+      self.class.new(to_f.round)
     end
 
     ##

data/lib/rdf/model/literal/integer.rb

@@ -83,7 +83,15 @@ module RDF; class Literal
     # @return [RDF::Literal]
     # @since  0.2.3
     def abs
-      (n = to_i) && n > 0 ? self : RDF::Literal(n.abs)
+      (n = to_i) && n > 0 ? self : self.class.new(n.abs)
+    end
+
+    ##
+    # Returns `self`.
+    #
+    # @return [RDF::Literal]
+    def round
+      self
     end
 
     ##

data/lib/rdf/model/literal/numeric.rb

@@ -144,6 +144,46 @@ module RDF; class Literal
       end
     end
 
+    ##
+    # Returns the absolute value of `self`.
+    #
+    # @return [RDF::Literal]
+    # @raise  [NotImplementedError] unless implemented in subclass
+    def abs
+      raise NotImplementedError
+    end
+
+    ##
+    # Returns the number with no fractional part that is closest to the argument. If there are two such numbers, then the one that is closest to positive infinity is returned. An error is raised if arg is not a numeric value.
+    #
+    # @return [RDF::Literal]
+    # @raise  [NotImplementedError] unless implemented in subclass
+    def round
+      raise NotImplementedError
+    end
+
+    ##
+    # Returns the smallest integer greater than or equal to `self`.
+    #
+    # @example
+    #   RDF::Literal(1).ceil            #=> RDF::Literal(1)
+    #
+    # @return [RDF::Literal]
+    def ceil
+      self
+    end
+
+    ##
+    # Returns the largest integer less than or equal to `self`.
+    #
+    # @example
+    #   RDF::Literal(1).floor            #=> RDF::Literal(1)
+    #
+    # @return [RDF::Literal]
+    def floor
+      self
+    end
+
     ##
     # Returns the value as an integer.
     #

data/lib/rdf/model/literal.rb

@@ -53,7 +53,7 @@ module RDF
   #   RDF::Literal.new(123).datatype                 #=> XSD.integer
   #   RDF::Literal.new(9223372036854775807).datatype #=> XSD.integer
   #   RDF::Literal.new(3.1415).datatype              #=> XSD.double
-  #   RDF::Literal.new(Time.now).datatype            #=> XSD.dateTime
+  #   RDF::Literal.new(Time.now).datatype            #=> XSD.time
   #   RDF::Literal.new(Date.new(2010)).datatype      #=> XSD.date
   #   RDF::Literal.new(DateTime.new(2010)).datatype  #=> XSD.dateTime
   #
@@ -97,6 +97,8 @@ module RDF
     ##
     # @private
     def self.new(value, options = {})
+      raise ArgumentError, "datatype with language" if options[:language] && (options[:datatype] || RDF.langString).to_s != RDF.langString.to_s
+
       klass = case
         when !self.equal?(RDF::Literal)
           self # subclasses can be directly constructed without type dispatch
@@ -122,9 +124,9 @@ module RDF
       literal
     end
 
-    TRUE  = RDF::Literal.new(true).freeze
-    FALSE = RDF::Literal.new(false).freeze
-    ZERO  = RDF::Literal.new(0).freeze
+    TRUE  = RDF::Literal.new(true)
+    FALSE = RDF::Literal.new(false)
+    ZERO  = RDF::Literal.new(0)
 
     # @return [Symbol] The language tag (optional).
     attr_accessor :language
@@ -142,6 +144,11 @@ module RDF
     # @option options [URI]     :datatype (nil)
     # @option options [Boolean] :validate (false)
     # @option options [Boolean] :canonicalize (false)
+    # @raise [ArgumentError]
+    #   if there is a language and datatype is no rdf:langString
+    #   or datatype is rdf:langString and there is no language
+    # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
+    # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
     def initialize(value, options = {})
       @object   = value
       @string   = options[:lexical] if options[:lexical]
@@ -149,6 +156,10 @@ module RDF
       @language = options[:language].to_s.to_sym if options[:language]
       @datatype = RDF::URI(options[:datatype]) if options[:datatype]
       @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
+
+      # Ignore rdf:langString if there is a language
+      @datatype = nil if @language && @datatype == RDF.langString
+      raise ArgumentError, "datatype of rdf:langString requires a language" if !@language && @datatype == RDF::langString
     end
 
     ##
@@ -186,7 +197,24 @@ module RDF
     #
     # @return [Fixnum]
     def hash
-      to_s.hash
+      @hash ||= to_s.hash
+    end
+
+
+    ##
+    # Returns a hash code for the value.
+    #
+    # @return [Fixnum]
+    def value_hash
+      @value_hash ||= value.hash
+    end
+
+    ##
+    # @private
+    def freeze
+      hash.freeze
+      value_hash.freeze
+      super
     end
 
     ##
@@ -224,9 +252,9 @@ module RDF
           true
         when self.has_language? && self.language.to_s.downcase == other.language.to_s.downcase
           # Literals with languages can compare if languages are identical
-          self.value == other.value
+          self.value_hash == other.value_hash && self.value == other.value
         when (self.simple? || self.datatype == XSD.string) && (other.simple? || other.datatype == XSD.string)
-          self.value == other.value
+          self.value_hash == other.value_hash && self.value == other.value
         when other.comperable_datatype?(self) || self.comperable_datatype?(other)
           # Comoparing plain with undefined datatypes does not generate an error, but returns false
           # From data-r2/expr-equal/eq-2-2.
@@ -235,21 +263,35 @@ module RDF
           type_error("unable to determine whether #{self.inspect} and #{other.inspect} are equivalent")
         end
       when String
-        self.plain? && self.value.eql?(other)
+        self.simple? && self.value.eql?(other)
       else false
       end
     end
     alias_method :===, :==
 
     ##
-    # Returns `true` if this is a plain literal.
+    # Returns `true` if this is a plain literal. A plain literal
+    # may have a language, but may not have a datatype. For
+    # all practical purposes, this includes xsd:string literals
+    # too.
     #
     # @return [Boolean] `true` or `false`
     # @see http://www.w3.org/TR/rdf-concepts/#dfn-plain-literal
     def plain?
-      language.nil? && datatype.nil?
+      has_language? ?
+        (datatype || RDF.langString) == RDF.langString :
+        (datatype || XSD.string) == XSD.string
+    end
+
+    ##
+    # Returns `true` if this is a simple literal.
+    # A simple literal has no datatype or language.
+    #
+    # @return [Boolean] `true` or `false`
+    # @see http://www.w3.org/TR/sparql11-query/#simple_literal
+    def simple?
+      !has_language? && !has_datatype?
     end
-    alias_method :simple?, :plain?
 
     ##
     # Returns `true` if this is a language-tagged literal.

data/lib/rdf/model/node.rb

@@ -132,7 +132,9 @@ module RDF
         # If other is a Literal, reverse test to consolodate complex type checking logic
         other == self
       else 
-        other.respond_to?(:node?) && other.node? && other.respond_to?(:id) && @id == other.id
+        other.respond_to?(:node?) && other.node? &&
+          self.hash == other.hash &&
+          other.respond_to?(:id) && @id == other.id
       end
     end
     alias_method :===, :==

data/lib/rdf/model/statement.rb

@@ -9,6 +9,7 @@ module RDF
   #   RDF::Statement.new(s, p, o)
   #
   # @example Creating an RDF statement with a context
+  #   uri = RDF::URI("http://example/")
   #   RDF::Statement.new(s, p, o, :context => uri)
   #
   # @example Creating an RDF statement from a `Hash`

data/lib/rdf/model/uri.rb

@@ -522,7 +522,7 @@ module RDF
     # @param  [RDF::URI] other
     # @return [Boolean] `true` or `false`
     def eql?(other)
-      other.is_a?(URI) && self == other
+      other.is_a?(URI) && self.hash == other.hash && self == other
     end
 
     ##
@@ -544,6 +544,7 @@ module RDF
         # If other is a Literal, reverse test to consolodate complex type checking logic
         other == self
       when String then to_s == other
+      when URI then hash == other.hash && to_s == other.to_s
       when URI, Addressable::URI then to_s == other.to_s
       else other.respond_to?(:to_uri) && to_s == other.to_uri.to_s
       end

data/lib/rdf/query/pattern.rb

@@ -104,7 +104,7 @@ module RDF; class Query
     # To match triples only in the default context, set context to `false`.
     #
     # @example
-    #   Pattern.new(:s, :p, :o).execute(RDF::Repository.load('data.nt'))
+    #   Pattern.new(:s, :p, :o).execute(RDF::Repository.load('etc/doap.nt'))
     #
     # @param  [RDF::Queryable] queryable
     #   the graph or repository to query
@@ -156,7 +156,12 @@ module RDF; class Query
     # pattern with the corresponding terms in the given `statement`.
     #
     # @example
-    #   pattern.solution(statement)
+    #   pattern = Pattern.new(:s, :p, :o)
+    #   solution = pattern.solution(statement)
+    #
+    #   pattern[:s] #=> statement.subject
+    #   pattern[:p] #=> statement.predicate
+    #   pattern[:o] #=> statement.object
     #
     # @param  [RDF::Statement] statement
     #   an RDF statement to bind terms from

data/lib/rdf/query/solution.rb

@@ -25,7 +25,7 @@ class RDF::Query
     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] == '__'}.
+                  reject {|m| %w(object_id dup instance_eval inspect to_s class should should_not pretty_print).include?(m) || m[0,2] == '__'}.
                   map(&:to_sym))
 
     include Enumerable
@@ -145,7 +145,7 @@ class RDF::Query
     # @return [RDF::Term]
     # @since  0.3.0
     def []=(name, value)
-      @bindings[name.to_sym] = value
+      @bindings[name.to_sym] = value.is_a?(RDF::Term) ? value : RDF::Literal(value)
     end
 
     ##

data/lib/rdf/query/solutions.rb

@@ -4,13 +4,13 @@ module RDF; class Query
   #
   # @example Filtering solutions using a hash
   #   solutions.filter(:author  => RDF::URI("http://ar.to/#self"))
-  #   solutions.filter(:author  => "Arto Bendiken")
-  #   solutions.filter(:author  => [RDF::URI("http://ar.to/#self"), "Arto Bendiken"])
+  #   solutions.filter(:author  => "Gregg Kellogg")
+  #   solutions.filter(:author  => [RDF::URI("http://ar.to/#self"), "Gregg Kellogg"])
   #   solutions.filter(:updated => RDF::Literal(Date.today))
   #
   # @example Filtering solutions using a block
   #   solutions.filter { |solution| solution.author.literal? }
-  #   solutions.filter { |solution| solution.title =~ /^SPARQL/ }
+  #   solutions.filter { |solution| solution.title.to_s =~ /^SPARQL/ }
   #   solutions.filter { |solution| solution.price < 30.5 }
   #   solutions.filter { |solution| solution.bound?(:date) }
   #   solutions.filter { |solution| solution.age.datatype == RDF::XSD.integer }
@@ -93,7 +93,11 @@ module RDF; class Query
         self.reject! do |solution|
           solution = solution.is_a?(Solution) ? solution : Solution.new(solution)
           results = criteria.map do |name, value|
-            solution[name] == value
+            case value
+            when Array then value.any? {|v| solution[name] == v}
+            when Regexp then solution[name].to_s.match(value)
+            else solution[name] == value
+            end
           end
           !results.all?
         end

data/lib/rdf/query/variable.rb

@@ -12,7 +12,7 @@ class RDF::Query
   #   var.name       #=> :g2166151240
   #
   # @example Unbound variables match any value
-  #   var === 42     #=> true
+  #   var === RDF::Literal(42)     #=> true
   #
   # @example Creating a bound variable
   #   var = RDF::Query::Variable.new(:y, 123)
@@ -20,10 +20,12 @@ class RDF::Query
   #   var.value      #=> 123
   #
   # @example Bound variables match only their actual value
+  #   var = RDF::Query::Variable.new(:y, 123)
   #   var === 42     #=> false
   #   var === 123    #=> true
   #
   # @example Getting the variable name
+  #   var = RDF::Query::Variable.new(:y, 123)
   #   var.named?     #=> true
   #   var.name       #=> :y
   #   var.to_sym     #=> :y

data/lib/rdf/query.rb

@@ -89,7 +89,7 @@ module RDF
     # @return [RDF::Query::Solutions]
     #   the resulting solution sequence
     # @see    RDF::Query#execute
-    def self.execute(queryable, patterns = nil, options = {}, &block)
+    def self.execute(queryable, patterns = {}, options = {}, &block)
       self.new(patterns, options, &block).execute(queryable, options)
     end
 
@@ -243,6 +243,9 @@ module RDF
     # or named contexts.
     # The name of `false` will only match against the default context.
     #
+    # If the query nas no patterns, it returns a single empty solution as
+    # per SPARQL 1.1 _Empty Group Pattern_.
+    #
     # @param  [RDF::Queryable] queryable
     #   the graph or repository to query
     # @param  [Hash{Symbol => Object}] options
@@ -259,6 +262,7 @@ module RDF
     # @return [RDF::Query::Solutions]
     #   the resulting solution sequence
     # @see    http://www.holygoat.co.uk/blog/entry/2005-10-25-1
+    # @see    http://www.w3.org/TR/sparql11-query/#emptyGroupPattern
     def execute(queryable, options = {})
       validate!
       options = options.dup
@@ -271,6 +275,9 @@ module RDF
       # the first pattern
       @solutions = options[:solutions] || (Solutions.new << RDF::Query::Solution.new({}))
 
+      # If there are no patterns, just return the empty solution
+      return @solutions if empty?
+
       patterns = @patterns
       context = options.fetch(:context, options.fetch(:name, self.context))
 

data/lib/rdf/repository.rb

@@ -237,13 +237,6 @@ module RDF
         false
       end
 
-      ##
-      # @private
-      # @see RDF::Countable#empty?
-      def empty?
-        @data.empty?
-      end
-
       ##
       # @private
       # @see RDF::Countable#count

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
   prerelease:
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-04-12 00:00:00.000000000 Z
+date: 2013-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -45,6 +45,24 @@ dependencies:
     none: false
   prerelease: false
   type: :development
+- !ruby/object:Gem::Dependency
+  name: rdf-rdfxml
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: !binary |-
+          MA==
+    none: false
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
   name: rspec
   version_requirements: !ruby/object:Gem::Requirement