rdf 0.3.3 → 0.3.4

data/lib/rdf/model/statement.rb

@@ -27,7 +27,8 @@ module RDF
     def self.from(statement, options = {})
       case statement
         when Array, Query::Pattern
-          self.new(statement[0], statement[1], statement[2], options.merge(:context => statement[3] || nil))
+          context = statement[3] == false ? nil : statement[3]
+          self.new(statement[0], statement[1], statement[2], options.merge(:context => context))
         when Statement then statement
         when Hash      then self.new(options.merge(statement))
         else raise ArgumentError, "expected RDF::Statement, Hash, or Array, but got #{statement.inspect}"
@@ -176,7 +177,7 @@ module RDF
     # @param  [Statement] other
     # @return [Boolean]
     def eql?(other)
-      other.is_a?(Statement) && self == other && self.context == other.context
+      other.is_a?(Statement) && self == other && (self.context || false) == (other.context || false)
     end
 
     ##
@@ -190,10 +191,10 @@ module RDF
     # @param  [Statement] other
     # @return [Boolean]
     def ===(other)
-      return false if has_context?   && context   != other.context
-      return false if has_subject?   && subject   != other.subject
-      return false if has_predicate? && predicate != other.predicate
-      return false if has_object?    && object    != other.object
+      return false if has_context?   && !context.eql?(other.context)
+      return false if has_subject?   && !subject.eql?(other.subject)
+      return false if has_predicate? && !predicate.eql?(other.predicate)
+      return false if has_object?    && !object.eql?(other.object)
       return true
     end
 

data/lib/rdf/model/term.rb

@@ -24,6 +24,38 @@ module RDF
       self.to_s <=> other.to_s
     end
 
+    ##
+    # Compares `self` to `other` to implement RDFterm-equal.
+    #
+    # Subclasses should override this to provide a more meaningful
+    # implementation than the default which simply performs a string
+    # comparison based on `#to_s`.
+    #
+    # @abstract
+    # @param  [Object]  other
+    # @return [Integer] `-1`, `0`, or `1`
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal
+    def ==(other)
+      super
+    end
+
+    ##
+    # Determins if `self` is the same term as `other`.
+    #
+    # Subclasses should override this to provide a more meaningful
+    # implementation than the default which simply performs a string
+    # comparison based on `#to_s`.
+    #
+    # @abstract
+    # @param  [Object]  other
+    # @return [Integer] `-1`, `0`, or `1`
+    #
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-sameTerm
+    def eql?(other)
+      super
+    end
+
     ##
     # Returns `true` if this term is constant.
     #

data/lib/rdf/model/uri.rb

@@ -244,8 +244,8 @@ module RDF
     #     RDF::URI.new('urn:isbn') / 125235111
     #     #=> RDF::URI('urn:isbn:125235111')
     def /(fragment)
-      fragment = fragment.respond_to?(:to_uri) ? fragment.to_uri : RDF::URI.intern(fragment.to_s)
-      raise ArgumentError, "Non-absolute URI or string required, got #{fragment}" unless fragment.relative?
+      frag = fragment.respond_to?(:to_uri) ? fragment.to_uri : RDF::URI(fragment.to_s)
+      raise ArgumentError, "Non-absolute URI or string required, got #{frag}" unless frag.relative?
       if urn?
         RDF::URI.intern(to_s.sub(/:+$/,'') + ':' + fragment.to_s.sub(/^:+/,''))
       else # !urn?
@@ -435,7 +435,7 @@ module RDF
     alias_method :ends_with?, :end_with?
 
     ##
-    # Checks whether this URI is equal to `other`.
+    # Checks whether this URI the same term as `other'.
     #
     # @example
     #   RDF::URI('http://t.co/').eql?(RDF::URI('http://t.co/')) #=> true
@@ -449,7 +449,9 @@ module RDF
     end
 
     ##
-    # Checks whether this URI is equal to `other`.
+    # Checks whether this URI is equal to `other` (type checking).
+    #
+    # Per SPARQL data-r2/expr-equal/eq-2-2, numeric can't be compared with other types
     #
     # @example
     #   RDF::URI('http://t.co/') == RDF::URI('http://t.co/')    #=> true
@@ -458,11 +460,15 @@ module RDF
     #
     # @param  [Object] other
     # @return [Boolean] `true` or `false`
+    # @see http://www.w3.org/TR/rdf-sparql-query/#func-RDFterm-equal
     def ==(other)
       case other
