gitlab-styles 3.2.0 → 5.1.0

data/lib/gitlab/styles/rubocop/cop/in_batches.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../model_helpers'
 
 module Gitlab
@@ -6,7 +8,7 @@ module Gitlab
       module Cop
         # Cop that prevents the use of `in_batches`
         class InBatches < RuboCop::Cop::Cop
-          MSG = 'Do not use `in_batches`, use `each_batch` from the EachBatch module instead'.freeze
+          MSG = 'Do not use `in_batches`, use `each_batch` from the EachBatch module instead'
 
           def on_send(node)
             return unless node.children[1] == :in_batches

data/lib/gitlab/styles/rubocop/cop/line_break_after_guard_clauses.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Gitlab
   module Styles
     module Rubocop
@@ -56,7 +58,7 @@ module Gitlab
         #
         #   do_something_more
         class LineBreakAfterGuardClauses < RuboCop::Cop::Cop
-          MSG = 'Add a line break after guard clauses'.freeze
+          MSG = 'Add a line break after guard clauses'
 
           def_node_matcher :guard_clause_node?, <<-PATTERN
             [{(send nil? {:raise :fail :throw} ...) return break next} single_line?]
@@ -67,7 +69,7 @@ module Gitlab
             return unless guard_clause?(node)
             return if next_line(node).blank? || clause_last_line?(next_line(node)) || guard_clause?(next_sibling(node))
 
-            add_offense(node, location: :expression, message: MSG)
+            add_offense(node)
           end
 
           def autocorrect(node)

