rdf 1.99.1 → 2.0.0.beta1

data/lib/rdf/model/value.rb

@@ -154,7 +154,7 @@ module RDF
     # @raise  [ArgumentError] if the value is invalid
     # @since  0.3.9
     def validate!
-      raise ArgumentError if invalid?
+      raise ArgumentError, "#{self.inspect} is not valid" if invalid?
       self
     end
     alias_method :validate, :validate!

data/lib/rdf/nquads.rb

@@ -43,7 +43,7 @@ module RDF
           \s*
           (?:(?:<[^>]*>) | (?:_:\w+) | (?:"[^"\n]*"(?:^^|@\S+)?)) # Object
           \s*
-          (?:\s*(?:<[^>]*>) | (?:_:\w+))                          # Context
+          (?:\s*(?:<[^>]*>) | (?:_:\w+))                          # Graph Name
           \s*\.
         )x) && !(
           sample.match(%r(@(base|prefix|keywords)|\{)) ||         # Not Turtle/N3/TriG
@@ -74,7 +74,7 @@ module RDF
               object    = read_uriref || read_node || read_literal || fail_object
               graph_name    = read_uriref || read_node
               if validate? && !read_eos
-                raise RDF::ReaderError.new("ERROR [line #{lineno}] Expected end of statement (found: #{current_line.inspect})")
+                log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
               end
               return [subject, predicate, object, {graph_name: graph_name}]
             end
@@ -88,15 +88,6 @@ module RDF
     end # Reader
 
     class Writer < NTriples::Writer
-      ##
-      # @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.
       #

data/lib/rdf/ntriples.rb

@@ -62,7 +62,7 @@ module RDF
     # @see    RDF::NTriples::Writer.serialize
     # @since  0.1.5
     def self.serialize(value)
-      Writer.serialize(value)
+      Writer.for(:ntriples).serialize(value)
     end
 
     ##

data/lib/rdf/ntriples/reader.rb

@@ -28,16 +28,14 @@ module RDF::NTriples
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   # @see http://www.w3.org/TR/n-triples/
   class Reader < RDF::Reader
+    include RDF::Util::Logger
     format RDF::NTriples::Format
 
     # @see http://www.w3.org/TR/rdf-testcases/#ntrip_strings
-    ESCAPE_CHARS          = ["\b", "\f", "\t", "\n", "\r", "\"", "\\"].freeze
-    ESCAPE_CHAR4          = /\\u([0-9A-Fa-f]{4,4})/.freeze
-    ESCAPE_CHAR8          = /\\U([0-9A-Fa-f]{8,8})/.freeze
-    ESCAPE_CHAR           = Regexp.union(ESCAPE_CHAR4, ESCAPE_CHAR8).freeze
-    ESCAPE_SURROGATE      = /\\u([0-9A-Fa-f]{4,4})\\u([0-9A-Fa-f]{4,4})/.freeze
-    ESCAPE_SURROGATE1     = (0xD800..0xDBFF).freeze
-    ESCAPE_SURROGATE2     = (0xDC00..0xDFFF).freeze
+    ESCAPE_CHARS    = ["\b", "\f", "\t", "\n", "\r", "\"", "\\"].freeze
+    UCHAR4          = /\\u([0-9A-Fa-f]{4,4})/.freeze
+    UCHAR8          = /\\U([0-9A-Fa-f]{8,8})/.freeze
+    UCHAR           = Regexp.union(UCHAR4, UCHAR8).freeze
 
 
     # Terminals from rdf-turtle.
@@ -53,7 +51,7 @@ module RDF::NTriples
                          [\\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
+    IRI_RANGE        = Regexp.compile("[[^<>\"{}\|\^`\\\\]&&[^\\x00-\\x20]]").freeze
 
     # 163s
     PN_CHARS_BASE        = /[A-Z]|[a-z]|#{U_CHARS1}/.freeze
@@ -64,13 +62,13 @@ module RDF::NTriples
     # 159s
     ECHAR                = /\\[tbnrf\\"]/.freeze
     # 18
-    IRIREF               = /<((?:#{IRI_RANGE}|#{ESCAPE_CHAR})*)>/.freeze
+    IRIREF               = /<((?:#{IRI_RANGE}|#{UCHAR})*)>/.freeze
     # 141s
     BLANK_NODE_LABEL     = /_:((?:[0-9]|#{PN_CHARS_U})(?:(?:#{PN_CHARS}|\.)*#{PN_CHARS})?)/.freeze
     # 144s
     LANGTAG              = /@([a-zA-Z]+(?:-[a-zA-Z0-9]+)*)/.freeze
     # 22
-    STRING_LITERAL_QUOTE = /"((?:[^\"\\\n\r]|#{ECHAR}|#{ESCAPE_CHAR})*)"/.freeze
+    STRING_LITERAL_QUOTE = /"((?:[^\"\\\n\r]|#{ECHAR}|#{UCHAR})*)"/.freeze
 
     # @see http://www.w3.org/TR/rdf-testcases/#ntrip_grammar
     COMMENT               = /^#\s*(.*)$/.freeze
@@ -91,57 +89,59 @@ module RDF::NTriples
     # representation.
     #
     # @param  [String] input
+    # @param [{Symbol => Object}] options
+    #   From {RDF::Reader#initialize}
     # @return [RDF::Term]
-    def self.unserialize(input)
+    def self.unserialize(input, options = {})
       case input
         when nil then nil
-        else self.new(input).read_value
+        else self.new(input, {logger: []}.merge(options)).read_value
       end
     end
 
     ##
-    # @param  [String] input
+    # (see unserialize)
     # @return [RDF::Resource]
-    def self.parse_subject(input)
-      parse_uri(input) || parse_node(input)
+    def self.parse_subject(input, options = {})
+      parse_uri(input, options) || parse_node(input, options)
     end
 
     ##
-    # @param  [String] input
+    # (see unserialize)
     # @return [RDF::URI]
-    def self.parse_predicate(input)
+    def self.parse_predicate(input, options = {})
       parse_uri(input, intern: true)
     end
 
     ##
-    # @param  [String] input
-    # @return [RDF::Term]
-    def self.parse_object(input)
-      parse_uri(input) || parse_node(input) || parse_literal(input)
+    # (see unserialize)
+    def self.parse_object(input, options = {})
+      parse_uri(input, options) || parse_node(input, options) || parse_literal(input, options)
     end
 
     ##
-    # @param  [String] input
+    # (see unserialize)
     # @return [RDF::Node]
-    def self.parse_node(input)
+    def self.parse_node(input, options = {})
       if input =~ NODEID
         RDF::Node.new($1)
       end
     end
 
     ##
-    # @param  [String] input
+    # (see unserialize)
     # @return [RDF::URI]
     def self.parse_uri(input, options = {})
       if input =~ URIREF
-        RDF::URI.send(options[:intern] ? :intern : :new, $1)
+        uri_str = unescape($1)
+        RDF::URI.send(options[:intern] ? :intern : :new, unescape($1))
       end
     end
 
     ##
-    # @param  [String] input
+    # (see unserialize)
     # @return [RDF::Literal]
-    def self.parse_literal(input)
+    def self.parse_literal(input, options = {})
       case input
         when LITERAL_WITH_LANGUAGE
           RDF::Literal.new(unescape($1), language: $4)
@@ -164,22 +164,8 @@ module RDF::NTriples
       # Decode \t|\n|\r|\"|\\ character escapes:
       ESCAPE_CHARS.each { |escape| string.gsub!(escape.inspect[1...-1], escape) }
 
-      # Decode \uXXXX\uXXXX surrogate pairs:
-      # XXX: This block should be removed in RDF.rb 2.0
-      while
-        (string.sub!(ESCAPE_SURROGATE) do
-          if ESCAPE_SURROGATE1.include?($1.hex) && ESCAPE_SURROGATE2.include?($2.hex)
-            warn "[DEPRECATION] Surrogate pairs support deprecated. Support will be removed in RDF.rb 2.0. Called from #{Gem.location_of_caller.join(':')}"
-            s = [$1, $2].pack('H*H*')
-            s.force_encoding(Encoding::UTF_16BE).encode!(Encoding::UTF_8)
-          else
-            [$1.hex].pack('U*') << '\u' << $2
-          end
-        end)
-      end
-
       # Decode \uXXXX and \UXXXXXXXX code points:
-      string.gsub!(ESCAPE_CHAR) do
+      string.gsub!(UCHAR) do
         [($1 || $2).hex].pack('U*')
       end
 
@@ -192,7 +178,9 @@ module RDF::NTriples
       begin
         read_statement
       rescue RDF::ReaderError
-        read_uriref || read_node || read_literal
+        value = read_uriref || read_node || read_literal
+        log_recover
+        value
       end
     end
 
@@ -211,8 +199,7 @@ module RDF::NTriples
             object    = read_uriref || read_node || read_literal || fail_object
 
             if validate? && !read_eos
-              raise RDF::ReaderError.new("ERROR [line #{lineno}] Expected end of statement (found: #{current_line.inspect})",
-                                         lineno: lineno)
+              log_error("Expected end of statement (found: #{current_line.inspect})", lineno: lineno, exception: RDF::ReaderError)
             end
             return [subject, predicate, object]
           end
@@ -242,7 +229,7 @@ module RDF::NTriples
         uri
       end
     rescue ArgumentError => e
-      raise RDF::ReaderError.new("ERROR [line #{lineno}] Invalid URI (found: \"<#{uri_str}>\")", lineno: lineno, token: "<#{uri_str}>")
+      log_error("Invalid URI (found: \"<#{uri_str}>\")", lineno: lineno, token: "<#{uri_str}>", exception: RDF::ReaderError)
     end
 
     ##

data/lib/rdf/ntriples/writer.rb

@@ -38,11 +38,12 @@ module RDF::NTriples
   # @see http://www.w3.org/TR/rdf-testcases/#ntriples
   # @see http://www.w3.org/TR/n-triples/
   class Writer < RDF::Writer
+    include RDF::Util::Logger
     format RDF::NTriples::Format
 
     # @see http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     ESCAPE_PLAIN = /\A[\x20-\x21\x23-#{Regexp.escape '['}#{Regexp.escape ']'}-\x7E]*\z/m.freeze
-    ESCAPE_ASCII = /\A[\x00-\x7F]*\z/m.freeze
+    ESCAPE_PLAIN_U = /\A(?:#{Reader::IRI_RANGE}|#{Reader::UCHAR})*\z/.freeze
 
     ##
     # Escape Literal and URI content. If encoding is ASCII, all unicode
@@ -63,7 +64,7 @@ module RDF::NTriples
             string.each_byte { |u| buffer << escape_ascii(u, encoding) }
             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)
@@ -95,6 +96,7 @@ module RDF::NTriples
     # @param  [Integer, #ord] u
     # @param  [Encoding] encoding
     # @return [String]
+    # @raise  [ArgumentError] if `u` is not a valid Unicode codepoint
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     def self.escape_unicode(u, encoding)
       case (u = u.ord)
@@ -116,6 +118,7 @@ module RDF::NTriples
     #
     # @param  [Integer, #ord] u
     # @return [String]
+    # @raise  [ArgumentError] if `u` is not a valid Unicode codepoint
     # @see    http://www.w3.org/TR/rdf-testcases/#ntrip_strings
     # @see    http://www.w3.org/TR/n-triples/
     def self.escape_ascii(u, encoding)
@@ -242,17 +245,51 @@ module RDF::NTriples
     #   Serialize node using unique identifier, rather than any used to create the node.
     # @return [String]
     def format_node(node, options = {})
-      options[:unique_bnodes] ? node.to_unique_base : node.to_base
+      options[:unique_bnodes] ? node.to_unique_base : node.to_s
     end
 
     ##
-    # Returns the N-Triples representation of a URI reference.
+    # Returns the N-Triples representation of a URI reference using write encoding.
     #
     # @param  [RDF::URI] uri
     # @param  [Hash{Symbol => Object}] options = ({})
     # @return [String]
     def format_uri(uri, options = {})
-      uri.to_base
+      string = uri.to_s
+      iriref = case
+        when string =~ ESCAPE_PLAIN_U # a shortcut for the simple case
+          string
+        when string.ascii_only? || (encoding && encoding != Encoding::ASCII)
+          StringIO.open do |buffer|
+            buffer.set_encoding(encoding)
+            string.each_char do |u|
+              buffer << case u.ord
+                when (0x00..0x20) then self.class.escape_utf16(u)
+                when 0x22, 0x3c, 0x3e, 0x5c, 0x5e, 0x60, 0x7b, 0x7c, 0x7d # <>"{}|`\
+                  self.class.escape_utf16(u)
+                else u
+              end
+            end
+            buffer.string
+          end
+        else
+          # Encode ASCII && UTF-8/16 characters
+          StringIO.open do |buffer|
+            buffer.set_encoding(Encoding::ASCII)
+            string.each_byte do |u|
+              buffer << case u
+                when (0x00..0x20) then self.class.escape_utf16(u)
+                when 0x22, 0x3c, 0x3e, 0x5c, 0x5e, 0x60, 0x7b, 0x7c, 0x7d # <>"{}|`\
+                  self.class.escape_utf16(u)
+                when (0x80..0xFFFF)                then self.class.escape_utf16(u)
+                when (0x10000..0x10FFFF)           then self.class.escape_utf32(u)
+                else u
+              end
+            end
+            buffer.string
+          end
+      end
+      encoding ? "<#{iriref}>".encode(encoding) : "<#{iriref}>"
     end
 
     ##

data/lib/rdf/query.rb

@@ -109,8 +109,10 @@ module RDF
     #   @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
+       if args.length == 1
+        return args[0] if args[0].is_a?(Solutions)
+        args = args[0] if args[0].is_a?(Array)
+      end
       return Solutions.new(args)
     end
 
@@ -154,8 +156,6 @@ module RDF
     #     Names that are against unbound variables match either default
     #     or named graphs.
     #     The name of `false` will only match against the default graph.
-    #   @option options [RDF::Resource, RDF::Query::Variable, false] :context (nil)
-    #     Alias for `:graph_name`. The :context option is deprecated in RDF.rb 2.0.
     #   @option options [RDF::Resource, RDF::Query::Variable, false] :name (nil)
     #     Alias for `:graph_name`.
     #   @yield  [query]
@@ -175,8 +175,6 @@ module RDF
     #     Names that are against unbound variables match either default
     #     or named graphs.
     #     The name of `false` will only match against the default graph.
-    #   @option options [RDF::Resource, RDF::Query::Variable, false] :context (nil)
-    #     Alias for `:graph_name`. The :context option is deprecated in RDF.rb 2.0.
     #   @option options [RDF::Resource, RDF::Query::Variable, false] :name (nil)
     #     Alias for `:graph_name`.
     #   @yield  [query]
@@ -184,10 +182,6 @@ module RDF
     #   @yieldreturn [void] ignored
     def initialize(*patterns, &block)
       @options  = patterns.last.is_a?(Hash) ? patterns.pop.dup : {}
-      if @options.has_key?(:context)
-        warn "[DEPRECATION] the :contexts option to Query#initialize is deprecated in RDF.rb 2.0, use :graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
-        @options[:graph_name] ||= options.delete(:context)
-      end
       patterns << @options if patterns.empty?
       @variables = {}
       @solutions = Query::Solutions(@options.delete(:solutions))
@@ -276,14 +270,14 @@ module RDF
     # If the query nas no patterns, it returns a single empty solution as
     # per SPARQL 1.1 _Empty Group Pattern_.
     #
+    # @note solutions could be an Iterator, but this algorithm cycles over solutions, which requires them to be an array internally.
+    #
     # @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 [RDF::Resource, RDF::Query::Variable, false] context (nil)
-    #   Alias for `:graph_name`. The :context option is deprecated in RDF.rb 2.0.
     # @option options [RDF::Resource, RDF::Query::Variable, false] graph_name (nil)
     #   Specific graph name for matching against queryable;
     #   overrides default graph defined on query.
@@ -302,10 +296,6 @@ module RDF
     def execute(queryable, options = {}, &block)
       validate!
       options = options.dup
-      if options.has_key?(:context)
-        warn "[DEPRECATION] the :contexts option to Query#execute is deprecated in RDF.rb 2.0, use :graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
-        options[:graph_name] ||= options.delete(:context)
-      end
 
       # just so we can call #keys below without worrying
       options[:bindings] ||= {}
@@ -433,15 +423,6 @@ module RDF
       options[:graph_name].nil?
     end
 
-    # Scope the query to named graphs matching value
-    # @param [RDF::IRI, RDF::Query::Variable] value
-    # @return [RDF::IRI, RDF::Query::Variable]
-    # @deprecated Use {#graph_name=} instead.
-    def context=(value)
-      warn "[DEPRECATION] Query#context= is deprecated in RDF.rb 2.0, use Query#graph_name= instead. Called from #{Gem.location_of_caller.join(':')}"
-      self.graph_name = value
-    end
-
     # Scope the query to named graphs matching value
     # @param [RDF::IRI, RDF::Query::Variable] value
     # @return [RDF::IRI, RDF::Query::Variable]
@@ -449,27 +430,12 @@ module RDF
       options[:graph_name] = value
     end
 
-    # Scope of this query, if any
-    # @return [RDF::IRI, RDF::Query::Variable]
-    # @deprecated Use {#graph_name} instead.
-    def context
-      warn "[DEPRECATION] Query#context is deprecated in RDF.rb 2.0, use Query#graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
-      graph_name
-    end
-
     # Scope of this query, if any
     # @return [RDF::IRI, RDF::Query::Variable]
     def graph_name
       options[:graph_name]
     end
 
-    # Apply the context specified (or configured) to all patterns that have no context
-    # @param [RDF::IRI, RDF::Query::Variable] context (self.context)
-    def apply_context(context = options[:context])
-      warn "[DEPRECATION] Query#apply_context is deprecated in RDF.rb 2.0, use Query#apply_graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
-      apply_graph_name(context)
-    end
-
     # Apply the graph name specified (or configured) to all patterns that have no graph name
     # @param [RDF::IRI, RDF::Query::Variable] graph_name (self.graph_name)
     def apply_graph_name(graph_name = options[:graph_name])

data/lib/rdf/query/pattern.rb

@@ -6,10 +6,6 @@ module RDF; class Query
     # @private
     # @since 0.2.2
     def self.from(pattern, options = {})
-      if options.has_key?(:context)
-        warn "[DEPRECATION] the :contexts option to Pattern.from is deprecated in RDF.rb 2.0, use :graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
-        options[:graph_name] ||= options.delete(:context)
-      end
       case pattern
         when Pattern then pattern
         when Array, Statement
@@ -25,9 +21,6 @@ module RDF; class Query
     #   @option options [Variable, Resource, Symbol, nil] :subject   (nil)
     #   @option options [Variable, URI, Symbol, nil]      :predicate (nil)
     #   @option options [Variable, Term, Symbol, nil]     :object    (nil)
-    #   @option options [Variable, Resource, Symbol, nil, false] :context   (nil)
-    #     A context of nil matches any context, a context of false, matches only the default context.
-    #     The :context option is deprecated in RDF.rb 2.0. Use :graph_name instead.
     #   @option options [Variable, Resource, Symbol, nil, false] :graph_name   (nil)
     #     A graph_name of nil matches any graph, a graph_name of false, matches only the default graph.
     #   @option options [Boolean]            :optional  (false)
@@ -37,19 +30,12 @@ module RDF; class Query
     #   @param  [Variable, URI, Symbol, nil]              predicate
     #   @param  [Variable, Termm, Symbol, nil]            object
     #   @param  [Hash{Symbol => Object}]          options
-    #   @option options [Variable, Resource, Symbol, nil, false] :context   (nil)
-    #     A context of nil matches any context, a context of false, matches only the default context.
-    #     The :context option is deprecated in RDF.rb 2.0. Use :graph_name instead.
     #   @option options [Variable, Resource, Symbol, nil, false] :graph_name   (nil)
     #     A graph_name of nil matches any graph, a graph_name of false, matches only the default graph.
     #   @option options [Boolean]                 :optional  (false)
     #
     # @note {Statement} treats symbols as interned {Node} instances, in a {Pattern}, they are treated as {Variable}.
     def initialize(subject = nil, predicate = nil, object = nil, options = {})
-      if options.has_key?(:context)
-        warn "[DEPRECATION] the :contexts option to Pattern#initialize is deprecated in RDF.rb 2.0, use :graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
-        options[:graph_name] ||= options.delete(:context)
-      end
       super
     end
 
@@ -170,12 +156,13 @@ module RDF; class Query
           terms = variable_terms(name)
           break terms if terms.size > 1
         end
-        queryable.query(query) do |statement|
+        queryable.query(query).select do |statement|
           # Only yield those matching statements where the variable
           # constraint is also satisfied:
           # FIXME: `Array#uniq` uses `#eql?` and `#hash`, not `#==`
-          if matches = terms.map { |term| statement.send(term) }.uniq.size.equal?(1)
-            block.call(statement)
+          if terms.map { |term| statement.send(term) }.uniq.size.equal?(1)
+            yield statement if block_given?
+            true
           end
         end
       end