Change most use of %w to %i and arrays of strings mapped to symbols to use %i.

Author: gkellogg

lib/rdf/model/dataset.rb

@@ -104,7 +104,7 @@ def isolation_level
     # @private
     # @see RDF::Enumerable#supports?
     def supports?(feature)
-      return true if [:graph_name, :rdfstar].include?(feature)
+      return true if %i(graph_name rdfstar).include?(feature)
       super
     end
 

lib/rdf/model/uri.rb

@@ -226,12 +226,12 @@ def initialize(*args, validate: false, canonicalize: false, **options)
         @value.dup.force_encoding(Encoding::UTF_8) if @value.encoding != Encoding::UTF_8
         @value.freeze
       else
-        %w(
+        %i(
           scheme
           user password userinfo
           host port authority
           path query fragment
-        ).map(&:to_sym).each do |meth|
+        ).each do |meth|
           if options.key?(meth)
             self.send("#{meth}=".to_sym, options[meth])
           else
@@ -416,7 +416,7 @@ def canonicalize!
     # @see http://tools.ietf.org/html/rfc3986#section-5.2.2
     # @see http://tools.ietf.org/html/rfc3986#section-5.2.3
     def join(*uris)
-      joined_parts = object.dup.delete_if {|k, v| [:user, :password, :host, :port].include?(k)}
+      joined_parts = object.dup.delete_if {|k, v| %i(user password host port).include?(k)}
 
       uris.each do |uri|
         uri = RDF::URI.new(uri) unless uri.is_a?(RDF::URI)
@@ -580,7 +580,7 @@ def root
       else
         RDF::URI.new(
           **object.merge(path: '/').
-          keep_if {|k, v| [:scheme, :authority, :path].include?(k)})
+          keep_if {|k, v| %i(scheme authority path).include?(k)})
       end
     end
 
@@ -1123,7 +1123,7 @@ def authority
     # @param [String, #to_s] value
     # @return [RDF::URI] self
     def authority=(value)
-      object.delete_if {|k, v| [:user, :password, :host, :port, :userinfo].include?(k)}
+      object.delete_if {|k, v| %i(user password host port userinfo).include?(k)}
       object[:authority] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
       user; password; userinfo; host; port
       @value = nil
@@ -1153,7 +1153,7 @@ def userinfo
     # @param [String, #to_s] value
     # @return [RDF::URI] self
     def userinfo=(value)
-      object.delete_if {|k, v| [:user, :password, :authority].include?(k)}
+      object.delete_if {|k, v| %i(user password authority).include?(k)}
       object[:userinfo] = (value.to_s.dup.force_encoding(Encoding::UTF_8) if value)
       user; password; authority
       @value = nil

lib/rdf/query/pattern.rb

@@ -248,7 +248,7 @@ def variable_terms(name = nil)
     # @param [RDF::Statement] statement
     # @return [Array<RDF::Term>]
     def var_values(var, statement)
-      [:subject, :predicate, :object, :graph_name].map do |position|
+      %i(subject predicate object graph_name).map do |position|
         po = self.send(position)
         so = statement.send(position)
         po.var_values(var, so) if po.respond_to?(:var_values)

lib/rdf/util/logger.rb

@@ -285,7 +285,7 @@ def method_missing(method, *args)
 
       def respond_to_missing?(name, include_private = false)
         return true if 
-          [:fatal, :error, :warn, :info, :debug, :level, :sev_threshold]
+          %i(fatal error warn info debug level sev_threshold)
           .include?(name.to_sym)
         super
       end

spec/dataset_spec.rb

@@ -34,13 +34,13 @@
     end
 
     describe '#supports?' do
-      [:validity, :literal_equality, :graph_name].each do |key|
+      %i(validity literal_equality graph_name).each do |key|
         it "supports #{key}" do
           expect(subject.supports?(key)).to be true
         end
       end
 
-      [:inference, :skolemize].each do |key|
+      %i(inference skolemize).each do |key|
         it "does not support #{key}" do
           expect(subject.supports?(key)).to be false
         end

spec/format_spec.rb

@@ -103,7 +103,7 @@ def self.to_sym; :foo_bar; end
 
   describe ".reader_symbols" do
     it "returns symbols of available readers" do
-      [:ntriples, :nquads, :foo_bar].each do |sym|
+      %i(ntriples nquads foo_bar).each do |sym|
         expect(RDF::Format.reader_symbols).to include(sym)
       end
     end
@@ -131,10 +131,10 @@ def self.to_sym; :foo_bar; end
 
   describe ".writer_symbols" do
     it "returns symbols of available writers" do
-      [:ntriples, :nquads].each do |sym|
+      %i(ntriples nquads).each do |sym|
         expect(RDF::Format.writer_symbols).to include(sym)
       end
-      [:fooformat, :barformat].each do |sym|
+      %i(fooformat barformat).each do |sym|
         expect(RDF::Format.writer_symbols).not_to include(sym)
       end
     end

spec/mixin_queryable_spec.rb

@@ -14,7 +14,7 @@
       it "calls #query_pattern" do
         is_expected.to receive(:query_pattern)
         is_expected.not_to receive(:query_execute)
-        subject.query([:s, :p, :o]) {}
+        subject.query(%i(s p o)) {}
       end
       it "with array" do
         expect(subject.query([nil, RDF::Vocab::DOAP.developer, nil]).to_a).not_to be_empty
@@ -29,7 +29,7 @@
     end
 
     context "Querying for solutions from a BGP" do
-      let(:query) { query = RDF::Query.new {pattern [:s, :p, :o]} }
+      let(:query) { query = RDF::Query.new {pattern %i(s p o)} }
       it "calls #query_execute" do
         is_expected.to receive(:query_execute)
         is_expected.not_to receive(:query_pattern)

spec/model_literal_spec.rb

@@ -34,10 +34,10 @@ def self.literal(selector)
   def self.literals(*selector)
     selector.inject([]) do |ary, sel|
       ary += case sel
-      when :all_simple        then [:empty, :plain, :string].map {|s| literal(s)}
-      when :all_plain_lang    then [:empty_lang, :plain_lang].map {|s| literal(s)}
-      when :all_native        then [:false, :true, :int, :long, :decimal, :double, :time, :date, :datetime].map {|s| literal(s)}
-      when :all_invalid_lang  then [:wrong_lang, :unset_lang].map {|s| literal(s)}
+      when :all_simple        then %i(empty plain string).map {|s| literal(s)}
+      when :all_plain_lang    then %i(empty_lang plain_lang).map {|s| literal(s)}
+      when :all_native        then %i(false true int long decimal double time date datetime).map {|s| literal(s)}
+      when :all_invalid_lang  then %i(wrong_lang unset_lang).map {|s| literal(s)}
       when :all_plain         then literals(:all_simple, :all_plain_lang)
       else                         literals(:all_plain, :all_native)
       end