data/lib/gitlab/styles/rubocop/cop/line_break_around_conditional_block.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        # Ensures a line break around conditional blocks.
+        #
+        # @example
+        #    # bad
+        #    do_something
+        #    if condition
+        #      do_extra_stuff
+        #    end
+        #    do_something_more
+        #
+        #    # good
+        #    do_something
+        #
+        #    if condition
+        #      do_extra_stuff
+        #    end
+        #
+        #    do_something_more
+        #
+        #    # bad
+        #    do_something
+        #    unless condition
+        #      do_extra_stuff
+        #    end
+        #
+        #    do_something_more
+        #
+        #    # good
+        #    def a_method
+        #      if condition
+        #        do_something
+        #      end
+        #    end
+        #
+        #    # good
+        #    on_block do
+        #      if condition
+        #        do_something
+        #      end
+        #    end
+        class LineBreakAroundConditionalBlock < RuboCop::Cop::Cop
+          include RuboCop::Cop::RangeHelp
+
+          MSG = 'Add a line break around conditional blocks'
+
+          def on_if(node)
+            # This cop causes errors in haml files, so let's skip those
+            return if in_haml?(node)
+            return if node.single_line?
+            return unless node.if? || node.unless?
+
+            add_offense(node) unless previous_line_valid?(node)
+            add_offense(node) unless last_line_valid?(node)
+          end
+
+          def autocorrect(node)
+            lambda do |corrector|
+              line = range_by_whole_lines(node.source_range)
+
+              corrector.insert_before(line, "\n") unless previous_line_valid?(node)
+              corrector.insert_after(line, "\n") unless last_line_valid?(node)
+            end
+          end
+
+          private
+
+          def previous_line_valid?(node)
+            previous_line(node).empty? ||
+              start_clause_line?(previous_line(node)) ||
+              block_start?(previous_line(node)) ||
+              begin_line?(previous_line(node)) ||
+              assignment_line?(previous_line(node)) ||
+              rescue_line?(previous_line(node))
+          end
+
+          def last_line_valid?(node)
+            last_line(node).empty? ||
+              end_line?(last_line(node)) ||
+              end_clause_line?(last_line(node))
+          end
+
+          def previous_line(node)
+            processed_source[node.loc.line - 2]
+          end
+
+          def last_line(node)
+            processed_source[node.loc.last_line]
+          end
+
+          def start_clause_line?(line)
+            line =~ /^\s*(def|=end|#|module|class|if|unless|else|elsif|ensure|when)/
+          end
+
+          def end_clause_line?(line)
+            line =~ /^\s*(#|rescue|else|elsif|when)/
+          end
+
+          def begin_line?(line)
+            # an assignment followed by a begin or ust a begin
+            line =~ /^\s*(@?(\w|\|+|=|\[|\]|\s)+begin|begin)/
+          end
+
+          def assignment_line?(line)
+            line =~ /^\s*.*=/
+          end
+
+          def rescue_line?(line)
+            line =~ /^\s*rescue/
+          end
+
+          def block_start?(line)
+            line.match(/ (do|{)( \|.*?\|)?\s?(#.+)?\z/)
+          end
+
+          def end_line?(line)
+            line =~ /^\s*(end|})/
+          end
+
+          def in_haml?(node)
+            node.location.expression.source_buffer.name.end_with?('.haml.rb')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/styles/rubocop/cop/migration/update_large_table.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require_relative '../../migration_helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module Migration
+          # This cop checks for methods that may lead to batch type issues on a table that's been
+          # explicitly denied because of its size.
+          #
+          # Even though though these methods perform functions to avoid
+          # downtime, using it with tables with millions of rows still causes a
+          # significant delay in the deploy process and is best avoided.
+          #
+          # See https://gitlab.com/gitlab-com/infrastructure/issues/1602 for more
+          # information.
+          class UpdateLargeTable < RuboCop::Cop::Cop
+            include MigrationHelpers
+
+            MSG = 'Using `%s` on the `%s` table will take a long time to ' \
+              'complete, and should be avoided unless absolutely ' \
+              'necessary'
+
+            def_node_matcher :batch_update?, <<~PATTERN
+              (send nil? ${#denied_method?}
+                (sym $...)
+                ...)
+            PATTERN
+
+            def on_send(node)
+              return if denied_tables.empty? || denied_methods.empty?
+              return unless in_migration?(node)
+
+              matches = batch_update?(node)
+              return unless matches
+
+              update_method = matches.first
+              table = matches.last.to_a.first
+
+              return unless denied_tables.include?(table)
+
+              add_offense(node, message: format(MSG, update_method, table))
+            end
+
+            private
+
+            def denied_tables
+              cop_config['DeniedTables'] || []
+            end
+
+            def denied_method?(method_name)
+              denied_methods.include?(method_name)
+            end
+
+            def denied_methods
+              cop_config['DeniedMethods'] || []
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/styles/rubocop/cop/polymorphic_associations.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../model_helpers'
 
 module Gitlab
@@ -8,7 +10,7 @@ module Gitlab
         class PolymorphicAssociations < RuboCop::Cop::Cop
           include ModelHelpers
 
-          MSG = 'Do not use polymorphic associations, use separate tables instead'.freeze
+          MSG = 'Do not use polymorphic associations, use separate tables instead'
 
           def on_send(node)
             return unless in_model?(node)
@@ -17,7 +19,7 @@ module Gitlab
             node.children.last.each_node(:pair) do |pair|
               key_name = pair.children[0].children[0]
 
-              add_offense(pair, location: :expression) if key_name == :polymorphic
+              add_offense(pair) if key_name == :polymorphic
             end
           end
         end

data/lib/gitlab/styles/rubocop/cop/redirect_with_status.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Gitlab
   module Styles
     module Rubocop
@@ -5,7 +7,7 @@ module Gitlab
         # This cop prevents usage of 'redirect_to' in actions 'destroy' without specifying 'status'.
         # See https://gitlab.com/gitlab-org/gitlab-ce/issues/31840
         class RedirectWithStatus < RuboCop::Cop::Cop
-          MSG = 'Do not use "redirect_to" without "status" in "destroy" action'.freeze
+          MSG = 'Do not use "redirect_to" without "status" in "destroy" action'
 
           def on_def(node)
             return unless in_controller?(node)

data/lib/gitlab/styles/rubocop/cop/rspec/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative '../../rspec/helpers'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module RSpec
+          class Base < RuboCop::Cop::RSpec::Base
+            include Rubocop::Rspec::Helpers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/styles/rubocop/cop/rspec/empty_line_after_let_block.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module RSpec
+          # Checks if there is an empty line after let blocks.
+          #
+          # @example
+          #   # bad
+          #   RSpec.describe Foo do
+          #     let(:something) { 'something' }
+          #     let(:another_thing) do
+          #     end
+          #     let(:something_else) do
+          #     end
+          #     let(:last_thing) { 'last thing' }
+          #   end
+          #
+          #   # good
+          #   RSpec.describe Foo do
+          #     let(:something) { 'something' }
+          #     let(:another_thing) do
+          #     end
+          #
+          #     let(:something_else) do
+          #     end
+          #
+          #     let(:last_thing) { 'last thing' }
+          #   end
+          #
+          #   # good - it's ok to have non-separated without do/end blocks
+          #   RSpec.describe Foo do
+          #     let(:something) { 'something' }
+          #     let(:last_thing) { 'last thing' }
+          #   end
+          #
+          class EmptyLineAfterLetBlock < Base
+            extend RuboCop::Cop::AutoCorrector
+            include RuboCop::RSpec::EmptyLineSeparation
+
+            MSG = 'Add an empty line after `%<let>s` block.'
+
+            def_node_matcher :lets, LET.block_pattern
+
+            def on_block(node)
+              lets(node) do
+                break if last_child?(node)
+                next if node.single_line?
+
+                missing_separating_line_offense(node) do |method|
+                  format(MSG, let: method)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/styles/rubocop/cop/rspec/empty_line_after_shared_example.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'rubocop-rspec'
+require_relative 'base'
+
+module Gitlab
+  module Styles
+    module Rubocop
+      module Cop
+        module RSpec
+          # Checks if there is an empty line after shared example blocks.
+          #
+          # @example
+          #   # bad
+          #   RSpec.describe Foo do
+          #     it_behaves_like 'do this first'
+          #     it_behaves_like 'does this' do
+          #     end
+          #     it_behaves_like 'does that' do
+          #     end
+          #     it_behaves_like 'do some more'
+          #   end
+          #
+          #   # good
+          #   RSpec.describe Foo do
+          #     it_behaves_like 'do this first'
+          #     it_behaves_like 'does this' do
+          #     end
+          #
+          #     it_behaves_like 'does that' do
+          #     end
+          #
+          #     it_behaves_like 'do some more'
+          #   end
+          #
+          #   # fair - it's ok to have non-separated without blocks
+          #   RSpec.describe Foo do
+          #     it_behaves_like 'do this first'
+          #     it_behaves_like 'does this'
+          #   end
+          #
+          class EmptyLineAfterSharedExample < Base
+            extend RuboCop::Cop::AutoCorrector
+            include RuboCop::RSpec::EmptyLineSeparation
+
+            MSG = 'Add an empty line after `%<example>s` block.'
+
+            def_node_matcher :shared_examples,
+                             (SharedGroups::ALL + Includes::ALL).block_pattern
+
+            def on_block(node)
+              shared_examples(node) do
+                break if last_child?(node)
+
+                missing_separating_line_offense(node) do |method|
+                  format(MSG, example: method)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/styles/rubocop/cop/rspec/have_link_parameters.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 require 'rubocop-rspec'
+require_relative 'base'
 
 module Gitlab
   module Styles
@@ -15,8 +18,10 @@ module Gitlab
           #   # good
           #   expect(page).to have_link('Link', href: 'https://example.com')
           #   expect(page).to have_link('Example')
-          class HaveLinkParameters < RuboCop::Cop::RSpec::Cop
-            MESSAGE = "The second argument to `have_link` should be a Hash.".freeze
+          class HaveLinkParameters < Base
+            extend RuboCop::Cop::AutoCorrector
+
+            MESSAGE = "The second argument to `have_link` should be a Hash."
 
             def_node_matcher :unused_parameters?, <<~PATTERN
               (send nil? :have_link
@@ -27,11 +32,13 @@ module Gitlab
             def on_send(node)
               return unless unused_parameters?(node)
 
-              location = node.arguments[1..-1]
-                .map(&:source_range)
-                .reduce(:join)
+              location = node.arguments[1..]
+                           .map(&:source_range)
+                           .reduce(:join)
 
-              add_offense(node, location: location, message: MESSAGE)
+              add_offense(location, message: MESSAGE) do |corrector|
+                corrector.insert_after(location.end, "\n")
+              end
             end
           end
         end