rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Bundler/OrderedGems and
+    # Gemspec/OrderedDependencies.
+    module OrderedGemNode
+      private
+
+      def get_source_range(node, comments_as_separators)
+        unless comments_as_separators
+          first_comment = processed_source.ast_with_comments[node].first
+          return first_comment.loc.expression unless first_comment.nil?
+        end
+        node.source_range
+      end
+
+      def case_insensitive_out_of_order?(string_a, string_b)
+        string_a.downcase < string_b.downcase
+      end
+
+      def consecutive_lines(previous, current)
+        first_line = get_source_range(
+          current,
+          treat_comments_as_separators
+        ).first_line
+        previous.source_range.last_line == first_line - 1
+      end
+
+      def register_offense(previous, current)
+        message = format(
+          self.class::MSG,
+          previous: gem_name(current),
+          current: gem_name(previous)
+        )
+        add_offense(current, message: message)
+      end
+
+      def gem_name(declaration_node)
+        declaration_node.first_argument.str_content
+      end
+
+      def treat_comments_as_separators
+        cop_config['TreatCommentsAsGroupSeparators']
+      end
+    end
+  end
+end

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

@@ -1,23 +1,17 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for handling parentheses.
     module Parentheses
+      private
+
       def parens_required?(node)
         range  = node.source_range
         source = range.source_buffer.source
         source[range.begin_pos - 1] =~ /[a-z]/ ||
           source[range.end_pos] =~ /[a-z]/
       end
-
-      def autocorrect(node)
-        lambda do |corrector|
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
-        end
-      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -27,7 +26,10 @@ module RuboCop
                       d.message.capitalize
                     end
 
-          add_offense(nil, d.location, message, d.level)
+          add_offense(nil,
+                      location: d.location,
+                      message: message,
+                      severity: d.level)
         end
       end
     end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling percent arrays.
+    module PercentArray
+      private
+
+      # Ruby does not allow percent arrays in an ambiguous block context.
+      #
+      # @example
+      #
+      #   foo %i[bar baz] { qux }
+      def invalid_percent_array_context?(node)
+        parent = node.parent
+
+        parent && parent.send_type? && parent.arguments.include?(node) &&
+          !parent.parenthesized? && parent.block_literal?
+      end
+
+      def allowed_bracket_array?(node)
+        comments_in_array?(node) || below_array_length?(node) ||
+          invalid_percent_array_context?(node)
+      end
+
+      def message(_node)
+        style == :percent ? self.class::PERCENT_MSG : self.class::ARRAY_MSG
+      end
+
+      def comments_in_array?(node)
+        comments = processed_source.comments
+        array_range = node.source_range.to_a
+
+        comments.any? do |comment|
+          !(comment.loc.expression.to_a & array_range).empty?
+        end
+      end
+
+      def check_percent_array(node)
+        array_style_detected(:percent, node.values.size)
+        add_offense(node) if style == :brackets
+      end
+
+      def check_bracketed_array(node)
+        return if allowed_bracket_array?(node)
+
+        array_style_detected(:brackets, node.values.size)
+        add_offense(node) if style == :percent
+      end
+    end
+  end
+end

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

@@ -1,10 +1,13 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for handling percent literals.
     module PercentLiteral
+      PERCENT_LITERAL_TYPES = %w[% %i %I %q %Q %r %s %w %W %x].freeze
+
+      private
+
       def percent_literal?(node)
         return unless (begin_source = begin_source(node))
         begin_source.start_with?('%')
@@ -26,11 +29,71 @@ module RuboCop
       # A range containing only the contents of the percent literal (e.g. in
       # %i{1 2 3} this will be the range covering '1 2 3' only)
       def contents_range(node)
