Modernize use of Ruby options and keyword parameters.

Author: gkellogg

Diff for: .gitignore

@@ -1,5 +1,6 @@
 /.yardoc/
 /doc/
+/coverage/
 /*.gem
 /coverage/
 /spec.html

Diff for: lib/json/ld/api.rb

@@ -86,16 +86,15 @@ class API
     # @yield [api]
     # @yieldparam [API]
     # @raise [JsonLdError]
-    def initialize(input, context, options = {}, &block)
+    def initialize(input, context, rename_bnodes: true, unique_bnodes: false, **options, &block)
       @options = {
         compactArrays:      true,
-        rename_bnodes:      true,
         documentLoader:     self.class.method(:documentLoader)
       }.merge(options)
-      @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
+      @namer = unique_bnodes ? BlankNodeUniqer.new : (rename_bnodes ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
 
       # For context via Link header
-      remote_base, context_ref = nil, nil
+      _, context_ref = nil, nil
 
       @value = case input
       when Array, Hash then input.dup
@@ -115,7 +114,6 @@ def initialize(input, context, options = {}, &block)
       when String
         remote_doc = @options[:documentLoader].call(input, @options)
 
-        remote_base = remote_doc.documentUrl
         context_ref = remote_doc.contextUrl
         @options = {base: remote_doc.documentUrl}.merge(@options) unless @options[:no_default_base]
 
@@ -166,12 +164,12 @@ def initialize(input, context, options = {}, &block)
     # @return [Object, Array<Hash>]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
     # @see http://json-ld.org/spec/latest/json-ld-api/#expansion-algorithm
-    def self.expand(input, options = {}, &block)
+    def self.expand(input, ordered: true, framing: false, **options, &block)
       result, doc_base = nil
       API.new(input, options[:expandContext], options) do
         result = self.expand(self.value, nil, self.context,
-          ordered: options.fetch(:ordered, true),
-          framing: @options[:processingMode].to_s.include?('expand-frame'))
+          ordered: ordered,
+          framing: framing)
         doc_base = @options[:base]
       end
 
@@ -215,18 +213,18 @@ def self.expand(input, options = {}, &block)
     #   If a block is given, the result of evaluating the block is returned, otherwise, the compacted JSON-LD document
     # @raise [JsonLdError]
     # @see http://json-ld.org/spec/latest/json-ld-api/#compaction-algorithm
-    def self.compact(input, context, options = {})
+    def self.compact(input, context, expanded: false, **options)
       result = nil
       options = {compactToRelative:  true}.merge(options)
 
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
-      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+      expanded_input = expanded ? input : API.expand(input, options) do |res, base_iri|
         options[:base] ||= base_iri if options[:compactToRelative]
-        result
+        res
       end
 
-      API.new(expanded_input, context, options.merge(no_default_base: true)) do
+      API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".compact") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value)
 
@@ -260,18 +258,18 @@ def self.compact(input, context, options = {})
     # @return [Object, Hash]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the flattened JSON-LD document
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
-    def self.flatten(input, context, options = {})
+    def self.flatten(input, context, expanded: false, **options)
       flattened = []
       options = {compactToRelative:  true}.merge(options)
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+      expanded_input = expanded ? input : API.expand(input, options) do |result, base_iri|
         options[:base] ||= base_iri if options[:compactToRelative]
         result
       end
 
       # Initialize input using
-      API.new(expanded_input, context, options.merge(no_default_base: true)) do
+      API.new(expanded_input, context, no_default_base: true, **options) do
         log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
@@ -333,7 +331,7 @@ def self.flatten(input, context, options = {})
     #   If a block is given, the result of evaluating the block is returned, otherwise, the framed JSON-LD document
     # @raise [InvalidFrame]
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
-    def self.frame(input, frame, options = {})
+    def self.frame(input, frame, expanded: false, **options)
       result = nil
       options = {
         base:                       (input if input.is_a?(String)),
@@ -367,16 +365,16 @@ def self.frame(input, frame, options = {})
       end
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options) do |result, base_iri|
+      expanded_input = expanded ? input : API.expand(input, options) do |res, base_iri|
         options[:base] ||= base_iri if options[:compactToRelative]
-        result
+        res
       end
 
       # Expand frame to simplify processing
-      expanded_frame = API.expand(frame, options.merge(processingMode: "json-ld-1.1-expand-frame"))
+      expanded_frame = API.expand(frame, framing: true, **options)
 
       # Initialize input using frame as context
-      API.new(expanded_input, nil, options.merge(no_default_base: true)) do
+      API.new(expanded_input, nil, no_default_base: true, **options) do
         log_debug(".frame") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
         log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
@@ -397,7 +395,7 @@ def self.frame(input, frame, options = {})
         framing_state[:subjects] = framing_state[:graphMap][framing_state[:graph]]
 
         result = []
-        frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))
+        frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), parent: result, **options)
 
         # Count blank node identifiers used in the document, if pruning
         bnodes_to_clear = if options[:pruneBlankNodeIdentifiers]
@@ -433,7 +431,7 @@ def self.frame(input, frame, options = {})
     # @yield statement
     # @yieldparam [RDF::Statement] statement
     # @return [RDF::Enumerable] set of statements, unless a block is given.
-    def self.toRdf(input, options = {}, &block)
+    def self.toRdf(input, expanded: false, **options, &block)
       unless block_given?
         results = []
         results.extend(RDF::Enumerable)
@@ -444,7 +442,7 @@ def self.toRdf(input, options = {}, &block)
       end
 
       # Expand input to simplify processing
-      expanded_input = options[:expanded] ? input : API.expand(input, options.merge(ordered: false))
+      expanded_input = expanded ? input : API.expand(input, ordered: false, **options)
 
       API.new(expanded_input, nil, options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
@@ -495,9 +493,7 @@ def self.toRdf(input, options = {}, &block)
     # @yieldreturn [Object] returned object
     # @return [Object, Hash]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the expanded JSON-LD document
-    def self.fromRdf(input, options = {}, &block)
-      useRdfType = options.fetch(:useRdfType, false)
-      useNativeTypes = options.fetch(:useNativeTypes, false)
+    def self.fromRdf(input, useRdfType: false, useNativeTypes: false, **options, &block)
       result = nil
 
       API.new(nil, nil, options) do |api|
@@ -519,12 +515,12 @@ def self.fromRdf(input, options = {}, &block)
     # @return [Object, RemoteDocument]
     #   If a block is given, the result of evaluating the block is returned, otherwise, the retrieved remote document and context information unless block given
     # @raise [JsonLdError]
-    def self.documentLoader(url, options = {})
+    def self.documentLoader(url, validate: false, **options)
       options = OPEN_OPTS.merge(options)
       RDF::Util::File.open_file(url, options) do |remote_doc|
         content_type = remote_doc.content_type if remote_doc.respond_to?(:content_type)
         # If the passed input is a DOMString representing the IRI of a remote document, dereference it. If the retrieved document's content type is neither application/json, nor application/ld+json, nor any other media type using a +json suffix as defined in [RFC6839], reject the promise passing an loading document failed error.
-        if content_type && options[:validate]
+        if content_type && validate
           main, sub = content_type.split("/")
           raise JSON::LD::JsonLdError::LoadingDocumentFailed, "url: #{url}, content_type: #{content_type}" if
             main != 'application' ||

Diff for: lib/json/ld/context.rb

@@ -735,7 +735,7 @@ def create_term_definition(local_context, term, defined)
     #
     # @param  [Hash{Symbol => Object}] options ({})
     # @return [Hash]
-    def serialize(options = {})
+    def serialize(**options)
       # FIXME: not setting provided_context now
       use_context = case provided_context
       when String, RDF::URI
@@ -1324,7 +1324,7 @@ def expand_value(property, value, useNativeTypes: false, **options)
     # @raise [JsonLdError] if the iri cannot be expanded
     # @see http://json-ld.org/spec/latest/json-ld-api/#value-compaction
     # FIXME: revisit the specification version of this.
-    def compact_value(property, value, options = {})
+    def compact_value(property, value, **options)
       #log_debug("compact_value") {"property: #{property.inspect}, value: #{value.inspect}"}
 
       num_members = value.length

Diff for: lib/json/ld/format.rb

@@ -63,12 +63,12 @@ def self.cli_commands
                 # 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))
-                JSON::LD::API.expand(input, options.merge(validate: false)) do |expanded|
+                JSON::LD::API.expand(input, validate: false, **options) do |expanded|
                   out.puts expanded.to_json(JSON::LD::JSON_STATE)
                 end
               else
                 files.each do |file|
-                  JSON::LD::API.expand(file, options.merge(validate: false)) do |expanded|
+                  JSON::LD::API.expand(file, validate: false, **options) do |expanded|
                     out.puts expanded.to_json(JSON::LD::JSON_STATE)
                   end
                 end

Diff for: lib/json/ld/frame.rb

@@ -20,13 +20,12 @@ module Frame
     # @option options [String] :property (nil)
     #   The parent property.
     # @raise [JSON::LD::InvalidFrame]
-    def frame(state, subjects, frame, **options)
+    def frame(state, subjects, frame, parent: nil, property: nil, **options)
       #log_depth do
       #log_debug("frame") {"subjects: #{subjects.inspect}"}
       #log_debug("frame") {"frame: #{frame.to_json(JSON_STATE)}"}
-      #log_debug("frame") {"property: #{options[:property].inspect}"}
+      #log_debug("frame") {"property: #{property.inspect}"}
 
-      parent, property = options[:parent], options[:property]
       # Validate the frame
       validate_frame(frame)
       frame = frame.first if frame.is_a?(Array)
@@ -105,7 +104,7 @@ def frame(state, subjects, frame, **options)
           if recurse
             state[:graphStack].push(state[:graph])
             state[:graph] = id
-            frame(state, state[:graphMap][id].keys, [subframe], options.merge(parent: output, property: '@graph'))
+            frame(state, state[:graphMap][id].keys, [subframe], parent: output, property: '@graph', **options)
             state[:graph] = state[:graphStack].pop
           end
         end
@@ -138,14 +137,14 @@ def frame(state, subjects, frame, **options)
               src = o['@list']
               src.each do |oo|
                 if node_reference?(oo)
-                  frame(state, [oo['@id']], subframe, options.merge(parent: list, property: '@list'))
+                  frame(state, [oo['@id']], subframe, parent: list, property: '@list', **options)
                 else
                   add_frame_output(list, '@list', oo.dup)
                 end
               end
             when node_reference?(o)
               # recurse into subject reference
-              frame(state, [o['@id']], subframe, options.merge(parent: output, property: prop))
+              frame(state, [o['@id']], subframe, parent: output, property: prop, **options)
             when value_match?(subframe, o)
               # Include values if they match
               add_frame_output(output, prop, o.dup)
@@ -174,7 +173,7 @@ def frame(state, subjects, frame, **options)
               # Node has property referencing this subject
               # recurse into  reference
               (output['@reverse'] ||= {})[reverse_prop] ||= []
-              frame(state, [r_id], subframe, options.merge(parent: output['@reverse'][reverse_prop]))
+              frame(state, [r_id], subframe, parent: output['@reverse'][reverse_prop], property: property, **options)
             end
           end
         end

Diff for: lib/json/ld/resource.rb

@@ -76,7 +76,7 @@ def new?; !!@new; end
     # @option options [Boolean] :stub (false)
     #   This is a stand-in for another resource that has
     #   not yet been retrieved (or created) from Mongo
-    def initialize(node_definition, options = {})
+    def initialize(node_definition, **options)
       @context = options[:context]
       @clean = options.fetch(:clean, false)
       @new = options.fetch(:new, true)

Diff for: lib/json/ld/writer.rb

@@ -139,7 +139,7 @@ def self.options
     # @yieldreturn [void]
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
-    def initialize(output = $stdout, options = {}, &block)
+    def initialize(output = $stdout, **options, &block)
       options[:base_uri] ||= options[:base] if options.has_key?(:base)
       options[:base] ||= options[:base_uri] if options.has_key?(:base_uri)
       super do

Diff for: script/parse

@@ -17,7 +17,7 @@ def run(input, options)
     output_dir = File.expand_path("../../doc/profiles/#{File.basename __FILE__, ".rb"}", __FILE__)
     FileUtils.mkdir_p(output_dir)
     result = RubyProf.profile do
-      run(input, options.merge(profile: false))
+      run(input, profile: false, **options)
     end
     result.eliminate_methods!([/Hash#each/, /JSON::LD::Utils#debug/, /Array#map/, /JSON::LD::Utils#depth/])
     # Print a graph profile to text

Diff for: spec/from_rdf_spec.rb

@@ -398,17 +398,17 @@
     end
   end
 
-  def parse(input, options = {})
+  def parse(input, **options)
     reader = options[:reader] || RDF::TriG::Reader
     reader.new(input, options, &:each_statement).to_a.extend(RDF::Enumerable)
   end
 
   # Serialize ntstr to a string and compare against regexps
-  def serialize(ntstr, options = {})
+  def serialize(ntstr, **options)
     logger.info ntstr if ntstr.is_a?(String)
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
     logger.info g.dump(:trig)
     statements = g.each_statement.to_a
-    JSON::LD::API.fromRdf(statements, options.merge(logger: logger))
+    JSON::LD::API.fromRdf(statements, logger: logger, **options)
   end
 end

Diff for: spec/streaming_writer_spec.rb

@@ -50,10 +50,10 @@
       )
       obj = serialize(input)
       expect(parse(obj.to_json, format: :jsonld)).to be_equivalent_graph(parse(input), logger: logger)
-      expect(obj).to contain_exactly *JSON.parse(%{[
+      expect(obj).to contain_exactly(*JSON.parse(%{[
         {"@id": "http://example.com/test-cases/0001", "@type": ["http://www.w3.org/2006/03/test-description#TestCase"]},
         {"@id": "http://example.com/test-cases/0002", "@type": ["http://www.w3.org/2006/03/test-description#TestCase"]}
-      ]})
+      ]}))
     end
   end
 
@@ -91,7 +91,7 @@
       context title do
         subject {serialize(input)}
         it "matches expected json" do
-          expect(subject).to contain_exactly *JSON.parse(matches)
+          expect(subject).to contain_exactly(*JSON.parse(matches))
         end
       end
     end
@@ -125,18 +125,17 @@
     end
   end unless ENV['CI']
 
-  def parse(input, options = {})
-    format = options.fetch(:format, :trig)
+  def parse(input, format: :trig, **options)
     reader = RDF::Reader.for(format)
     RDF::Repository.new << reader.new(input, options)
   end
 
   # Serialize ntstr to a string and compare against regexps
-  def serialize(ntstr, options = {})
+  def serialize(ntstr, **options)
     g = ntstr.is_a?(String) ? parse(ntstr, options) : ntstr
     logger = RDF::Spec.logger
     logger.info(g.dump(:ttl))
-    result = JSON::LD::Writer.buffer(options.merge(logger: logger, stream: true)) do |writer|
+    result = JSON::LD::Writer.buffer(logger: logger, stream: true, **options) do |writer|
       writer << g
     end
     puts result if $verbose