Adapt custom cops to v1

spec/linters/match_requires_with_includes.rb

@@ -1,6 +1,6 @@
 module RuboCop
   module Cop
-    class MatchRequiresWithIncludes < RuboCop::Cop::Cop
+    class MatchRequiresWithIncludes < RuboCop::Cop::Base
       REQ_FOR_INCLUDES = {
         'VCAP::CloudController::Presenters::Mixins::MetadataPresentationHelpers' =>
           'presenters/mixins/metadata_presentation_helpers',
@@ -25,7 +25,7 @@ def on_send(node)
         req = REQ_FOR_INCLUDES[included_module]
         return unless req && [email protected]?(req)
 
-        add_offense(node, location: :expression, message: "Included '#{included_module}' but need to require '#{req}'")
+        add_offense(node.loc.expression, message: "Included '#{included_module}' but need to require '#{req}'")
       end
 
       private

spec/linters/match_requires_with_includes_spec.rb

@@ -18,7 +18,7 @@
   end
 
   it 'registers an offense if MetadataPresentationHelpers is included without requiring it' do
-    inspect_source(<<~RUBY)
+    result = inspect_source(<<~RUBY)
       require 'cows'
       module M
       class C
@@ -27,12 +27,12 @@ class C
       end
     RUBY
 
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages).to eq([missing_metadata_presentation_helper])
+    expect(result.size).to eq(1)
+    expect(result.map(&:message)).to eq([missing_metadata_presentation_helper])
   end
 
   it 'does not register an offense if metadata_presentation_helpers required' do
-    inspect_source(<<~RUBY)
+    result = inspect_source(<<~RUBY)
       require 'presenters/mixins/metadata_presentation_helpers'
       module M
       class C
@@ -41,11 +41,11 @@ class C
       end
     RUBY
 
-    expect(cop.offenses.size).to eq(0)
+    expect(result.size).to eq(0)
   end
 
   it 'registers an offense if SubResource is included without requiring it' do
-    inspect_source(<<~RUBY)
+    result = inspect_source(<<~RUBY)
       require 'cows'
       module M
       class C
@@ -54,12 +54,12 @@ class C
       end
     RUBY
 
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.messages).to eq([missing_sub_resource])
+    expect(result.size).to eq(1)
+    expect(result.map(&:message)).to eq([missing_sub_resource])
   end
 
   it 'does not register an offense if metadata_presentation_helpers required' do
-    inspect_source(<<~RUBY)
+    result = inspect_source(<<~RUBY)
       require 'controllers/v3/mixins/sub_resource'
       module M
       class C
@@ -68,11 +68,11 @@ class C
       end
     RUBY
 
-    expect(cop.offenses.size).to eq(0)
+    expect(result.size).to eq(0)
   end
 
   it 'finds multiple offences' do
-    inspect_source(<<~RUBY)
+    result = inspect_source(<<~RUBY)
       require 'cows'
       module M
       class C
@@ -81,7 +81,8 @@ class C
       end
       end
     RUBY
-    expect(cop.offenses.size).to eq(2)
-    expect(cop.messages).to contain_exactly(missing_metadata_presentation_helper, missing_sub_resource)
+
+    expect(result.size).to eq(2)
+    expect(result.map(&:message)).to contain_exactly(missing_metadata_presentation_helper, missing_sub_resource)
   end
 end

spec/linters/migration/add_constraint_name.rb

@@ -1,7 +1,7 @@
 module RuboCop
   module Cop
     module Migration
