rdf 1.1.17.1 → 1.99.0

data/lib/rdf/repository.rb

@@ -96,13 +96,19 @@ module RDF
     # @param  [Hash{Symbol => Object}] options
     # @option options [URI, #to_s]    :uri (nil)
     # @option options [String, #to_s] :title (nil)
-    # @option options [Boolean] :with_context (true)
+    # @option options [Boolean] :with_graph_name (true)
     #   Indicates that the repository supports named graphs, otherwise,
     #   only the default graph is supported.
+    # @option options [Boolean] :with_context (true)
+    #   Alias for :with_graph_name. :with_context is deprecated in RDF.rb 2.0.
     # @yield  [repository]
     # @yieldparam [Repository] repository
     def initialize(options = {}, &block)
-      @options = {:with_context => true}.merge(options)
+      if options[:with_context]
+        warn "[DEPRECATION] the :contexts option to Repository#initialize is deprecated in RDF.rb 2.0, use :graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
+        options[:graph_name] ||= options.delete(:with_context)
+      end
+      @options = {with_graph_name: true}.merge(options)
       @uri     = @options.delete(:uri)
       @title   = @options.delete(:title)
 
@@ -140,20 +146,20 @@ module RDF
     #
     # @example
     #   repository.transaction do |tx|
-    #     tx.insert [RDF::URI("http://rubygems.org/gems/rdf"), RDF::DC.title, "RDF.rb"]
+    #     tx.insert [RDF::URI("http://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
     #   end
     #
-    # @param  [RDF::Resource] context
+    # @param  [RDF::Resource] graph_name
     #   Context on which to run the transaction, use `false` for the default
-    #   context and `nil` the entire Repository
+    #   graph_name and `nil` the entire Repository
     # @yield  [tx]
     # @yieldparam  [RDF::Transaction] tx
     # @yieldreturn [void] ignored
-    # @return [void] `self`
+    # @return [self]
     # @see    RDF::Transaction
     # @since  0.3.0
-    def transaction(context = nil, &block)
-      tx = begin_transaction(context)
+    def transaction(graph_name = nil, &block)
+      tx = begin_transaction(graph_name)
       begin
         case block.arity
           when 1 then block.call(tx)
@@ -177,11 +183,11 @@ module RDF
     # to override this method in order to begin a transaction against the
     # underlying storage.
     #
-    # @param  [RDF::Resource] context
+    # @param  [RDF::Resource] graph_name
     # @return [RDF::Transaction]
     # @since  0.3.0
-    def begin_transaction(context)
-      RDF::Transaction.new(:graph => context)
+    def begin_transaction(graph_name)
+      RDF::Transaction.new(graph: graph_name)
     end
 
     ##
@@ -215,7 +221,7 @@ module RDF
     ##
     # @see RDF::Repository
     module Implementation
-      DEFAULT_CONTEXT = false
+      DEFAULT_GRAPH = false
 
       ##
       # @private
@@ -229,8 +235,11 @@ module RDF
       # @see RDF::Enumerable#supports?
       def supports?(feature)
         case feature.to_sym
-          # statement contexts / named graphs
-          when :context   then @options[:with_context]
+          #statement named graphs
+          when :context
+            warn "[DEPRECATION] the :context feature is deprecated in RDF.rb 2.0; use :graph_name instead. Called from #{Gem.location_of_caller.join(':')}"
+            @options[:with_context] || @options[:with_graph_name]
+          when :graph_name   then @options[:with_graph_name]
           when :inference then false  # forward-chaining inference
           when :validity  then @options.fetch(:with_validity, true)
           else false
@@ -249,7 +258,7 @@ module RDF
       # @see RDF::Countable#count
       def count
         count = 0
-        @data.each do |c, ss|
+        @data.each do |g, ss|
           ss.each do |s, ps|
             ps.each do |p, os|
               count += os.size
@@ -263,12 +272,12 @@ module RDF
       # @private
       # @see RDF::Enumerable#has_statement?
       def has_statement?(statement)
