rubocop 0.40.0 → 0.41.0

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for quotes and commas in %w, e.g.
+      #
+      #   `%w('foo', "bar")`
+      #
+      # it is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting strings.
+      class PercentStringArray < Cop
+        include PercentLiteral
+
+        MSG = "Within `%w`/`%W`, quotes and ',' are unnecessary and may be " \
+          'unwanted in the resulting strings.'.freeze
+
+        def on_array(node)
+          process(node, *%w(%w %W))
+        end
+
+        def on_percent_literal(node)
+          if contains_quotes_or_commas?(node)
+            add_offense(node, :expression, MSG)
+          end
+        end
+
+        private
+
+        def contains_quotes_or_commas?(node)
+          patterns = [/,$/, /^'.*'$/, /^".*"$/]
+
+          node.children.any? do |child|
+            literal = child.children.first
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.to_s.gsub(/[^\p{Alnum}]/, '').empty?
+
+            patterns.any? { |pat| literal =~ pat }
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.children.each do |child|
+              range = child.loc.expression
+
+              match = /['"]?,?$/.match(range.source)
+              corrector.remove_trailing(range, match[0].length) if match
+
+              corrector.remove_leading(range, 1) if /^['"]/ =~ range.source
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for colons and commas in %i, e.g.
+      #
+      #   `%i(:foo, :bar)`
+      #
+      # it is more likely that the additional characters are unintended (for
+      # example, mistranslating an array of literals to percent string notation)
+      # rather than meant to be part of the resulting symbols.
+      class PercentSymbolArray < Cop
+        include PercentLiteral
+
+        MSG = "Within `%i`/`%I`, ':' and ',' are unnecessary and may be " \
+          'unwanted in the resulting symbols.'.freeze
+
+        def on_array(node)
+          process(node, *%w(%i %I))
+        end
+
+        def on_percent_literal(node)
+          if contains_colons_or_commas?(node)
+            add_offense(node, :expression, MSG)
+          end
+        end
+
+        private
+
+        def contains_colons_or_commas?(node)
+          patterns = [/^:/, /,$/]
+          node.children.any? do |child|
+            literal = child.children.first
+
+            # To avoid likely false positives (e.g. a single ' or ")
+            next if literal.to_s.gsub(/[^\p{Alnum}]/, '').empty?
+
+            patterns.any? { |pat| literal =~ pat }
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            node.children.each do |child|
+              range = child.loc.expression
+
+              corrector.remove_trailing(range, 1) if /,$/ =~ range.source
+              corrector.remove_leading(range, 1) if /^:/ =~ range.source
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for a rescued exception that get shadowed by a
+      # less specific exception being rescued before a more specific
+      # exception is rescued.
+      #
+      # @example
+      # # bad
+      # begin
+      #   something
+      # rescue Exception
+      #   handle_exception
+      # rescue StandardError
+      #   handle_standard_error
+      # end
+      #
+      # #good
+      # begin
+      #   something
+      # rescue StandardError
+      #   handle_standard_error
+      # rescue Exception
+      #   handle_exception
+      # end
+      class ShadowedException < Cop
+        MSG = 'Do not shadow rescued Exceptions'.freeze
+
+        def on_rescue(node)
+          return if rescue_modifier?(node)
+          _body, *rescues, _else = *node
+          rescued_groups = rescues.each_with_object([]) do |group, exceptions|
+            rescue_group, = *group
+
+            exceptions << evaluate_exceptions(rescue_group)
+          end
+
+          rescue_group_rescues_multiple_levels = rescued_groups.any? do |group|
+            !contains_multiple_levels_of_exceptions?(group)
+          end
+
+          return if rescue_group_rescues_multiple_levels &&
+                    rescued_groups == sort_rescued_groups(rescued_groups)
+
+          add_offense(node, :expression)
+        end
+
+        private
+
+        def rescue_modifier?(node)
+          node && node.rescue_type? &&
+            (node.parent.nil? || !(node.parent.kwbegin_type? ||
+             node.parent.ensure_type?))
+        end
+
+        def contains_multiple_levels_of_exceptions?(group)
+          group.any? do |exception|
+            higher_exception = false
+            group.each_with_index do |_e, i|
+              higher_exception ||= group[i] < exception
+            end
+
+            higher_exception
+          end
+        end
+
+        def evaluate_exceptions(rescue_group)
+          if rescue_group
+            rescued_exceptions = rescue_group.source.delete(' ').split(',')
+
+            rescued_exceptions.each_with_object([]) do |exception, converted|
+              begin
+                converted << instance_eval(exception, __FILE__, __LINE__)
+              rescue StandardError, ScriptError
+                next
+              end
+            end
+          else
+            # treat an empty `rescue` as `rescue StandardError`
+            [StandardError]
+          end
+        end
+
+        def sort_rescued_groups(groups)
+          groups.sort do |x, y|
+            x <=> y || 0
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -68,7 +68,7 @@ module RuboCop
         end
 
         def on_block(node)
-          return unless class_or_instance_eval?(node)
+          return unless instance_eval_or_new_call?(node)
 
           check_node(node.children[2]) # block body
         end
@@ -95,6 +95,10 @@ module RuboCop
           (block (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
+        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+        PATTERN
+
         def check_node(node)
           return if node.nil?
 
@@ -114,17 +118,8 @@ module RuboCop
         def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if (new_vis = access_modifier(child))
-              # does this modifier just repeat the existing visibility?
-              if new_vis == cur_vis
-                add_offense(child, :expression, format(MSG, cur_vis))
-              else
-                # was the previous modifier never applied to any defs?
-                add_offense(unused, :expression, format(MSG, cur_vis)) if unused
-                # once we have already warned about a certain modifier, don't
-                # warn again even if it is never applied to any method defs
-                unused = child
-              end
-              cur_vis = new_vis
+              cur_vis, unused =
+                check_new_visibility(child, unused, new_vis, cur_vis)
             elsif method_definition?(child)
               unused = nil
             elsif start_of_new_scope?(child)
@@ -137,13 +132,33 @@ module RuboCop
           [cur_vis, unused]
         end
 
+        def check_new_visibility(node, unused, new_vis, cur_vis)
+          # does this modifier just repeat the existing visibility?
+          if new_vis == cur_vis
+            add_offense(node, :expression, format(MSG, cur_vis))
+          else
+            # was the previous modifier never applied to any defs?
+            add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+            # once we have already warned about a certain modifier, don't
+            # warn again even if it is never applied to any method defs
+            unused = node
+          end
+
+          [new_vis, unused]
+        end
+
         def method_definition?(child)
           static_method_definition?(child) || dynamic_method_definition?(child)
         end
 
         def start_of_new_scope?(child)
           child.module_type? || child.class_type? ||
-            child.sclass_type? || class_or_instance_eval?(child)
+            child.sclass_type? || instance_eval_or_new_call?(child)
+        end
+
+        def instance_eval_or_new_call?(child)
+          class_or_instance_eval?(child) ||
+            class_or_module_or_struct_new_call?(child)
         end
       end
     end

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

@@ -31,26 +31,19 @@ module RuboCop
         unless items.empty?
           base_column ||= display_column(items.first.source_range)
         end
-        prev_line = -1
-        items.each do |current|
-          if current.loc.line > prev_line &&
-             begins_its_line?(current.source_range)
-            @column_delta = base_column - display_column(current.source_range)
-            if @column_delta != 0
-              expr = current.source_range
-              if offenses.any? { |o| within?(expr, o.location) }
-                # If this offense is within a line range that is already being
-                # realigned by autocorrect, we report the offense without
-                # autocorrecting it. Two rewrites in the same area by the same
-                # cop can not be handled. The next iteration will find the
-                # offense again and correct it.
-                add_offense(nil, expr)
-              else
-                add_offense(current, :expression)
-              end
-            end
+
+        each_bad_alignment(items, base_column) do |current|
+          expr = current.source_range
+          if offenses.any? { |o| within?(expr, o.location) }
+            # If this offense is within a line range that is already being
+            # realigned by autocorrect, we report the offense without
+            # autocorrecting it. Two rewrites in the same area by the same
+            # cop can not be handled. The next iteration will find the
+            # offense again and correct it.
+            add_offense(nil, expr)
+          else
+            add_offense(current, :expression)
           end
-          prev_line = current.loc.line
         end
       end
 
@@ -77,6 +70,19 @@ module RuboCop
 
       private
 
+      def each_bad_alignment(items, base_column)
+        prev_line = -1
+        items.each do |current|
+          if current.loc.line > prev_line &&
+             begins_its_line?(current.source_range)
+            @column_delta = base_column - display_column(current.source_range)
+
+            yield current if @column_delta != 0
+          end
+          prev_line = current.loc.line
+        end
+      end
+
       def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
                            heredoc_ranges)
         range = calculate_range(expr, line_begin_pos, column_delta)

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

@@ -21,22 +21,30 @@ module RuboCop
         end_loc = node.loc.end
         return unless end_loc # Discard modifier forms of if/while/until.
 
-        matching = align_ranges.select do |_, range|
-          range.line == end_loc.line ||
-            effective_column(range) == end_loc.column
-        end
+        matching = matching_ranges(end_loc, align_ranges)
 
         if matching.key?(style)
           correct_style_detected
         else
-          align_with = align_ranges[style]
-          msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
-                       align_with.line, align_with.column)
-          add_offense(node, end_loc, msg)
+          add_offense_for_misalignment(node, align_ranges[style])
           style_detected(matching.keys)
         end
       end
 
+      def matching_ranges(end_loc, align_ranges)
+        align_ranges.select do |_, range|
+          range.line == end_loc.line ||
+            effective_column(range) == end_loc.column
+        end
+      end
+
+      def add_offense_for_misalignment(node, align_with)
+        end_loc = node.loc.end
+        msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
+                     align_with.line, align_with.column)
+        add_offense(node, end_loc, msg)
+      end
+
       def parameter_name
         'AlignWith'
       end

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

@@ -11,8 +11,7 @@ module RuboCop
 
       def modifier_if?(node)
         node.loc.respond_to?(:keyword) &&
-          %w(if unless).include?(node.loc.keyword.source) &&
-          node.loc.respond_to?(:end) && node.loc.end.nil?
+          %w(if unless).include?(node.loc.keyword.source) && node.modifier_form?
       end
 
       def elsif?(node)

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking integer nodes.
+    module IntegerNode
+      def integer_part(node)
+        node.source.sub(/^[+-]/, '').split('.').first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for obtaining source ranges from regexp matches
+    module MatchRange
+      # Return a new `Range` covering the first matching group number for each
+      # match of `regex` inside `range`
+      def each_match_range(range, regex)
+        range.source.scan(regex) do
+          yield match_range(range, Regexp.last_match)
+        end
+      end
+
+      # For a `match` inside `range`, return a new `Range` covering the match
+      def match_range(range, match)
+        Parser::Source::Range.new(
+          range.source_buffer,
+          range.begin_pos + match.begin(1),
+          range.begin_pos + match.end(1)
+        )
+      end
+    end
+  end
+end

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

@@ -71,7 +71,8 @@ module RuboCop
 
       def incorrect_style_detected(range, node, lhs, rhs)
         add_offense(range, range, message(node, lhs, rhs)) do
-          if offending_range(node, lhs, rhs, alternative_style)
+          if supported_styles.size > 2 ||
+             offending_range(node, lhs, rhs, alternative_style)
             unrecognized_style_detected
           else
             opposite_style_detected
@@ -130,17 +131,25 @@ module RuboCop
           when :block
             break if part_of_block_body?(candidate, a)
           when :send
-            _receiver, method_name, *args = *a
-
-            # The []= operator and setters (a.b = c) are parsed as :send nodes.
-            assignment_call?(method_name) &&
-              (!candidate || within_node?(candidate, args.last))
+            valid_method_rhs_candidate?(candidate, a)
           when *Util::ASGN_NODES
-            !candidate || within_node?(candidate, assignment_rhs(a))
+            valid_rhs_candidate?(candidate, assignment_rhs(a))
           end
         end
       end
 
+      # The []= operator and setters (a.b = c) are parsed as :send nodes.
+      def valid_method_rhs_candidate?(candidate, node)
+        _receiver, method_name, *args = *node
+
+        assignment_call?(method_name) &&
+          valid_rhs_candidate?(candidate, args.last)
+      end
+
+      def valid_rhs_candidate?(candidate, node)
+        !candidate || within_node?(candidate, node)
+      end
+
       def assignment_call?(method_name)
         method_name == :[]= || method_name.to_s =~ /^\w.*=$/
       end