A number of compatible keyword arguments changes, Methods that can ta…

…ke a Statement must wait for `Statement#to_hash` to be completely removed.

Logger level can be an integer in some existing calls. Map those to symbols.

lib/rdf/cli.rb

@@ -338,23 +338,24 @@ def self.usage(options, banner: nil)
     # Execute one or more commands, parsing input as necessary
     #
     # @param  [Array<String>] args
+    # @param  [IO] output
+    # @param  [Hash{Symbol => Object}] options
     # @return [Boolean]
-    def self.exec(args, **options)
-      out = options[:output] || $stdout
-      out.set_encoding(Encoding::UTF_8) if out.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
+    def self.exec(args, output: $stdout, option_parser: self.options, **options)
+      output.set_encoding(Encoding::UTF_8) if output.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
       cmds, args = args.partition {|e| commands.include?(e.to_s)}
 
       if cmds.empty?
-        usage(options.fetch(:option_parser, self.options))
+        usage(option_parser)
         abort "No command given"
       end
 
       if cmds.first == 'help'
         on_cmd = cmds[1]
         if on_cmd && COMMANDS.fetch(on_cmd.to_sym, {})[:help]
-          usage(options.fetch(:option_parser, self.options), banner: "Usage: #{self.basename.split('/').last} #{COMMANDS[on_cmd.to_sym][:help]}")
+          usage(option_parser, banner: "Usage: #{self.basename.split('/').last} #{COMMANDS[on_cmd.to_sym][:help]}")
         else
-          usage(options.fetch(:option_parser, self.options))
+          usage(option_parser)
         end
         return
       end
@@ -431,15 +432,19 @@ def self.formats(reader: false, writer: false)
     # yielding a reader
     #
     # @param  [Array<String>] files
+    # @param  [String] evaluate from command-line, rather than referenced file
+    # @param  [Symbol] format (:ntriples) Reader symbol for finding reader
+    # @param  [Encoding] encoding set on the input
+    # @param  [Hash{Symbol => Object}] options sent to reader
     # @yield  [reader]
     # @yieldparam [RDF::Reader]
     # @return [nil]
-    def self.parse(files, **options, &block)
+    def self.parse(files, evaluate: nil, format: :ntriples, encoding: Encoding::UTF_8, **options, &block)
       if files.empty?
         # If files are empty, either use options[:execute]
-        input = options[:evaluate] ? StringIO.new(options[:evaluate]) : $stdin
-        input.set_encoding(options.fetch(:encoding, Encoding::UTF_8))
-        r = RDF::Reader.for(options[:format] || :ntriples)
+        input = evaluate ? StringIO.new(evaluate) : $stdin
+        input.set_encoding(encoding)
+        r = RDF::Reader.for(format)
         (@readers ||= []) << r
         r.new(input, options) do |reader|
           yield(reader)

lib/rdf/mixin/enumerable.rb

@@ -738,11 +738,10 @@ def to_h
     # @see    RDF::Writer.dump
     # @raise [RDF::WriterError] if no writer found
     # @since  0.2.0
