rdf 1.1.0p4 → 1.1.0

data/lib/rdf/format.rb

@@ -142,8 +142,8 @@ 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.to_s
-        sample.force_encoding(Encoding::UTF_8) if sample.respond_to?(:force_encoding)
+        sample = sample.dup.to_s
+        sample.force_encoding(Encoding::ASCII_8BIT) if sample.respond_to?(:force_encoding)
         # Given a sample, perform format detection across the appropriate formats, choosing
         # the first that matches
         format ||= @@subclasses

data/lib/rdf/mixin/enumerable.rb

@@ -67,20 +67,23 @@ module RDF
     # Supported features include:
     #   * `:context` supports statements with a context, allowing multiple contexts
     #   * `:inferrence` supports RDFS inferrence of queryable contents.
+    #   * `:validatable` allows a concrete Enumerable implementation to indicate that it does or does not support valididty checking. By default implementations are assumed to support validity checking.
     #
     # @param  [Symbol, #to_sym] feature
     # @return [Boolean]
     # @since  0.3.5
     def supports?(feature)
-      false
+      feature == :validity
     end
 
     ##
     # Returns `true` if all statements are valid
     #
     # @return [Boolean] `true` or `false`
+    # @raise  [NotImplementedError] unless enumerable supports validation
     # @since  0.3.11
     def valid?
+      raise NotImplementedError, "#{self.class} does not support validation" unless supports?(:validity)
       each_statement do |s|
         return false if s.invalid?
       end
@@ -91,6 +94,7 @@ module RDF
     # Returns `true` if value is not valid
     #
     # @return [Boolean] `true` or `false`
+    # @raise  [NotImplementedError] unless enumerable supports validation
     # @since  0.2.1
     def invalid?
       !valid?
@@ -102,7 +106,7 @@ module RDF
     # @raise  [ArgumentError] if the value is invalid
     # @since  0.3.9
     def validate!
-      raise ArgumentError if invalid?
+      raise ArgumentError if supports?(:validity) && invalid?
     end
     alias_method :validate, :validate!
 
@@ -226,7 +230,9 @@ module RDF
     # @return [Enumerator]
     # @see    #each_triple
     def enum_triple
-      enum_for(:each_triple)
+      Countable::Enumerator.new do |yielder|
+        each_triple {|s, p, o| yielder << [s, p, o]}
+      end
     end
     alias_method :enum_triples, :enum_triple
 
@@ -287,7 +293,9 @@ module RDF
     # @return [Enumerator]
     # @see    #each_quad
     def enum_quad
-      enum_for(:each_quad)
+      Countable::Enumerator.new do |yielder|
+        each_quad {|s, p, o, c| yielder << [s, p, o, c]}
+      end
     end
     alias_method :enum_quads, :enum_quad
 

data/lib/rdf/mixin/queryable.rb

@@ -37,7 +37,8 @@ module RDF
     # @yieldparam  [RDF::Statement, RDF::Query::Solution] statement
     #   Statement or Solution
     # @yieldreturn [void] ignored
-    # @return [Enumerator]
+    # @return [Enumerator, Query::Solutions]
+    #   Returns an enumerator over statements or query solutions, if passed an {RDF::Query}
     # @see    RDF::Queryable#query_pattern
     def query(pattern, options = {}, &block)
       raise TypeError, "#{self} is not readable" if respond_to?(:readable?) && !readable?
@@ -45,17 +46,16 @@ module RDF
       case pattern
         # A basic graph pattern (BGP) query:
         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
-            after_query(pattern) if respond_to?(:after_query)
+          before_query(pattern) if respond_to?(:before_query)
+          solutions = if method(:query_execute).arity == 1
+            query_execute(pattern, &block)
+          else
+            query_execute(pattern, options, &block)
           end
-          enum_for(:query_execute, pattern)
-
+          after_query(pattern) if respond_to?(:after_query)
+          # Returns the solutions, not an enumerator
+          solutions
+ 
         # A simple triple/quad pattern query:
         else
           pattern = Query::Pattern.from(pattern)
@@ -116,7 +116,7 @@ module RDF
       # 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, options, &block)
     end
     protected :query_execute
 
@@ -296,7 +296,7 @@ module RDF
       # Ensure that enumerators are, themselves, queryable
       this = self
       Queryable::Enumerator.new do |yielder|
-        this.send(method, *args) {|y| yielder << y}
+        this.send(method, *args) {|*y| yielder << (y.length > 1 ? y : y.first)}
       end
     end
     alias_method :to_enum, :enum_for

data/lib/rdf/model/graph.rb

@@ -100,10 +100,11 @@ module RDF
     #   @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.
