yard 0.9.5 → 0.9.6

data/spec/parser/ruby/token_resolver_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe YARD::Parser::Ruby::TokenResolver do
+  before(:all) do
+    YARD.parse_string <<-eof
+      module A
+        def nomatch; end
+
+        module B
+          class C
+            def initialize; end
+
+            # @return [A::B::C]
+            def self.foo; end
+
+            # @return [self]
+            def self.foo2; end
+
+            def bar; end
+
+            # @return [nil, D<String>]
+            def baz; end
+
+            # @return [nil]
+            # @return [D<String>]
+            def baz2; end
+
+            # @overload qux(a)
+            #   @return [nil]
+            # @overload qux(b)
+            #   @return [D<String>]
+            def qux; end
+          end
+
+          class SubC < C
+          end
+        end
+      end
+
+      module D
+        def baz; end
+      end
+
+      class Q
+        def method; end
+
+        # @return [Q]
+        def self.q; end
+      end
+    eof
+  end
+
+  def tokens_match
+    expect(@resolved.map {|t| t.first.last }.join).to eq @src
+  end
+
+  def objs_match(*objects)
+    other_objs = @resolved.reject {|_, o| !o }.map {|_, o| o.path }
+    expect(other_objs).to eq objects.flatten
+    tokens_match
+  end
+
+  def tokenize(src, object = nil)
+    @src = src
+    @resolver = YARD::Parser::Ruby::TokenResolver.new(src, object)
+    @resolved = @resolver.map {|t, o| [t[0, 2], o] }
+  end
+
+  it "returns regular tokens" do
+    str = "def foo; Z::X::Y end"
+    tokenize(str)
+    tokens_match
+  end
+
+  it "resolves objects in compound constant paths" do
+    tokenize "A::B::C"
+    objs_match "A", "A::B", "A::B::C"
+  end
+
+  it "ignores full constant path if it breaks at beginning" do
+    tokenize "E::A::B::C"
+    objs_match []
+  end
+
+  it "ignores rest of constant path if sub-objects don't match" do
+    tokenize "D::A::B::C"
+    objs_match "D"
+  end
+
+  it "resets parsing at non-op tokens" do
+    tokenize "A::B::C < Q"
+    objs_match "A", "A::B", "A::B::C", "Q"
+  end
+
+  it "does not restart constant path" do
+    tokenize "A::B::D::A"
+    objs_match "A", "A::B"
+  end
+
+  it "resolves objects from base namespace" do
+    tokenize "A::B::C C", Registry.at("A::B")
+    objs_match "A", "A::B", "A::B::C", "A::B::C"
+  end
+
+  it "resolves methods" do
+    tokenize "A::B::C.foo"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo"
+  end
+
+  it "supports 'new' constructor method" do
+    tokenize "A::B::C.new"
+    objs_match "A", "A::B", "A::B::C", "A::B::C#initialize"
+  end
+
+  it "skips constructor method if not found but continues resolving" do
+    tokenize "Q.new.method"
+    objs_match "Q", "Q#method"
+  end
+
+  it "resolves methods in inheritance tree" do
+    tokenize "A::B::SubC.new"
+    objs_match "A", "A::B", "A::B::SubC", "A::B::C#initialize"
+  end
+
+  it "parses compound method call chains based on return type" do
+    tokenize "A::B::C.foo.baz"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo", "A::B::C#baz"
+  end
+
+  it "stops resolving if return types not found" do
+    tokenize "A::B::C.foo.bar.baz.baz"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo", "A::B::C#bar"
+  end
+
+  it "handles multiple return types (returns first valid type match)" do
+    tokenize "A::B::C.foo.baz.baz"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo", "A::B::C#baz", "D#baz"
+  end
+
+  it "doesn't perform lexical matching on methods" do
+    tokenize "A::B::C.nomatch"
+    objs_match "A", "A::B", "A::B::C"
+  end
+
+  it "handles multiple return tags (returns first valid type match)" do
+    tokenize "A::B::C.foo.baz2.baz"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo", "A::B::C#baz2", "D#baz"
+  end
+
+  it "handles self as return type" do
+    tokenize "A::B::C.foo2.baz"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo2", "A::B::C#baz"
+  end
+
+  it "handles multiple return tags inside overload tags" do
+    tokenize "A::B::C.foo.qux.baz"
+    objs_match "A", "A::B", "A::B::C", "A::B::C.foo", "A::B::C#qux", "D#baz"
+  end
+
+  it "resolves method calls with arguments" do
+    tokenize "Q.q(A::B, A::B::C.foo().bar).q.q"
+    objs_match "Q", "Q.q", "A", "A::B", "A", "A::B", "A::B::C",
+               "A::B::C.foo", "A::B::C#bar", "Q.q", "Q.q"
+  end
+end if HAVE_RIPPER