-        s, p, o, c = statement.to_quad
-        c ||= DEFAULT_CONTEXT
-        @data.has_key?(c) &&
-          @data[c].has_key?(s) &&
-          @data[c][s].has_key?(p) &&
-          @data[c][s][p].include?(o)
+        s, p, o, g = statement.to_quad
+        g ||= DEFAULT_GRAPH
+        @data.has_key?(g) &&
+          @data[g].has_key?(s) &&
+          @data[g][s].has_key?(p) &&
+          @data[g][s][p].include?(o)
       end
 
       ##
@@ -280,12 +289,12 @@ module RDF
           # possible concurrent mutations to `@data`, we use `#dup` to make
           # shallow copies of the nested hashes before beginning the
           # iteration over their keys and values.
-          @data.dup.each do |c, ss|
+          @data.dup.each do |g, ss|
             ss.dup.each do |s, ps|
               ps.dup.each do |p, os|
                 os.dup.each do |o|
                   # FIXME: yield has better performance, but broken in MRI 2.2: See https://bugs.ruby-lang.org/issues/11451.
-                  block.call(RDF::Statement.new(s, p, o, :context => c.equal?(DEFAULT_CONTEXT) ? nil : c))
+                  block.call(RDF::Statement.new(s, p, o, graph_name: g.equal?(DEFAULT_GRAPH) ? nil : g))
                 end
               end
             end
@@ -298,48 +307,87 @@ module RDF
       ##
       # @private
       # @see RDF::Enumerable#has_context?
+      # @deprecated Use {#has_graph?} instead.
       def has_context?(value)
+       warn "[DEPRECATION] Repository#has_context? is deprecated in RDF.rb 2.0, use Repository#has_graph? instead. Called from #{Gem.location_of_caller.join(':')}"
+       has_graph?(value)
+      end
+
+      ##
+      # @private
+      # @see RDF::Enumerable#has_graph?
+      def has_graph?(value)
         @data.keys.include?(value)
       end
+      ##
+      # @private
+      # @see RDF::Enumerable#each_graph
+      def graph_names(options = nil, &block)
+        @data.keys.reject {|g| g == DEFAULT_GRAPH}
+      end
 
       ##
       # @private
       # @see RDF::Enumerable#each_context
+      # @deprecated Use {#each_graph} instead.
       def each_context(&block)
+        warn "[DEPRECATION] Repository#each_context is deprecated in RDF.rb 2.0, use Repository#each_graph instead. Called from #{Gem.location_of_caller.join(':')}"
         if block_given?
           contexts = @data.keys
-          contexts.delete(DEFAULT_CONTEXT)
+          contexts.delete(DEFAULT_GRAPH)
           contexts.each(&block)
         end
         enum_context
       end
 
+      ##
+      # @private
+      # @see RDF::Enumerable#each_graph
+      def each_graph(&block)
+        if block_given?
+          @data.each_key do |gn|
+            yield RDF::Graph.new(gn == DEFAULT_GRAPH ? nil : gn, data: self)
+          end
+        end
+        enum_graph
+      end
+
     protected
 
       ##
       # Match elements with eql?, not ==
-      # Context of `false` matches default context. Unbound variable matches non-false context
+      # Context of `false` matches default graph. Unbound variable matches non-false graph name
       # @private
       # @see RDF::Queryable#query
       def query_pattern(pattern, &block)
-        context   = pattern.context
+        graph_name  = pattern.graph_name
         subject   = pattern.subject
         predicate = pattern.predicate
         object    = pattern.object
 
-        cs = @data.has_key?(context) ? {context => @data[context]} : @data.dup
+        cs = @data.has_key?(graph_name) ? {graph_name => @data[graph_name]} : @data.dup
         cs.each do |c, ss|
-          next unless context.nil? || context == false && !c || context.eql?(c)
-          ss = ss.has_key?(subject) ? {subject => ss[subject]} : ss.dup
+          next unless graph_name.nil? || graph_name == false && !c || graph_name.eql?(c)
+          ss = if ss.has_key?(subject)
+                 { subject => ss[subject] }
+               elsif subject.nil? || subject.is_a?(RDF::Query::Variable)
+                 ss.dup
+               else
+                 []
+               end
           ss.each do |s, ps|
