rubocop 0.91.0 → 0.91.1

data/lib/rubocop/cop/lint/duplicate_rescue_exception.rb

@@ -33,10 +33,8 @@ module RuboCop
         def on_rescue(node)
           return if rescue_modifier?(node)
 
-          _body, *resbodies, _else = *node
-
-          resbodies.each_with_object(Set.new) do |resbody, previous|
-            rescued_exceptions = rescued_exceptions(resbody)
+          node.resbody_branches.each_with_object(Set.new) do |resbody, previous|
+            rescued_exceptions = resbody.exceptions
 
             rescued_exceptions.each do |exception|
               add_offense(exception) unless previous.add?(exception)

data/lib/rubocop/cop/lint/identity_comparison.rb

@@ -26,9 +26,11 @@ module RuboCop
           return unless compare_between_object_id_by_double_equal?(node)
 
           add_offense(node) do |corrector|
-            receiver = node.receiver.receiver.source
-            argument = node.first_argument.receiver.source
-            replacement = "#{receiver}.equal?(#{argument})"
+            receiver = node.receiver.receiver
+            argument = node.first_argument.receiver
+            return unless receiver && argument
+
+            replacement = "#{receiver.source}.equal?(#{argument.source})"
 
             corrector.replace(node, replacement)
           end

data/lib/rubocop/cop/lint/ineffective_access_modifier.rb

@@ -58,12 +58,9 @@ module RuboCop
         PATTERN
 
         def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
+          check_node(node.body)
         end
+        alias on_module on_class
 
         private
 

data/lib/rubocop/cop/lint/redundant_cop_disable_directive.rb

@@ -56,19 +56,29 @@ module RuboCop
 
         private
 
+        def previous_line_blank?(range)
+          processed_source.buffer.source_line(range.line - 1).blank?
+        end
+
         def comment_range_with_surrounding_space(range)
-          # Eat the entire comment, the preceding space, and the preceding
-          # newline if there is one.
-          original_begin = range.begin_pos
-          range = range_with_surrounding_space(range: range,
-                                               side: :left,
-                                               newlines: true)
-          range_with_surrounding_space(range: range,
-                                       side: :right,
-                                       # Special for a comment that
-                                       # begins the file: remove
-                                       # the newline at the end.
-                                       newlines: original_begin.zero?)
+          if previous_line_blank?(range)
+            # When the previous line is blank, it should be retained
+            range_with_surrounding_space(range: range, side: :right)
+          else
+            # Eat the entire comment, the preceding space, and the preceding
+            # newline if there is one.
+            original_begin = range.begin_pos
+            range = range_with_surrounding_space(range: range,
+                                                 side: :left,
+                                                 newlines: true)
+
+            range_with_surrounding_space(range: range,
+                                         side: :right,
+                                         # Special for a comment that
+                                         # begins the file: remove
+                                         # the newline at the end.
+                                         newlines: original_begin.zero?)
+          end
         end
 
         def directive_range_in_list(range, ranges)

data/lib/rubocop/cop/lint/redundant_cop_enable_directive.rb

@@ -45,18 +45,28 @@ module RuboCop
           return if processed_source.blank?
 
           offenses = processed_source.comment_config.extra_enabled_comments
-          offenses.each do |comment, name|
+          offenses.each { |comment, cop_names| register_offense(comment, cop_names) }
+        end
+
+        private
+
+        def register_offense(comment, cop_names)
+          directive = DirectiveComment.new(comment)
+
+          cop_names.each do |name|
             add_offense(
               range_of_offense(comment, name),
               message: format(MSG, cop: all_or_name(name))
             ) do |corrector|
-              corrector.remove(range_with_comma(comment, name))
+              if directive.match?(cop_names)
+                corrector.remove(range_with_surrounding_space(range: directive.range, side: :right))
+              else
+                corrector.remove(range_with_comma(comment, name))
+              end
             end
           end
         end
 
-        private
-
         def range_of_offense(comment, name)
           start_pos = comment_start(comment) + cop_name_indention(comment, name)
           range_between(start_pos, start_pos + name.size)

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -35,7 +35,6 @@ module RuboCop
       #     baz
       #   end
       class RescueType < Base
-        include RescueNode
         extend AutoCorrector
 
         MSG = 'Rescuing from `%<invalid_exceptions>s` will raise a ' \

data/lib/rubocop/cop/lint/shadowed_exception.rb

@@ -75,8 +75,7 @@ module RuboCop
 
         def rescued_groups_for(rescues)
           rescues.map do |group|
-            rescue_group, = *group
-            evaluate_exceptions(rescue_group)
+            evaluate_exceptions(group)
           end
         end
 
@@ -117,14 +116,15 @@ module RuboCop
           $VERBOSE = old_verbose
         end
 
