Merge 9f69025 into 11389f2

lib/rdf.rb

@@ -156,7 +156,7 @@ def self.List(*args)
   # @overload Statement()
   #   @return [RDF::URI] returns the IRI for `rdf:Statement`
   #
-  # @overload Statement(options = {})
+  # @overload Statement(**options)
   #   @param  [Hash{Symbol => Object}] options
   #   @option options [RDF::Resource]  :subject   (nil)
   #   @option options [RDF::URI]       :predicate (nil)
@@ -165,7 +165,7 @@ def self.List(*args)
   #     Note, a graph_name MUST be an IRI or BNode.
   #   @return [RDF::Statement]
   #
-  # @overload Statement(subject, predicate, object, options = {})
+  # @overload Statement(subject, predicate, object, **options)
   #   @param  [RDF::Resource]          subject
   #   @param  [RDF::URI]               predicate
   #   @param  [RDF::Term]              object

lib/rdf/changeset.rb

@@ -41,7 +41,7 @@ class Changeset
     # @yield  [changes]
     # @yieldparam [RDF::Changeset] changes
     # @return [void]
-    def self.apply(mutable, options = {}, &block)
+    def self.apply(mutable, **options, &block)
       self.new(&block).apply(mutable, options)
     end
 
@@ -106,7 +106,7 @@ def readable?
     # @param  [RDF::Mutable] mutable
     # @param  [Hash{Symbol => Object}] options
     # @return [void]
-    def apply(mutable, options = {})
+    def apply(mutable, **options)
       mutable.apply_changeset(self)
     end
 

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
@@ -374,7 +375,7 @@ def self.exec(args, options = {})
 
       # Run each command in sequence
       cmds.each do |command|
-        COMMANDS[command.to_sym][:lambda].call(args, options)
+        COMMANDS[command.to_sym][:lambda].call(args, output: output, **options)
       end
     rescue ArgumentError => e
       abort e.message
@@ -409,7 +410,7 @@ def self.commands
     # @yieldparam [Array<String>] argv
     # @yieldparam [Hash] opts
     # @yieldreturn [void]
-    def self.add_command(command, options = {}, &block)
+    def self.add_command(command, **options, &block)
       options[:lambda] = block if block_given?
       COMMANDS[command.to_sym] ||= options
     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/format.rb

@@ -70,7 +70,7 @@ def self.each(&block)
     #   @param  [String, RDF::URI] filename
     #   @return [Class]
     #
-    # @overload for(options = {})
+    # @overload for(**options)
     #   Finds an RDF serialization format class based on various options.
     #
     #   @param  [Hash{Symbol => Object}] options

lib/rdf/mixin/enumerable.rb

@@ -121,7 +121,7 @@ def validate!
     # @return [Array<RDF::Statement>]
     # @see    #each_statement
     # @see    #enum_statement
-    def statements(options = {})
+    def statements(**options)
       Array(enum_statement)
     end
 
@@ -184,7 +184,7 @@ def enum_statement
     # @return [Array<Array(RDF::Resource, RDF::URI, RDF::Term)>]
     # @see    #each_triple
     # @see    #enum_triple
-    def triples(options = {})
+    def triples(**options)
       enum_statement.map(&:to_triple) # TODO: optimize
     end
 
@@ -245,7 +245,7 @@ def enum_triple
     # @return [Array<Array(RDF::Resource, RDF::URI, RDF::Term, RDF::Resource)>]
     # @see    #each_quad
     # @see    #enum_quad
-    def quads(options = {})
+    def quads(**options)
       enum_statement.map(&:to_quad) # TODO: optimize
     end
 
@@ -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/mixin/queryable.rb

@@ -41,7 +41,7 @@ module Queryable
     #   Returns an enumerable of statements (may be an enumerator) or query solutions, if passed an {RDF::Query}
     # @see    RDF::Queryable#query_pattern
     # @note   Since 2.0, this may return an Enumerable or an Enumerator in addition to Solutions
-    def query(pattern, options = {}, &block)
+    def query(pattern, **options, &block)
       raise TypeError, "#{self} is not readable" if respond_to?(:readable?) && !readable?
 
       case pattern
@@ -111,7 +111,7 @@ def query(pattern, options = {}, &block)
     # @see    RDF::Queryable#query
     # @see    RDF::Query#execute
     # @since  0.3.0
-    def query_execute(query, options = {}, &block)
+    def query_execute(query, **options, &block)
       # By default, we let RDF.rb's built-in `RDF::Query#execute` handle BGP
       # query execution by breaking down the query into its constituent
       # triple patterns and invoking `RDF::Query::Pattern#execute` on each
@@ -139,7 +139,7 @@ def query_execute(query, options = {}, &block)
     # @see    RDF::Queryable#query
     # @see    RDF::Query::Pattern#execute
     # @since  0.2.0
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       # By default, we let Ruby's built-in `Enumerable#grep` handle the
       # matching of statements by iterating over all statements and calling
       # `RDF::Query::Pattern#===` on each statement.

lib/rdf/model/dataset.rb

@@ -119,7 +119,7 @@ def supports?(feature)
     ##
     # Implements basic query pattern matching over the Dataset, with handling 
     # for a default graph.
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       return super unless pattern.graph_name == DEFAULT_GRAPH
 
       if block_given?

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.
@@ -273,7 +273,7 @@ def ==(other)
     ##
     # @private
     # @see RDF::Queryable#query_pattern
-    def query_pattern(pattern, options = {}, &block)
+    def query_pattern(pattern, **options, &block)
       pattern = pattern.dup
       pattern.graph_name = graph_name || false
       @data.query(pattern, &block)
@@ -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,9 @@ 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]
+      literal.send(:initialize, value, language: language, datatype: datatype, **options)
+      literal.validate!     if validate
+      literal.canonicalize! if canonicalize
       literal
     end
 
@@ -147,28 +147,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, **options)
       @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 +441,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, **options)
+      @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, **options)
+      @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, **options)
+      @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, **options)
+      @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?(::Float)      then BigDecimal(value.to_s)

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, **options)
+      @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