-            next unless subject.nil? || subject.eql?(s)
-            ps = ps.has_key?(predicate) ? {predicate => ps[predicate]} : ps.dup
+            ps = if ps.has_key?(predicate)
+                   { predicate => ps[predicate] }
+                 elsif predicate.nil? || predicate.is_a?(RDF::Query::Variable)
+                   ps.dup
+                 else
+                   []
+                 end
             ps.each do |p, os|
-              next unless predicate.nil? || predicate.eql?(p)
               os = os.dup # TODO: is this really needed?
               os.each do |o|
                 next unless object.nil? || object.eql?(o)
-                block.call(RDF::Statement.new(s, p, o, :context => c.equal?(DEFAULT_CONTEXT) ? nil : c))
+                block.call(RDF::Statement.new(s, p, o, graph_name: c.equal?(DEFAULT_GRAPH) ? nil : c))
               end
             end
           end
@@ -350,10 +398,11 @@ module RDF
       # @private
       # @see RDF::Mutable#insert
       def insert_statement(statement)
+        raise ArgumentError, "Statement #{statement.inspect} is incomplete" if statement.incomplete?
         unless has_statement?(statement)
           s, p, o, c = statement.to_quad
-          c = DEFAULT_CONTEXT unless supports?(:context)
-          c ||= DEFAULT_CONTEXT
+          c = DEFAULT_GRAPH unless supports?(:graph_name)
+          c ||= DEFAULT_GRAPH
           @data[c] ||= {}
           @data[c][s] ||= {}
           @data[c][s][p] ||= []
@@ -367,8 +416,8 @@ module RDF
       def delete_statement(statement)
         if has_statement?(statement)
           s, p, o, c = statement.to_quad
-          c = DEFAULT_CONTEXT unless supports?(:context)
-          c ||= DEFAULT_CONTEXT
+          c = DEFAULT_GRAPH unless supports?(:graph_name)
+          c ||= DEFAULT_GRAPH
           @data[c][s][p].delete(o)
           @data[c][s].delete(p) if @data[c][s][p].empty?
           @data[c].delete(s) if @data[c][s].empty?

data/lib/rdf/transaction.rb

@@ -13,8 +13,8 @@ module RDF
   #   repository = ...
   #   RDF::Transaction.execute(repository) do |tx|
   #     subject = RDF::URI("http://example.org/article")
-  #     tx.delete [subject, RDF::DC.title, "Old title"]
-  #     tx.insert [subject, RDF::DC.title, "New title"]
+  #     tx.delete [subject, RDF::RDFS.label, "Old title"]
+  #     tx.insert [subject, RDF::RDFS.label, "New title"]
   #   end
   #
   # @since 0.3.0
@@ -35,13 +35,25 @@ module RDF
 
     ##
     # Name of this graph, if it is part of an {RDF::Repository}
-    # @!attribute [rw] context
+    # @!attribute [rw] graph_name
     # @return [RDF::Resource]
     # @since 1.1.0
-    attr_accessor :context
+    attr_accessor :graph_name
 
-    alias_method :graph, :context
-    alias_method :graph=, :context=
+    # @deprecated Use {#graph_name} instead.
+    def context
+      warn "[DEPRECATION] Statement#context is being replaced with Statement@graph_name in RDF.rb 2.0. Called from #{Gem.location_of_caller.join(':')}"
+	  graph_name
+    end
+
+    # @deprecated Use {#graph_name=} instead.
+    def context=(value)
+      warn "[DEPRECATION] Statement#context= is being replaced with Statement@graph_name= in RDF.rb 2.0. Called from #{Gem.location_of_caller.join(':')}"
+	  self.graph_name = value
+    end
+
+    alias_method :graph, :graph_name
+    alias_method :graph=, :graph_name=
 
     ##
     # RDF statements to delete when executed.