-        def evaluate_exceptions(rescue_group)
-          if rescue_group
-            rescued_exceptions = rescued_exceptions(rescue_group)
+        def evaluate_exceptions(group)
+          rescued_exceptions = group.exceptions
+
+          if rescued_exceptions.any?
             rescued_exceptions.each_with_object([]) do |exception, converted|
               begin
                 silence_warnings do
                   # Avoid printing deprecation warnings about constants
-                  converted << Kernel.const_get(exception)
+                  converted << Kernel.const_get(exception.source)
                 end
               rescue NameError
                 converted << nil

data/lib/rubocop/cop/lint/unreachable_loop.rb

@@ -159,16 +159,12 @@ module RuboCop
         end
 
         def preceded_by_continue_statement?(break_statement)
-          left_siblings_of(break_statement).any? do |sibling|
+          break_statement.left_siblings.any? do |sibling|
             next if sibling.loop_keyword? || loop_method?(sibling)
 
             sibling.each_descendant(:next, :redo).any?
           end
         end
-
-        def left_siblings_of(node)
-          node.parent.children[0, node.sibling_index]
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -131,12 +131,10 @@ module RuboCop
         MSG = 'Useless `%<current>s` access modifier.'
 
         def on_class(node)
-          check_node(node.children[2]) # class body
-        end
-
-        def on_module(node)
-          check_node(node.children[1]) # module body
+          check_node(node.body)
         end
+        alias on_module on_class
+        alias on_sclass on_class
 
         def on_block(node)
           return unless eval_call?(node)
@@ -144,10 +142,6 @@ module RuboCop
           check_node(node.body)
         end
 
-        def on_sclass(node)
-          check_node(node.children[1]) # singleton class body
-        end
-
         private
 
         def autocorrect(corrector, node)

data/lib/rubocop/cop/lint/useless_times.rb

@@ -49,7 +49,7 @@ module RuboCop
           add_offense(node, message: format(MSG, count: count)) do |corrector|
             next unless own_line?(node)
 
-            if count < 1
+            if never_process?(count, node)
               remove_node(corrector, node)
             elsif !proc_name.empty?
               autocorrect_block_pass(corrector, node, proc_name)
@@ -61,6 +61,10 @@ module RuboCop
 
         private
 
+        def never_process?(count, node)
+          count < 1 || node.block_type? && node.body.nil?
+        end
+
         def remove_node(corrector, node)
           corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
         end
@@ -82,7 +86,12 @@ module RuboCop
         def fix_indentation(source, range)
           # Cleanup indentation in a multiline block
           source_lines = source.split("\n")
-          source_lines[1..-1].each { |line| line[range] = '' }
+
+          source_lines[1..-1].each do |line|
+            next if line.empty?
+
+            line[range] = ''
+          end
           source_lines.join("\n")
         end
 

data/lib/rubocop/cop/metrics/utils/abc_size_calculator.rb

@@ -81,40 +81,49 @@ module RuboCop
           private
 
           def assignment?(node)
+            return compound_assignment(node) if node.masgn_type? || node.shorthand_asgn?
+
             node.for_type? ||
-              node.op_asgn_type? ||
               (node.respond_to?(:setter_method?) && node.setter_method?) ||
-              (simple_assignment?(node) && capturing_variable?(node.children.first))
+              simple_assignment?(node) ||
+              argument?(node)
           end
 
-          def simple_assignment?(node)
-            return false if node.masgn_type?
+          def compound_assignment(node)
+            # Methods setter can not be detected for multiple assignments
+            # and shorthand assigns, so we'll count them here instead
+            children = node.masgn_type? ? node.children[0].children : node.children
 
-            if node.equals_asgn?
-              reset_on_lvasgn(node) if node.lvasgn_type?
-              return true
+            will_be_miscounted = children.count do |child|
+              child.respond_to?(:setter_method?) &&
+                !child.setter_method?
             end
+            @assignment += will_be_miscounted
 
-            argument?(node)
+            false
           end
 
-          def capturing_variable?(name)
-            name && !/^_/.match?(name)
+          def simple_assignment?(node)
+            if !node.equals_asgn?
+              false
+            elsif node.lvasgn_type?
+              reset_on_lvasgn(node)
+              capturing_variable?(node.children.first)
+            else
+              true
+            end
           end
 
-          # Returns true for nodes which otherwise would be counted
-          # as one too many assignment
-          def assignment_doubled_in_ast?(node)
-            node.masgn_type? || node.or_asgn_type? || node.and_asgn_type?
+          def capturing_variable?(name)
+            name && !/^_/.match?(name)
           end
 
           def branch?(node)
             BRANCH_NODES.include?(node.type)
           end
 
-          # TODO: move to rubocop-ast
           def argument?(node)
-            ARGUMENT_TYPES.include?(node.type)
+            ARGUMENT_TYPES.include?(node.type) && capturing_variable?(node.children.first)
           end
 
           def condition?(node)

data/lib/rubocop/cop/mixin/configurable_numbering.rb