data/spec/parser/source_parser_spec.rb

@@ -1,15 +1,15 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+# frozen_string_literal: true
 
 class MyParser < Parser::Base; end
 
-shared_examples_for "parser type registration" do
+RSpec.shared_examples_for "parser type registration" do
   after do
     Parser::SourceParser.parser_types.delete(:my_parser)
     Parser::SourceParser.parser_type_extensions.delete(:my_parser)
   end
 end
 
-describe YARD::Parser::SourceParser do
+RSpec.describe YARD::Parser::SourceParser do
   before do
     Registry.clear
   end
@@ -84,10 +84,10 @@ describe YARD::Parser::SourceParser do
     end
 
     it "passes in globals" do
-      before_list {|f,g| g.x = 1 }
-      before_list {|f,g| g.x += 1 }
-      before_list {|f,g| g.x += 1 }
-      after_list {|f,g| expect(g.x).to eq 3 }
+      before_list {|_f, g| g.x = 1 }
+      before_list {|_f, g| g.x += 1 }
+      before_list {|_f, g| g.x += 1 }
+      after_list {|_f, g| expect(g.x).to eq 3 }
       parse_list ['file.rb', ''], ['file2.rb', ''], ['file3.rb', 'class Foo; end']
       expect(Registry.at('Foo')).not_to be nil
     end
@@ -100,7 +100,7 @@ describe YARD::Parser::SourceParser do
     end
 
     it "handles basic callback support and maintain files/globals" do
-      before_list do |f,g| g.foo = :bar end
+      before_list {|_f, g| g.foo = :bar }
       after_list do |files, globals|
         expect(files).to eq ['foo.rb', 'bar.rb']
         expect(globals.foo).to eq :bar
@@ -138,7 +138,7 @@ describe YARD::Parser::SourceParser do
     it "handles basic callback support" do
       before_file do |parser|
         expect(parser.contents).to eq 'class Foo; end'
-        expect(parser.file).to match /(foo|bar)\.rb/
+        expect(parser.file).to match(/(foo|bar)\.rb/)
       end
       parse_list ['foo.rb', 'class Foo; end'], ['bar.rb', 'class Foo; end']
       expect(Registry.at('Foo')).not_to be nil
@@ -183,7 +183,7 @@ describe YARD::Parser::SourceParser do
     it "handles basic callback support" do
       after_file do |parser|
         expect(parser.contents).to eq 'class Foo; end'
-        expect(parser.file).to match /(foo|bar)\.rb/
+        expect(parser.file).to match(/(foo|bar)\.rb/)
       end
       parse_list ['foo.rb', 'class Foo; end'], ['bar.rb', 'class Foo; end']
       expect(Registry.at('Foo')).not_to be nil
@@ -270,7 +270,7 @@ describe YARD::Parser::SourceParser do
       expect(Registry.at(:Hello)).not_to eq nil
       expect(Registry.at("Hello::Hi#me")).not_to eq nil
       expect(Registry.at("Hello::Hi#me").docstring).to eq "Docstring\nDocstring2"
-      expect(Registry.at("Hello::Hi#me").docstring.line_range).to eq (3..4)
+      expect(Registry.at("Hello::Hi#me").docstring.line_range).to eq(3..4)
     end
 
     it "parses Ruby code with metaclasses" do
@@ -551,8 +551,8 @@ describe YARD::Parser::SourceParser do
               default_encoding = 'UTF-8'
               expect(result.enumerator[0].source.encoding.to_s).to eq(default_encoding)
             else
-              expect(['Shift_JIS', 'Windows-31J', 'UTF-8']).send(msg, include(
-                result.enumerator[0].source.encoding.to_s))
+              expect(['Shift_JIS', 'Windows-31J', 'UTF-8']).send(msg,
+                include(result.enumerator[0].source.encoding.to_s))
             end
           end
           expect(result.encoding_line).send(msg, eq(src.split("\n").last))
@@ -582,7 +582,7 @@ describe YARD::Parser::SourceParser do
     Parser::SourceParser::ENCODING_BYTE_ORDER_MARKS.each do |encoding, bom|
       it "understands #{encoding.upcase} BOM" do
         parser = Parser::SourceParser.new