-        when String then to_s == other
-        when URI, Addressable::URI then to_s == other.to_s
-        else other.respond_to?(:to_uri) && to_s == other.to_uri.to_s
+      when Literal
+        # If other is a Literal, reverse test to consolodate complex type checking logic
+        other == self
+      when String then to_s == other
+      when URI, Addressable::URI then to_s == other.to_s
+      else other.respond_to?(:to_uri) && to_s == other.to_uri.to_s
       end
     end
 

data/lib/rdf/model/value.rb

@@ -119,5 +119,15 @@ module RDF
     def inspect!
       warn(inspect)
     end
+    
+    ##
+    # Default implementation of raise_error, which returns false.
+    # Classes including RDF::TypeCheck will raise RDF::TypeError
+    # instead.
+    #
+    # @return [false]
+    def type_error(message)
+      false
+    end
   end # Value
 end # RDF

data/lib/rdf/nquads.rb

@@ -4,6 +4,8 @@ module RDF
   #
   # This has not yet been implemented as of RDF.rb 0.3.x.
   module NQuads
+    include NTriples
+
     ##
     # N-Quads format specification.
     #
@@ -15,20 +17,135 @@ module RDF
     #   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_encoding 'ascii'
+      content_encoding 'utf-8'
 
       reader { RDF::NQuads::Reader }
       writer { RDF::NQuads::Writer }
