rdf 2.1.1 → 2.2.0.pre.rc1

data/lib/rdf/repository.rb

@@ -118,7 +118,7 @@ module RDF
     # @yield  [repository]
     # @yieldparam [Repository]
     # @return [void]
-    def self.load(urls, options = {}, &block)
+    def self.load(urls, **options, &block)
       self.new(options) do |repository|
         Array(urls).each do |url|
           repository.load(url, options)
@@ -371,7 +371,7 @@ module RDF
       #
       # @private
       # @see RDF::Queryable#query_pattern
-      def query_pattern(pattern, options = {}, &block)
+      def query_pattern(pattern, **options, &block)
         snapshot = @data
         if block_given?
           graph_name  = pattern.graph_name

data/lib/rdf/transaction.rb

@@ -88,7 +88,7 @@ module RDF
     # @yieldparam [RDF::Transaction] tx
     # @return [void]
     def self.begin(repository, mutable: false, **options, &block)
-      self.new(repository, options.merge(mutable: mutable), &block)
+      self.new(repository, mutable: mutable, **options, &block)
     end
 
     ##

data/lib/rdf/util/file.rb

@@ -30,8 +30,7 @@ module RDF; module Util
       # @option options [Array, String] :headers
       #   HTTP Request headers
       # @return [Hash] A hash of HTTP request headers
-      def self.headers options
-        headers = options.fetch(:headers, {})
+      def self.headers headers: {}
         headers['Accept'] ||= default_accept_header
         headers
       end
@@ -45,19 +44,19 @@ module RDF; module Util
       ##
       # @abstract
       # @param [String] base_uri to open
+      # @param [String] proxy
+      #   HTTP Proxy to use for requests.
+      # @param [Array, String] headers ({})
+      #   HTTP Request headers
+      # @param [Boolean] verify_none (false)
+      #   Don't verify SSL certificates
       # @param  [Hash{Symbol => Object}] options
       #   options are ignored in this implementation. Applications are encouraged
       #   to override this implementation to provide more control over HTTP
       #   headers and redirect following.
-      # @option options [String] :proxy
-      #   HTTP Proxy to use for requests.
-      # @option options [Array, String] :headers
-      #   HTTP Request headers
-      # @option options [Boolean] :verify_none (false)
-      #   Don't verify SSL certificates
       # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
       # @raise [IOError] if not found
-      def self.open_url(base_uri, options)
+      def self.open_url(base_uri, proxy: nil, headers: {}, verify_none: false, **options)
         raise NoMethodError.new("#{self.inspect} does not implement required method `open_url` for ", "open_url")
       end
     end
@@ -69,18 +68,14 @@ module RDF; module Util
     # allowing the use of `Rack::Cache` to avoid network access.
     # @since 1.2
     class RestClientAdapter < HttpAdapter
-      # @see HttpAdapter.open_url
-      # @param [String] base_uri to open
-      # @param  [Hash{Symbol => Object}] options
-      # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
-      # @raise [IOError] if not found
-      def self.open_url(base_uri, options)
-        ssl_verify = options[:verify_none] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+      # (see HttpAdapter.open_url)
+      def self.open_url(base_uri, proxy: nil, headers: {}, verify_none: false, **options)
+        ssl_verify = verify_none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
 
         # If RestClient is loaded, prefer it
-        RestClient.proxy = options[:proxy].to_s if options[:proxy]
+        RestClient.proxy = proxy.to_s if proxy
         client = RestClient::Resource.new(base_uri, verify_ssl: ssl_verify)
-        client.get(headers(options)) do |response, request, res, &blk|
+        client.get(headers(headers: headers)) do |response, request, res, &blk|
           case response.code
           when 200..299
             # found object
@@ -109,18 +104,14 @@ module RDF; module Util
     # Net::HTTP adapter to retrieve resources without additional dependencies
     # @since 1.2
     class NetHttpAdapter < HttpAdapter
-      # @see HttpAdapter.open_url
-      # @param [String] base_uri to open
-      # @param  [Hash{Symbol => Object}] options
-      # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
-      # @raise [IOError] if not found
-      def self.open_url(base_uri, options)
-        ssl_verify = options[:verify_none] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+      # (see HttpAdapter.open_url)
+      def self.open_url(base_uri, proxy: nil, headers: {}, verify_none: false, **options)
+        ssl_verify = verify_none ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
 
         redirect_count = 0
         max_redirects = 5
         parsed_url = ::URI.parse(base_uri)
