gitlab-styles 6.6.0 → 8.0.0

data/lib/gitlab/styles/rubocop/cop/rails/include_url_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../model_helpers'
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module Rails
-          class IncludeUrlHelper < RuboCop::Cop::Cop
-            MSG = <<~MSG
-              Avoid including `ActionView::Helpers::UrlHelper`.
-              It adds/overrides ~40 methods while usually only one is needed.
-              Instead, use the `Gitlab::Routing.url_helpers`/`Application.routes.url_helpers`(outside of gitlab)
-              and `ActionController::Base.helpers.link_to`.
-              See https://gitlab.com/gitlab-org/gitlab/-/issues/340567.
-            MSG
-
-            def_node_matcher :include_url_helpers_node?, <<~PATTERN
-              (send nil? :include (const (const (const {nil? cbase} :ActionView) :Helpers) :UrlHelper))
-            PATTERN
-
-            def on_send(node)
-              add_offense(node) if include_url_helpers_node?(node)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        # 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'
-
-          def on_def(node)
-            return unless in_controller?(node)
-            return unless destroy?(node) || destroy_all?(node)
-
-            node.each_descendant(:send) do |def_node|
-              next unless redirect_to?(def_node)
-
-              methods = []
-
-              def_node.children.last.each_node(:pair) do |pair|
-                methods << pair.children.first.children.first
-              end
-
-              add_offense(def_node, location: :selector) unless methods.include?(:status)
-            end
-          end
-
-          private
-
-          def in_controller?(node)
-            node.location.expression.source_buffer.name.end_with?('_controller.rb')
-          end
-
-          def destroy?(node)
-            node.children.first == :destroy
-          end
-
-          def destroy_all?(node)
-            node.children.first == :destroy_all
-          end
-
-          def redirect_to?(node)
-            node.children[1] == :redirect_to
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# 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_final_let_it_be.rb