-      class AddConstraintName < RuboCop::Cop::Cop
+      class AddConstraintName < RuboCop::Cop::Base
         # Postgres and MySQL have different naming conventions, so if we need to remove them we cannot predict accurately what the constraint name would be.
         MSG = 'Please explicitly name your index or constraint.'.freeze
         CONSTRAINT_METHODS = %i[
@@ -28,7 +28,7 @@ def on_block(node)
               end
             end
 
-            add_offense(send_node, location: :expression) if missing_named_constraint
+            add_offense(send_node.loc.expression) if missing_named_constraint
           end
         end
 

spec/linters/migration/add_constraint_name_spec.rb

@@ -11,111 +11,106 @@
 
   RSpec.shared_examples 'a cop that validates explicit names are added to the index' do |method_name|
     it 'registers an offense if index is called without a name' do
-      inspect_source(<<~RUBY)
+      result = inspect_source(<<~RUBY)
         create_table :jobs do
           #{method_name} :foo
         end
       RUBY
 
-      expect(cop.offenses.size).to eq(1)
-      expect(cop.messages).to eq(['Please explicitly name your index or constraint.'])
+      expect(result.size).to eq(1)
+      expect(result.map(&:message)).to eq(['Please explicitly name your index or constraint.'])
     end
 
     it 'does not register an offense if index is called with a name' do
-      inspect_source(<<~RUBY)
+      result = inspect_source(<<~RUBY)
         create_table :jobs do
           #{method_name} :foo, name: :bar
         end
       RUBY
 
-      expect(cop.offenses.size).to eq(0)
-      expect(cop.messages).to be_empty
+      expect(result.size).to eq(0)
     end
   end
 
   RSpec.shared_examples 'a cop that validates explicit names are used when adding a column with an index' do |method_name|
     context 'and the column is adding an index' do
       it 'registers an offense if index is called without a name' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo, :index
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(1)
-        expect(cop.messages).to eq(['Please explicitly name your index or constraint.'])
+        expect(result.size).to eq(1)
+        expect(result.map(&:message)).to eq(['Please explicitly name your index or constraint.'])
       end
 
       it 'does not register an offense if index is called with a name' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo, index: {name: 'foo'}
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(0)
-        expect(cop.messages).to be_empty
+        expect(result.size).to eq(0)
       end
     end
 
     context 'and the column is adding a unique constraint' do
       it 'registers an offense if unique is called without a unique_constraint_name' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo, unique: true
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(1)
-        expect(cop.messages).to eq(['Please explicitly name your index or constraint.'])
+        expect(result.size).to eq(1)
+        expect(result.map(&:message)).to eq(['Please explicitly name your index or constraint.'])
       end
 
       it 'does not register an offense if unique is called with a unique_constraint_name' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo, unique: true, unique_constraint_name: 'something_real_unique'
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(0)
-        expect(cop.messages).to be_empty
+        expect(result.size).to eq(0)
       end
     end
 
     context 'and the column is adding a primary_key constraint' do
       it 'registers an offense if unique is called without a primary_key_constraint_name' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo, primary_key: true
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(1)
-        expect(cop.messages).to eq(['Please explicitly name your index or constraint.'])
+        expect(result.size).to eq(1)
+        expect(result.map(&:message)).to eq(['Please explicitly name your index or constraint.'])
       end
 
       it 'does not register an offense if primary_key is called with a primary_key_constraint_name' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo, primary_key: true, primary_key_constraint_name: 'something_real_unique'
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(0)
-        expect(cop.messages).to be_empty
+        expect(result.size).to eq(0)
       end
     end
 
     context 'and the column is not adding any index or constraint' do
       it 'does not register an offense' do
-        inspect_source(<<~RUBY)
+        result = inspect_source(<<~RUBY)
           create_table :jobs do
             #{method_name} :foo
           end
         RUBY
 
-        expect(cop.offenses.size).to eq(0)
-        expect(cop.messages).to be_empty
+        expect(result.size).to eq(0)
       end
     end
   end

spec/linters/migration/include_string_size.rb

@@ -1,7 +1,7 @@
 module RuboCop
   module Cop
     module Migration
-      class IncludeStringSize < RuboCop::Cop::Cop
+      class IncludeStringSize < RuboCop::Cop::Base
         # Postgres and MySQL have different size limits on String and TEXT fields
         # MySQL: `String` is `varchar(255)`, `String, text: true` has a max size of 16_000 for UTF8 encoded DBs
         # Postgres: `String` and `String, text: true` are `TEXT` and has a max size of ~1GB
@@ -25,13 +25,13 @@ def on_block(node)
             has_text = node_has_hash_key?(inner_node, :text, &:truthy_literal?)
 
             if has_text
-              add_offense(inner_node, location: :expression, message: STRING_TEXT_WARNING)
+              add_offense(inner_node.loc.expression, message: STRING_TEXT_WARNING)
               next
             end
 
             has_size = node_has_hash_key?(inner_node, :size)
 
-            add_offense(inner_node, location: :expression, message: STRING_SIZE_WARNING) unless has_size
+            add_offense(inner_node.loc.expression, message: STRING_SIZE_WARNING) unless has_size
           end
         end