Fix Lint/ConstantDefinitionInBlock cop

.rubocop_todo.yml

@@ -106,19 +106,6 @@ Lint/AmbiguousOperatorPrecedence:
   Exclude:
     - 'config/initializers/rack_attack.rb'
 
-# Configuration parameters: AllowedMethods.
-# AllowedMethods: enums
-Lint/ConstantDefinitionInBlock:
-  Exclude:
-    - 'spec/controllers/api/base_controller_spec.rb'
-    - 'spec/controllers/application_controller_spec.rb'
-    - 'spec/controllers/concerns/accountable_concern_spec.rb'
-    - 'spec/controllers/concerns/signature_verification_spec.rb'
-    - 'spec/lib/activitypub/adapter_spec.rb'
-    - 'spec/lib/connection_pool/shared_connection_pool_spec.rb'
-    - 'spec/lib/connection_pool/shared_timed_stack_spec.rb'
-    - 'spec/models/concerns/remotable_spec.rb'
-
 # Configuration parameters: AllowComments, AllowEmptyLambdas.
 Lint/EmptyBlock:
   Exclude:

spec/controllers/api/base_controller_spec.rb

@@ -72,21 +72,19 @@ def error
   end
 
   describe 'error handling' do
-    ERRORS_WITH_CODES = {
+    before do
+      routes.draw { get 'error' => 'api/base#error' }
+    end
+
+    {
       ActiveRecord::RecordInvalid => 422,
       Mastodon::ValidationError => 422,
       ActiveRecord::RecordNotFound => 404,
       Mastodon::UnexpectedResponseError => 503,
       HTTP::Error => 503,
       OpenSSL::SSL::SSLError => 503,
       Mastodon::NotPermittedError => 403,
-    }
-
-    before do
-      routes.draw { get 'error' => 'api/base#error' }
-    end
-
-    ERRORS_WITH_CODES.each do |error, code|
+    }.each do |error, code|
       it "Handles error class of #{error}" do
         expect(FakeService).to receive(:new).and_raise(error)
 

spec/controllers/application_controller_spec.rb

@@ -223,14 +223,16 @@ def route_unprocessable_entity
   end
 
   describe 'cache_collection' do
-    class C < ApplicationController
-      public :cache_collection
+    subject do
+      Class.new(ApplicationController) do
+        public :cache_collection
+      end
     end
 
     shared_examples 'receives :with_includes' do |fabricator, klass|
       it 'uses raw if it is not an ActiveRecord::Relation' do
         record = Fabricate(fabricator)
-        expect(C.new.cache_collection([record], klass)).to eq [record]
+        expect(subject.new.cache_collection([record], klass)).to eq [record]
       end
     end
 
@@ -241,13 +243,13 @@ class C < ApplicationController
         record = Fabricate(fabricator)
         relation = klass.none
         allow(relation).to receive(:cache_ids).and_return([record])
-        expect(C.new.cache_collection(relation, klass)).to eq [record]
+        expect(subject.new.cache_collection(relation, klass)).to eq [record]
       end
     end
 
     it 'returns raw unless class responds to :with_includes' do
       raw = Object.new
-      expect(C.new.cache_collection(raw, Object)).to eq raw
+      expect(subject.new.cache_collection(raw, Object)).to eq raw
     end
 
     context 'Status' do

spec/controllers/concerns/accountable_concern_spec.rb

@@ -3,18 +3,20 @@
 require 'rails_helper'
 
 RSpec.describe AccountableConcern do
-  class Hoge
-    include AccountableConcern
-    attr_reader :current_account
+  let(:hoge_class) do
+    Class.new do
+      include AccountableConcern
+      attr_reader :current_account
 
-    def initialize(current_account)
-      @current_account = current_account
+      def initialize(current_account)
+        @current_account = current_account
+      end
     end
   end
 
   let(:user)   { Fabricate(:account) }
   let(:target) { Fabricate(:account) }
-  let(:hoge)   { Hoge.new(user) }
+  let(:hoge)   { hoge_class.new(user) }
 
   describe '#log_action' do
     it 'creates Admin::ActionLog' do

spec/controllers/concerns/signature_verification_spec.rb

@@ -3,14 +3,16 @@
 require 'rails_helper'
 
 describe ApplicationController, type: :controller do