@@ -1,51 +0,0 @@
-# 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 the last `let_it_be` block.
-          #
-          # @example
-          #   # bad
-          #   let_it_be(:foo) { bar }
-          #   let_it_be(:something) { other }
-          #   it { does_something }
-          #
-          #   # good
-          #   let_it_be(:foo) { bar }
-          #   let_it_be(:something) { other }
-          #
-          #   it { does_something }
-          class EmptyLineAfterFinalLetItBe < Base
-            extend RuboCop::Cop::AutoCorrector
-            include RuboCop::RSpec::EmptyLineSeparation
-
-            MSG = 'Add an empty line after the last `let_it_be`.'
-
-            def_node_matcher :let_it_be?, <<-PATTERN
-              {
-                (block (send #rspec? {:let_it_be :let_it_be_with_refind :let_it_be_with_reload} ...) ...)
-                (send #rspec? {:let_it_be :let_it_be_with_refind :let_it_be_with_reload} _ block_pass)
-              }
-            PATTERN
-
-            def on_block(node)
-              return unless example_group_with_body?(node)
-
-              final_let_it_be = node.body.child_nodes.reverse.find { |child| let_it_be?(child) }
-
-              return if final_let_it_be.nil?
-
-              missing_separating_line_offense(final_let_it_be) { MSG }
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# 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

@@ -1,65 +0,0 @@
-# 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/example_starting_character.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop-rspec'
-require_relative 'base'
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module RSpec
-          # Checks for common mistakes in example descriptions.
-          #
-          # This cop will correct docstrings that begin/end with space or words that start with a capital letter.
-          #
-          # @see https://gitlab.com/gitlab-org/gitlab/-/merge_requests/46336#note_442669518
-          #
-          # @example
-          #   # bad
-          #   it 'Does something' do
-          #   end
-          #
-          #   # good
-          #   it 'does nothing' do
-          #   end
-          #
-          # @example
-          #   # bad
-          #   it ' does something' do
-          #   end
-          #
-          #   # good
-          #   it 'does something' do
-          #   end
-          #
-          # @example
-          #   # bad
-          #   it 'does something ' do
-          #   end
-          #
-          #   # good
-          #   it 'does something' do
-          #   end
-          #
-          # @example
-          #   # bad
-          #   it ' does something ' do
-          #   end
-          #
-          #   # good
-          #   it 'does something' do
-          #   end
-          class ExampleStartingCharacter < Base
-            extend RuboCop::Cop::AutoCorrector
-
-            MSG = 'Only start words with lowercase alpha with no leading/trailing spaces when describing your tests.'
-
-            def_node_matcher :it_description, <<-PATTERN
-          (block (send _ :it ${
-            (str $_)
-            (dstr (str $_ ) ...)
-          } ...) ...)
-            PATTERN
-
-            def on_block(node)
-              it_description(node) do |description_node, _message|
-                add_wording_offense(description_node, MSG) if invalid_description?(text(description_node))
-              end
-            end
-
-            private
-
-            def add_wording_offense(node, message)
-              docstring = docstring(node)
-              add_offense(docstring, message: message) do |corrector|
-                corrector.replace(docstring, replacement_text(node))
-              end
-            end
-
-            def docstring(node)
-              expr = node.loc.expression
-
-              Parser::Source::Range.new(
-                expr.source_buffer,
-                expr.begin_pos + 1,
-                expr.end_pos - 1
-              )
-            end
-
-            def invalid_description?(message)
-              message.match?(/(^([A-Z]{1}[a-z]+\s|\s)|\s$)/)
-            end
-
-            def replacement_text(node)
-              text = text(node)
-
-              text.strip!
-
-              text = downcase_first_letter(text) if invalid_description?(text)
-
-              text
-            end
-
-            # Recursive processing is required to process nested dstr nodes
-            # that is the case for \-separated multiline strings with interpolation.
-            def text(node)
-              case node.type
-              when :dstr
-                node.node_parts.map { |child_node| text(child_node) }.join
-              when :str
-                node.value
-              when :begin
-                node.source
-              end
-            end
-
-            def downcase_first_letter(str)
-              str[0].downcase + str[1..]
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop-rspec'
-require_relative 'base'
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module RSpec
-          # This cop checks for unused parameters to the `have_link` matcher.
-          #
-          # @example
-          #
-          #   # bad
-          #   expect(page).to have_link('Link', 'https://example.com')
-          #
-          #   # good
-          #   expect(page).to have_link('Link', href: 'https://example.com')
-          #   expect(page).to have_link('Example')
-          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
-                _ !{hash nil}
-              )
-            PATTERN
-
-            def on_send(node)
-              return unless unused_parameters?(node)
-
-              location = node.arguments[1..]
-                           .map(&:source_range)
-                           .reduce(:join)
-
-              add_offense(location, message: MESSAGE) do |corrector|
-                corrector.insert_after(location.end, "\n")
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop-rspec'
-require_relative 'base'
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module RSpec
-          # This cop checks for single-line hook blocks
-          #
-          # @example
-          #
-          #   # bad
-          #   before { do_something }
-          #   after(:each) { undo_something }
-          #
-          #   # good
-          #   before do
-          #     do_something
-          #   end
-          #
-          #   after(:each) do
-          #     undo_something
-          #   end
-          class SingleLineHook < Base
-            MESSAGE = "Don't use single-line hook blocks."
-
-            def_node_search :rspec_hook?, <<~PATTERN
-              (send nil? {:after :around :before} ...)
-            PATTERN
-
-            def on_block(node)
-              return unless node.single_line?
-              return unless rspec_hook?(node)
-
-              add_offense(node, message: MESSAGE)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require 'rubocop-rspec'
-require_relative 'base'
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module RSpec
-          # Checks for verbose include metadata used in the specs.
-          #
-          # @example
-          #   # bad
-          #   describe MyClass, js: true do
-          #   end
-          #
-          #   # good
-          #   describe MyClass, :js do
-          #   end
-          class VerboseIncludeMetadata < Base
-            extend RuboCop::Cop::AutoCorrector
-
-            MSG = 'Use `%s` instead of `%s`.'
-
-            SELECTORS = %i[describe context feature example_group it specify example scenario its].freeze
-
-            def_node_matcher :include_metadata, <<-PATTERN
-              (send {(const nil? :RSpec) nil?} {#{SELECTORS.map(&:inspect).join(' ')}}
-                !const
-                ...
-                (hash $...))
-            PATTERN
-
-            def_node_matcher :invalid_metadata?, <<-PATTERN
-              (pair
-                (sym $...)
-                (true))
-            PATTERN
-
-            def on_send(node)
-              invalid_metadata_matches(node) do |match|
-                add_offense(node, message: format(MSG, good(match), bad(match))) do |corrector|
-                  invalid_metadata_matches(node) do |match|
-                    corrector.replace(match.loc.expression, good(match))
-                  end
-                end
-              end
-            end
-
-            private
-
-            def invalid_metadata_matches(node, &block)
-              include_metadata(node) do |matches|
-                matches.select { |match| invalid_metadata?(match) }.each(&block)
-              end
-            end
-
-            def bad(match)
-              "#{metadata_key(match)}: true"
-            end
-
-            def good(match)
-              ":#{metadata_key(match)}"
-            end
-
-            def metadata_key(match)
-              match.children[0].source
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/styles/rubocop/cop/style/hash_transformation.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module Style
-          # This cop identifies places where `map { ... }.to_h` or
-          # `Hash[map { ... }]` can be replaced with `to_h { ... }`,
-          # saving an intermediate array allocation.
-          #
-          # @example
-          #   # bad
-          #   hash.map { |k, v| [v.upcase, k.downcase] }.to_h
-          #   hash.collect { |k, v| [v.upcase, k.downcase] }.to_h
-          #   Hash[hash.map { |k, v| [v.upcase, k.downcase] }]
-          #   Hash[hash.collect { |k, v| [v.upcase, k.downcase] }]
-          #   array.map { |x| [x, x + 1] }.to_h
-          #
-          #   # good
-          #   hash.to_h { |k, v| [v.upcase, k.downcase] }
-          #   array.to_h { |x| [x, x + 1] }
-          #
-          # Full credit: https://github.com/eugeneius/rubocop-performance/blob/hash_transformation/lib/rubocop/cop/performance/hash_transformation.rb
-          class HashTransformation < RuboCop::Cop::Cop
-            include RuboCop::Cop::RangeHelp
-
-            MSG = 'Use `to_h { ... }` instead of `%<current>s`.'
-
-            def_node_matcher :to_h_candidate?, <<~PATTERN
-              {
-                [(send
-                  $(block $(send _ {:map :collect}) ...) :to_h) !block_literal?]
-                (send (const nil? :Hash) :[]
-                  $(block $(send _ {:map :collect}) ...))
-              }
-            PATTERN
-
-            def on_send(node)
-              to_h_candidate?(node) do |_block, call|
-                range = offense_range(node, call)
-                message = message(node, call)
-                add_offense(node, location: range, message: message)
-              end
-            end
-
-            def autocorrect(node)
-              block, call = to_h_candidate?(node)
-
-              lambda do |corrector|
-                corrector.remove(after_block(node, block))
-                corrector.replace(call.loc.selector, 'to_h')
-                corrector.remove(before_block(node, block))
-              end
-            end
-
-            private
-
-            def offense_range(node, call)
-              return node.source_range if node.children.first.const_type?
-
-              range_between(call.loc.selector.begin_pos, node.loc.selector.end_pos)
-            end
-
-            def message(node, call)
-              current = if node.children.first.const_type?
-                          "Hash[#{call.method_name} { ... }]"
-                        else
-                          "#{call.method_name} { ... }.to_h"
-                        end
-
-              format(MSG, current: current)
-            end
-
-            def after_block(node, block)
-              block.source_range.end.join(node.source_range.end)
-            end
-
-            def before_block(node, block)
-              node.source_range.begin.join(block.source_range.begin)
-            end
-          end
-        end
-      end
-    end
-  end
-end