Modernize hashes with symbol keys to trailing colon style.

Author: gkellogg

Gemfile

@@ -2,7 +2,7 @@ source "http://rubygems.org"
 
 gemspec
 
-gem "rdf", :git => "git://github.com/ruby-rdf/rdf.git", :branch => "develop"
+gem "rdf", git: "git://github.com/ruby-rdf/rdf.git", branch: "develop"
 
 group :development do
   gem "wirble"

Rakefile

@@ -16,7 +16,7 @@ namespace :gem do
 end
 
 desc "Build etc files"
-task :etc => %w(etc/triples.nt etc/quads.nq)
+task etc: %w(etc/triples.nt etc/quads.nq)
 
 desc "Clean etc files"
 task :clean do

lib/rdf/spec/format.rb

@@ -17,17 +17,17 @@
       end
 
       it "detects #{formats.first} using file_name foo.#{ext}" do
-        expect(RDF::Format.for(:file_name => "foo.#{ext}")).to eq formats.first
+        expect(RDF::Format.for(file_name: "foo.#{ext}")).to eq formats.first
       end
 
       it "detects #{formats.first} using file_extension #{ext}" do
-        expect(RDF::Format.for(:file_extension => ext)).to eq formats.first
+        expect(RDF::Format.for(file_extension: ext)).to eq formats.first
       end
     end
 
     RDF::Format.content_types.each do |content_type, formats|
       it "detects #{formats.first} using content_type #{content_type}" do
-        expect(RDF::Format.for(:content_type => content_type)).to eq formats.first
+        expect(RDF::Format.for(content_type: content_type)).to eq formats.first
       end
     end
   end

lib/rdf/spec/literal.rb

@@ -69,7 +69,7 @@
 shared_examples 'RDF::Literal lookup' do |uri_hash|
   uri_hash.each do |uri, klass|
     it "finds #{klass} for #{uri}" do
-      expect(RDF::Literal("0", :datatype => uri).class).to eq klass
+      expect(RDF::Literal("0", datatype: uri).class).to eq klass
     end
   end
 end

lib/rdf/spec/reader.rb

@@ -29,7 +29,7 @@
         f.file_extensions.each_pair do |sym, content_type|
           reader_mock = double("reader")
           expect(reader_mock).to receive(:got_here)
