rdf 1.0.10.2 → 1.1.0.p0

data/lib/rdf/nquads.rb

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 module RDF
   ##
   # **`RDF::NQuads`** provides support for the N-Quads serialization format.
@@ -18,7 +17,7 @@ module RDF
     #   RDF::Format.for(:content_type   => "application/n-quads")
     #   RDF::Format.for(:content_type   => "text/x-nquads")
     #
-    # @see http://www.w3.org/TR/n-quads/
+    # @see http://sw.deri.org/2008/07/n-quads/#mediatype
     # @since  0.4.0
     class Format < RDF::Format
       content_type     'application/n-quads', :extension => :nq, :alias => ['text/x-nquads']
@@ -39,14 +38,12 @@ module RDF
       def self.detect(sample)
         !!sample.match(%r(
           (?:\s*(?:<[^>]*>) | (?:_:\w+))                          # Subject
-          \s*
           (?:\s*<[^>]*>)                                          # Predicate
           \s*
           (?:(?:<[^>]*>) | (?:_:\w+) | (?:"[^"\n]*"(?:^^|@\S+)?)) # Object
-          \s*
-          (?:\s*(?:<[^>]*>) | (?:_:\w+))                          # Context
+          (?:\s*<[^>]*>)                                          # Context
           \s*\.
-        )x) && !(
+        )mx) && !(
           sample.match(%r(@(base|prefix|keywords)|\{)) ||         # Not Turtle/N3/TriG
           sample.match(%r(<(html|rdf))i)                          # Not HTML or XML
         )
@@ -81,7 +78,7 @@ module RDF
               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
+              context    = read_uriref || read_node || read_literal
               if validate? && !read_eos
                 raise RDF::ReaderError, "expected end of statement in line #{lineno}: #{current_line.inspect}"
               end

data/lib/rdf/ntriples.rb

@@ -32,12 +32,12 @@ module RDF
   # @example Requiring the `RDF::NTriples` module explicitly
   #   require 'rdf/ntriples'
   #
-  # @see http://www.w3.org/TR/n-triples/
+  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   # @see http://en.wikipedia.org/wiki/N-Triples
+  # @see http://librdf.org/ntriples/
   #
   # @author [Arto Bendiken](http://ar.to/)
   module NTriples
-    require 'iconv' unless "".respond_to?(:encode )# needed on Ruby 1.8.x
     require 'rdf/ntriples/format'
     autoload :Reader, 'rdf/ntriples/reader'
     autoload :Writer, 'rdf/ntriples/writer'

data/lib/rdf/ntriples/format.rb

@@ -15,7 +15,6 @@ module RDF::NTriples
   #   RDF::Format.for(:content_type   => "text/plain")
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
-  # @see http://www.w3.org/TR/n-triples/
   class Format < RDF::Format
     content_type     'application/n-triples', :extension => :nt, :alias => ['text/plain']
     content_encoding 'utf-8'
@@ -40,7 +39,7 @@ module RDF::NTriples
         \s*
         (?:(?:<[^>]*>) | (?:_:\w+) | (?:"[^"\n]*"(?:^^|@\S+)?)) # Object
         \s*\.
-      )x) && !(
+      )mx) && !(
         sample.match(%r(@(base|prefix|keywords)|\{)) ||         # Not Turtle/N3/TriG
         sample.match(%r(<(html|rdf))i)                          # Not HTML or XML
       ) && !RDF::NQuads::Format.detect(sample)

data/lib/rdf/ntriples/reader.rb

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 module RDF::NTriples
   ##
   # N-Triples parser.
@@ -26,7 +25,6 @@ module RDF::NTriples
   #   end
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
-  # @see http://www.w3.org/TR/n-triples/
   class Reader < RDF::Reader
     format RDF::NTriples::Format
 
@@ -44,60 +42,16 @@ module RDF::NTriples
     #
     # @see http://www.w3.org/TR/n-triples/
     # @see http://www.w3.org/TR/turtle/
-    if RUBY_VERSION >= '1.9'
-      ##
-      # Unicode regular expressions for Ruby 1.9+ with the Oniguruma engine.
-      U_CHARS1         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
-                           [\\u00C0-\\u00D6]|[\\u00D8-\\u00F6]|[\\u00F8-\\u02FF]|
-                           [\\u0370-\\u037D]|[\\u037F-\\u1FFF]|[\\u200C-\\u200D]|
-                           [\\u2070-\\u218F]|[\\u2C00-\\u2FEF]|[\\u3001-\\uD7FF]|
-                           [\\uF900-\\uFDCF]|[\\uFDF0-\\uFFFD]|[\\u{10000}-\\u{EFFFF}]
-                         EOS
-      U_CHARS2         = Regexp.compile("\\u00B7|[\\u0300-\\u036F]|[\\u203F-\\u2040]").freeze
-      IRI_RANGE        = Regexp.compile("[[^<>\"{}|^`\\\\]&&[^\\x00-\\x20]]").freeze
-    else
-      ##
-      # UTF-8 regular expressions for Ruby 1.8.x.
-      U_CHARS1         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
-                           \\xC3[\\x80-\\x96]|                                (?# [\\u00C0-\\u00D6]|)
-                           \\xC3[\\x98-\\xB6]|                                (?# [\\u00D8-\\u00F6]|)
-                           \\xC3[\\xB8-\\xBF]|[\\xC4-\\xCB][\\x80-\\xBF]|     (?# [\\u00F8-\\u02FF]|)
-                           \\xCD[\\xB0-\\xBD]|                                (?# [\\u0370-\\u037D]|)
-                           \\xCD\\xBF|[\\xCE-\\xDF][\\x80-\\xBF]|             (?# [\\u037F-\\u1FFF]|)
-                           \\xE0[\\xA0-\\xBF][\\x80-\\xBF]|                   (?# ...)
-                           \\xE1[\\x80-\\xBF][\\x80-\\xBF]|                   (?# ...)
-                           \\xE2\\x80[\\x8C-\\x8D]|                           (?# [\\u200C-\\u200D]|)
-                           \\xE2\\x81[\\xB0-\\xBF]|                           (?# [\\u2070-\\u218F]|)
-                           \\xE2[\\x82-\\x85][\\x80-\\xBF]|                   (?# ...)
-                           \\xE2\\x86[\\x80-\\x8F]|                           (?# ...)
-                           \\xE2[\\xB0-\\xBE][\\x80-\\xBF]|                   (?# [\\u2C00-\\u2FEF]|)
-                           \\xE2\\xBF[\\x80-\\xAF]|                           (?# ...)
-                           \\xE3\\x80[\\x81-\\xBF]|                           (?# [\\u3001-\\uD7FF]|)
-                           \\xE3[\\x81-\\xBF][\\x80-\\xBF]|                   (?# ...)
-                           [\\xE4-\\xEC][\\x80-\\xBF][\\x80-\\xBF]|           (?# ...)
-                           \\xED[\\x80-\\x9F][\\x80-\\xBF]|                   (?# ...)
-                           \\xEF[\\xA4-\\xB6][\\x80-\\xBF]|                   (?# [\\uF900-\\uFDCF]|)
-                           \\xEF\\xB7[\\x80-\\x8F]|                           (?# ...)
-                           \\xEF\\xB7[\\xB0-\\xBF]|                           (?# [\\uFDF0-\\uFFFD]|)
-                           \\xEF[\\xB8-\\xBE][\\x80-\\xBF]|                   (?# ...)
-                           \\xEF\\xBF[\\x80-\\xBD]|                           (?# ...)
-                           \\xF0[\\x90-\\xBF][\\x80-\\xBF][\\x80-\\xBF]|      (?# [\\u{10000}-\\u{EFFFF}])
-                           [\\xF1-\\xF2][\\x80-\\xBF][\\x80-\\xBF][\\x80-\\xBF]|
-                           \\xF3[\\x80-\\xAF][\\x80-\\xBF][\\x80-\\xBF]       (?# ...)
-                         EOS
-      U_CHARS2         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
-                           \\xC2\\xB7|                                        (?# \\u00B7|)
-                           \\xCC[\\x80-\\xBF]|\\xCD[\\x80-\\xAF]|             (?# [\\u0300-\\u036F]|)
-                           \\xE2\\x80\\xBF|\\xE2\\x81\\x80                    (?# [\\u203F-\\u2040])
-                         EOS
-      IRI_RANGE        = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
-                           \\x21|                                             (?# ")
-                           [\\x23-\\x3b]|\\x3d|                               (?# < & >)
-                           [\\x3f-\\x5b]|\\x5d|\\x5f|                         (?# \ ^ `)
-                           [\\x61-\\x7a]|                                     (?# { } |)
-                           [\\x7e-\\xff]
-                         EOS
-    end
+    ##
+    # Unicode regular expressions.
+    U_CHARS1         = Regexp.compile(<<-EOS.gsub(/\s+/, ''))
+                         [\\u00C0-\\u00D6]|[\\u00D8-\\u00F6]|[\\u00F8-\\u02FF]|
+                         [\\u0370-\\u037D]|[\\u037F-\\u1FFF]|[\\u200C-\\u200D]|
+                         [\\u2070-\\u218F]|[\\u2C00-\\u2FEF]|[\\u3001-\\uD7FF]|
+                         [\\uF900-\\uFDCF]|[\\uFDF0-\\uFFFD]|[\\u{10000}-\\u{EFFFF}]
+                       EOS
+    U_CHARS2         = Regexp.compile("\\u00B7|[\\u0300-\\u036F]|[\\u203F-\\u2040]").freeze
+    IRI_RANGE        = Regexp.compile("[[^<>\"{}|^`\\\\]&&[^\\x00-\\x20]]").freeze
 
     # 163s
     PN_CHARS_BASE        = /[A-Z]|[a-z]|#{U_CHARS1}/.freeze
@@ -203,8 +157,7 @@ module RDF::NTriples
     # @see    http://blog.grayproductions.net/articles/understanding_m17n
     # @see    http://yehudakatz.com/2010/05/17/encodings-unabridged/
     def self.unescape(string)
-      string = string.to_s
-      string = string.dup.force_encoding(Encoding::ASCII_8BIT) if string.respond_to?(:force_encoding)
+      string = string.to_s.force_encoding(Encoding::ASCII_8BIT)
 
       # Decode \t|\n|\r|\"|\\ character escapes:
       ESCAPE_CHARS.each { |escape| string.gsub!(escape.inspect[1...-1], escape) }
@@ -214,25 +167,21 @@ 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.respond_to?(:force_encoding) ?
-              # for Ruby 1.9+
-              s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8) :
-              # for Ruby 1.8.x
-              Iconv.conv('UTF-8', 'UTF-16BE', s)
+            s = s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
           else
             s = [$1.hex].pack('U*') << '\u' << $2
           end
-          s.respond_to?(:force_encoding) ? s.force_encoding(Encoding::ASCII_8BIT) : s
+          s.force_encoding(Encoding::ASCII_8BIT)
         end)
       end
 
       # Decode \uXXXX and \UXXXXXXXX code points:
       string.gsub!(ESCAPE_CHAR) do
         s = [($1 || $2).hex].pack('U*')
-        s.respond_to?(:force_encoding) ? s.force_encoding(Encoding::ASCII_8BIT) : s
+        s.force_encoding(Encoding::ASCII_8BIT)
       end
 
-      string.force_encoding(Encoding::UTF_8) if string.respond_to?(:force_encoding)
+      string.force_encoding(Encoding::UTF_8)
       string
     end
 
@@ -290,8 +239,6 @@ module RDF::NTriples
         uri.canonicalize! if canonicalize?
         uri
       end
-    rescue ArgumentError => e
-      raise RDF::ReaderError, "invalid URI"
     end
 
     ##

data/lib/rdf/ntriples/writer.rb

@@ -1,4 +1,3 @@
-# -*- encoding: utf-8 -*-
 module RDF::NTriples
   ##
   # N-Triples serializer.
@@ -36,7 +35,6 @@ module RDF::NTriples
   #   end
   #
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
-  # @see http://www.w3.org/TR/n-triples/
   class Writer < RDF::Writer
     format RDF::NTriples::Format
 
@@ -45,67 +43,53 @@ module RDF::NTriples
     ESCAPE_ASCII = /\A[\x00-\x7F]*\z/m.freeze
 
     ##
-    # Escape Literal and URI content. If encoding is ASCII, all unicode
-    # is escaped, otherwise only ASCII characters that must be escaped are
-    # escaped.
-    #
     # @param  [String] string
-    # @param  [Encoding] encoding Ruby 1.9 only
+    # @param  [Encoding] encoding
     # @return [String]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     def self.escape(string, encoding = nil)
       ret = case
         when string =~ ESCAPE_PLAIN # a shortcut for the simple case
           string
-        when string.respond_to?(:ascii_only?) && string.ascii_only?
+        when string.ascii_only?
           StringIO.open do |buffer|
-            buffer.set_encoding(Encoding::ASCII) if buffer.respond_to?(:set_encoding)
-            string.each_byte { |u| buffer << escape_ascii(u, encoding) }
+            string.each_byte { |u| buffer << escape_ascii(u) }
             buffer.string
           end
-        when string.respond_to?(:each_char) && encoding && encoding != Encoding::ASCII
+        when encoding && encoding != Encoding::ASCII
           # Not encoding UTF-8 characters
           StringIO.open do |buffer|
-            buffer.set_encoding(encoding) if buffer.respond_to?(:set_encoding)
             string.each_char do |u|
               buffer << case u.ord
               when (0x00..0x7F)
-                escape_ascii(u, encoding)
+                escape_ascii(u)
               else
                 u
               end
             end
             buffer.string
           end
-        when string.respond_to?(:each_codepoint)
-          # Encode ASCII && UTF-8 characters
+        else
           StringIO.open do |buffer|
-            buffer.set_encoding(Encoding::ASCII) if buffer.respond_to?(:set_encoding)
             string.each_codepoint { |u| buffer << escape_unicode(u, encoding) }
             buffer.string
           end
-        else # works in Ruby 1.8.x, too
-          # Encode ASCII && UTF-8 characters
-          StringIO.open do |buffer|
-            buffer.set_encoding(Encoding::ASCII) if buffer.respond_to?(:set_encoding)
-            string.scan(/./mu) { |c| buffer << escape_unicode(u = c.unpack('U*').first, encoding) }
-            buffer.string
-          end
       end
-      ret.respond_to?(:encode) && encoding && ret.encoding != encoding ? ret.encode(encoding) : ret
+      encoding ? ret.dup.force_encoding(encoding) : ret
     end
 
     ##
     # Escape ascii and unicode characters.
+    # If encoding is UTF_8, only ascii characters are escaped.
     #
     # @param  [Integer, #ord] u
-    # @param  [Encoding] encoding Ruby 1.9 only
+    # @param  [Encoding] encoding
     # @return [String]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     def self.escape_unicode(u, encoding)
       case (u = u.ord)
         when (0x00..0x7F)        # ASCII 7-bit
-          escape_ascii(u, encoding)
+          escape_ascii(u)
         when (0x80..0xFFFF)      # Unicode BMP
           escape_utf16(u)
         when (0x10000..0x10FFFF) # Unicode
@@ -116,22 +100,15 @@ module RDF::NTriples
     end
 
     ##
-    # Standard ASCII escape sequences. If encoding is ASCII, use Test-Cases
-    # sequences, otherwise, assume the test-cases escape sequences. Otherwise,
-    # the N-Triples recommendation includes `\b` and `\f` escape sequences.
-    #
     # @param  [Integer, #ord] u
     # @return [String]
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
-    # @see    http://www.w3.org/TR/n-triples/
-    def self.escape_ascii(u, encoding)
+    def self.escape_ascii(u)
       case (u = u.ord)
-        when (0x00..0x07) then escape_utf16(u)
-        when (0x08)       then (encoding.nil? || encoding == Encoding::ASCII ? escape_utf16(u) : "\\b")
+        when (0x00..0x08) then escape_utf16(u)
         when (0x09)       then "\\t"
         when (0x0A)       then "\\n"
-        when (0x0B)       then escape_utf16(u)
-        when (0x0C)       then (encoding.nil? || encoding == Encoding::ASCII ? escape_utf16(u) : "\\f")
+        when (0x0B..0x0C) then escape_utf16(u)
         when (0x0D)       then "\\r"
         when (0x0E..0x1F) then escape_utf16(u)
         when (0x22)       then "\\\""
@@ -180,23 +157,6 @@ module RDF::NTriples
       end
     end
 
-    ##
-    # Initializes the writer.
-    #
-    # @param  [IO, File] output
-    #   the output stream
-    # @param  [Hash{Symbol => Object}] options
-    #   any additional options. See {RDF::Writer#initialize}
-    # @option options [Boolean]  :validate (true)
-    #   whether to validate terms when serializing
-    # @yield  [writer] `self`
-    # @yieldparam  [RDF::Writer] writer
-    # @yieldreturn [void]
-    def initialize(output = $stdout, options = {}, &block)
-      options = {:validate => true}.merge(options)
-      super
-    end
-
     ##
     # Outputs an N-Triples comment line.
     #

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 = {}, options = {}, &block)
+    def self.execute(queryable, patterns = nil, options = {}, &block)
       self.new(patterns, options, &block).execute(queryable, options)
     end
 
@@ -243,9 +243,6 @@ 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
@@ -262,7 +259,6 @@ 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
@@ -275,9 +271,6 @@ 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/query/pattern.rb

@@ -67,6 +67,29 @@ module RDF; class Query
       subject.nil? && predicate.nil? && object.nil? && context.nil?
     end
 
+    ##
+    # Returns `true` if this is a constant pattern, with all terms being
+    # either URIs, blank nodes, or literals.
+    #
+    # A constant pattern is structurally and functionally equivalent to an
+    # RDF statement.
+    #
+    # @return [Boolean] `true` or `false`
+    # @since  0.3.0
+    def constant?
+      !(variable?)
+    end
+
+    ##
+    # Returns `true` if this is a variable pattern, with any term being
+    # `nil` or a variable.
+    #
+    # @return [Boolean] `true` or `false`
+    # @since  0.3.0
+    def variable?
+      subject.nil? || predicate.nil? || object.nil? || context.nil? || has_variables?
+    end
+
     ##
     # Returns `true` if this pattern contains any variables.
     #
@@ -104,7 +127,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('etc/doap.nt'))
+    #   Pattern.new(:s, :p, :o).execute(RDF::Repository.load('data.nt'))
     #
     # @param  [RDF::Queryable] queryable
     #   the graph or repository to query
@@ -156,12 +179,7 @@ module RDF; class Query
     # pattern with the corresponding terms in the given `statement`.
     #
     # @example
-    #   pattern = Pattern.new(:s, :p, :o)
-    #   solution = pattern.solution(statement)
-    #
-    #   pattern[:s] #=> statement.subject
-    #   pattern[:p] #=> statement.predicate
-    #   pattern[:o] #=> statement.object
+    #   pattern.solution(statement)
     #
     # @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 should should_not pretty_print).include?(m) || m[0,2] == '__'}.
+                  reject {|m| %w(object_id dup instance_eval inspect to_s class).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.is_a?(RDF::Term) ? value : RDF::Literal(value)
+      @bindings[name.to_sym] = value
     end
 
     ##
@@ -182,33 +182,17 @@ class RDF::Query
 
     ##
     # Compatible Mappings
-    #
     # Two solution mappings u1 and u2 are compatible if, for every variable v in dom(u1) and in dom(u2), u1(v) = u2(v).
     #
     # @param [RDF::Query::Solution, #to_hash] other
     #   another query solution or hash bindings
     # @return [Boolean]
-    # @see http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#defn_algCompatibleMapping
     def compatible?(other)
       @bindings.all? do |k, v|
         !other.to_hash.has_key?(k) || other[k].eql?(v)
       end
     end
-
-    ##
-    # Disjoint mapping
-    #
-    # A solution is disjoint with another solution if it shares no common variables in their domains.
-    #
-    # @param [RDF::Query::Solution] other
-    # @return [Boolean]
-    # @see http://www.w3.org/TR/2013/REC-sparql11-query-20130321/#defn_algMinus
-    def disjoint?(other)
-      @bindings.none? do |k, v|
-        v && other.to_hash.has_key?(k) && other[k].eql?(v)
-      end
-    end
-
+    
     ##
     # Isomorphic Mappings
     # Two solution mappings u1 and u2 are isomorphic if,