-        Parser::Source::Range.new(
-          node.loc.expression.source_buffer,
-          node.loc.begin.end_pos,
-          node.loc.end.begin_pos
-        )
+        range_between(node.loc.begin.end_pos, node.loc.end.begin_pos)
+      end
+
+      # ['a', 'b', 'c'] => %w(a b c)
+      def correct_percent(node, char)
+        words = node.children
+        escape = words.any? { |w| needs_escaping?(w.children[0]) }
+        char = char.upcase if escape
+        delimiters = preferred_delimiters_for("%#{char}")
+        contents = autocorrect_words(words, escape, node.first_line, delimiters)
+
+        lambda do |corrector|
+          corrector.replace(
+            node.source_range,
+            "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
+          )
+        end
+      end
+
+      def autocorrect_words(word_nodes, escape, base_line_number, delimiters)
+        previous_node_line_number = base_line_number
+        word_nodes.map do |node|
+          number_of_line_breaks = node.first_line - previous_node_line_number
+          line_breaks = "\n" * number_of_line_breaks
+          previous_node_line_number = node.first_line
+          content = node.children.first.to_s
+          content = escape ? escape_string(content) : content
+          delimiters.each do |delimiter|
+            content.gsub!(delimiter, "\\#{delimiter}")
+          end
+          line_breaks + content
+        end.join(' ')
+      end
+
+      def ensure_valid_preferred_delimiters
+        invalid = preferred_delimiters_config.keys -
+                  (PERCENT_LITERAL_TYPES + %w[default])
+        return if invalid.empty?
+
+        raise ArgumentError,
+              "Invalid preferred delimiter config key: #{invalid.join(', ')}"
+      end
+
+      def preferred_delimiters
+        @preferred_delimiters ||=
+          begin
+            ensure_valid_preferred_delimiters
+
+            if preferred_delimiters_config.key?('default')
+              Hash[PERCENT_LITERAL_TYPES.map do |type|
+                [type, preferred_delimiters_config[type] ||
+                  preferred_delimiters_config['default']]
+              end]
+            else
+              preferred_delimiters_config
+            end
+          end
+      end
+
+      def preferred_delimiters_config
+        @config.for_cop('Style/PercentLiteralDelimiters')['PreferredDelimiters']
+      end
+
+      def preferred_delimiters_for(type)
+        preferred_delimiters[type].split(//)
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,6 +5,8 @@ module RuboCop
     # Common functionality for checking whether an AST node/token is aligned
     # with something on a preceding or following line
     module PrecedingFollowingAlignment
+      private
+
       def allow_for_alignment?
         cop_config['AllowForAlignment']
       end
@@ -22,14 +23,24 @@ module RuboCop
         # minus 2 because node.loc.line is zero-based
         pre  = (range.line - 2).downto(0)
         post = range.line.upto(processed_source.lines.size - 1)
-        return true if aligned_with_line?(pre, range, &predicate) ||
-                       aligned_with_line?(post, range, &predicate)
+
+        aligned_with_any_line_range?([pre, post], range, &predicate)
+      end
+
+      def aligned_with_any_line_range?(line_ranges, range, &predicate)
+        return true if aligned_with_any_line?(line_ranges, range, &predicate)
 
         # If no aligned token was found, search for an aligned token on the
         # nearest line with the same indentation as the checked line.
         base_indentation = processed_source.lines[range.line - 1] =~ /\S/
-        aligned_with_line?(pre, range, base_indentation, &predicate) ||
-          aligned_with_line?(post, range, base_indentation, &predicate)
+
+        aligned_with_any_line?(line_ranges, range, base_indentation, &predicate)
+      end
+
+      def aligned_with_any_line?(line_ranges, range, indent = nil, &predicate)
+        line_ranges.any? do |line_nos|
+          aligned_with_line?(line_nos, range, indent, &predicate)
+        end
       end
 
       def aligned_with_line?(line_nos, range, indent = nil)

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking `rescue` nodes.
+    module RescueNode
+      def investigate(processed_source)
+        @modifier_locations = processed_source
+                              .tokens
+                              .select { |t| t.type == :kRESCUE_MOD }
+                              .map(&:pos)
+      end
+
+      private
+
+      def rescue_modifier?(node)
+        node &&
+          node.resbody_type? &&
+          @modifier_locations.include?(node.loc.keyword)
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,6 +8,9 @@ module RuboCop
     module SafeAssignment
       extend NodePattern::Macros
 
+      private
+
+      def_node_matcher :empty_condition?, '(begin)'
       def_node_matcher :safe_assignment?,
                        '(begin {equals_asgn? asgn_method_call?})'
 

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for Rails safe mode.
+    module SafeMode
+      private
+
+      def rails_safe_mode?
+        safe_mode? || rails?
+      end
+
+      def safe_mode?
+        cop_config['SafeMode']
+      end
+
+      def rails?
+        config['Rails'] && config['Rails'].fetch('Enabled')
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,14 +5,17 @@ module RuboCop
     # Common functionality for cops checking for missing space after
     # punctuation.
     module SpaceAfterPunctuation
-      MSG = 'Space missing after %s.'.freeze
+      MSG = 'Space missing after %<token>s.'.freeze
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token|
-          add_offense(token, token.pos, format(MSG, kind(token)))
+          add_offense(token, location: token.pos,
+                             message: format(MSG, token: kind(token)))
         end
       end
 
+      private
+
       def each_missing_space(tokens)
         tokens.each_cons(2) do |t1, t2|
           next unless kind(t1)
@@ -25,16 +27,16 @@ module RuboCop
       end
 
       def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.column == t1.pos.column + offset
+        t1.line == t2.line && t2.column == t1.column + offset
       end
 
       def space_required_before?(token)
         !(allowed_type?(token) ||
-          (token.type == :tRCURLY && space_forbidden_before_rcurly?))
+          (token.right_curly_brace? && space_forbidden_before_rcurly?))
       end
 
       def allowed_type?(token)
-        [:tRPAREN, :tRBRACK, :tPIPE].include?(token.type)
+        %i[tRPAREN tRBRACK tPIPE].include?(token.type)
       end
 
       def space_forbidden_before_rcurly?
@@ -47,10 +49,6 @@ module RuboCop
       def offset
         1
       end
-
-      def autocorrect(token)
-        ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
-      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,46 +5,43 @@ module RuboCop
     # Common functionality for cops checking for space before
     # punctuation.
     module SpaceBeforePunctuation
-      MSG = 'Space found before %s.'.freeze
+      MSG = 'Space found before %<token>s.'.freeze
 
       def investigate(processed_source)
         each_missing_space(processed_source.tokens) do |token, pos_before|