-        parsed_proxy = ::URI.parse(options[:proxy].to_s)
+        parsed_proxy = ::URI.parse(proxy.to_s)
         base_uri = parsed_url.to_s
         remote_document = nil
 
@@ -131,7 +122,7 @@ module RDF; module Util
                           use_ssl: parsed_url.scheme == 'https',
                           verify_mode: ssl_verify
           ) do |http|
-            request = Net::HTTP::Get.new(parsed_url.request_uri, headers(options))
+            request = Net::HTTP::Get.new(parsed_url.request_uri, headers(headers: headers))
             http.request(request) do |response|
               case response
               when Net::HTTPSuccess
@@ -193,14 +184,11 @@ module RDF; module Util
         end
       end
 
-      # @see HttpAdapter.open_url
-      # @param [String] base_uri to open
-      # @param  [Hash{Symbol => Object}] options
-      # @return [RemoteDocument, Object] A {RemoteDocument}.
-      def self.open_url(base_uri, options)
+      # (see HttpAdapter.open_url)
+      def self.open_url(base_uri, proxy: nil, headers: {}, verify_none: false, **options)
         response = conn.get do |req|
           req.url base_uri
-          headers(options).each do |k,v|
+          headers(headers: headers).each do |k,v|
             req.headers[k] = v
           end
         end
@@ -283,29 +271,34 @@ module RDF; module Util
     #      # => Cached resource if current, otherwise returned resource
     #
     # @param [String] filename_or_url to open
+    # @param [String] proxy
+    #   HTTP Proxy to use for requests.
+    # @param [Array, String] headers ({})
+    #   HTTP Request headers
+    # @param [Boolean] verify_none (false)
+    #   Don't verify SSL certificates
     # @param  [Hash{Symbol => Object}] options
     #   options are ignored in this implementation. Applications are encouraged
     #   to override this implementation to provide more control over HTTP
     #   headers and redirect following. If opening as a file,
     #   options are passed to `Kernel.open`.
-    # @option options [String] :proxy
-    #   HTTP Proxy to use for requests.
-    # @option options [Array, String] :headers
-    #   HTTP Request headers, passed to Kernel.open.
-    # @option options [Boolean] :verify_none (false)
-    #   Don't verify SSL certificates
     # @return [RemoteDocument, Object] A {RemoteDocument}. If a block is given, the result of evaluating the block is returned.
     # @yield [ RemoteDocument] A {RemoteDocument} for local files
     # @yieldreturn [Object] returned from open_file
     # @raise [IOError] if not found
-    def self.open_file(filename_or_url, options = {}, &block)
+    def self.open_file(filename_or_url, proxy: nil, headers: {}, verify_none: false, **options, &block)
       filename_or_url = $1 if filename_or_url.to_s.match(/^file:(.*)$/)
       remote_document = nil
 
       if filename_or_url.to_s =~ /^https?/
         base_uri = filename_or_url.to_s
 
-        remote_document = self.http_adapter(!!options[:use_net_http]).open_url(base_uri, options)
+        remote_document = self.http_adapter(!!options[:use_net_http]).
+          open_url(base_uri,
+                   proxy:       proxy,
+                   headers:     headers,
+                   verify_none: verify_none,
+                   **options)
       else
         # Fake content type based on found format
         format = RDF::Format.for(filename_or_url.to_s)

data/lib/rdf/util/logger.rb

@@ -13,7 +13,7 @@ module RDF; module Util
     # @param [Hash{Symbol => Object}] options
     # @option options [Logger, #<<] :logger
     # @return [Logger, #write, #<<]
-    def logger(options = {})
+    def logger(**options)
       logger = options.fetch(:logger, @logger)
       logger = @options[:logger] if logger.nil? && @options
       if logger.nil?
@@ -33,20 +33,20 @@ module RDF; module Util
     # @param [Hash{Symbol => Object}] options
     # @option options [Logger, #<<] :logger
     # @return [Hash{Symbol => Integer}]
-    def log_statistics(options = {})
+    def log_statistics(**options)
       logger(options).log_statistics
     end
 
     ##
     # Used for fatal errors where processing cannot continue. If `logger` is not configured, it logs to `$stderr`.
     #