@@ -66,19 +78,25 @@ module RDF
     #
     # @param  [Hash{Symbol => Object}]  options
     # @option options [RDF::Resource]   :context  (nil)
+    #   Alias for `:graph_name`. Deprected in RDF.rb 2.0.
+    # @option options [RDF::Resource]   :graph_name (nil)
     #   Name of named graph to be affected if `inserts` or `deletes`
-    #   do not have a `context`.
+    #   do not have a `graph_name`.
     # @option options [RDF::Resource]   :graph  (nil)
-    #   Alias for `:context`.
+    #   Alias for `:graph_name`.
     # @option options [RDF::Enumerable] :insert (RDF::Graph.new)
     # @option options [RDF::Enumerable] :delete (RDF::Graph.new)
     # @yield  [tx]
     # @yieldparam [RDF::Transaction] tx
     def initialize(options = {}, &block)
       @options = options.dup
-      @context = @options.delete(:graph)  || @options.delete(:context)
-      @inserts = @options.delete(:insert) || RDF::Graph.new
-      @deletes = @options.delete(:delete) || RDF::Graph.new
+      if @options.has_key?(:context)
+        warn "[DEPRECATION] the :contexts option to Mutable#load 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
+      @graph_name = @options.delete(:graph) || @options.delete(:graph_name)
+      @inserts = @options.delete(:insert)   || []
+      @deletes = @options.delete(:delete)   || []
       @inserts.extend(RDF::Enumerable) unless @inserts.kind_of?(RDF::Enumerable)
       @deletes.extend(RDF::Enumerable) unless @deletes.kind_of?(RDF::Enumerable)
 
@@ -112,18 +130,21 @@ module RDF
     def execute(repository, options = {})
       before_execute(repository, options) if respond_to?(:before_execute)
 
-      deletes.each_statement do |statement|
-        statement = statement.dup
-        statement.context ||= graph
-        repository.delete(statement)
+      dels = deletes.map do |s|
+        statement = s.dup
+        statement.graph_name ||= graph_name
+        statement
       end
 
-      inserts.each_statement do |statement|
-        statement = statement.dup
-        statement.context ||= graph
-        repository.insert(statement)
+      ins = inserts.map do |s|
+        statement = s.dup
+        statement.graph_name ||= graph_name
+        statement
       end
-
+      
+      repository.delete(*dels) unless dels.empty?
+      repository.insert(*ins) unless ins.empty?
+      
       after_execute(repository, options) if respond_to?(:after_execute)
       self
     end

data/lib/rdf/util/file.rb

@@ -100,7 +100,6 @@ module RDF; module Util
             # If a Location is returned, it defines the base resource for this file, not it's actual ending location
             document_options = {
               base_uri:     RDF::URI(response.headers.fetch(:location, base_uri)),
-              charset:      Encoding::UTF_8,
               code:         response.code.to_i,
               headers:      response.headers
             }