@@ -8,9 +8,9 @@ module RuboCop
       include ConfigurableFormatting
 
       FORMATS = {
-        snake_case:  /(?:[a-z_]|_\d+)$/,
-        normalcase:  /(?:_\D*|[A-Za-z]\d*)$/,
-        non_integer: /[A-Za-z_]$/
+        snake_case:  /(?:[[[:lower:]]_]|_\d+)$/,
+        normalcase:  /(?:_\D*|[[[:upper:]][[:lower:]]]\d*)$/,
+        non_integer: /[[[:upper:]][[:lower:]]_]$/
       }.freeze
     end
   end

data/lib/rubocop/cop/mixin/rescue_node.rb

@@ -18,6 +18,7 @@ module RuboCop
           @modifier_locations.include?(node.loc.keyword)
       end
 
+      # @deprecated Use ResbodyNode#exceptions instead
       def rescued_exceptions(resbody)
         rescue_group, = *resbody
         if rescue_group

data/lib/rubocop/cop/mixin/statement_modifier.rb

@@ -57,10 +57,11 @@ module RuboCop
       end
 
       def first_line_comment(node)
-        comment =
-          processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        comment = processed_source.find_comment { |c| c.loc.line == node.loc.line }
+        return unless comment
 
-        comment ? comment.loc.expression.source : nil
+        comment_source = comment.loc.expression.source
+        comment_source unless comment_disables_cop?(comment_source)
       end
 
       def parenthesize?(node)
@@ -80,6 +81,11 @@ module RuboCop
 
         config.for_cop('Layout/LineLength')['Max']
       end
+
+      def comment_disables_cop?(comment)
+        regexp_pattern = "# rubocop : (disable|todo) ([^,],)* (all|#{cop_name})"
+        Regexp.new(regexp_pattern.gsub(' ', '\s*')).match?(comment)
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/visibility_help.rb

@@ -16,32 +16,20 @@ module RuboCop
       end
 
       def find_visibility_start(node)
-        left_siblings_of(node)
-          .reverse
-          .find(&method(:visibility_block?))
+        node.left_siblings
+            .reverse
+            .find(&method(:visibility_block?))
       end
 
       # Navigate to find the last protected method
       def find_visibility_end(node)
         possible_visibilities = VISIBILITY_SCOPES - [node_visibility(node)]
-        right = right_siblings_of(node)
+        right = node.right_siblings
         right.find do |child_node|
           possible_visibilities.include?(node_visibility(child_node))
         end || right.last
       end
 
-      def left_siblings_of(node)
-        siblings_of(node)[0, node.sibling_index]
-      end
-
-      def right_siblings_of(node)
-        siblings_of(node)[node.sibling_index..-1]
-      end
-
-      def siblings_of(node)
-        node.parent.children
-      end
-
       def_node_matcher :visibility_block?, <<~PATTERN
         (send nil? { :private :protected :public })
       PATTERN

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

@@ -53,14 +53,16 @@ module RuboCop
         MSG = 'Combine this loop with the previous loop.'
 
         def on_block(node)
+          return unless node.parent&.begin_type?
           return unless collection_looping_method?(node)
 
-          sibling = left_sibling_of(node)
-          add_offense(node) if same_collection_looping?(node, sibling)
+          add_offense(node) if same_collection_looping?(node, node.left_sibling)
         end
 
         def on_for(node)
-          sibling = left_sibling_of(node)
+          return unless node.parent&.begin_type?
+
+          sibling = node.left_sibling
           add_offense(node) if sibling&.for_type? && node.collection == sibling.collection
         end
 
@@ -71,13 +73,6 @@ module RuboCop
           method_name.match?(/^each/) || method_name.match?(/_each$/)
         end
 
-        def left_sibling_of(node)
-          return unless node.parent&.begin_type?
-
-          index = node.sibling_index - 1
-          node.parent.children[index] if index >= 0
-        end
-
         def same_collection_looping?(node, sibling)
           sibling&.block_type? &&
             sibling.send_node.method?(node.method_name) &&

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

@@ -33,13 +33,17 @@ module RuboCop
       #   class X # :nodoc:
       #     y
       #   end
-      class CommentedKeyword < Cop
+      class CommentedKeyword < Base
         MSG = 'Do not place comments on the same line as the ' \
               '`%<keyword>s` keyword.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           processed_source.comments.each do |comment|
-            add_offense(comment) if offensive?(comment)
+            next unless (match = line(comment).match(/(?<keyword>\S+).*#/))
+
+            if offensive?(comment)
+              add_offense(comment, message: format(MSG, keyword: match[:keyword]))
+            end
           end
         end
 
@@ -62,11 +66,6 @@ module RuboCop
             ALLOWED_COMMENT_REGEXES.none? { |r| r.match?(line) }
         end
 
-        def message(comment)
-          keyword = line(comment).match(/(\S+).*#/)[1]
-          format(MSG, keyword: keyword)
-        end
-
         def line(comment)
           comment.location.expression.source_line
         end