rubocop 0.51.0 → 0.87.0

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

@@ -5,50 +5,82 @@ module RuboCop
     module Style
       # This cop checks that comment annotation keywords are written according
       # to guidelines.
+      #
+      # @example
+      #   # 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
       class CommentAnnotation < Cop
         include AnnotationComment
+        include RangeHelp
 
-        MSG = 'Annotation keywords like `%s` should be all upper case, ' \
-              'followed by a colon, and a space, ' \
-              'then a note describing the problem.'.freeze
-        MISSING_NOTE = 'Annotation comment, with keyword `%s`, ' \
-                       'is missing a note.'.freeze
+        MSG = 'Annotation keywords like `%<keyword>s` should be all ' \
+              'upper case, followed by a colon, and a space, ' \
+              'then a note describing the problem.'
+        MISSING_NOTE = 'Annotation comment, with keyword `%<keyword>s`, ' \
+                       'is missing a note.'
 
         def investigate(processed_source)
-          processed_source.comments.each_with_index do |comment, ix|
-            next unless first_comment_line?(processed_source.comments, ix)
+          processed_source.comments.each_with_index do |comment, index|
+            next unless first_comment_line?(processed_source.comments, index) ||
+                        inline_comment?(comment)
 
             margin, first_word, colon, space, note = split_comment(comment)
             next unless annotation?(comment) &&
                         !correct_annotation?(first_word, colon, space, note)
 
-            length = concat_length(first_word, colon, space)
             add_offense(
               comment,
-              location: annotation_range(comment, margin, length),
-              message: format(note ? MSG : MISSING_NOTE, first_word)
+              location: annotation_range(comment, margin,
+                                         first_word, colon, space),
+              message: format(note ? MSG : MISSING_NOTE, keyword: first_word)
             )
           end
         end
 
-        private
-
-        def first_comment_line?(comments, ix)
-          ix.zero? || comments[ix - 1].loc.line < comments[ix].loc.line - 1
-        end
-
         def autocorrect(comment)
           margin, first_word, colon, space, note = split_comment(comment)
           return if note.nil?
 
-          length = concat_length(first_word, colon, space)
-          range = annotation_range(comment, margin, length)
+          range = annotation_range(comment, margin, first_word, colon, space)
 
           ->(corrector) { corrector.replace(range, "#{first_word.upcase}: ") }
         end
 
-        def annotation_range(comment, margin, length)
+        private
+
+        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.loc.expression.source_line)
+        end
+
+        def annotation_range(comment, margin, first_word, colon, space)
           start = comment.loc.expression.begin_pos + margin.length
+          length = concat_length(first_word, colon, space)
           range_between(start, start + length)
         end
 

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

@@ -6,8 +6,9 @@ module RuboCop
       # This cop checks for comments put on the same line as some keywords.
       # These keywords are: `begin`, `class`, `def`, `end`, `module`.
       #
-      # Note that some comments (such as `:nodoc:` and `rubocop:disable`) are
-      # allowed.
+      # Note that some comments
+      # (`:nodoc:`, `:yields:`, `rubocop:disable` and `rubocop:todo`)
+      # are allowed.
       #
       # @example
       #   # bad
@@ -29,51 +30,42 @@ module RuboCop
       #   end
       #
       #   # good
-      #   class x # :nodoc:
+      #   class X # :nodoc:
       #     y
       #   end
       class CommentedKeyword < Cop
         MSG = 'Do not place comments on the same line as the ' \
-              '`%s` keyword.'.freeze
+              '`%<keyword>s` keyword.'
 
         def investigate(processed_source)
-          heredoc_lines = extract_heredoc_lines(processed_source.ast)
-
-          processed_source.lines.each_with_index do |line, index|
-            next if heredoc_lines.any? { |r| r.include?(index + 1) }
-            next unless offensive?(line)
-
-            range = source_range(processed_source.buffer,
-                                 index + 1,
-                                 (line.index('#'))...(line.length))
-
-            add_offense(range, location: range)
+          processed_source.each_comment do |comment|
+            add_offense(comment) if offensive?(comment)
           end
         end
 
         private
 
         KEYWORDS = %w[begin class def end module].freeze
-        ALLOWED_COMMENTS = %w[:nodoc: rubocop:disable].freeze
+        ALLOWED_COMMENTS = %w[
+          :nodoc:
+          :yields:
+          rubocop:disable
+          rubocop:todo
+        ].freeze
 