@@ -159,7 +158,6 @@ module RDF; module Util
                 # If a Location is returned, it defines the base resource for this file, not it's actual ending location
                 document_options = {
                   base_uri:     RDF::URI(response["Location"] ? response["Location"] : base_uri),
-                  charset:      Encoding::UTF_8,
                   code:         response.code.to_i,
                   content_type: response.content_type,
                   headers:      response_headers
@@ -226,7 +224,6 @@ module RDF; module Util
           # If a Location is returned, it defines the base resource for this file, not it's actual ending location
           document_options = {
             base_uri:     RDF::URI(response.headers.fetch(:location, response.env.url)),
-            charset:      Encoding::UTF_8,
             code:         response.status,
             headers:      response.headers
           }
@@ -279,6 +276,8 @@ module RDF; module Util
     # Adds Accept header based on available reader content types to allow
     # for content negotiation based on available readers.
     #
+    # Input received as non-unicode, is transformed to UTF-8. With Ruby >= 2.2, all UTF is normalized to [Unicode Normalization Form C (NFC)](http://unicode.org/reports/tr15/#Norm_Forms).
+    #
     # HTTP resources may be retrieved via proxy using the `proxy` option. If `RestClient` is loaded, they will use the proxy globally by setting something like the following:
     #     `RestClient.proxy = "http://proxy.example.com/"`.
     # When retrieving documents over HTTP(S), use the mechanism described in [Providing and Discovering URI Documentation](http://www.w3.org/2001/tag/awwsw/issue57/latest/) to pass the appropriate `base_uri` to the block or as the return.
@@ -328,11 +327,11 @@ module RDF; module Util
           Kernel.open(filename_or_url, "r:utf-8", options) do |file|
             document_options = {
               base_uri:     filename_or_url.to_s,
-              charset:      file.external_encoding,
+              charset:      file.external_encoding.to_s,
               code:         200,
               content_type: content_type,
               last_modified:file.mtime,
-              headers:      {'Content-Type' => content_type, 'Last-Modified' => file.mtime.xmlschema}
+              headers:      {content_type: content_type, last_modified: file.mtime.xmlschema}
             }
 
             remote_document = RemoteDocument.new(file.read, document_options)
@@ -363,8 +362,8 @@ module RDF; module Util
       # @return [String]
       attr_reader :content_type
 
-      # Encoding of resource (from header), also applied to content
-      # @return [Encoding}]
+      # Encoding of resource (from Content-Type), downcased. Also applied to content if it is UTF
+      # @return [String}]
       attr_reader :charset
 
       # Response code
@@ -381,7 +380,7 @@ module RDF; module Util
       attr_reader :last_modified
 
       # Raw headers from response
-      # @return [Hash{String => Object}]
+      # @return [Hash{Symbol => Object}]
       attr_reader :headers
 
       # Originally requested URL
@@ -390,40 +389,58 @@ module RDF; module Util
 
       ##
       # Set content
-      # @param [String] body entiry content of request.
+      # @param [String] body entity content of request.
       def initialize(body, options = {})
-        super(body)
         options.each do |key, value|
           # de-quote charset
           matchdata = value.match(/^["'](.*)["']$/.freeze) if key == "charset"
           value = matchdata[1] if matchdata
+          value = value.downcase if value.is_a?(String)
           instance_variable_set(:"@#{key}", value)
         end
-        @headers ||= {}
+        @headers = options.fetch(:headers, {})
+        @charset = options[:charset].to_s.downcase if options[:charset]
 
         # Find Content-Type
-        if !@content_type && headers[:content_type]
-          @content_type, *params = headers[:content_type].split(';').map(&:strip)
+        if headers[:content_type]
+          ct, *params = headers[:content_type].split(';').map(&:strip)
+          @content_type ||= ct
 
           # Find charset
           params.each do |param|
             p, v = param.split('=')
             next unless p.downcase == 'charset'
-            @charset = v.sub(/^["']?(.*)["']?$/, '\1')
+            @charset ||= v.sub(/^["']?(.*)["']?$/, '\1').downcase
           end
         end
 
         @etag = headers[:etag]
         @last_modified = DateTime.parse(headers[:last_modified]) if headers[:last_modified]
+        encoding = @charset ||= "utf-8"
+
+        unless encoding.start_with?("utf")
+          body.force_encoding(Encoding::UTF_8)
+          encoding = "utf-8"
+        end
 
-        set_encoding Encoding.find(@charset) if @charset
+        # Make sure Unicode is in NFC
+        
+        begin
+          body.unicode_normalize! unless !body.unicode_normalized?
+        rescue Encoding::CompatibilityError
+          # Oh, well ...
+        end if body.respond_to?(:unicode_normalized?)
+
+        super(body, "r:#{encoding}")
       end
 
       ##
-      # Content encoding, based on {#charset} normalized to lower-case
-      # @return [String]
+      # Returns a list of encodings in Content-Encoding field as an array of strings.
+      #
+      # The encodings are downcased for canonicalization.
+      # @return [Array<String>]
       def content_encoding
-        charset.to_s.downcase
+        headers.fetch(:content_encoding, "").split(',').map(&:strip).map(&:downcase)
       end
 
       ##