-        src = bom + "class FooBar; end".force_encoding('binary')
+        src = bom + String.new("class FooBar; end").force_encoding('binary')
         src.force_encoding('binary')
         expect(File).to receive(:read_binary).with('tmpfile').and_return(src)
         result = parser.parse('tmpfile')
@@ -604,10 +604,10 @@ describe YARD::Parser::SourceParser do
         expect(log).to receive(:debug) {|m| msgs << m }.at_least(:once)
         allow(log).to receive(:<<)
         in_order_parse 'parse_in_order_001', 'parse_in_order_002'
-        expect(msgs[1]).to match /Parsing .+parse_in_order_001.+/
-        expect(msgs[2]).to match /Missing object MyModule/
-        expect(msgs[3]).to match /Parsing .+parse_in_order_002.+/
-        expect(msgs[4]).to match /Re-processing .+parse_in_order_001.+/
+        expect(msgs[1]).to match(/Parsing .+parse_in_order_001.+/)
+        expect(msgs[2]).to match(/Missing object MyModule/)
+        expect(msgs[3]).to match(/Parsing .+parse_in_order_002.+/)
+        expect(msgs[4]).to match(/Re-processing .+parse_in_order_001.+/)
       end
     end
 

data/spec/parser/tag_parsing_spec.rb

@@ -1,6 +1,6 @@
-require File.join(File.dirname(__FILE__), '..', 'spec_helper')
+# frozen_string_literal: true
 
-describe YARD::Parser, "tag handling" do
+RSpec.describe YARD::Parser, "tag handling" do
   before { parse_file :tag_handler_001, __FILE__ }
 
   it "knows the list of all available tags" do

data/spec/rake/yardoc_task_spec.rb

@@ -1,6 +1,6 @@
-require File.dirname(__FILE__) + '/../spec_helper'
+# frozen_string_literal: true
 
-describe YARD::Rake::YardocTask do
+RSpec.describe YARD::Rake::YardocTask do
   before do
     @yardoc = YARD::CLI::Yardoc.new
     @yardoc.statistics = false
@@ -75,7 +75,7 @@ describe YARD::Rake::YardocTask do
 
   describe "#before" do
     it "allows before callback" do
-      proc = lambda { }
+      proc = lambda {}
       expect(proc).to receive(:call)
       expect(@yardoc).to receive(:run)
       YARD::Rake::YardocTask.new {|t| t.before = proc }
@@ -85,7 +85,7 @@ describe YARD::Rake::YardocTask do
 
   describe "#after" do
     it "allows after callback" do
-      proc = lambda { }
+      proc = lambda {}
       expect(proc).to receive(:call)
       expect(@yardoc).to receive(:run)
       YARD::Rake::YardocTask.new {|t| t.after = proc }

data/spec/registry_spec.rb

@@ -1,9 +1,9 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
+# frozen_string_literal: true
 include CodeObjects
 
 require "thread"
 
-describe YARD::Registry do
+RSpec.describe YARD::Registry do
   before { Registry.clear }
 
   describe ".yardoc_file_for_gem" do
@@ -17,67 +17,69 @@ describe YARD::Registry do
     end
 
     it "returns nil if gem isn't found" do
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([])
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([])
       expect(Registry.yardoc_file_for_gem('foo')).to eq nil
     end
 
     it "allows version to be specified" do
-      expect(Gem.source_index).to receive(:find_name).with('foo', '= 2').and_return([])
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '= 2').and_return([])
       expect(Registry.yardoc_file_for_gem('foo', '= 2')).to eq nil
     end
 
     it "returns existing .yardoc path for gem when for_writing=false" do
-      expect(File).to receive(:exist?).twice.and_return(false)
-      expect(File).to receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).twice.and_return(false)
+      allow(File).to receive(:exist?).with('/path/to/foo/.yardoc').and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo')).to eq '/path/to/foo/.yardoc'
     end
 
     it "returns new existing .yardoc path for gem when for_writing=false" do
-      expect(File).to receive(:exist?).once.and_return(false)
-      expect(File).to receive(:exist?).with('/path/to/foo/doc/.yardoc').and_return(true)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).and_return(false)
+      allow(File).to receive(:exist?).with('/path/to/foo/doc/.yardoc').and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo')).to eq '/path/to/foo/doc/.yardoc'
     end
 
     it "returns nil if no .yardoc path exists in gem when for_writing=false" do
-      expect(File).to receive(:exist?).twice.and_return(false)
-      expect(File).to receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).twice.and_return(false)
+      allow(File).to receive(:exist?).with('/path/to/foo/.yardoc').and_return(false)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo')).to eq nil
     end
 
     it "searches local gem path first if for_writing=false" do
