rubocop-grantbirki 1.75.2

data/lib/rubocop/cop/style/colon_method_definition.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for class methods that are defined using the `::`
+      # operator instead of the `.` operator.
+      #
+      # @example
+      #   # bad
+      #   class Foo
+      #     def self::bar
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     def self.bar
+      #     end
+      #   end
+      #
+      class ColonMethodDefinition < Base
+        extend AutoCorrector
+
+        MSG = 'Do not use `::` for defining class methods.'
+
+        def on_defs(node)
+          return unless node.loc.operator.source == '::'
+
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '.')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/combinable_defined.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for multiple `defined?` calls joined by `&&` that can be combined
+      # into a single `defined?`.
+      #
+      # When checking that a nested constant or chained method is defined, it is
+      # not necessary to check each ancestor or component of the chain.
+      #
+      # @example
+      #   # bad
+      #   defined?(Foo) && defined?(Foo::Bar) && defined?(Foo::Bar::Baz)
+      #
+      #   # good
+      #   defined?(Foo::Bar::Baz)
+      #
+      #   # bad
+      #   defined?(foo) && defined?(foo.bar) && defined?(foo.bar.baz)
+      #
+      #   # good
+      #   defined?(foo.bar.baz)
+      class CombinableDefined < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Combine nested `defined?` calls.'
+        OPERATORS = %w[&& and].freeze
+
+        def on_and(node)
+          # Only register an offense if all `&&` terms are `defined?` calls
+          return unless (terms = terms(node)).all?(&:defined_type?)
+
+          calls = defined_calls(terms)
+          namespaces = namespaces(calls)
+
+          calls.each do |call|
+            next unless namespaces.any?(call)
+
+            add_offense(node) do |corrector|
+              remove_term(corrector, call)
+            end
+          end
+        end
+
+        private
+
+        def terms(node)
+          node.each_descendant.select do |descendant|
+            descendant.parent.and_type? && !descendant.and_type?
+          end
+        end
+
+        def defined_calls(nodes)
+          nodes.filter_map do |defined_node|
+            subject = defined_node.first_argument
+            subject if subject.type?(:const, :call)
+          end
+        end
+
+        def namespaces(nodes)
+          nodes.filter_map do |node|
+            if node.respond_to?(:namespace)
+              node.namespace
+            elsif node.respond_to?(:receiver)
+              node.receiver
+            end
+          end
+        end
+
+        def remove_term(corrector, term)
+          term = term.parent until term.parent.and_type?
+          range = if term == term.parent.children.last
+                    rhs_range_to_remove(term)
+                  else
+                    lhs_range_to_remove(term)
+                  end
+
+          corrector.remove(range)
+        end
+
+        # If the redundant `defined?` node is the LHS of an `and` node,
+        # the term as well as the subsequent `&&`/`and` operator will be removed.
+        def lhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.end_pos
+          pos += 1 until source[..pos].end_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(end_pos: pos + 1),
+            side: :right,
+            newlines: false
+          )
+        end
+
+        # If the redundant `defined?` node is the RHS of an `and` node,
+        # the term as well as the preceding `&&`/`and` operator will be removed.
+        def rhs_range_to_remove(term)
+          source = @processed_source.buffer.source
+
+          pos = term.source_range.begin_pos
+          pos -= 1 until source[pos, 3].start_with?(*OPERATORS)
+
+          range_with_surrounding_space(
+            range: term.source_range.with(begin_pos: pos - 1),
+            side: :right,
+            newlines: false
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/combinable_loops.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for places where multiple consecutive loops over the same data
+      # can be combined into a single loop. It is very likely that combining them
+      # will make the code more efficient and more concise.
+      #
+      # NOTE: Autocorrection is not applied when the block variable names differ in separate loops,
+      # as it is impossible to determine which variable name should be prioritized.
+      #
+      # @safety
+      #   The cop is unsafe, because the first loop might modify state that the
+      #   second loop depends on; these two aren't combinable.
+      #
+      # @example
+      #   # bad
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #     end
+      #
+      #     items.each do |item|
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     items.each do |item|
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # bad
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #     end
+      #
+      #     for item in items do
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     for item in items do
+      #       do_something(item)
+      #       do_something_else(item)
+      #     end
+      #   end
+      #
+      #   # good
+      #   def method
+      #     each_slice(2) { |slice| do_something(slice) }
+      #     each_slice(3) { |slice| do_something(slice) }
+      #   end
+      #
+      class CombinableLoops < Base
+        extend AutoCorrector
+
+        MSG = 'Combine this loop with the previous loop.'
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def on_block(node)
+          return unless node.parent&.begin_type?
+          return unless collection_looping_method?(node)
+          return unless same_collection_looping_block?(node, node.left_sibling)
+          return unless node.body && node.left_sibling.body
+
+          add_offense(node) do |corrector|
+            next unless node.arguments == node.left_sibling.arguments
+
+            combine_with_left_sibling(corrector, node)
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+
+        alias on_numblock on_block
+        alias on_itblock on_block
+
+        def on_for(node)
+          return unless node.parent&.begin_type?
+          return unless same_collection_looping_for?(node, node.left_sibling)
+
+          add_offense(node) do |corrector|
+            combine_with_left_sibling(corrector, node)
+          end
+        end
+
+        private
+
+        def collection_looping_method?(node)
+          method_name = node.method_name
+          method_name.start_with?('each') || method_name.end_with?('_each')
+        end
+
+        def same_collection_looping_block?(node, sibling)
+          return false if sibling.nil? || !sibling.any_block_type?
+
+          sibling.method?(node.method_name) &&
+            sibling.receiver == node.receiver &&
+            sibling.send_node.arguments == node.send_node.arguments
+        end
+
+        def same_collection_looping_for?(node, sibling)
+          sibling&.for_type? && node.collection == sibling.collection
+        end
+
+        def combine_with_left_sibling(corrector, node)
+          corrector.remove(node.left_sibling.body.source_range.end.join(node.left_sibling.loc.end))
+          corrector.remove(node.source_range.begin.join(node.body.source_range.begin))
+
+          correct_end_of_block(corrector, node)
+        end
+
+        def correct_end_of_block(corrector, node)
+          return unless node.left_sibling.respond_to?(:braces?)
+          return if node.right_sibling&.any_block_type?
+
+          end_of_block = node.left_sibling.braces? ? '}' : ' end'
+          corrector.remove(node.loc.end)
+          corrector.insert_before(node.source_range.end, end_of_block)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/command_literal.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Enforces using `` or %x around command literals.
+      #
+      # @example EnforcedStyle: backticks (default)
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      # @example EnforcedStyle: mixed
+      #   # bad
+      #   folders = %x(find . -type d).split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = `find . -type d`.split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example EnforcedStyle: percent_x
+      #   # bad
+      #   folders = `find . -type d`.split
+      #
+      #   # bad
+      #   `
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   `
+      #
+      #   # good
+      #   folders = %x(find . -type d).split
+      #
+      #   # good
+      #   %x(
+      #     ln -s foo.example.yml foo.example
+      #     ln -s bar.example.yml bar.example
+      #   )
+      #
+      # @example AllowInnerBackticks: false (default)
+      #   # If `false`, the cop will always recommend using `%x` if one or more
+      #   # backticks are found in the command string.
+      #
+      #   # bad
+      #   `echo \`ls\``
+      #
+      #   # good
+      #   %x(echo `ls`)
+      #
+      # @example AllowInnerBackticks: true
+      #   # good
+      #   `echo \`ls\``
+      class CommandLiteral < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG_USE_BACKTICKS = 'Use backticks around command string.'
+        MSG_USE_PERCENT_X = 'Use `%x` around command string.'
+
+        def on_xstr(node)
+          return if node.heredoc?
+
+          if backtick_literal?(node)
+            check_backtick_literal(node, MSG_USE_PERCENT_X)
+          else
+            check_percent_x_literal(node, MSG_USE_BACKTICKS)
+          end
+        end
+
+        private
+
+        def check_backtick_literal(node, message)
+          return if allowed_backtick_literal?(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def check_percent_x_literal(node, message)
+          return if allowed_percent_x_literal?(node)
+
+          add_offense(node, message: message) { |corrector| autocorrect(corrector, node) }
+        end
+
+        def autocorrect(corrector, node)
+          return if contains_backtick?(node)
+
+          replacement = if backtick_literal?(node)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
+                        else
+                          %w[` `]
+                        end
+
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
+
+        def allowed_backtick_literal?(node)
+          case style
+          when :backticks
+            !contains_disallowed_backtick?(node)
+          when :mixed
+            node.single_line? && !contains_disallowed_backtick?(node)
+          end
+        end
+
+        def allowed_percent_x_literal?(node)
+          case style
+          when :backticks
+            contains_disallowed_backtick?(node)
+          when :mixed
+            node.multiline? || contains_disallowed_backtick?(node)
+          when :percent_x
+            true
+          end
+        end
+
+        def contains_disallowed_backtick?(node)
+          !allow_inner_backticks? && contains_backtick?(node)
+        end
+
+        def allow_inner_backticks?
+          cop_config['AllowInnerBackticks']
+        end
+
+        def contains_backtick?(node)
+          node_body(node).include?('`')
+        end
+
+        def node_body(node)
+          loc = node.loc
+          loc.expression.source[loc.begin.length...-loc.end.length]
+        end
+
+        def backtick_literal?(node)
+          node.loc.begin.source == '`'
+        end
+
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).chars
+        end
+
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
+
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
+
+        def preferred_delimiters_config
+          config.for_cop('Style/PercentLiteralDelimiters') ['PreferredDelimiters']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/comment_annotation.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks that comment annotation keywords are written according
+      # to guidelines.
+      #
+      # Annotation keywords can be specified by overriding the cop's `Keywords`
+      # configuration. Keywords are allowed to be single words or phrases.
+      #
+      # NOTE: With a multiline comment block (where each line is only a
+      # comment), only the first line will be able to register an offense, even
+      # if an annotation keyword starts another line. This is done to prevent
+      # incorrect registering of keywords (eg. `review`) inside a paragraph as an
+      # annotation.
+      #
+      # @example RequireColon: true (default)
+      #   # bad
+      #   # TODO make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # TODO:make better
+      #
+      #   # good
+      #   # TODO: make better
+      #
+      #   # bad
+      #   # fixme: does not work
+      #
+      #   # good
+      #   # FIXME: does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE: does not work
+      #
+      # @example RequireColon: false
+      #   # bad
+      #   # TODO: make better
+      #
+      #   # good
+      #   # TODO make better
+      #
+      #   # bad
+      #   # fixme does not work
+      #
+      #   # good
+      #   # FIXME does not work
+      #
+      #   # bad
+      #   # Optimize does not work
+      #
+      #   # good
+      #   # OPTIMIZE does not work
+      class CommentAnnotation < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG_COLON_STYLE = 'Annotation keywords like `%<keyword>s` should be all ' \
+                          'upper case, followed by a colon, and a space, ' \
+                          'then a note describing the problem.'
+        MSG_SPACE_STYLE = 'Annotation keywords like `%<keyword>s` should be all ' \
+                          'upper case, followed by a space, ' \
+                          'then a note describing the problem.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, is missing a note.'
+
+        def on_new_investigation
+          processed_source.comments.each_with_index do |comment, index|
+            next unless first_comment_line?(processed_source.comments, index) ||
+                        inline_comment?(comment)
+
+            annotation = AnnotationComment.new(comment, keywords)
+            next unless annotation.annotation? && !annotation.correct?(colon: requires_colon?)
+
+            register_offense(annotation)
+          end
+        end
+
+        private
+
+        def register_offense(annotation)
+          range = annotation_range(annotation)
+          message = if annotation.note
+                      requires_colon? ? MSG_COLON_STYLE : MSG_SPACE_STYLE
+                    else
+                      MISSING_NOTE
+                    end
+
+          add_offense(range, message: format(message, keyword: annotation.keyword)) do |corrector|
+            next if annotation.note.nil?
+
+            correct_offense(corrector, range, annotation.keyword)
+          end
+        end
+
+        def first_comment_line?(comments, index)
+          index.zero? || comments[index - 1].loc.line < comments[index].loc.line - 1
+        end
+
+        def inline_comment?(comment)
+          !comment_line?(comment.source_range.source_line)
+        end
+
+        def annotation_range(annotation)
+          range_between(*annotation.bounds)
+        end
+
+        def correct_offense(corrector, range, keyword)
+          return corrector.replace(range, "#{keyword.upcase}: ") if requires_colon?
+
+          corrector.replace(range, "#{keyword.upcase} ")
+        end
+
+        def requires_colon?
+          cop_config['RequireColon']
+        end
+
+        def keywords
+          cop_config['Keywords']
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/commented_keyword.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative '../../directive_comment'
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for comments put on the same line as some keywords.
+      # These keywords are: `class`, `module`, `def`, `begin`, `end`.
+      #
+      # Note that some comments
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`),
+      # RBS::Inline annotation, and Steep annotation (`steep:ignore`) are allowed.
+      #
+      # Autocorrection removes comments from `end` keyword and keeps comments
+      # for `class`, `module`, `def` and `begin` above the keyword.
+      #
+      # @safety
+      #   Autocorrection is unsafe because it may remove a comment that is
+      #   meaningful.
+      #
+      # @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   end # end if
+      #
+      #   # bad
+      #   class X # comment
+      #     statement
+      #   end
+      #
+      #   # bad
+      #   def x; end # comment
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   class X # :nodoc:
+      #     y
+      #   end
+      class CommentedKeyword < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Do not place comments on the same line as the `%<keyword>s` keyword.'
+
+        KEYWORDS = %w[begin class def end module].freeze
+        KEYWORD_REGEXES = KEYWORDS.map { |w| /^\s*#{w}\s/ }.freeze
+
+        ALLOWED_COMMENTS = %w[:nodoc: :yields:].freeze
+        ALLOWED_COMMENT_REGEXES = (ALLOWED_COMMENTS.map { |c| /#\s*#{c}/ } +
+                                   [DirectiveComment::DIRECTIVE_COMMENT_REGEXP]).freeze
+
+        REGEXP = /(?<keyword>\S+).*#/.freeze
+
+        SUBCLASS_DEFINITION = /\A\s*class\s+(\w|::)+\s*<\s*(\w|::)+/.freeze
+        METHOD_OR_END_DEFINITIONS = /\A\s*(def\s|end)/.freeze
+
+        STEEP_REGEXP = /#\ssteep:ignore(\s|\z)/.freeze
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            next unless offensive?(comment) && (match = source_line(comment).match(REGEXP))
+
+            register_offense(comment, match[:keyword])
+          end
+        end
+
+        private
+
+        def register_offense(comment, matched_keyword)
+          add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
+            range = range_with_surrounding_space(comment.source_range, newlines: false)
+            corrector.remove(range)
+
+            unless matched_keyword == 'end'
+              corrector.insert_before(
+                range.source_buffer.line_range(comment.loc.line), "#{comment.text}\n"
+              )
+            end
+          end
+        end
+
+        def offensive?(comment)
+          line = source_line(comment)
+          return false if rbs_inline_annotation?(line, comment)
+          return false if steep_annotation?(comment)
+
+          KEYWORD_REGEXES.any? { |r| r.match?(line) } &&
+            ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
+        end
+
+        def source_line(comment)
+          comment.source_range.source_line
+        end
+
+        def rbs_inline_annotation?(line, comment)
+          case line
+          when SUBCLASS_DEFINITION
+            comment.text.start_with?(/#\[.+\]/)
+          when METHOD_OR_END_DEFINITIONS
+            comment.text.start_with?('#:')
+          else
+            false
+          end
+        end
+
+        def steep_annotation?(comment)
+          comment.text.match?(STEEP_REGEXP)
+        end
+      end
+    end
+  end
+end