-    # @overload log_fatal(*args, options = {}, &block)
+    # @overload log_fatal(*args, **options, &block)
     #   @param [Array<String>] args
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level (:fatal)
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
-    #   @option options [:fatal, :error, :warn, :info, :debug] level (:<<)
     #   @option options [Integer] :lineno associated with message
     #   @option options [Logger, #<<] :logger
     #   @option options [Class] :exception, (StandardError)
@@ -54,9 +54,8 @@ module RDF; module Util
     #   @yieldreturn [String] added to message
     #   @return [void]
     #   @raise Raises the provided exception class using the first element from args as the message component.
-    def log_fatal(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      logger_common(*args, "Called from #{Gem.location_of_caller.join(':')}", options.merge(level: :fatal), &block)
+    def log_fatal(*args, level: :fatal, **options, &block)
+      logger_common(*args, "Called from #{Gem.location_of_caller.join(':')}", level: level, **options, &block)
       raise options.fetch(:exception, StandardError), args.first
     end
 
@@ -65,9 +64,10 @@ module RDF; module Util
     #
     # As a side-effect of setting `@logger_in_error`, which will suppress further error messages until cleared using {#log_recover}.
     #
-    # @overload log_error(*args, options = {}, &block)
+    # @overload log_error(*args, **options, &block)
     #   @param [Array<String>] args
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level (:error)
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
@@ -79,12 +79,11 @@ module RDF; module Util
     #   @yieldreturn [String] added to message
     #   @return [void]
     #   @raise Raises the provided exception class using the first element from args as the message component, if `:exception` option is provided.
-    def log_error(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
+    def log_error(*args, level: :error, **options, &block)
       logger = self.logger(options)
       return if logger.recovering
       logger.recovering = true
-      logger_common(*args, options.merge(level: :error), &block)
+      logger_common(*args, level: level, **options, &block)
       raise options[:exception], args.first if options[:exception]
     end
 
@@ -92,16 +91,17 @@ module RDF; module Util
     # @param [Hash{Symbol => Object}] options
     # @option options [Logger, #<<] :logger
     # @return [Boolean]
-    def log_recovering?(options = {})
+    def log_recovering?(**options)
       self.logger(options).recovering
     end
 
     ##
     # Warning message.
     #
-    # @overload log_warn(*args, options = {}, &block)
+    # @overload log_warn(*args, **options, &block)
     #   @param [Array<String>] args
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level (:warn)
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
@@ -110,9 +110,8 @@ module RDF; module Util
     #   @option options [Logger, #<<] :logger
     #   @yieldreturn [String] added to message
     #   @return [void]
-    def log_warn(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      logger_common(*args, options.merge(level: :warn), &block)
+    def log_warn(*args, level: :warn, **options, &block)
+      logger_common(*args, level: level, **options, &block)
     end
 
     ##
@@ -120,9 +119,10 @@ module RDF; module Util
     #
     # As a side-effect of clearing `@logger_in_error`.
     #
-    # @overload log_recover(*args, options = {}, &block)
+    # @overload log_recover(*args, **options, &block)
     #   @param [Array<String>] args
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level (:info)
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
@@ -130,20 +130,20 @@ module RDF; module Util
     #   @option options [Logger, #<<] :logger
     #   @yieldreturn [String] added to message
     #   @return [void]
-    def log_recover(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
+    def log_recover(*args, level: :info, **options, &block)
       logger = self.logger(options)
       logger.recovering = false
       return if args.empty? && !block_given?
-      logger_common(*args, options.merge(level: :info), &block)
+      logger_common(*args, level: level, **options, &block)
     end
 
     ##
     # Informational message.
     #
-    # @overload log_info(*args, options = {}, &block)
+    # @overload log_info(*args, **options, &block)
     #   @param [Array<String>] args
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level (:info)
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
@@ -151,17 +151,17 @@ module RDF; module Util
     #   @option options [Logger, #<<] :logger
     #   @yieldreturn [String] added to message
     #   @return [void]
-    def log_info(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      logger_common(*args, options.merge(level: :info), &block)
+    def log_info(*args, level: :info, **options, &block)
+      logger_common(*args, level: level, **options, &block)
     end
 
     ##
     # Debug message.
     #
-    # @overload log_debug(*args, options = {}, &block)
+    # @overload log_debug(*args, **options, &block)
     #   @param [Array<String>] args
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level (:debug)
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
@@ -169,9 +169,8 @@ module RDF; module Util
     #   @option options [Logger, #<<] :logger
     #   @yieldreturn [String] added to message
     #   @return [void]
-    def log_debug(*args, &block)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      logger_common(*args, options.merge(level: :debug), &block)
+    def log_debug(*args, level: :debug, **options, &block)
+      logger_common(*args, level: level, **options, &block)
     end
 
     ##
@@ -188,7 +187,7 @@ module RDF; module Util
     # @overload log_depth
     #   # Return the current log depth
     #   @return [Integer]
-    def log_depth(options = {}, &block)
+    def log_depth(**options, &block)
       self.logger(options).log_depth(&block)
     end
 
@@ -200,6 +199,7 @@ module RDF; module Util
     #
     # @overload logger_common(args, options)
     #   @param [Array<String>] args Messages
+    #   @param [:fatal, :error, :warn, :info, :debug] level
     #   @param [Hash{Symbol => Object}] options
     #   @option options [Integer] :depth
     #     Recursion depth for indenting output
@@ -208,11 +208,11 @@ module RDF; module Util
     #   @option options [Logger, #<<] :logger
     #   @yieldreturn [String] added to message
     #   @return [void]
-    def logger_common(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      level = options[:level]
+    def logger_common(*args, level:, **options)
       logger = self.logger(options)
       logger.log_statistics[level] = logger.log_statistics[level].to_i + 1
+      # Some older code uses integer level numbers
+      level = [:debug, :info, :warn, :error, :fatal][level] if level.is_a?(Integer)
       return if logger.level > {fatal: 4, error: 3, warn: 2, info: 1, debug: 0}[level]
 
       depth = options.fetch(:depth, logger.log_depth)
@@ -234,8 +234,8 @@ module RDF; module Util
       ##
       # @overload log_depth(options, &block)
       #   Increase depth around a method invocation
+      #   @param [Integer] depth (1) recursion depth
       #   @param [Hash{Symbol}] options (@options || {})
-      #   @option options [Integer] :depth (1) recursion depth
       #   @option options [Logger, #<<] :logger
       #   @yield
       #     Yields with no arguments
@@ -245,16 +245,16 @@ module RDF; module Util
       # @overload log_depth
       #   # Return the current log depth
       #   @return [Integer]
-      def log_depth(options = {})
+      def log_depth(depth: 1, **options)
         @log_depth ||= 0
         if block_given?
-          @log_depth += options.fetch(:depth, 1)
+          @log_depth += depth
           yield
         else
           @log_depth
         end
       ensure
-        @log_depth -= options.fetch(:depth, 1) if block_given?
+        @log_depth -= depth if block_given?
       end
 
       # Give Logger like behavior to non-logger objects

data/lib/rdf/util/uuid.rb

@@ -13,16 +13,17 @@ module RDF; module Util
     # [UUID]:      http://rubygems.org/gems/uuid
     # [UUIDTools]: http://rubygems.org/gems/uuidtools
     #
+    # @param  [:default, :compact, :urn] format (:default)
     # @param  [Hash{Symbol => Object}] options
     #   any options to pass through to the underlying UUID library
     # @return [String] a UUID string
     # @raise  [LoadError] if no UUID library is available
     # @see    http://rubygems.org/gems/uuid
     # @see    http://rubygems.org/gems/uuidtools
-    def self.generate(options = {})
+    def self.generate(format: :default, **options)
       begin
         require 'uuid'
-        ::UUID.generate(options[:format] || :default)
+        ::UUID.generate(format)
       rescue LoadError => e
         begin
           require 'uuidtools'

data/lib/rdf/vocab/writer.rb

@@ -54,10 +54,10 @@ module RDF
       #
       # @param  [IO, File] output
       #   the output stream
+      # @param [RDF::URI]  base_uri
+      #   URI of this vocabulary
       # @param  [Hash{Symbol => Object}] options = ({})
       #   any additional options. See {RDF::Writer#initialize}
-      # @option options [RDF::URI]  :base_uri
-      #   URI of this vocabulary
       # @option options [String]  :class_name
       #   Class name for this vocabulary
       # @option options [String]  :module_name ("RDF")
@@ -71,9 +71,9 @@ module RDF
       # @yield  [writer] `self`
       # @yieldparam  [RDF::Writer] writer
       # @yieldreturn [void]
-      def initialize(output = $stdout, options = {}, &block)
-        options.fetch(:base_uri) {raise ArgumentError, "base_uri option required"}
+      def initialize(output = $stdout, base_uri:, **options, &block)
         @graph = RDF::Repository.new
+        options.merge(base_uri: base_uri)
         super
       end