rubocop 0.70.0 → 1.6.1

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

@@ -20,7 +20,7 @@ module RuboCop
         return if ignored_node?(node)
 
         end_loc = node.loc.end
-        return unless end_loc # Discard modifier forms of if/while/until.
+        return if accept_end_kw_alignment?(end_loc)
 
         matching = matching_ranges(end_loc, align_ranges)
 
@@ -39,6 +39,15 @@ module RuboCop
         end
       end
 
+      def start_line_range(node)
+        expr   = node.source_range
+        buffer = expr.source_buffer
+        source = buffer.source_line(expr.line)
+        range  = buffer.line_range(expr.line)
+
+        range_between(range.begin_pos + (source =~ /\S/), range.begin_pos + (source =~ /\s*\z/))
+      end
+
       def add_offense_for_misalignment(node, align_with)
         end_loc = node.loc.end
         msg = format(MSG, end_line: end_loc.line,
@@ -46,7 +55,14 @@ module RuboCop
                           source: align_with.source,
                           align_line: align_with.line,
                           align_col: align_with.column)
-        add_offense(node, location: end_loc, message: msg)
+        add_offense(end_loc, message: msg) do |corrector|
+          autocorrect(corrector, node)
+        end
+      end
+
+      def accept_end_kw_alignment?(end_loc)
+        end_loc.nil? || # Discard modifier forms of if/while/until.
+          !/\A[ \t]*end/.match?(processed_source.lines[end_loc.line - 1])
       end
 
       def style_parameter_name

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

@@ -2,15 +2,25 @@
 
 module RuboCop
   module Cop
-    # Common functionality for enforcing a specific superclass
+    # Common functionality for enforcing a specific superclass.
+    #
+    # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
+    # Rails department has been extracted to RuboCop Rails gem.
+    # This module is deprecated and will be removed by RuboCop 2.0.
+    # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
+    # with existing RuboCop Rails 2.8 or lower.
+    #
+    # @api private
     module EnforceSuperclass
       def self.included(base)
