spec/code_objects/proxy_spec.rb in yard-0.9.5 vs spec/code_objects/proxy_spec.rb in yard-0.9.6

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
 require File.dirname(__FILE__) + '/spec_helper'
 
-describe YARD::CodeObjects::Proxy do
+RSpec.describe YARD::CodeObjects::Proxy do
   before { Registry.clear }
 
   it "returns the object if it's in the Registry" do
-    pathobj = ModuleObject.new(:root, :YARD)
+    ModuleObject.new(:root, :YARD)
     proxyobj = P(:root, :YARD)
     expect(proxyobj.type).to eq :module
     expect(Proxy === proxyobj).to be false
   end
 
   it "handles complex string namespaces" do
     ModuleObject.new(:root, :A)
-    pathobj = ModuleObject.new(P(nil, :A), :B)
+    ModuleObject.new(P(nil, :A), :B)
     expect(P(:root, "A::B")).to be_instance_of(ModuleObject)
   end
 
   it "does not return true to Proxy === obj if obj is a Proxy class holding a resolved object" do
     expect(Proxy === P(:root, 'a')).to be true
@@ -31,12 +32,12 @@
     pathobj.instance_mixins << yardobj
     expect(P(P(nil, :TestClass), :YARD)).to be_instance_of(ModuleObject)
   end
 
   it "responds to respond_to?" do
-    obj = ClassObject.new(:root, :Object)
-    yardobj = ModuleObject.new(:root, :YARD)
+    ClassObject.new(:root, :Object)
+    ModuleObject.new(:root, :YARD)
     expect(P(:YARD).respond_to?(:children)).to be true
     expect(P(:NOTYARD).respond_to?(:children)).to be false
 
     expect(P(:YARD).respond_to?(:initialize)).to be false
     expect(P(:YARD).respond_to?(:initialize, true)).to be true
@@ -49,11 +50,11 @@
     expect(pathobj.class).to eq Proxy
     expect(Proxy === pathobj).to be true
   end
 
   it "pretends it's the object's type if it can resolve" do
-    pathobj = ModuleObject.new(:root, :YARD)
+    ModuleObject.new(:root, :YARD)
     proxyobj = P(:root, :YARD)
     expect(proxyobj).to be_instance_of(ModuleObject)
   end
 
   it "handles instance method names" do
@@ -115,17 +116,17 @@
   end
 
   it "ensures that the correct object was resolved" do
     foo = ModuleObject.new(:root, :Foo)
     foobar = ModuleObject.new(foo, :Bar)
-    foobaz = ClassObject.new(foo, :Baz)
+    ClassObject.new(foo, :Baz)
 
     # Remember, we're looking for Qux::Bar, not just 'Bar'
     proxy = Proxy.new(foobar, 'Foo::Qux::Bar')
     expect(proxy.type).to eq :proxy
 
     qux = ModuleObject.new(foo, :Qux)
-    quxbar = ModuleObject.new(qux, :Bar)
+    ModuleObject.new(qux, :Bar)
 
     # Now it should resolve
     expect(proxy.type).to eq :module
   end