-  class WrappedActor
-    attr_reader :wrapped_account
+  let(:wrapped_actor_class) do
+    Class.new do
+      attr_reader :wrapped_account
 
-    def initialize(wrapped_account)
-      @wrapped_account = wrapped_account
-    end
+      def initialize(wrapped_account)
+        @wrapped_account = wrapped_account
+      end
 
-    delegate :uri, :keypair, to: :wrapped_account
+      delegate :uri, :keypair, to: :wrapped_account
+    end
   end
 
   controller do
@@ -93,7 +95,7 @@ def signature_required
     end
 
     context 'with a valid actor that is not an Account' do
-      let(:actor) { WrappedActor.new(author) }
+      let(:actor) { wrapped_actor_class.new(author) }
 
       before do
         get :success

spec/lib/activitypub/adapter_spec.rb

@@ -3,43 +3,51 @@
 require 'rails_helper'
 
 RSpec.describe ActivityPub::Adapter do
-  class TestObject < ActiveModelSerializers::Model
-    attributes :foo
-  end
+  before do
+    test_object_class = Class.new(ActiveModelSerializers::Model) do
+      attributes :foo
+    end
+    stub_const('TestObject', test_object_class)
 
-  class TestWithBasicContextSerializer < ActivityPub::Serializer
-    attributes :foo
-  end
+    test_with_basic_context_serializer = Class.new(ActivityPub::Serializer) do
+      attributes :foo
+    end
+    stub_const('TestWithBasicContextSerializer', test_with_basic_context_serializer)
 
-  class TestWithNamedContextSerializer < ActivityPub::Serializer
-    context :security
-    attributes :foo
-  end
+    test_with_named_context_serializer = Class.new(ActivityPub::Serializer) do
+      context :security
+      attributes :foo
+    end
+    stub_const('TestWithNamedContextSerializer', test_with_named_context_serializer)
 
-  class TestWithNestedNamedContextSerializer < ActivityPub::Serializer
-    attributes :foo
+    test_with_nested_named_context_serializer = Class.new(ActivityPub::Serializer) do
+      attributes :foo
 
-    has_one :virtual_object, key: :baz, serializer: TestWithNamedContextSerializer
+      has_one :virtual_object, key: :baz, serializer: TestWithNamedContextSerializer
 
-    def virtual_object
-      object
+      def virtual_object
+        object
+      end
     end
-  end
+    stub_const('TestWithNestedNamedContextSerializer', test_with_nested_named_context_serializer)
 
-  class TestWithContextExtensionSerializer < ActivityPub::Serializer
-    context_extensions :sensitive
-    attributes :foo
-  end
+    test_with_context_extension_serializer = Class.new(ActivityPub::Serializer) do
+      context_extensions :sensitive
+      attributes :foo
+    end
+    stub_const('TestWithContextExtensionSerializer', test_with_context_extension_serializer)
 
-  class TestWithNestedContextExtensionSerializer < ActivityPub::Serializer
-    context_extensions :manually_approves_followers
-    attributes :foo
+    test_with_nested_context_extension_serializer = Class.new(ActivityPub::Serializer) do
+      context_extensions :manually_approves_followers
+      attributes :foo
 
-    has_one :virtual_object, key: :baz, serializer: TestWithContextExtensionSerializer
+      has_one :virtual_object, key: :baz, serializer: TestWithContextExtensionSerializer
 
-    def virtual_object
-      object
+      def virtual_object
+        object
+      end
     end
+    stub_const('TestWithNestedContextExtensionSerializer', test_with_nested_context_extension_serializer)
   end
 
   describe '#serializable_hash' do

spec/lib/connection_pool/shared_connection_pool_spec.rb

@@ -3,22 +3,24 @@
 require 'rails_helper'
 
 describe ConnectionPool::SharedConnectionPool do
-  class MiniConnection
-    attr_reader :site
+  subject { described_class.new(size: 5, timeout: 5) { |site| mini_connection_class.new(site) } }
 
-    def initialize(site)
-      @site = site
+  let(:mini_connection_class) do
+    Class.new do
+      attr_reader :site
+
+      def initialize(site)
+        @site = site
+      end
     end
   end
 
-  subject { described_class.new(size: 5, timeout: 5) { |site| MiniConnection.new(site) } }
-
   describe '#with' do
     it 'runs a block with a connection' do
       block_run = false
 
       subject.with('foo') do |connection|