+    #   @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)

data/lib/rdf/model/list.rb

@@ -42,8 +42,8 @@ module RDF
       @subject = subject || RDF.nil
       @graph   = graph   || RDF::Graph.new
 
-      unless values.to_a.empty?
-        values.reverse_each {|value| self.unshift(value)}
+      unless Array(values).empty?
+        Array(values).reverse_each {|value| self.unshift(value)}
       end
 
       if block_given?
@@ -761,6 +761,18 @@ module RDF
       each.to_set
     end
 
+    ##
+    # Returns the subject of the list.
+    #
+    # @example
+    #   RDF::List[].to_term                     #=> "RDF[:nil]"
+    #   RDF::List[1, 2, 3].to_term              #=> "RDF::Node"
+    #
+    # @return [RDF::Resource]
+    def to_term
+      subject
+    end
+
     ##
     # Returns a string representation of this list.
     #
@@ -784,8 +796,7 @@ module RDF
       if self.equal?(NIL)
         'RDF::List::NIL'
       else
-        #sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, subject.to_s)
-        sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, to_s) # FIXME
+        sprintf("#<%s:%#0x(%s)>", self.class.name, __id__, join(', '))
       end
     end
   end

data/lib/rdf/model/literal.rb

@@ -164,7 +164,8 @@ module RDF
       @object   = value
       @string   = options[:lexical] if options[:lexical]
       @string   = value if !defined?(@string) && value.is_a?(String)
-      @string.encode!(Encoding::UTF_8) if @string && @string.respond_to?(:encode!)
+      @string   = @string.encode(Encoding::UTF_8) if @string
+      @object   = @string if @string && @object.is_a?(String)
       @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)

data/lib/rdf/model/statement.rb

@@ -59,6 +59,7 @@ module RDF
     #   @option options [RDF::Term]      :object    (nil)
     #   @option options [RDF::Resource]  :context   (nil)
     #     Note, in RDF 1.1, a context MUST be an IRI.
+    #   @return [RDF::Statement]
     #
     # @overload initialize(subject, predicate, object, options = {})
     #   @param  [RDF::Resource]          subject
@@ -66,6 +67,7 @@ module RDF
     #   @param  [RDF::Term]              object
     #   @param  [Hash{Symbol => Object}] options
     #   @option options [RDF::Resource]  :context   (nil)
+    #   @return [RDF::Statement]
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
       case subject
         when Hash
@@ -88,12 +90,19 @@ module RDF
     # @private
     def initialize!
       @context   = Node.intern(@context)   if @context.is_a?(Symbol)
-      @subject   = Node.intern(@subject)   if @subject.is_a?(Symbol)
+      @subject   = case @subject
+        when nil      then nil
+        when Symbol   then Node.intern(@subject)
+        when Term     then @subject
+        when Value    then @subject.to_term
+        else          raise_error(ArgumentError, "expected subject to be nil or a term, was #{@subject.inspect}")
+      end
       @predicate = Node.intern(@predicate) if @predicate.is_a?(Symbol)
       @object    = case @object
         when nil    then nil
         when Symbol then Node.intern(@object)
         when Term   then @object
+        when Value  then @object.to_term
         else Literal.new(@object)
       end
     end

data/lib/rdf/model/term.rb

@@ -72,6 +72,14 @@ module RDF
       true
     end
 
+    ##
+    # Returns itself.
+    #
+    # @return [RDF::Value]
+    def to_term
+      self
+    end
+
     protected
     ##
     # Escape a term using standard character escapes

data/lib/rdf/model/uri.rb

@@ -1146,15 +1146,120 @@ module RDF
       normalized_user + (password ? ":#{normalized_password}" : "") if userinfo
     end
 