-          add_offense(pos_before, pos_before, format(MSG, kind(token)))
+          add_offense(pos_before, location: pos_before,
+                                  message: format(MSG, token: kind(token)))
         end
       end
 
+      private
+
       def each_missing_space(tokens)
         tokens.each_cons(2) do |t1, t2|
           next unless kind(t2)
           next unless space_missing?(t1, t2)
           next if space_required_after?(t1)
 
-          buffer = processed_source.buffer
-          pos_before_punctuation = Parser::Source::Range.new(buffer,
-                                                             t1.pos.end_pos,
-                                                             t2.pos.begin_pos)
+          pos_before_punctuation = range_between(t1.end_pos,
+                                                 t2.begin_pos)
 
           yield t2, pos_before_punctuation
         end
       end
 
       def space_missing?(t1, t2)
-        t1.pos.line == t2.pos.line && t2.pos.begin_pos > t1.pos.end_pos
+        t1.line == t2.line && t2.begin_pos > t1.end_pos
       end
 
       def space_required_after?(token)
-        token.type == :tLCURLY && space_required_after_lcurly?
+        token.left_curly_brace? && space_required_after_lcurly?
       end
 
       def space_required_after_lcurly?
-        cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+        cfg = config.for_cop('Layout/SpaceInsideBlockBraces')
         style = cfg['EnforcedStyle'] || 'space'
         style == 'space'
       end
-
-      def autocorrect(pos_before_punctuation)
-        ->(corrector) { corrector.remove(pos_before_punctuation) }
-      end
     end
   end
 end

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

@@ -1,26 +1,40 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for modifier cops.
     module StatementModifier
-      include IfNode
+      private
 
-      def fit_within_line_as_modifier_form?(node)
-        cond, body, _else = if_node_parts(node)
+      def single_line_as_modifier?(node)
+        return false if non_eligible_node?(node) ||
+                        non_eligible_body?(node.body) ||
+                        non_eligible_condition?(node.condition)
 
-        return false if length(node) > 3
-        return false if body && body.begin_type? # multiple statements
+        modifier_fits_on_single_line?(node)
+      end
+
+      def non_eligible_node?(node)
+        node.nonempty_line_count > 3 ||
+          !node.modifier_form? && commented?(node.loc.end)
+      end
 
-        body_length = body_length(body)
+      def non_eligible_body?(body)
+        body.nil? ||
+          body.empty_source? ||
+          body.begin_type? ||
+          commented?(body.source_range)
+      end
+
+      def non_eligible_condition?(condition)
+        condition.each_node.any?(&:lvasgn_type?)
+      end
 
-        return false if body_length.zero?
-        return false if cond.each_node.any?(&:lvasgn_type?)
-        return false if body_has_comment?(body)
-        return false if end_keyword_has_comment?(node)
+      def modifier_fits_on_single_line?(node)
+        modifier_length = length_in_modifier_form(node, node.condition,
+                                                  node.body.source_length)
 
-        length_in_modifier_form(node, cond, body_length) <= max_line_length
+        modifier_length <= max_line_length
       end
 
       def length_in_modifier_form(node, cond, body_length)
@@ -32,28 +46,11 @@ module RuboCop
       end
 
       def max_line_length
-        cop_config['MaxLineLength'] ||
-          config.for_cop('Metrics/LineLength')['Max']
-      end
-
-      def length(node)
-        node.source.lines.grep(/\S/).size
-      end
-
-      def body_length(body)
-        if body && body.source_range
-          body.source_range.size
-        else
-          0
-        end
-      end
-
-      def body_has_comment?(body)
-        comment_lines.include?(body.source_range.line)
+        config.for_cop('Metrics/LineLength')['Max']
       end
 
-      def end_keyword_has_comment?(node)
-        comment_lines.include?(node.loc.end.line)
+      def commented?(source)
+        comment_lines.include?(source.line)
       end
 
       def comment_lines

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -15,7 +14,7 @@ module RuboCop
         return if part_of_ignored_node?(node)
 
         if offense?(node)
-          add_offense(node, :expression) { opposite_style_detected }
+          add_offense(node) { opposite_style_detected }
         else
           correct_style_detected
         end
@@ -25,6 +24,8 @@ module RuboCop
         ignore_node(node)
       end
 
+      private
+
       def inside_interpolation?(node)
         # A :begin node inside a :dstr node is an interpolation.
         node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -7,26 +6,15 @@ module RuboCop
     module StringLiteralsHelp
       include StringHelp
 
+      private
+
       def wrong_quotes?(node)
         src = node.source
         return false if src.start_with?('%', '?')
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\ | \#(@|\{)/x
-        end
-      end
-
-      def autocorrect(node)
-        return if node.dstr_type?
-
-        lambda do |corrector|
-          str = node.str_content
-          if style == :single_quotes
-            corrector.replace(node.source_range, to_string_literal(str))
-          else
-            corrector.replace(node.source_range, str.inspect)
-          end
+          src !~ /" | \\[^'] | \#(@|\{)/x
         end
       end
     end