-          expect(reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(reader_class)
+          expect(reader_class).to receive(:for).with(file_name: "foo.#{sym}").and_return(reader_class)
           reader_class.open("foo.#{sym}") do |r|
             expect(r).to be_a(RDF::Reader)
             reader_mock.got_here
@@ -44,34 +44,34 @@
         reader_mock = double("reader")
         expect(reader_mock).to receive(:got_here)
         expect(reader_class).to receive(:for).with(sym).and_return(reader_class)
-        reader_class.open("foo.#{sym}", :format => sym) do |r|
+        reader_class.open("foo.#{sym}", format: sym) do |r|
           expect(r).to be_a(RDF::Reader)
           reader_mock.got_here
         end
       end
     end
 
-    it "yields reader given {:file_name => file_name}" do
+    it "yields reader given {file_name: file_name}" do
       reader_class.format.each do |f|
         f.file_extensions.each_pair do |sym, content_type|
           reader_mock = double("reader")
           expect(reader_mock).to receive(:got_here)
-          expect(reader_class).to receive(:for).with(:file_name => "foo.#{sym}").and_return(reader_class)
-          reader_class.open("foo.#{sym}", :file_name => "foo.#{sym}") do |r|
+          expect(reader_class).to receive(:for).with(file_name: "foo.#{sym}").and_return(reader_class)
+          reader_class.open("foo.#{sym}", file_name: "foo.#{sym}") do |r|
             expect(r).to be_a(RDF::Reader)
             reader_mock.got_here
           end
         end
       end
     end
 
-    it "yields reader given {:content_type => 'a/b'}" do
+    it "yields reader given {content_type: 'a/b'}" do
       reader_class.format.each do |f|
         f.content_types.each_pair do |content_type, formats|
           reader_mock = double("reader")
           expect(reader_mock).to receive(:got_here)
-          expect(reader_class).to receive(:for).with(:content_type => content_type, :file_name => "foo").and_return(reader_class)
-          reader_class.open("foo", :content_type => content_type) do |r|
+          expect(reader_class).to receive(:for).with(content_type: content_type, file_name: "foo").and_return(reader_class)
+          reader_class.open("foo", content_type: content_type) do |r|
             expect(r).to be_a(RDF::Reader)
             reader_mock.got_here
           end
@@ -107,44 +107,44 @@
       end
     end
 
-    it "sets validate given :validate => true" do
-      reader_class.new(reader_input, :validate => true) do |r|
+    it "sets validate given validate: true" do
+      reader_class.new(reader_input, validate: true) do |r|
         expect(r).to be_valid
       end
     end
 
-    it "sets canonicalize given :canonicalize => true" do
+    it "sets canonicalize given canonicalize: true" do
       reader_mock = double("reader")
       expect(reader_mock).to receive(:got_here)
-      reader_class.new(reader_input, :canonicalize => true) do |r|
+      reader_class.new(reader_input, canonicalize: true) do |r|
         reader_mock.got_here
         expect(r).to be_canonicalize
       end
     end
 
-    it "sets intern given :intern => true" do
+    it "sets intern given intern: true" do
       reader_mock = double("reader")
       expect(reader_mock).to receive(:got_here)
-      reader_class.new(reader_input, :intern => true) do |r|
+      reader_class.new(reader_input, intern: true) do |r|
         reader_mock.got_here
         expect(r).to be_intern
       end
     end
 
-    it "sets prefixes given :prefixes => {}" do
+    it "sets prefixes given prefixes: {}" do
       reader_mock = double("reader")
       expect(reader_mock).to receive(:got_here)
-      reader_class.new(reader_input, :prefixes => {:a => "b"}) do |r|
+      reader_class.new(reader_input, prefixes: {a: "b"}) do |r|
         reader_mock.got_here
-        expect(r.prefixes).to eq({:a => "b"})
+        expect(r.prefixes).to eq({a: "b"})
       end
     end
   end
 
   describe "#prefixes=" do
     it "sets prefixes from hash" do
-      reader.prefixes = {:a => "b"}
-      expect(reader.prefixes).to eq({:a => "b"})
+      reader.prefixes = {a: "b"}
+      expect(reader.prefixes).to eq({a: "b"})
     end
   end
 

lib/rdf/spec/transaction.rb

@@ -12,41 +12,41 @@
     subject {klass}
     it "accepts a graph" do
       g = double("graph")
-      this = subject.new(:graph => g)
+      this = subject.new(graph: g)
       expect(this.graph).to eq g
     end
 
     it "accepts a context", unless: RDF::VERSION.to_s >= "1.99" do
       c = double("context")
-      this = subject.new(:graph => c)
+      this = subject.new(graph: c)
       expect(this.graph).to eq c
       expect(this.context).to eq c
 
-      this = subject.new(:context => c)
+      this = subject.new(context: c)
       expect(this.graph).to eq c
       expect(this.context).to eq c
     end
 
     it "accepts a graph_name", if: RDF::VERSION.to_s >= "1.99" do
       c = double("graph_name")
-      this = subject.new(:graph => c)
+      this = subject.new(graph: c)
       expect(this.graph).to eq c
       expect(this.graph_name).to eq c
 
-      this = subject.new(:graph_name => c)
+      this = subject.new(graph_name: c)
       expect(this.graph).to eq c
       expect(this.graph_name).to eq c
     end
 
     it "accepts inserts" do
       g = double("inserts")
-      this = subject.new(:insert => g)
+      this = subject.new(insert: g)
       expect(this.inserts).to eq g
     end
 
     it "accepts deletes" do
       g = double("deletes")
-      this = subject.new(:delete => g)
+      this = subject.new(delete: g)
       expect(this.deletes).to eq g
     end
   end

lib/rdf/spec/writer.rb

@@ -44,7 +44,7 @@
         f.file_extensions.each_pair do |sym, content_type|
           writer_mock = double("writer")
           expect(writer_mock).to receive(:got_here)
-          expect(writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(writer_class)
+          expect(writer_class).to receive(:for).with(file_name: "#{@basename}.#{sym}").and_return(writer_class)
           writer_class.open("#{@basename}.#{sym}") do |r|
             expect(r).to be_a(RDF::Writer)
             writer_mock.got_here
@@ -59,34 +59,34 @@
         writer_mock = double("writer")
         expect(writer_mock).to receive(:got_here)
         expect(writer_class).to receive(:for).with(sym).and_return(writer_class)
-        writer_class.open("#{@basename}.#{sym}", :format => sym) do |r|
+        writer_class.open("#{@basename}.#{sym}", format: sym) do |r|
           expect(r).to be_a(RDF::Writer)
           writer_mock.got_here
         end
       end
     end
 
-    it "yields writer given {:file_name => file_name}" do
+    it "yields writer given {file_name: file_name}" do
       writer_class.format.each do |f|
         f.file_extensions.each_pair do |sym, content_type|
           writer_mock = double("writer")
           expect(writer_mock).to receive(:got_here)
-          expect(writer_class).to receive(:for).with(:file_name => "#{@basename}.#{sym}").and_return(writer_class)
-          writer_class.open("#{@basename}.#{sym}", :file_name => "#{@basename}.#{sym}") do |r|
+          expect(writer_class).to receive(:for).with(file_name: "#{@basename}.#{sym}").and_return(writer_class)
+          writer_class.open("#{@basename}.#{sym}", file_name: "#{@basename}.#{sym}") do |r|
             expect(r).to be_a(RDF::Writer)
             writer_mock.got_here
           end
         end
       end
     end
 
-    it "yields writer given {:content_type => 'a/b'}" do
+    it "yields writer given {content_type: 'a/b'}" do
       writer_class.format.each do |f|
         f.content_types.each_pair do |content_type, formats|
           writer_mock = double("writer")
           expect(writer_mock).to receive(:got_here)
-          expect(writer_class).to receive(:for).with(:content_type => content_type, :file_name => @basename).and_return(writer_class)
-          writer_class.open(@basename, :content_type => content_type) do |r|
+          expect(writer_class).to receive(:for).with(content_type: content_type, file_name: @basename).and_return(writer_class)
+          writer_class.open(@basename, content_type: content_type) do |r|
             expect(r).to be_a(RDF::Writer)
             writer_mock.got_here
           end
@@ -125,12 +125,12 @@
       end
     end
 
-    it "sets prefixes given :prefixes => {}" do
+    it "sets prefixes given prefixes: {}" do
       writer_mock = double("writer")
       expect(writer_mock).to receive(:got_here)
-      writer_class.new(StringIO.new, :prefixes => {:a => "b"}) do |r|
+      writer_class.new(StringIO.new, prefixes: {a: "b"}) do |r|
         writer_mock.got_here
-        expect(r.prefixes).to eq({:a => "b"})
+        expect(r.prefixes).to eq({a: "b"})
       end
     end
 
@@ -155,8 +155,8 @@
 
   describe "#prefixes=" do
     it "sets prefixes from hash" do
-      writer.prefixes = {:a => "b"}
-      expect(writer.prefixes).to eq({:a => "b"})
+      writer.prefixes = {a: "b"}
+      expect(writer.prefixes).to eq({a: "b"})
     end
   end
 

spec/spec_helper.rb

@@ -5,9 +5,9 @@
 
 RSpec.configure do |config|
   config.include(RDF::Spec::Matchers)
-  config.filter_run :focus => true
+  config.filter_run focus: true
   config.run_all_when_everything_filtered = true
-  config.exclusion_filter = {:ruby => lambda { |version|
+  config.exclusion_filter = {ruby: lambda { |version|
     RUBY_VERSION.to_s !~ /^#{version}/
   }}
 end