-      expect(File).to receive(:exist?).and_return(true)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo')).to match %r{/.yard/gem_index/foo-1.0.yardoc$}
     end
 
     it "returns global .yardoc path for gem if for_writing=true and dir is writable" do
-      expect(File).to receive(:writable?).with(@gem.doc_dir).and_return(false)
-      expect(File).to receive(:writable?).with(@gem.full_gem_path).and_return(true)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).and_return(false)
+      allow(File).to receive(:directory?).with(@gem.doc_dir).and_return(true)
+      allow(File).to receive(:writable?).with(@gem.doc_dir).and_return(false)
+      allow(File).to receive(:writable?).with(@gem.full_gem_path).and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo', '>= 0', true)).to eq '/path/to/foo/.yardoc'
     end
 
     it "returns new global .yardoc path for gem if for_writing=true and dir is writable" do
-      expect(File).to receive(:writable?).with(@gem.doc_dir).and_return(true)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:writable?).with(@gem.doc_dir).and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo', '>= 0', true)).to eq '/path/to/foo/doc/.yardoc'
     end
 
     it "returns new global .yardoc path for gem if for_writing=true and parent dir is writable (but dir does not exist)" do
-      expect(File).to receive(:writable?).with(@gem.doc_dir).and_return(false)
-      expect(File).to receive(:directory?).with(@gem.doc_dir).and_return(false)
-      expect(File).to receive(:writable?).with(File.dirname(@gem.doc_dir)).and_return(true)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:writable?).with(@gem.doc_dir).and_return(false)
+      allow(File).to receive(:directory?).with(@gem.doc_dir).and_return(false)
+      allow(File).to receive(:writable?).with(File.dirname(@gem.doc_dir)).and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo', '>= 0', true)).to eq '/path/to/foo/doc/.yardoc'
     end
 
     it "returns local .yardoc path for gem if for_writing=true and dir is not writable" do
-      expect(File).to receive(:writable?).with(@gem.doc_dir).and_return(false)
-      expect(File).to receive(:writable?).with(@gem.full_gem_path).and_return(false)
-      expect(Gem.source_index).to receive(:find_name).with('foo', '>= 0').and_return([@gem])
+      allow(File).to receive(:writable?).with(@gem.doc_dir).and_return(false)
+      allow(File).to receive(:writable?).with(@gem.full_gem_path).and_return(false)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('foo', '>= 0').and_return([@gem])
       expect(Registry.yardoc_file_for_gem('foo', '>= 0', true)).to match %r{/.yard/gem_index/foo-1.0.yardoc$}
     end
 
@@ -85,8 +87,8 @@ describe YARD::Registry do
       allow(@gem).to receive(:name).and_return('yard-doc-core')
       allow(@gem).to receive(:full_name).and_return('yard-doc-core-1.0')
       allow(@gem).to receive(:full_gem_path).and_return('/path/to/yard-doc-core')
-      expect(Gem.source_index).to receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
-      expect(File).to receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
       expect(Registry.yardoc_file_for_gem('yard-doc-core')).to eq '/path/to/yard-doc-core/.yardoc'
     end
 
@@ -94,8 +96,8 @@ describe YARD::Registry do
       allow(@gem).to receive(:name).and_return('yard-doc-core')
       allow(@gem).to receive(:full_name).and_return('yard-doc-core-1.0')
       allow(@gem).to receive(:full_gem_path).and_return('/path/to/yard-doc-core')
-      expect(Gem.source_index).to receive(:find_name).with('yard-doc-core', '>= 0').and_return([@gem])
-      expect(File).to receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
+      allow(YARD::GemIndex).to receive(:find_all_by_name).with('yard-doc-core', '>= 0').and_return([@gem])
+      allow(File).to receive(:exist?).with('/path/to/yard-doc-core/.yardoc').and_return(true)
       expect(Registry.yardoc_file_for_gem('yard-doc-core', '>= 0', true)).to eq nil
     end
   end
@@ -211,6 +213,21 @@ describe YARD::Registry do
       expect(Registry.resolve(P('MyObject'), '#foo', true)).to eq P('BasicObject#foo')
     end
 