+    ##
+    # Converts the query component to a Hash value.
+    #
+    # @example
+    #   RDF::URI.new("?one=1&two=2&three=3").query_values
+    #   #=> {"one" => "1", "two" => "2", "three" => "3"}
+    #   RDF::URI.new("?one=two&one=three").query_values(Array)
+    #   #=> [["one", "two"], ["one", "three"]]
+    #   RDF::URI.new("?one=two&one=three").query_values(Hash)
+    #   #=> {"one" => ["two", "three"]}
+    #
+    # @param [Class] return_type (Hash)
+    #   The return type desired. Value must be either #   `Hash` or `Array`.
+    # @return [Hash, Array] The query string parsed as a Hash or Array object.
+    def query_values(return_type=Hash)
+      raise ArgumentError, "Invalid return type. Must be Hash or Array." unless [Hash, Array].include?(return_type)
+      return nil if query.nil?
+      query.to_s.split('&').
+        inject(return_type == Hash ? {} : []) do |memo,kv|
+          k,v = kv.to_s.split('=', 2)
+          next if k.to_s.empty?
+          k = ::URI.decode(k)
+          v = ::URI.decode(v) if v
+          if return_type == Hash
+            case memo[k]
+            when nil then memo[k] = v
+            when Array then memo[k] << v
+            else memo[k] = [memo[k], v]
+            end
+          else
+            memo << [k, v].compact
+          end
+          memo
+        end
+    end
+
+    ##
+    # Sets the query component for this URI from a Hash object.
+    # An empty Hash or Array will result in an empty query string.
+    #
+    # @example
+    #   uri.query_values = {:a => "a", :b => ["c", "d", "e"]}
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', 'c'], ['b', 'd'], ['b', 'e']]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['a', 'a'], ['b', ['c', 'd', 'e']]]
+    #   uri.query
+    #   # => "a=a&b=c&b=d&b=e"
+    #   uri.query_values = [['flag'], ['key', 'value']]
+    #   uri.query
+    #   # => "flag&key=value"
+    #
+    # @param [Hash, #to_hash, Array] value The new query values.
+    def query_values=(value)
+      if value.nil?
+        self.query = nil
+        return
+      end
+
+      value = value.to_hash if value.respond_to?(:to_hash)
+      self.query = case value
+      when Array
+        value.map do |(k,v)|
+          k = normalize_segment(k.to_s, UNRESERVED)
+          if v.nil?
+            k
+          else
+            "#{k}=#{normalize_segment(v.to_s, UNRESERVED)}"
+          end
+        end
+      when Hash
+        value.map do |k, v|
+          k = normalize_segment(k.to_s, UNRESERVED)
+          if v.nil?
+            k
+          else
+            Array(v).map do |vv|
+              if vv === TrueClass
+                k
+              else
+                "#{k}=#{normalize_segment(vv.to_s, UNRESERVED)}"
+              end
+            end.join("&")
+          end
+        end
+      else
+        raise TypeError,
+          "Can't convert #{value.class} into Hash."
+      end.join("&")
+    end
+
+    ##
+    # The HTTP request URI for this URI.  This is the path and the
+    # query string.
+    #
+    # @return [String] The request URI required for an HTTP request.
+    def request_uri
+      return nil if absolute? && scheme !~ /^https?$/
+      res = path.to_s.empty? ? "/" : path
+      res += "?#{self.query}" if self.query
+      return res
+    end
+
   private
 
     ##
     # Normalize a segment using a character range
     #
-    # @param [String] segment
+    # @param [String] value
     # @param [Regexp] expr
     # @param [Boolean] downcase
-    # @result [String]
+    # @return [String]
     def normalize_segment(value, expr, downcase = false)
       if value
         value = value.dup if value.frozen?

data/lib/rdf/model/value.rb

@@ -185,6 +185,14 @@ module RDF
       self
     end
 
+    ##
+    # Returns an `RDF::Term` representation of `self`.
+    #
+    # @return [RDF::Value]
+    def to_term
+      raise NotImplementedError, "#{self.class}#read_triple" # override in subclasses
+    end
+
     ##
     # Returns a developer-friendly representation of `self`.
     #

data/lib/rdf/ntriples/reader.rb

@@ -62,7 +62,7 @@ module RDF::NTriples
     # 166s
     PN_CHARS             = /-|[0-9]|#{PN_CHARS_U}|#{U_CHARS2}/.freeze
     # 159s