+    
+      ##
+      # Sample detection to see if it matches N-Quads (or N-Triples)
+      #
+      # Use a text sample to detect the format of an input file. Sub-classes implement
+      # a matcher sufficient to detect probably format matches, including disambiguating
+      # between other similar formats.
+      #
+      # @param [String] sample Beginning several bytes (about 1K) of input.
+      # @return [Boolean]
+      def self.detect(sample)
+        !!sample.match(%r(
+          (?:\s*(?:<[^>]*>) | (?:_:\w+))                        # Subject
+          (?:\s*<[^>]*>)                                        # Predicate
+          \s*
+          (?:(?:<[^>]*>) | (?:_:\w+) | (?:"[^"]*"(?:^^|@\S+)?)) # Object
+          (?:\s*<[^>]*>)?                                       # Optional context
+          \s*\.
+        )mx) && (
+          !sample.match(%r(@(base|prefix|keywords)))            # Not Turtle/N3
+        )
+      end
     end
 
     class Reader < NTriples::Reader
-      # TODO
+      ##
+      # @param  [String] input
+      # @return [RDF::Term]
+      # @since  0.4.0
+      def self.parse_context(input)
+        parse_uri(input) || parse_node(input) || parse_literal(input)
+      end
+
+      ##
+      # Read a Quad, where the context is optional
+      #
+      # @return [Array]
+      # @see    http://sw.deri.org/2008/07/n-quads/#grammar
+      # @since  0.4.0
+      def read_triple
+        loop do
+          readline.strip! # EOFError thrown on end of input
+          line = @line    # for backtracking input in case of parse error
+
+          begin
+            unless blank? || read_comment
+              subject   = read_uriref || read_node || fail_subject
+              predicate = read_uriref(:intern => true) || fail_predicate
+              object    = read_uriref || read_node || read_literal || fail_object
+              context    = read_uriref || read_node || read_literal
+              return [subject, predicate, object, {:context => context}]
+            end
+          rescue RDF::ReaderError => e
+            @line = line  # this allows #read_value to work
+            raise e
+          end
+        end
+      end
+
     end # Reader
 
     class Writer < NTriples::Writer
-      # TODO
+      ##
+      # @param  [RDF::Statement] statement
+      # @return [void] `self`
+      def write_statement(statement)
+        write_quad(*statement.to_quad)
+        self
+      end
+      alias_method :insert_statement, :write_statement # support the RDF::Writable interface
+
+      ##
+      # Outputs the N-Quads representation of a statement.
+      #
+      # @param  [RDF::Resource] subject
+      # @param  [RDF::URI]      predicate
+      # @param  [RDF::Term]     object
+      # @return [void]
+      def write_quad(subject, predicate, object, context)
+        puts format_quad(subject, predicate, object, context)
+      end
+
+      ##
+      # Returns the N-Quads representation of a statement.
+      #
+      # @param  [RDF::Statement] statement
+      # @return [String]
+      # @since  0.4.0
+      def format_statement(statement)
+        format_quad(*statement.to_quad)
+      end
+
+      ##
+      # Returns the N-Triples representation of a triple.
+      #
+      # @param  [RDF::Resource] subject
+      # @param  [RDF::URI]      predicate
+      # @param  [RDF::Term]     object
+      # @param  [RDF::Term]     context
+      # @return [String]
+      def format_quad(subject, predicate, object, context)
+        s = "%s %s %s " % [subject, predicate, object].map { |value| format_term(value) }
+        s += format_term(context) + " " if context
+        s + "."
+      end
     end # Writer
   end # NQuads
+
+
+  ##
+  # Extensions for `RDF::Value`.
+  module Value
+    ##
+    # Returns the N-Triples representation of this value.
+    #
+    # This method is only available when the 'rdf/ntriples' serializer has
+    # been explicitly required.
+    #
+    # @return [String]
+    # @since  0.4.0
+    def to_quad
+      RDF::NQuads.serialize(self)
+    end
+  end # Value
 end # RDF

data/lib/rdf/ntriples/format.rb

@@ -2,19 +2,27 @@ module RDF::NTriples
   ##
   # N-Triples format specification.
   #
+  # Note: Latest standards activities treat N-Triples as a subset
+  # of Turtle. This includes text/ntriples+turtle mime type and a
+  # new default encoding of utf-8.
+  #
   # @example Obtaining an NTriples format class
   #   RDF::Format.for(:ntriples)     #=> RDF::NTriples::Format
   #   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   => "text/ntriples+turtle")
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
     content_type     'text/plain', :extension => :nt
-    content_encoding 'ascii'
+    content_type     'text/ntriples+turtle', :extension => :nt
+    content_encoding 'utf-8'
 
     reader { RDF::NTriples::Reader }
     writer { RDF::NTriples::Writer }
+    
+    # No format detection, as N-Triples can be parsed by N-Quads
   end
 end

data/lib/rdf/ntriples/writer.rb

@@ -122,6 +122,7 @@ module RDF::NTriples
       writer = self.new
       case value
         when nil then nil
+        when FalseClass then value.to_s
         when RDF::Statement
           writer.format_statement(value) + "\n"
         when RDF::Term

data/lib/rdf/query.rb

@@ -2,6 +2,15 @@ module RDF
   ##
   # An RDF basic graph pattern (BGP) query.
   #
+  # Named queries either match against a specifically named
+  # contexts if the name is an RDF::Term or bound RDF::Query::Variable.
+  # Names that are against unbound variables match either default
+  # or named contexts.
+  # The name of `false' will only match against the default context.
+  #
+  # Variable names cause the variable to be added to the solution set
+  # elements.
+  #
   # @example Constructing a basic graph pattern query (1)
   #   query = RDF::Query.new do
   #     pattern [:person, RDF.type,  FOAF.Person]
@@ -36,6 +45,27 @@ module RDF
   #     }
   #   })
   #
+  # @example In this example, the default graph contains the names of the publishers of two named graphs. The triples in the named graphs are not visible in the default graph in this example.
+  #   # default graph
+  #   @prefix dc: <http://purl.org/dc/elements/1.1/
+  #
+  #   <http://example.org/bob>    dc:publisher  "Bob" .
+  #   <http://example.org/alice>  dc:publisher  "Alice" .
+  #
+  #   # Named graph: http://example.org/bob
+  #   @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+  #
+  #   _:a foaf:name "Bob" .
+  #   _:a foaf:mbox <mailto:bob@oldcorp.example.org> .
+  #
+  #   # Named graph: http://example.org/alice
+  #   @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+  #
+  #   _:a foaf:name "Alice" .
+  #   _:a foaf:mbox <mailto:alice@work.example.org> .
+  #
+  #   
+  # @see http://www.w3.org/TR/rdf-sparql-query/#rdfDataset
   # @since 0.3.0
   class Query
     autoload :Pattern,   'rdf/query/pattern'
@@ -95,6 +125,13 @@ module RDF
     #   @param  [Hash{Symbol => Object}] options
     #     any additional keyword options
     #   @option options [RDF::Query::Solutions] :solutions (Solutions.new)
+    #   @option options [RDF::Term, RDF::Query::Variable, Boolean] :context (nil)
+    #     Default context for matching against queryable.
+    #     Named queries either match against a specifically named
+    #     contexts if the name is an RDF::Term or bound RDF::Query::Variable.
+    #     Names that are against unbound variables match either detault
+    #     or named contexts.
+    #     The name of `false' will only match against the default context.
     #   @yield  [query]
     #   @yieldparam  [RDF::Query] query
     #   @yieldreturn [void] ignored
@@ -105,24 +142,34 @@ module RDF
     #   @param  [Hash{Symbol => Object}] options
     #     any additional keyword options
     #   @option options [RDF::Query::Solutions] :solutions (Solutions.new)
+    #   @option options [RDF::Term, RDF::Query::Variable, Boolean] :context (nil)
+    #     Default context for matching against queryable.
+    #     Named queries either match against a specifically named
+    #     contexts if the name is an RDF::Term or bound RDF::Query::Variable.
+    #     Names that are against unbound variables match either detault
+    #     or named contexts.
     #   @yield  [query]
     #   @yieldparam  [RDF::Query] query
     #   @yieldreturn [void] ignored
-    def initialize(patterns = nil, options = {}, &block)
-      @options   = options.dup
+    def initialize(*patterns, &block)
+      @options  = patterns.last.is_a?(Hash) ? patterns.pop.dup : {}
+      patterns << @options if patterns.empty?
       @variables = {}
       @solutions = @options.delete(:solutions) || Solutions.new
+      context = @options.delete(:context)
 
-      @patterns  = case patterns
-        when Hash  then compile_hash_patterns(patterns.dup)
-        when Array then patterns
-        else []
+      @patterns  = case patterns.first
+        when Hash  then compile_hash_patterns(patterns.first.dup)
+        when Array then patterns.first
+        else patterns
       end
 
+      self.context = context
+
       if block_given?
         case block.arity
-          when 0 then instance_eval(&block)
-          else block.call(self)
+          when 1 then block.call(self)
+          else instance_eval(&block)
         end
       end
     end
@@ -183,10 +230,20 @@ module RDF
     ##
     # Executes this query on the given `queryable` graph or repository.
     #
+    # Named queries either match against a specifically named
+    # contexts if the name is an RDF::Term or bound RDF::Query::Variable.
+    # Names that are against unbound variables match either detault
+    # or named contexts.
+    # The name of `false' will only match against the default context.
+    #
     # @param  [RDF::Queryable] queryable
     #   the graph or repository to query
     # @param  [Hash{Symbol => Object}] options
     #   any additional keyword options
+    # @option options [Hash{Symbol => RDF::Term}] bindings
+    #   optional variable bindings to use
+    # @option options [Hash{Symbol => RDF::Term}] solutions
+    #   optional initial solutions for chained queries
     # @return [RDF::Query::Solutions]
     #   the resulting solution sequence
     # @see    http://www.holygoat.co.uk/blog/entry/2005-10-25-1
@@ -196,13 +253,24 @@ module RDF
       # just so we can call #keys below without worrying
       options[:bindings] ||= {}
 
-      @solutions = Solutions.new
-      # A quick empty solution simplifies the logic below; no special case for
+      # 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 << RDF::Query::Solution.new({})
+      @solutions = options[:solutions] || (Solutions.new << RDF::Query::Solution.new({}))
+
+      patterns = @patterns
+
+      # Add context to pattern, if necessary
+      unless self.context.nil?
+        if patterns.empty?
+          patterns = [Pattern.new(nil, nil, nil, :context => self.context)]
+        elsif patterns.first.context.nil?
+          patterns.first.context = self.context
+        end
+      end
+      
+      patterns.each do |pattern|
 
-      @patterns.each do |pattern|
-        
         old_solutions, @solutions = @solutions, Solutions.new
 
         options[:bindings].keys.each do |variable|
@@ -223,6 +291,8 @@ module RDF
           end
         end
 
+        #puts "solutions after #{pattern} are #{@solutions.to_a.inspect}"
+
         # It's important to abort failed queries quickly because later patterns
         # that can have constraints are often broad without them.
         # We have no solutions at all:
@@ -259,6 +329,44 @@ module RDF
       !@failed
     end
 
+    # Add patterns from another query to form a new Query
+    # @param [RDF::Query] other
+    # @return [RDF::Query]
+    def +(other)
+      Query.new(self.patterns + other.patterns)
+    end
+    
+    # Is this is a named query?
+    # @return [Boolean]
+    def named?
+      !!options[:context]
+    end
+    
+    # Is this is an unamed query?
+    # @return [Boolean]
+    def unnamed?
+      !named?
+    end
+    
+    # Add name to query
+    # @param [RDF::Value] value
+    # @return [RDF::Value]
+    def context=(value)
+      options[:context] = value
+    end
+    
+    # Name of this query, if any
+    # @return [RDF::Value]
+    def context
+      options[:context]
+    end
+
+    # Query has no patterns
+    # @return [Boolean]
+    def empty?
+      patterns.empty?
+    end
+
     ##
     # Enumerates over each matching query solution.
     #