-    def dump(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
+    def dump(*args, **options)
       writer = RDF::Writer.for(*args)
       raise RDF::WriterError, "No writer found using #{args.inspect}" unless writer
-      writer.dump(self, nil, options)
+      writer.dump(self, nil, **options)
     end
 
   protected

lib/rdf/model/graph.rb

@@ -87,12 +87,12 @@ def self.load(url, graph_name: nil, **options, &block)
     end
 
     ##
-    # @param  [RDF::Resource]          graph_name
+    # @param  [RDF::Resource] graph_name
     #   The graph_name from the associated {RDF::Queryable} associated
     #   with this graph as provided with the `:data` option
     #   (only for {RDF::Queryable} instances supporting
     #   named graphs).
-    # @param [RDF::Queryable] :data (RDF::Repository.new)
+    # @param [RDF::Queryable] data (RDF::Repository.new)
     #   Storage behind this graph.
     #
     # @raise [ArgumentError] if a `data` does not support named graphs.
@@ -294,7 +294,7 @@ def insert_statement(statement)
     def insert_statements(statements)
       enum = Enumerable::Enumerator.new do |yielder|
 
-        statements.send(method = statements.respond_to?(:each_statement) ? :each_statement : :each) do |s|
+        statements.send(statements.respond_to?(:each_statement) ? :each_statement : :each) do |s|
           s = s.dup
           s.graph_name = graph_name
           yielder << s

lib/rdf/model/literal.rb

@@ -104,13 +104,13 @@ def self.datatyped_class(uri)
 
     ##
     # @private
-    def self.new(value, **options)
-      raise ArgumentError, "datatype with language must be rdf:langString" if options[:language] && (options[:datatype] || RDF.langString).to_s != RDF.langString.to_s
+    def self.new(value, language: nil, datatype: nil, lexical: nil, validate: false, canonicalize: false, **options)
+      raise ArgumentError, "datatype with language must be rdf:langString" if language && (datatype || RDF.langString).to_s != RDF.langString.to_s
 
       klass = case
         when !self.equal?(RDF::Literal)
           self # subclasses can be directly constructed without type dispatch
-        when typed_literal = datatyped_class(options[:datatype].to_s)
+        when typed_literal = datatyped_class(datatype.to_s)
           typed_literal
         else case value
           when ::TrueClass  then RDF::Literal::Boolean
@@ -126,9 +126,13 @@ def self.new(value, **options)
         end
       end
       literal = klass.allocate
-      literal.send(:initialize, value, options)
-      literal.validate!     if options[:validate]
-      literal.canonicalize! if options[:canonicalize]
+      if klass.equal?(RDF::Literal)
+        literal.send(:initialize, value, language: language, datatype: datatype)
+      else
+        literal.send(:initialize, value, datatype: datatype)
+      end
+      literal.validate!     if validate
+      literal.canonicalize! if canonicalize
       literal
     end
 
@@ -147,28 +151,28 @@ def self.new(value, **options)
     # depending on if there is language
     #
     # @param  [Object] value
-    # @option options [Symbol]  :language (nil)
+    # @param  [Symbol]  language (nil)
     #   Language is downcased to ensure proper matching
-    # @option options [String]  :lexical (nil)
+    # @param [String]  lexical (nil)
     #   Supplied lexical representation of this literal,
-    #   otherwise it comes from transforming `value` to a string form
-    #   See {#to_s}.
-    # @option options [URI]     :datatype (nil)
-    # @option options [Boolean] :validate (false)
-    # @option options [Boolean] :canonicalize (false)
+    #   otherwise it comes from transforming `value` to a string form..
+    # @param [URI]     datatype (nil)
+    # @param [Boolean] validate (false)
+    # @param [Boolean] canonicalize (false)
     # @raise [ArgumentError]
     #   if there is a language and datatype is no rdf:langString
     #   or datatype is rdf:langString and there is no language
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
-    def initialize(value, **options)
+    # @see #to_s
+    def initialize(value, language: nil, datatype: nil, lexical: nil, validate: false, canonicalize: false)
       @object   = value.freeze
-      @string   = options[:lexical] if options[:lexical]
+      @string   = lexical if lexical
       @string   = value if !defined?(@string) && value.is_a?(String)
       @string   = @string.encode(Encoding::UTF_8).freeze if @string
       @object   = @string if @string && @object.is_a?(String)
-      @language = options[:language].to_s.downcase.to_sym if options[:language]
-      @datatype = RDF::URI(options[:datatype]).freeze if options[:datatype]
+      @language = language.to_s.downcase.to_sym if language
+      @datatype = RDF::URI(datatype).freeze if datatype
       @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
       @datatype ||= @language ? RDF.langString : RDF::XSD.string
       raise ArgumentError, "datatype of rdf:langString requires a language" if !@language && @datatype == RDF::langString
@@ -441,7 +445,7 @@ def squish!
     #
     # @param  [String] string
     # @return [String]
-    # @see {RDF::Term#escape}
+    # @see RDF::Term#escape
     def escape(string)
       string.gsub('\\', '\\\\').
              gsub("\t", '\\t').

lib/rdf/model/literal/boolean.rb

@@ -11,12 +11,11 @@ class Boolean < Literal
     FALSES   = %w(false 0).freeze
 
     ##
-    # @param  [Boolean] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Boolean] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when true.equal?(value)  then true
         when false.equal?(value) then false

lib/rdf/model/literal/date.rb

@@ -10,12 +10,11 @@ class Date < Literal
     FORMAT   = '%Y-%m-%d'.freeze
 
     ##
-    # @param  [Date] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Date, #to_date] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::Date)         then value
         when value.respond_to?(:to_date) then value.to_date

lib/rdf/model/literal/datetime.rb

@@ -12,10 +12,9 @@ class DateTime < Literal
     ##
     # @param  [DateTime] value
     # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::DateTime)         then value
         when value.respond_to?(:to_datetime) then value.to_datetime

lib/rdf/model/literal/decimal.rb

@@ -15,12 +15,11 @@ class Decimal < Numeric
     GRAMMAR  = /^[\+\-]?\d+(\.\d*)?$/.freeze
 
     ##
-    # @param  [BigDecimal] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, BidDecimal, Numeric] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(BigDecimal) then value
         when value.is_a?(Numeric) then BigDecimal(value)

lib/rdf/model/literal/double.rb

@@ -15,12 +15,11 @@ class Double < Numeric
     GRAMMAR  = /^(?:NaN|(?:[\+\-]?(?:INF|(?:\d+(\.\d*)?(e[\+\-]?\d+)?))))$/i.freeze
 
     ##
-    # @param  [Float, #to_f] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Float, #to_f] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::String) then case value
           when '+INF'  then 1/0.0

lib/rdf/model/literal/integer.rb

@@ -16,15 +16,14 @@ class Integer < Decimal
     GRAMMAR  = /^[\+\-]?\d+$/.freeze
 
     ##
-    # @param  [Integer, #to_i] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, Integer, #to_i] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
+      when value.is_a?(::Integer)   then value
         when value.respond_to?(:to_i) then value.to_i
-        when value.is_a?(::Integer)   then value
         else Integer(value.to_s) rescue nil
       end
     end

lib/rdf/model/literal/time.rb

@@ -15,12 +15,11 @@ class Time < Literal
     FORMAT   = '%H:%M:%S%:z'.freeze
 
     ##
-    # @param  [Time] value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
+    # @param  [String, DateTime, #to_datetime] value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
       @object   = case
         when value.is_a?(::DateTime)         then value
         when value.respond_to?(:to_datetime) then value.to_datetime rescue ::DateTime.parse(value.to_s)

lib/rdf/model/literal/token.rb

@@ -9,13 +9,12 @@ class Token < Literal
     GRAMMAR  = /\A[^\x0D\x0A\x09]+\z/i.freeze # FIXME
 
     ##
-    # @param  [Symbol, #to_s]  value
-    # @option options [String] :lexical (nil)
-    def initialize(value, **options)
-      @datatype = RDF::URI(options[:datatype] || self.class.const_get(:DATATYPE))
-      @string   = options[:lexical] if options.has_key?(:lexical)
-      @string   ||= value if value.is_a?(String)
-      @object   = value.is_a?(Symbol) ? value : value.to_s
+    # @param  [String, Symbol, #to_sym]  value
+    # @param  (see Literal#initialize)
+    def initialize(value, datatype: nil, lexical: nil)
+      @datatype = RDF::URI(datatype || self.class.const_get(:DATATYPE))
+      @string   = lexical || (value if value.is_a?(String))
+      @object   = value.is_a?(Symbol) ? value : value.to_sym
     end
 
     ##

lib/rdf/model/statement.rb

@@ -31,11 +31,11 @@ class Statement
     ##
     # @private
     # @since 0.2.2
-    def self.from(statement, **options)
+    def self.from(statement, graph_name: nil, **options)
       case statement
         when Array, Query::Pattern
-          graph_name = statement[3] == false ? nil : statement[3]
-          self.new(statement[0], statement[1], statement[2], options.merge(graph_name: graph_name))
+          graph_name ||= statement[3] == false ? nil : statement[3]
+          self.new(statement[0], statement[1], statement[2], graph_name: graph_name, **options)
         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}"