-        def offensive?(line)
-          KEYWORDS.any? { |k| line =~ /^\s*#{k}\s+.*#/ } &&
-            ALLOWED_COMMENTS.none? { |c| line =~ /#\s*#{c}/ }
+        def offensive?(comment)
+          line = line(comment)
+          KEYWORDS.any? { |word| /^\s*#{word}\s/.match?(line) } &&
+            ALLOWED_COMMENTS.none? { |c| /#\s*#{c}/.match?(line) }
         end
 
-        def message(node)
-          line = node.source_line
-          keyword = /^\s*(\S+).*#/.match(line)[1]
-          format(MSG, keyword)
+        def message(comment)
+          keyword = line(comment).match(/(\S+).*#/)[1]
+          format(MSG, keyword: keyword)
         end
 
-        def extract_heredoc_lines(ast)
-          return [] unless ast
-          ast.each_node.with_object([]) do |node, heredocs|
-            next unless node.location.is_a?(Parser::Source::Map::Heredoc)
-            body = node.location.heredoc_body
-            heredocs << (body.first_line...body.last_line)
-          end
+        def line(comment)
+          comment.location.expression.source_line
         end
       end
     end

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

@@ -8,10 +8,10 @@ module RuboCop
       module ConditionalAssignmentHelper
         extend NodePattern::Macros
 
-        EQUAL = '='.freeze
-        END_ALIGNMENT = 'Lint/EndAlignment'.freeze
-        ALIGN_WITH = 'EnforcedStyleAlignWith'.freeze
-        KEYWORD = 'keyword'.freeze
+        EQUAL = '='
+        END_ALIGNMENT = 'Layout/EndAlignment'
+        ALIGN_WITH = 'EnforcedStyleAlignWith'
+        KEYWORD = 'keyword'
 
         # `elsif` branches show up in the `node` as an `else`. We need
         # to recursively iterate over all `else` branches and consider all
@@ -67,16 +67,17 @@ module RuboCop
 
         private
 
-        def expand_elsif(node, elsif_branches = [])
-          return [] if node.nil? || !node.if_type?
-          _condition, elsif_branch, else_branch = *node
-          elsif_branches << elsif_branch
-          if else_branch && else_branch.if_type?
+        def expand_elsif(node, elsif_branches = []) # rubocop:todo Metrics/CyclomaticComplexity
+          return [] if node.nil? || !node.if_type? || !node.elsif?
+
+          elsif_branches << node.if_branch
+
+          else_branch = node.else_branch
+          if else_branch&.if_type? && else_branch&.elsif?
             expand_elsif(else_branch, elsif_branches)
           else
             elsif_branches << else_branch
           end
-          elsif_branches
         end
 
         def lhs_for_send(node)
@@ -100,6 +101,7 @@ module RuboCop
         def assignment_rhs_exist?(node)
           parent = node.parent
           return true unless parent
+
           !(parent.mlhs_type? || parent.resbody_type?)
         end
       end
@@ -108,9 +110,7 @@ module RuboCop
       # assignment to the same variable when using the return of the
       # condition can be used instead.
       #
-      # @example
-      #   EnforcedStyle: assign_to_condition
-      #
+      # @example EnforcedStyle: assign_to_condition (default)
       #   # bad
       #   if foo
       #     bar = 1
@@ -155,7 +155,7 @@ module RuboCop
       #            2
       #          end
       #
-      #   EnforcedStyle: assign_inside_condition
+      # @example EnforcedStyle: assign_inside_condition
       #   # bad
       #   bar = if foo
       #           1
@@ -205,25 +205,23 @@ module RuboCop
         include IgnoredNode
 
         MSG = 'Use the return of the conditional for variable assignment ' \
-              'and comparison.'.freeze
+              'and comparison.'
         ASSIGN_TO_CONDITION_MSG =
-          'Assign variables inside of conditionals'.freeze
+          'Assign variables inside of conditionals'
         VARIABLE_ASSIGNMENT_TYPES =
           %i[casgn cvasgn gvasgn ivasgn lvasgn].freeze
         ASSIGNMENT_TYPES = VARIABLE_ASSIGNMENT_TYPES +
                            %i[and_asgn or_asgn op_asgn masgn].freeze
-        LINE_LENGTH = 'Metrics/LineLength'.freeze
-        INDENTATION_WIDTH = 'Layout/IndentationWidth'.freeze
-        ENABLED = 'Enabled'.freeze
-        MAX = 'Max'.freeze
-        SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'.freeze
-        WIDTH = 'Width'.freeze
-
-        def_node_matcher :condition?, '{if case}'
+        LINE_LENGTH = 'Layout/LineLength'
+        INDENTATION_WIDTH = 'Layout/IndentationWidth'
+        ENABLED = 'Enabled'
+        MAX = 'Max'
+        SINGLE_LINE_CONDITIONS_ONLY = 'SingleLineConditionsOnly'
+        WIDTH = 'Width'
 
         # The shovel operator `<<` does not have its own type. It is a `send`
         # type.
-        def_node_matcher :assignment_type?, <<-PATTERN
+        def_node_matcher :assignment_type?, <<~PATTERN
           {
             #{ASSIGNMENT_TYPES.join(' ')}
             (send _recv {:[]= :<< :=~ :!~ :<=> #end_with_eq?} ...)
@@ -268,6 +266,14 @@ module RuboCop
           check_node(node, branches)
         end
 
+        def autocorrect(node)
+          if assignment_type?(node)
+            move_assignment_inside_condition(node)
+          else
+            move_assignment_outside_condition(node)
+          end
+        end
+
         private
 
         def check_assignment_to_condition(node)
@@ -300,23 +306,13 @@ module RuboCop
           single_line_conditions_only? && branches.any?(&:begin_type?)
         end
 
-        def autocorrect(node)
-          if assignment_type?(node)
-            move_assignment_inside_condition(node)
-          else
-            move_assignment_outside_condition(node)
-          end
-        end
-
         def assignment_node(node)
           *_variable, assignment = *node
 
           # ignore pseudo-assignments without rhs in for nodes
-          return if node.parent && node.parent.for_type?
+          return if node.parent&.for_type?
 
-          if assignment.begin_type? && assignment.children.one?
-            assignment, = *assignment
-          end
+          assignment, = *assignment if assignment.begin_type? && assignment.children.one?
 
           assignment
         end
@@ -326,10 +322,8 @@ module RuboCop
             CaseCorrector.correct(self, node)
           elsif node.ternary?
             TernaryCorrector.correct(node)
-          elsif node.if?
+          elsif node.if? || node.unless?
             IfCorrector.correct(self, node)
-          elsif node.unless?
-            UnlessCorrector.correct(self, node)
           end
         end
 
@@ -350,6 +344,8 @@ module RuboCop
         end
 
         def lhs_all_match?(branches)
+          return true if branches.empty?
+
           first_lhs = lhs(branches.first)
           branches.all? { |branch| lhs(branch) == first_lhs }
         end
@@ -372,13 +368,13 @@ module RuboCop
         def allowed_statements?(branches)
           return false unless branches.all?
 
-          statements = branches.map { |branch| tail(branch) }
+          statements = branches.map { |branch| tail(branch) }.compact
 
           lhs_all_match?(statements) && statements.none?(&:masgn_type?) &&
             assignment_types_match?(*statements)
         end
 
-        # If `Metrics/LineLength` is enabled, we do not want to introduce an
+        # If `Layout/LineLength` is enabled, we do not want to introduce an
         # offense by auto-correcting this cop. Find the max configured line
         # length. Find the longest line of condition. Remove the assignment
         # from lines that contain the offending assignment because after
@@ -460,7 +456,7 @@ module RuboCop
         def correct_if_branches(corrector, cop, node)
           if_branch, elsif_branches, else_branch = extract_tail_branches(node)
 
-          corrector.insert_before(node.source_range, lhs(if_branch))
+          corrector.insert_before(node, lhs(if_branch))
           replace_branch_assignment(corrector, if_branch)
           correct_branches(corrector, elsif_branches)
           replace_branch_assignment(corrector, else_branch)
@@ -477,13 +473,13 @@ module RuboCop
                           source
                         end
 
-          corrector.replace(branch.source_range, replacement)
+          corrector.replace(branch, replacement)
         end
 
         def correct_branches(corrector, branches)
           branches.each do |branch|
             *_, assignment = *branch
-            corrector.replace(branch.source_range, assignment.source)
+            corrector.replace(branch, assignment.source)
           end
         end
       end
@@ -496,7 +492,7 @@ module RuboCop
 
           def correct(node)
             lambda do |corrector|
-              corrector.replace(node.source_range, correction(node))
+              corrector.replace(node, correction(node))
             end
           end
 
@@ -517,18 +513,18 @@ module RuboCop
           private
 
           def correction(node)
-            condition, if_branch, else_branch = *node
-
-            "#{lhs(if_branch)}#{ternary(condition, if_branch, else_branch)}"
+            "#{lhs(node.if_branch)}#{ternary(node)}"
           end
 
-          def ternary(condition, if_branch, else_branch)
-            _variable, *_operator, if_rhs = *if_branch
-            _else_variable, *_operator, else_rhs = *else_branch
+          def ternary(node)
+            _variable, *_operator, if_rhs = *node.if_branch
+            _else_variable, *_operator, else_rhs = *node.else_branch
 
-            expr = "#{condition.source} ? #{if_rhs.source} : #{else_rhs.source}"
+            expr = "#{node.condition.source} ? " \
+                   "#{if_rhs.source} : " \
+                   "#{else_rhs.source}"
 
-            element_assignment?(if_branch) ? "(#{expr})" : expr
+            element_assignment?(node.if_branch) ? "(#{expr})" : expr
           end
 
           def element_assignment?(node)
@@ -549,7 +545,7 @@ module RuboCop
           end
 
           def move_branch_inside_condition(corrector, branch, assignment)
-            corrector.insert_before(branch.loc.expression, assignment.source)
+            corrector.insert_before(branch, assignment.source)
           end
         end
       end
@@ -572,7 +568,7 @@ module RuboCop
             lambda do |corrector|
               corrector.remove(assignment)
 
-              extract_branches(condition).flatten.each do |branch|
+              condition.branches.flatten.each do |branch|
                 move_branch_inside_condition(corrector, branch, condition,
                                              assignment, column)
               end
@@ -582,28 +578,22 @@ module RuboCop
           private
 
           def extract_tail_branches(node)
-            if_branch, elsif_branches, else_branch = extract_branches(node)
+            if_branch, *elsif_branches, else_branch = *node.branches
             elsif_branches.map! { |branch| tail(branch) }
 
             [tail(if_branch), elsif_branches, tail(else_branch)]
           end
 
-          def extract_branches(node)
-            _condition, if_branch, else_branch = *node
-            elsif_branches, else_branch = expand_elses(else_branch)
-
-            [if_branch, elsif_branches, else_branch]
-          end
-
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment.loc.expression,
+            corrector.insert_before(branch_assignment,
                                     assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
 
-            branch_else = branch.parent.loc.else
+            return unless (branch_else = branch.parent.loc.else)
+
             corrector.remove_preceding(branch_else, branch_else.column - column)
           end
         end
@@ -619,7 +609,7 @@ module RuboCop
             when_branches, else_branch = extract_tail_branches(node)
 
             lambda do |corrector|
-              corrector.insert_before(node.source_range, lhs(else_branch))
+              corrector.insert_before(node, lhs(else_branch))
               correct_branches(corrector, when_branches)
               replace_branch_assignment(corrector, else_branch)
 
@@ -651,16 +641,16 @@ module RuboCop
             [when_branches, tail(else_branch)]
           end
 
-          def extract_branches(node)
-            _condition, *when_branches, else_branch = *node
-            when_branches = expand_when_branches(when_branches)
-            [when_branches, else_branch]
+          def extract_branches(case_node)
+            when_branches = expand_when_branches(case_node.when_branches)
+
+            [when_branches, case_node.else_branch]
           end
 
           def move_branch_inside_condition(corrector, branch, condition,
                                            assignment, column)
             branch_assignment = tail(branch)
-            corrector.insert_before(branch_assignment.loc.expression,
+            corrector.insert_before(branch_assignment,
                                     assignment.source)
 
             remove_whitespace_in_branches(corrector, branch, condition, column)
@@ -671,26 +661,6 @@ module RuboCop
           end
         end
       end
-
-      # Corrector to correct conditional assignment in `unless` statements.
-      class UnlessCorrector
-        class << self
-          include ConditionalAssignmentHelper
-          include ConditionalCorrectorHelper
-
-          def correct(cop, node)
-            ->(corrector) { correct_if_branches(corrector, cop, node) }
-          end
-
-          private
-
-          def extract_tail_branches(node)
-            _condition, else_branch, if_branch = *node
-
-            [tail(if_branch), [], tail(else_branch)]
-          end
-        end
-      end
     end
   end
 end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that constants defined in classes and modules have
+      # an explicit visibility declaration. By default, Ruby makes all class-
+      # and module constants public, which litters the public API of the
+      # class or module. Explicitly declaring a visibility makes intent more
+      # clear, and prevents outside actors from touching private state.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Foo
+      #     BAR = 42
+      #     BAZ = 43
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     BAR = 42
+      #     private_constant :BAR
+      #
+      #     BAZ = 43
+      #     public_constant :BAZ
+      #   end
+      #
+      class ConstantVisibility < Cop
+        MSG = 'Explicitly make `%<constant_name>s` public or private using ' \
+              'either `#public_constant` or `#private_constant`.'
+
+        def on_casgn(node)
+          return unless class_or_module_scope?(node)
+          return if visibility_declaration?(node)
+
+          add_offense(node)
+        end
+
+        private
+
+        def message(node)
+          _namespace, constant_name, _value = *node
+
+          format(MSG, constant_name: constant_name)
+        end
+
+        def class_or_module_scope?(node)
+          return false unless node.parent
+
+          case node.parent.type
+          when :begin
+            class_or_module_scope?(node.parent)
+          when :class, :module
+            true
+          end
+        end
+
+        def visibility_declaration?(node)
+          _namespace, constant_name, _value = *node
+
+          node.parent.each_child_node(:send).any? do |child|
+            visibility_declaration_for?(child, constant_name)
+          end
+        end
+
+        def_node_matcher :visibility_declaration_for?, <<~PATTERN
+          (send nil? {:public_constant :private_constant} ({sym str} #match_name?(%1)))
+        PATTERN
+
+        def match_name?(name, constant_name)
+          name.to_sym == constant_name.to_sym
+        end
+      end
+    end
+  end
+end