gitlab-styles 7.0.0 → 9.0.0

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

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        # Checks for return inside blocks.
-        # For more information see: https://gitlab.com/gitlab-org/gitlab-foss/issues/42889
-        #
-        # @example
-        #   # bad
-        #   call do
-        #     return if something
-        #
-        #     do_something_else
-        #   end
-        #
-        #   # good
-        #   call do
-        #     break if something
-        #
-        #     do_something_else
-        #   end
-        #
-        class AvoidReturnFromBlocks < RuboCop::Cop::Cop
-          MSG = 'Do not return from a block, use next or break instead.'
-          DEF_METHODS = %i[define_method lambda].freeze
-          WHITELISTED_METHODS = %i[each each_filename times loop].freeze
-
-          def on_block(node)
-            block_body = node.body
-
-            return unless block_body
-            return unless top_block?(node)
-
-            block_body.each_node(:return) do |return_node|
-              next if parent_blocks(node, return_node).all? { |block| whitelisted?(block) }
-
-              add_offense(return_node)
-            end
-          end
-
-          private
-
-          def top_block?(node)
-            current_node = node
-            top_block = nil
-
-            while current_node && current_node.type != :def
-              top_block = current_node if current_node.block_type?
-              current_node = current_node.parent
-            end
-
-            top_block == node
-          end
-
-          def parent_blocks(node, current_node)
-            blocks = []
-
-            until node == current_node || def?(current_node)
-              blocks << current_node if current_node.block_type?
-              current_node = current_node.parent
-            end
-
-            blocks << node if node == current_node && !def?(node)
-            blocks
-          end
-
-          def def?(node)
-            node.def_type? || node.defs_type? ||
-              (node.block_type? && DEF_METHODS.include?(node.method_name))
-          end
-
-          def whitelisted?(block_node)
-            WHITELISTED_METHODS.include?(block_node.method_name)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/styles/rubocop/cop/code_reuse/active_record.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module CodeReuse
-          # Cop that denies the use of ActiveRecord methods outside of models.
-          class ActiveRecord < RuboCop::Cop::Cop
-            MSG = 'This method can only be used inside an ActiveRecord model: ' \
-        'https://gitlab.com/gitlab-org/gitlab-foss/issues/49653'
-
-            # Various methods from ActiveRecord::Querying that are denied. We
-            # exclude some generic ones such as `any?` and `first`, as these may
-            # lead to too many false positives, since `Array` also supports these
-            # methods.
-            #
-            # The keys of this Hash are the denied method names. The values are
-            # booleans that indicate if the method should only be denied if any
-            # arguments are provided.
-            NOT_ALLOWED = {
-              average: true,
-              calculate: true,
-              count_by_sql: true,
-              create_with: true,
-              distinct: false,
-              eager_load: true,
-              exists?: true,
-              find_by: true,
-              find_by!: true,
-              find_by_sql: true,
-              find_each: true,
-              find_in_batches: true,
-              find_or_create_by: true,
-              find_or_create_by!: true,
-              find_or_initialize_by: true,
-              first!: false,
-              first_or_create: true,
-              first_or_create!: true,
-              first_or_initialize: true,
-              from: true,
-              group: true,
-              having: true,
-              ids: false,
-              includes: true,
-              joins: true,
-              lock: false,
-              many?: false,
-              offset: true,
-              order: true,
-              pluck: true,
-              preload: true,
-              readonly: false,
-              references: true,
-              reorder: true,
-              rewhere: true,
-              take: false,
-              take!: false,
-              unscope: false,
-              where: false,
-              with: true
-            }.freeze
-
-            def on_send(node)
-              receiver = node.children[0]
-              send_name = node.children[1]
-              first_arg = node.children[2]
-
-              return unless receiver && NOT_ALLOWED.key?(send_name)
-
-              # If the rule requires an argument to be given, but none are
-              # provided, we won't register an offense. This prevents us from
-              # adding offenses for `project.group`, while still covering
-              # `Project.group(:name)`.
-              return if NOT_ALLOWED[send_name] && !first_arg
-
-              add_offense(node, location: :selector)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        # This cop makes sure that custom error classes, when empty, are declared
-        # with Class.new.
-        #
-        # @example
-        #   # bad
-        #   class FooError < StandardError
-        #   end
-        #
-        #   # okish
-        #   class FooError < StandardError; end
-        #
-        #   # good
-        #   FooError = Class.new(StandardError)
-        class CustomErrorClass < RuboCop::Cop::Cop
-          MSG = 'Use `Class.new(SuperClass)` to define an empty custom error class.'
-
-          def on_class(node)
-            parent = node.parent_class
-            body = node.body
-
-            return if body
-
-            parent_klass = class_name_from_node(parent)
-
-            return unless parent_klass&.to_s&.end_with?('Error')
-
-            add_offense(node)
-          end
-
-          def autocorrect(node)
-            klass = node.identifier
-            parent = node.parent_class
-
-            replacement = "#{class_name_from_node(klass)} = Class.new(#{class_name_from_node(parent)})"
-
-            lambda do |corrector|
-              corrector.replace(node.source_range, replacement)
-            end
-          end
-
-          private
-
-          # The nested constant `Foo::Bar::Baz` looks like:
-          #
-          #   s(:const,
-          #     s(:const,
-          #       s(:const, nil, :Foo), :Bar), :Baz)
-          #
-          # So recurse through that to get the name as written in the source.
-          #
-          def class_name_from_node(node, suffix = nil)
-            return unless node&.type == :const
-
-            name = node.children[1].to_s
-            name = "#{name}::#{suffix}" if suffix
-
-            if node.children[0]
-              class_name_from_node(node.children[0], name)
-            else
-              name
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        # This cop prevents usage of the `git` and `github` arguments to `gem` in a
-        # `Gemfile` in order to avoid additional points of failure beyond
-        # rubygems.org.
-        class GemFetcher < RuboCop::Cop::Cop
-          MSG = 'Do not use gems from git repositories, only use gems from RubyGems.'
-
-          GIT_KEYS = [:git, :github].freeze
-
-          def on_send(node)
-            return unless gemfile?(node)
-
-            func_name = node.children[1]
-            return unless func_name == :gem
-
-            node.children.last.each_node(:pair) do |pair|
-              key_name = pair.children[0].children[0].to_sym
-              add_offense(node, location: pair.source_range) if GIT_KEYS.include?(key_name)
-            end
-          end
-
-          private
-
-          def gemfile?(node)
-            node
-              .location
-              .expression
-              .source_buffer
-              .name
-              .end_with?("Gemfile")
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../model_helpers'
-
-module Gitlab
-  module Styles
-    module Rubocop
-      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'
-
-          def on_send(node)
-            return unless node.children[1] == :in_batches
-
-            add_offense(node, location: :selector)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/styles/rubocop/cop/internal_affairs/deprecate_cop_helper.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module InternalAffairs
-          # Cop that denies the use of CopHelper.
-          class DeprecateCopHelper < RuboCop::Cop::Cop
-            MSG = 'Do not use `CopHelper` or methods from it, use improved patterns described in https://www.rubydoc.info/gems/rubocop/RuboCop/RSpec/ExpectOffense'
-
-            def_node_matcher :cop_helper, <<~PATTERN
-              (send nil? ${:include :extend :prepend}
-                (const _ {:CopHelper}))
-            PATTERN
-
-            def_node_search :cop_helper_method, <<~PATTERN
-              (send nil? {:inspect_source :inspect_source_file :parse_source :autocorrect_source_file :autocorrect_source :_investigate} ...)
-            PATTERN
-
-            def_node_search :cop_helper_method_on_instance, <<~PATTERN
-              (send (send nil? _) {:messages :highlights :offenses} ...)
-            PATTERN
-
-            def on_send(node)
-              cop_helper(node) do
-                add_offense(node)
-              end
-
-              cop_helper_method(node) do
-                add_offense(node)
-              end
-
-              cop_helper_method_on_instance(node) do
-                add_offense(node)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        # Ensures a line break after guard clauses.
-        #
-        # @example
-        #   # bad
-        #   return unless condition
-        #   do_stuff
-        #
-        #   # good
-        #   return unless condition
-        #
-        #   do_stuff
-        #
-        #   # bad
-        #   raise if condition
-        #   do_stuff
-        #
-        #   # good
-        #   raise if condition
-        #
-        #   do_stuff
-        #
-        #   Multiple guard clauses are allowed without
-        #   line break.
-        #
-        #   # good
-        #   return unless condition_a
-        #   return unless condition_b
-        #
-        #   do_stuff
-        #
-        #   Guard clauses in case statement are allowed without
-        #   line break.
-        #
-        #   # good
-        #   case model
-        #     when condition_a
-        #       return true unless condition_b
-        #     when
-        #       ...
-        #   end
-        #
-        #   Guard clauses before end are allowed without
-        #   line break.
-        #
-        #   # good
-        #   if condition_a
-        #     do_something
-        #   else
-        #     do_something_else
-        #     return unless condition
-        #   end
-        #
-        #   do_something_more
-        class LineBreakAfterGuardClauses < RuboCop::Cop::Cop
-          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?]
-          PATTERN
-
-          def on_if(node)
-            return unless node.single_line?
-            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)
-          end
-
-          def autocorrect(node)
-            lambda do |corrector|
-              corrector.insert_after(node.loc.expression, "\n")
-            end
-          end
-
-          private
-
-          def guard_clause?(node)
-            return false unless node.if_type?
-
-            guard_clause_node?(node.if_branch)
-          end
-
-          def next_sibling(node)
-            node.parent.children[node.sibling_index + 1]
-          end
-
-          def next_line(node)
-            processed_source[node.loc.line]
-          end
-
-          def clause_last_line?(line)
-            line =~ /^\s*(?:end|elsif|else|when|rescue|ensure)/
-          end
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,64 +0,0 @@
-# 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/performance/rubyzip.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Gitlab
-  module Styles
-    module Rubocop
-      module Cop
-        module Performance
-          # This cop flags inefficient uses of rubyzip's Zip::File, since when instantiated
-          # it reads the file's Central Directory into memory entirely. For zips with many
-          # files and directories, this can be very expensive even when the archive's size
-          # in bytes is small.
-          #
-          # See also:
-          # - https://github.com/rubyzip/rubyzip/issues/506
-          # - https://github.com/rubyzip/rubyzip#notes-on-zipinputstream
-          class Rubyzip < RuboCop::Cop::Cop
-            MSG = 'Be careful when opening or iterating zip files via Zip::File. ' \
-                  'Zip archives may contain many entries, and their file index is ' \
-                  'read into memory upon construction, which can lead to ' \
-                  'high memory use and poor performance. ' \
-                  'Consider iterating archive entries via Zip::InputStream instead.'
-
-            def_node_matcher :reads_central_directory?, <<-PATTERN
-              (send
-                (const
-                  (const {nil? (cbase)} :Zip) :File) {:new :open :foreach} ...)
-            PATTERN
-
-            def on_send(node)
-              return unless reads_central_directory?(node)
-
-              add_offense(node)
-            end
-          end
-        end
-      end
-    end
-  end
-end