@@ -73,8 +73,8 @@ def self.from(statement, **options)
     # @overload initialize(subject, predicate, object, **options)
     #   @param  [RDF::Term]          subject
     #     A symbol is converted to an interned {Node}.
-    #   @param  [RDF::URI]               predicate
-    #   @param  [RDF::Resource]              object
+    #   @param  [RDF::URI]           predicate
+    #   @param  [RDF::Resource]      object
     #     if not a {Resource}, it is coerced to {Literal} or {Node} depending on if it is a symbol or something other than a {Term}.
     #   @param  [Hash{Symbol => Object}] options
     #   @option options [RDF::Term]  :graph_name   (nil)
@@ -397,12 +397,17 @@ def to_s
     ##
     # Returns a graph containing this statement in reified form.
     #
-    # @param  [Hash{Symbol => Object}] options
+    # @param [RDF::Term]  subject   (nil)
+    #   Subject of reification.
+    # @param [RDF::Term]  id   (nil)
+    #   Node identifier, when subject is anonymous
+    # @param [RDF::Term]  graph_name   (nil)
+    #   Note, in RDF 1.1, a graph name MUST be an {Resource}.
     # @return [RDF::Graph]
     # @see    http://www.w3.org/TR/rdf-primer/#reification
-    def reified(**options)
-      RDF::Graph.new(graph_name: options[:graph_name]) do |graph|
-        subject = options[:subject] || RDF::Node.new(options[:id])
+    def reified(subject: nil, id: nil, graph_name: nil)
+      RDF::Graph.new(graph_name: graph_name) do |graph|
+        subject = subject || RDF::Node.new(id)
         graph << [subject, RDF.type,      RDF[:Statement]]
         graph << [subject, RDF.subject,   self.subject]
         graph << [subject, RDF.predicate, self.predicate]

lib/rdf/model/uri.rb

@@ -281,7 +281,7 @@ def urn?
     #
     # @return [Boolean] `true` or `false`
     # @see    http://en.wikipedia.org/wiki/URI_scheme
-    # @see    {NON_HIER_SCHEMES}
+    # @see    NON_HIER_SCHEMES
     # @since  1.0.10
     def hier?
       !NON_HIER_SCHEMES.include?(scheme)