-    ECHAR                = /\\[tbnrf\\"']/.freeze
+    ECHAR                = /\\[tbnrf\\"]/.freeze
     # 18
     IRIREF               = /<((?:#{IRI_RANGE}|#{ESCAPE_CHAR})*)>/.freeze
     # 141s
@@ -84,7 +84,7 @@ module RDF::NTriples
     SUBJECT               = Regexp.union(URIREF, NODEID).freeze
     PREDICATE             = Regexp.union(URIREF).freeze
     OBJECT                = Regexp.union(URIREF, NODEID, LITERAL).freeze
-    END_OF_STATEMENT      = /^\s*\.\s*$/.freeze
+    END_OF_STATEMENT      = /^\s*\.\s*(?:#.*)?$/.freeze
 
     ##
     # Reconstructs an RDF value from its serialized N-Triples
@@ -159,7 +159,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.force_encoding(Encoding::ASCII_8BIT)
+      string = string.dup.force_encoding(Encoding::ASCII_8BIT)
 
       # Decode \t|\n|\r|\"|\\ character escapes:
       ESCAPE_CHARS.each { |escape| string.gsub!(escape.inspect[1...-1], escape) }
@@ -169,7 +169,7 @@ module RDF::NTriples
         (string.sub!(ESCAPE_SURROGATE) do
           if ESCAPE_SURROGATE1.include?($1.hex) && ESCAPE_SURROGATE2.include?($2.hex)
             s = [$1, $2].pack('H*H*')
-            s = s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
+            s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
           else
             s = [$1.hex].pack('U*') << '\u' << $2
           end
@@ -210,6 +210,7 @@ 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

data/lib/rdf/query.rb

@@ -93,6 +93,27 @@ module RDF
       self.new(patterns, options, &block).execute(queryable, options)
     end
 
+    ##
+    # Cast values as Solutions
+    # @overload Solutions()
+    #   @return [Solutions] returns Solutions.new()
+    #
+    # @overload Solutions(solutions)
+    #   @return [Solutions] returns the argument
+    #
+    # @overload Solutions(array)
+    #   @param [Array] array
+    #   @return [Solutions] returns the array extended with solutions
+    #
+    # @overload Solutions(*args)
+    #   @param [Array<Solution>] args
+    #   @return [Solutions] returns new solutions including the arguments, which must each be a {Solution}
+    def self.Solutions(*args)
+      return args.first if args.length == 1 && args.first.is_a?(Solutions)
+      args = args.first if args.first.is_a?(Array) && args.length == 1
+      return Solutions.new(args)
+    end
+
     ##
     # The variables used in this query.
     #
@@ -160,7 +181,7 @@ module RDF
       @options  = patterns.last.is_a?(Hash) ? patterns.pop.dup : {}
       patterns << @options if patterns.empty?
       @variables = {}
-      @solutions = @options.delete(:solutions) || Solutions.new
+      @solutions = Query::Solutions(@options.delete(:solutions))
       context = @options.fetch(:context, @options.fetch(:name, nil))
       @options.delete(:context)
       @options.delete(:name)
@@ -257,13 +278,17 @@ module RDF
     #   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
+    # @option options [RDF::Query::Solutions] solutions
     #   optional initial solutions for chained queries
+    # @yield  [solution]
+    #   each matching solution
+    # @yieldparam  [RDF::Query::Solution] solution
+    # @yieldreturn [void] ignored
     # @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 = {})
+    def execute(queryable, options = {}, &block)
       validate!
       options = options.dup
 
@@ -273,10 +298,13 @@ module RDF
       # Use provided solutions to allow for query chaining
       # Otherwise, a quick empty solution simplifies the logic below; no special case for
       # the first pattern
-      @solutions = options[:solutions] || (Solutions.new << RDF::Query::Solution.new({}))
+      @solutions = Query::Solutions(options[:solutions] || Solution.new)
 
       # If there are no patterns, just return the empty solution
-      return @solutions if empty?
+      if empty?
+        @solutions.each(&block) if block_given?
+        return @solutions
+      end
 
       patterns = @patterns
       context = options.fetch(:context, options.fetch(:name, self.context))
@@ -289,14 +317,14 @@ module RDF
           patterns.first.context = context
         end
       end
-      
+
       patterns.each do |pattern|
 
-        old_solutions, @solutions = @solutions, Solutions.new
+        old_solutions, @solutions = @solutions, Query::Solutions()
 
         options[:bindings].keys.each do |variable|
           if pattern.variables.include?(variable)
-            unbound_solutions, old_solutions = old_solutions, Solutions.new
+            unbound_solutions, old_solutions = old_solutions, Query::Solutions()
             options[:bindings][variable].each do |binding|
               unbound_solutions.each do |solution|
                 old_solutions << solution.merge(variable => binding)
@@ -325,11 +353,18 @@ module RDF
         # that can have constraints are often broad without them.
         # We have no solutions at all:
         return @solutions if @solutions.empty?
-        # We have no solutions for variables we should have solutions for:
-        if !pattern.optional? && pattern.variables.keys.any? { |variable| !@solutions.variable_names.include?(variable) }
-          return Solutions.new
+
+        if !pattern.optional?
+          # We have no solutions for variables we should have solutions for:
+          need_vars = pattern.variables.keys
+          @solutions.each do |solution|
+            break if need_vars.empty?
+            need_vars -= solution.bindings.keys
+          end
+          return Query::Solutions() unless need_vars.empty?
         end
       end
+      @solutions.each(&block) if block_given?
       @solutions
     end
 
@@ -354,7 +389,7 @@ module RDF
     # @return [Boolean]
     # @see    #failed?
     def matched?
-      !@failed
+      !failed?
     end
 
     # Add patterns from another query to form a new Query