+    it "does not perform lexical lookup to resolve a method object by more than one namespace" do
+      YARD.parse_string <<-eof
+        module A
+          def foo; end
+          def self.bar; end
+          module B; module C; end end
+        end
+      eof
+
+      expect(Registry.resolve(P('A::B::C'), '#foo', true)).to be nil
+      expect(Registry.resolve(P('A::B::C'), '.bar', true)).to be nil
+      expect(Registry.resolve(P('A::B'), '#foo', true)).not_to be nil
+      expect(Registry.resolve(P('A::B'), '.bar', true)).not_to be nil
+    end
+
     it "does not resolve methods in Object if inheriting BasicObject when inheritance = true" do
       YARD.parse_string <<-eof
         class Object; def foo; end end
@@ -249,7 +266,8 @@ describe YARD::Registry do
       eof
       expect(Registry.resolve(P('Foo'), 'Bar', false, false, :class)).to eq Registry.at('Foo::Bar')
       expect(Registry.resolve(P('Foo'), 'Bar', false, false, :method)).to eq(
-        Registry.at('Foo.Bar'))
+        Registry.at('Foo.Bar')
+      )
     end
 
     it "returns proxy fallback with given type if supplied" do
@@ -299,8 +317,8 @@ describe YARD::Registry do
 
   describe ".paths" do
     it "returns all object paths" do
-      o1 = ModuleObject.new(:root, :A)
-      o2 = ClassObject.new(:root, :B)
+      ModuleObject.new(:root, :A)
+      ClassObject.new(:root, :B)
       expect(Registry.paths).to include('A', 'B')
     end
   end
@@ -323,7 +341,7 @@ describe YARD::Registry do
       Registry.load!(File.dirname(__FILE__) + '/serializers/data/serialized_yardoc')
       baz = Registry.at('Foo#baz')
       expect(Registry.at('Foo').aliases.keys).to include(baz)
-      expect(Registry.at('Foo').aliases.has_key?(baz)).to be true
+      expect(Registry.at('Foo').aliases.key?(baz)).to be true
     end
   end
 
@@ -375,21 +393,17 @@ describe YARD::Registry do
         Registry.clear
         YARD.parse_string "# docstring 1\nclass Foo; end"
         mutex.synchronize { barrier += 1 }
-        while barrier < 2 do
-          s = "barrier < 2, spinning"
-        end
+        "barrier < 2, spinning" while barrier < 2
         expect(Registry.at('Foo').docstring).to eq "docstring 1"
       end
       threads << Thread.new do
         Registry.clear
         YARD.parse_string "# docstring 2\nclass Foo; end"
         mutex.synchronize { barrier += 1 }
-        while barrier < 2 do
-          s = "barrier < 2, spinning"
-        end
+        "barrier < 2, spinning" while barrier < 2
         expect(Registry.at('Foo').docstring).to eq "docstring 2"
       end
-      threads.each {|t| t.join }
+      threads.each(&:join)
     end
 
     it "allows setting of yardoc_file in separate threads" do
@@ -400,20 +414,16 @@ describe YARD::Registry do
         expect(Registry.yardoc_file).to eq '.yardoc'
         Registry.yardoc_file = 'foo'
         mutex.synchronize { barrier += 1 }
-        while barrier == 1 do
-          s = "barrier = 1, spinning"
-        end
+        "barrier = 1, spinning" while barrier == 1
         expect(Registry.yardoc_file).to eq 'foo'
       end
       threads << Thread.new do
-        while barrier == 0 do
-          s = "barrier = 0, spinning"
-        end
+        "barrier = 0, spinning" while barrier == 0
         expect(Registry.yardoc_file).to eq '.yardoc'
         mutex.synchronize { barrier += 1 }
         Registry.yardoc_file = 'foo2'
       end
-      threads.each {|t| t.join }
+      threads.each(&:join)
       Registry.yardoc_file = Registry::DEFAULT_YARDOC_FILE
     end
 
@@ -429,20 +439,16 @@ describe YARD::Registry do
         expect(Registry.po_dir).to eq 'po'
         Registry.po_dir = 'locale'
         mutex.synchronize { barrier += 1 }
-        while barrier == 1 do
-          s = "barrier = 1, spinning"
-        end
+        "barrier = 1, spinning" while barrier == 1
         expect(Registry.po_dir).to eq 'locale'
       end
       threads << Thread.new do
-        while barrier == 0 do
-          s = "barrier = 0, spinning"
-        end
+        "barrier = 0, spinning" while barrier == 0
         expect(Registry.po_dir).to eq 'po'
         mutex.synchronize { barrier += 1 }
         Registry.po_dir = '.'
       end
-      threads.each {|t| t.join }
+      threads.each(&:join)
       Registry.po_dir = Registry::DEFAULT_PO_DIR
     end
   end