-        expect(connection).to be_a MiniConnection
+        expect(connection).to be_a mini_connection_class
         block_run = true
       end
 

spec/lib/connection_pool/shared_timed_stack_spec.rb

@@ -3,30 +3,32 @@
 require 'rails_helper'
 
 describe ConnectionPool::SharedTimedStack do
-  class MiniConnection
-    attr_reader :site
+  subject { described_class.new(5) { |site| mini_connection_class.new(site) } }
 
-    def initialize(site)
-      @site = site
+  let(:mini_connection_class) do
+    Class.new do
+      attr_reader :site
+
+      def initialize(site)
+        @site = site
+      end
     end
   end
 
-  subject { described_class.new(5) { |site| MiniConnection.new(site) } }
-
   describe '#push' do
     it 'keeps the connection in the stack' do
-      subject.push(MiniConnection.new('foo'))
+      subject.push(mini_connection_class.new('foo'))
       expect(subject.size).to eq 1
     end
   end
 
   describe '#pop' do
     it 'returns a connection' do
-      expect(subject.pop('foo')).to be_a MiniConnection
+      expect(subject.pop('foo')).to be_a mini_connection_class
     end
 
     it 'returns the same connection that was pushed in' do
-      connection = MiniConnection.new('foo')
+      connection = mini_connection_class.new('foo')
       subject.push(connection)
       expect(subject.pop('foo')).to be connection
     end
@@ -36,8 +38,8 @@ def initialize(site)
     end
 
     it 'repurposes a connection for a different site when maximum amount is reached' do
-      5.times { subject.push(MiniConnection.new('foo')) }
-      expect(subject.pop('bar')).to be_a MiniConnection
+      5.times { subject.push(mini_connection_class.new('foo')) }
+      expect(subject.pop('bar')).to be_a mini_connection_class
     end
   end
 
@@ -47,14 +49,14 @@ def initialize(site)
     end
 
     it 'returns false when there are connections on the stack' do
-      subject.push(MiniConnection.new('foo'))
+      subject.push(mini_connection_class.new('foo'))
       expect(subject.empty?).to be false
     end
   end
 
   describe '#size' do
     it 'returns the number of connections on the stack' do
-      2.times { subject.push(MiniConnection.new('foo')) }
+      2.times { subject.push(mini_connection_class.new('foo')) }
       expect(subject.size).to eq 2
     end
   end

spec/models/concerns/remotable_spec.rb

@@ -3,48 +3,47 @@
 require 'rails_helper'
 
 RSpec.describe Remotable do
-  class Foo
-    def initialize
-      @attrs = {}
-    end
+  let(:foo_class) do
+    Class.new do
+      def initialize
+        @attrs = {}
+      end
 
-    def [](arg)
-      @attrs[arg]
-    end
+      def [](arg)
+        @attrs[arg]
+      end
 
-    def []=(arg1, arg2)
-      @attrs[arg1] = arg2
-    end
+      def []=(arg1, arg2)
+        @attrs[arg1] = arg2
+      end
 
-    def hoge=(arg); end
+      def hoge=(arg); end
 
-    def hoge_file_name; end
+      def hoge_file_name; end
 
-    def hoge_file_name=(arg); end
+      def hoge_file_name=(arg); end
 
-    def has_attribute?(arg); end
+      def has_attribute?(arg); end
 
-    def self.attachment_definitions
-      { hoge: nil }
-    end
-  end
-
-  before do
-    class Foo
-      include Remotable
-
-      remotable_attachment :hoge, 1.kilobyte
+      def self.attachment_definitions
+        { hoge: nil }
+      end
     end
   end
 
   let(:attribute_name) { "#{hoge}_remote_url".to_sym }
   let(:code)           { 200 }
   let(:file)           { 'filename="foo.txt"' }
-  let(:foo)            { Foo.new }
+  let(:foo)            { foo_class.new }
   let(:headers)        { { 'content-disposition' => file } }
   let(:hoge)           { :hoge }
   let(:url)            { 'https://google.com' }
 
+  before do
+    foo_class.include described_class
+    foo_class.remotable_attachment :hoge, 1.kilobyte
+  end
+
   it 'defines a method #hoge_remote_url=' do
     expect(foo).to respond_to(:hoge_remote_url=)
   end