-        base.def_node_matcher :class_definition, <<-PATTERN
-        (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
+        base.def_node_matcher :class_definition, <<~PATTERN
+          (class (const _ !:#{base::SUPERCLASS}) #{base::BASE_PATTERN} ...)
         PATTERN
 
-        base.def_node_matcher :class_new_definition, <<-PATTERN
-        [!^(casgn nil? :#{base::SUPERCLASS} ...) (send (const nil? :Class) :new #{base::BASE_PATTERN})]
+        base.def_node_matcher :class_new_definition, <<~PATTERN
+          [!^(casgn {nil? cbase} :#{base::SUPERCLASS} ...)
+           !^^(casgn {nil? cbase} :#{base::SUPERCLASS} (block ...))
+           (send (const {nil? cbase} :Class) :new #{base::BASE_PATTERN})]
         PATTERN
       end
 

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

@@ -17,7 +17,7 @@ module RuboCop
 
       def method_uses_parens?(node, limit)
         source = node.source_range.source_line[0...limit.loc.column]
-        source =~ /\s*\(\s*$/
+        /\s*\(\s*$/.match?(source)
       end
 
       def check_children_line_break(node, children, start = node)
@@ -31,7 +31,9 @@ module RuboCop
         max = last_by_line(children)
         return if line == max.last_line
 
-        add_offense(min)
+        add_offense(min) do |corrector|
+          EmptyLineCorrector.insert_before(corrector, min)
+        end
       end
 
       def first_by_line(nodes)

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

@@ -12,7 +12,7 @@ module RuboCop
 
       def frozen_string_literal_comment_exists?
         leading_comment_lines.any? do |line|
-          MagicComment.parse(line).frozen_string_literal_specified?
+          MagicComment.parse(line).valid_literal_value?
         end
       end
 
@@ -39,13 +39,22 @@ module RuboCop
         end
       end
 
-      def leading_comment_lines
-        comments = processed_source.comments
+      def frozen_string_literal_specified?
+        leading_comment_lines.any? do |line|
+          MagicComment.parse(line).frozen_string_literal_specified?
+        end
+      end
 
-        comments.each_with_object([]) do |comment, leading_comments|
-          next if comment.loc.line > 3
+      def leading_comment_lines
+        first_non_comment_token = processed_source.tokens.find do |token|
+          !token.comment?
+        end
 
-          leading_comments << comment.text
+        if first_non_comment_token
+          # `line` is 1-indexed so we need to subtract 1 to get the array index
+          processed_source.lines[0...first_non_comment_token.line - 1]
+        else
+          processed_source.lines
         end
       end
     end

data/lib/rubocop/cop/mixin/{hash_alignment.rb → hash_alignment_styles.rb}

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     # Common functionality for checking hash alignment.
-    module HashAlignment
+    module HashAlignmentStyles
       # Handles calculation of deltas when the enforced style is 'key'.
       class KeyAlignment
         def checkable_layout?(_node)
@@ -83,6 +83,10 @@ module RuboCop
       class TableAlignment
         include ValueAlignment
 
+        def initialize
+          self.max_key_width = 0
+        end
+
         def deltas_for_first_pair(first_pair, node)
           self.max_key_width = node.keys.map { |key| key.source.length }.max
 

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

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Style/HashTransformKeys and
+    # Style/HashTransformValues
+    module HashTransformMethod # rubocop:disable Metrics/ModuleLength
+      extend NodePattern::Macros
+
+      RESTRICT_ON_SEND = %i[[] to_h].freeze
+
+      def_node_matcher :array_receiver?, <<~PATTERN
+        {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
+      PATTERN
+
+      def on_block(node)
+        on_bad_each_with_object(node) do |*match|
+          handle_possible_offense(node, match, 'each_with_object')
+        end
+
+        return if target_ruby_version < 2.6
+
+        on_bad_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'to_h {...}')
+        end
+      end
+
+      def on_send(node)
+        on_bad_hash_brackets_map(node) do |*match|
+          handle_possible_offense(node, match, 'Hash[_.map {...}]')
+        end
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      def on_csend(node)
+        on_bad_map_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'map {...}.to_h')
+        end
+      end
+
+      private
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_each_with_object(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_hash_brackets_map(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_map_to_h(_node)
+        raise NotImplementedError
+      end
+
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_to_h(_node)
+        raise NotImplementedError
+      end
+
+      def handle_possible_offense(node, match, match_desc)
+        captures = extract_captures(match)
+
+        # If key didn't actually change either, this is most likely a false
+        # positive (receiver isn't a hash).
+        return if captures.noop_transformation?
+
+        # Can't `transform_keys` if key transformation uses value, or
+        # `transform_values` if value transformation uses key.
+        return if captures.transformation_uses_both_args?
+
+        message = "Prefer `#{new_method_name}` over `#{match_desc}`."
+        add_offense(node, message: message) do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
+      end
+
+      # @abstract
+      #
+      # @return [Captures]
+      def extract_captures(_match)
+        raise NotImplementedError
+      end
+
+      # @abstract
+      #
+      # @return [String]
+      def new_method_name
+        raise NotImplementedError
+      end
+
+      def prepare_correction(node)
+        if (match = on_bad_each_with_object(node))
+          Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_hash_brackets_map(node))
+          Autocorrection.from_hash_brackets_map(node, match)
+        elsif (match = on_bad_map_to_h(node))
+          Autocorrection.from_map_to_h(node, match)
+        elsif (match = on_bad_to_h(node))
+          Autocorrection.from_to_h(node, match)
+        else
+          raise 'unreachable'
+        end
+      end
+
+      def execute_correction(corrector, node, correction)
+        correction.strip_prefix_and_suffix(node, corrector)
+        correction.set_new_method_name(new_method_name, corrector)
+
+        captures = extract_captures(correction.match)
+        correction.set_new_arg_name(captures.transformed_argname, corrector)
+        correction.set_new_body_expression(
+          captures.transforming_body_expr,
+          corrector
+        )
+      end
+
+      # Internal helper class to hold match data
+      Captures = Struct.new(
+        :transformed_argname,
+        :transforming_body_expr,
+        :unchanged_body_expr
+      ) do
+        def noop_transformation?
+          transforming_body_expr.lvar_type? &&
+            transforming_body_expr.children == [transformed_argname]
+        end
+
+        def transformation_uses_both_args?
+          transforming_body_expr.descendants.include?(unchanged_body_expr)
+        end
+      end
+
+      # Internal helper class to hold autocorrect data
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
+        def self.from_each_with_object(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def self.from_hash_brackets_map(node, match)
+          new(match, node.children.last, 'Hash['.length, ']'.length)
+        end
+
+        def self.from_map_to_h(node, match)
+          strip_trailing_chars = 0
+
+          unless node.parent&.block_type?
+            map_range = node.children.first.source_range
+            node_range = node.source_range
+            strip_trailing_chars = node_range.end_pos - map_range.end_pos
+          end
+
+          new(match, node.children.first, 0, strip_trailing_chars)
+        end
+
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
+        def strip_prefix_and_suffix(node, corrector)
+          expression = node.loc.expression
+          corrector.remove_leading(expression, leading)
+          corrector.remove_trailing(expression, trailing)
+        end
+
+        def set_new_method_name(new_method_name, corrector)
+          range = block_node.send_node.loc.selector
+          if (send_end = block_node.send_node.loc.end)
+            # If there are arguments (only true in the `each_with_object`
+            # case)
+            range = range.begin.join(send_end)
+          end
+          corrector.replace(range, new_method_name)
+        end
+
+        def set_new_arg_name(transformed_argname, corrector)
+          corrector.replace(
+            block_node.arguments.loc.expression,
+            "|#{transformed_argname}|"
+          )
+        end
+
+        def set_new_body_expression(transforming_body_expr, corrector)
+          corrector.replace(
+            block_node.body,
+            transforming_body_expr.loc.expression.source
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -4,15 +4,48 @@ module RuboCop
   module Cop
     # This module encapsulates the ability to ignore certain methods when
     # parsing.
+    # Cops that use `IgnoredMethods` can accept either strings or regexes to match
+    # against.
     module IgnoredMethods
-      private
+      # Configuration for IgnoredMethods. It is added to classes that include
+      # the module so that configuration can be set using the `ignored_methods`
+      # class macro.
+      module Config
+        attr_accessor :deprecated_key
+
+        def ignored_methods(**config)
+          self.deprecated_key = config[:deprecated_key]
+        end
+      end
+
+      def self.included(base)
+        base.extend(Config)
+      end
 
       def ignored_method?(name)
-        ignored_methods.include?(name.to_s)
+        ignored_methods.any? do |value|
+          case value
+          when Regexp
+            value.match? String(name)
+          else
+            value == String(name)
+          end
+        end
       end
 
       def ignored_methods
-        cop_config.fetch('IgnoredMethods', [])
+        keys = %w[IgnoredMethods]
+        keys << deprecated_key if deprecated_key
+
+        cop_config.slice(*keys).values.reduce(&:concat)
+      end
+
+      private
+
+      def deprecated_key
+        return unless self.class.respond_to?(:deprecated_key)
+
+        self.class.deprecated_key&.to_s
       end
     end
   end

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

@@ -18,7 +18,7 @@ module RuboCop
       end
 
       def matches_ignored_pattern?(line)
-        ignored_patterns.any? { |pattern| Regexp.new(pattern).match(line) }
+        ignored_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
       end
 
       def ignored_patterns

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for working with string interpolations.
+    #
+    # @abstract Subclasses are expected to implement {#on_interpolation}.
+    module Interpolation
+      def on_dstr(node)
+        on_node_with_interpolations(node)
+      end
+
+      alias on_xstr on_dstr
+      alias on_dsym on_dstr
+      alias on_regexp on_dstr
+
+      def on_node_with_interpolations(node)
+        node.each_child_node(:begin) do |begin_node|
+          on_interpolation(begin_node)
+        end
+      end
+
+      # @!method on_interpolation(begin_node)
+      #   Inspect the `:begin` node of an interpolation
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Help methods for determining if a line is too long.
+    module LineLengthHelp
+      private
+
+      def ignore_cop_directives?
+        config.for_cop('Layout/LineLength')['IgnoreCopDirectives']
+      end
+
+      def directive_on_source_line?(line_index)
+        source_line_number = line_index + processed_source.buffer.first_line
+        comment = processed_source.comment_at_line(source_line_number)
+
+        return false unless comment
+
+        comment.text.match?(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+      end
+
+      def allow_uri?
+        config.for_cop('Layout/LineLength')['AllowURI']
+      end
+
+      def allowed_uri_position?(line, uri_range)
+        uri_range.begin < max_line_length &&
+          (uri_range.end == line_length(line) ||
+           uri_range.end == line_length(line) - 1)
+      end
+
+      def line_length(line)
+        line.length + indentation_difference(line)
+      end
+
+      def find_excessive_uri_range(line)
+        last_uri_match = match_uris(line).last
+        return nil unless last_uri_match
+
+        begin_position, end_position = last_uri_match.offset(0).map do |pos|
+          pos + indentation_difference(line)
+        end
+        return nil if begin_position < max_line_length &&
+                      end_position < max_line_length
+
+        begin_position...end_position
+      end
+
+      def match_uris(string)
+        matches = []
+        string.scan(uri_regexp) do
+          matches << $LAST_MATCH_INFO if valid_uri?($LAST_MATCH_INFO[0])
+        end
+        matches
+      end
+
+      def indentation_difference(line)
+        return 0 unless tab_indentation_width
+
+        (line.index(/[^\t]/) || 0) * (tab_indentation_width - 1)
+      end
+
+      def tab_indentation_width
+        config.for_cop('Layout/IndentationStyle')['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width']
+      end
+
+      def uri_regexp
+        @uri_regexp ||=
+          URI::DEFAULT_PARSER
+          .make_regexp(config.for_cop('Layout/LineLength')['URISchemes'])
+      end
+
+      def valid_uri?(uri_ish_string)
+        URI.parse(uri_ish_string)
+        true
+      rescue URI::InvalidURIError, NoMethodError
+        false
+      end
+
+      def line_length_without_directive(line)
+        before_comment, = line.split(CommentConfig::COMMENT_DIRECTIVE_REGEXP)
+        before_comment.rstrip.length
+      end
+    end
+  end
+end

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

@@ -2,25 +2,39 @@
 
 module RuboCop
   module Cop
+    # @api private
+    #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
       include ConfigurableMax
+      include IgnoredMethods
+      include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
 
+      # Ensure cops that include `MethodComplexity` have the config
+      # `attr_accessor`s that `ignored_method?` needs.
+      def self.included(base)
+        base.extend(IgnoredMethods::Config)
+      end
+
       def on_def(node)
+        return if ignored_method?(node.method_name)
+
         check_complexity(node, node.method_name)
       end
       alias on_defs on_def
 
       def on_block(node)
         define_method?(node) do |name|
+          return if ignored_method?(name)
+
           check_complexity(node, name)
         end
       end
 
       private
 
-      def_node_matcher :define_method?, <<-PATTERN
+      def_node_matcher :define_method?, <<~PATTERN
         (block
          (send nil? :define_method ({sym str} $_))
          args
@@ -32,13 +46,15 @@ module RuboCop
         return unless node.body
 
         max = cop_config['Max']
-        complexity = complexity(node.body)
+        reset_repeated_csend
+        complexity, abc_vector = complexity(node.body)
 
         return unless complexity > max
 
         msg = format(self.class::MSG,
                      method: method_name,
                      complexity: complexity,
+                     abc_vector: abc_vector,
                      max: max)
 
         add_offense(node, message: msg) do
@@ -47,8 +63,12 @@ module RuboCop
       end
 
       def complexity(body)
-        body.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
-          score + complexity_score_for(n)
+        body.each_node(:lvasgn, *self.class::COUNTED_NODES).reduce(1) do |score, node|
+          if node.lvasgn_type?
+            reset_on_lvasgn(node)
+            next score
+          end
+          score + complexity_score_for(node)
         end
       end
     end

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

@@ -16,7 +16,9 @@ module RuboCop
         last_seen_line = -1
         children.each do |child|
           if last_seen_line >= child.first_line
-            add_offense(child)
+            add_offense(child) do |corrector|
+              EmptyLineCorrector.insert_before(corrector, child)
+            end
           else
             last_seen_line = child.last_line
           end

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

@@ -31,7 +31,7 @@ module RuboCop
       #   b c { block }.            <-- b is indented relative to a
       #   d                         <-- d is indented relative to a
       def left_hand_side(lhs)
-        lhs = lhs.parent while lhs.parent&.send_type?
+        lhs = lhs.parent while lhs.parent&.send_type? && lhs.parent.loc.dot
         lhs
       end
 
@@ -152,18 +152,18 @@ module RuboCop
         expression
       end
 
-      def argument_in_method_call(node, kind)
+      def argument_in_method_call(node, kind) # rubocop:todo Metrics/CyclomaticComplexity
         node.each_ancestor(:send, :block).find do |a|
           # If the node is inside a block, it makes no difference if that block
           # is an argument in a method call. It doesn't count.
           break false if a.block_type?
 
           next if a.setter_method?
+          next unless kind == :with_or_without_parentheses ||
+                      kind == :with_parentheses && parentheses?(a)
 
           a.arguments.any? do |arg|
-            within_node?(node, arg) && (kind == :with_or_without_parentheses ||
-                                        kind == :with_parentheses &&
-                                        parentheses?(node.parent))
+            within_node?(node, arg)
           end
         end
       end