rubocop 0.52.1 → 0.53.0

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

@@ -45,7 +45,7 @@ module RuboCop
 
       def aligned_with_line?(line_nos, range, indent = nil)
         line_nos.each do |lineno|
-          next if comment_lines.include?(lineno + 1)
+          next if aligned_comment_lines.include?(lineno + 1)
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
@@ -55,10 +55,11 @@ module RuboCop
         false
       end
 
-      def comment_lines
-        @comment_lines ||= processed_source.comments.map(&:loc).select do |r|
-          begins_its_line?(r.expression)
-        end.map(&:line)
+      def aligned_comment_lines
+        @aligned_comment_lines ||=
+          processed_source.comments.map(&:loc).select do |r|
+            begins_its_line?(r.expression)
+          end.map(&:line)
       end
 
       def aligned_token?(range, line)

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Methods that calculate and return Parser::Source::Ranges
+    module RangeHelp
+      private
+
+      def source_range(source_buffer, line_number, column, length = 1)
+        if column.is_a?(Range)
+          column_index = column.begin
+          length = column.size
+        else
+          column_index = column
+        end
+
+        line_begin_pos = if line_number.zero?
+                           0
+                         else
+                           source_buffer.line_range(line_number).begin_pos
+                         end
+        begin_pos = line_begin_pos + column_index
+        end_pos = begin_pos + length
+
+        Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+      end
+
+      def range_between(start_pos, end_pos)
+        Parser::Source::Range.new(processed_source.buffer, start_pos, end_pos)
+      end
+
+      def range_with_surrounding_comma(range, side = :both)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        begin_pos = move_pos(src, begin_pos, -1, go_left, /,/)
+        end_pos = move_pos(src, end_pos, 1, go_right, /,/)
+
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_with_surrounding_space(range:, side: :both,
+                                       newlines: true, whitespace: false)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        go_left, go_right = directions(side)
+
+        begin_pos = range.begin_pos
+        if go_left
+          begin_pos =
+            final_pos(src, begin_pos, -1, newlines, whitespace)
+        end
+        end_pos = range.end_pos
+        end_pos = final_pos(src, end_pos, 1, newlines, whitespace) if go_right
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
+      end
+
+      def range_by_whole_lines(range, include_final_newline: false)
+        buffer = @processed_source.buffer
+
+        begin_pos = range.begin_pos
+        begin_offset = range.column
+        begin_of_first_line = begin_pos - begin_offset
+
+        last_line = buffer.source_line(range.last_line)
+        end_pos = range.end_pos
+        end_offset = last_line.length - range.last_column
+        end_offset += 1 if include_final_newline
+        end_of_last_line = end_pos + end_offset
+
+        Parser::Source::Range.new(buffer, begin_of_first_line, end_of_last_line)
+      end
+
+      ## Helpers for above range methods. Do not use inside Cops.
+
+      def directions(side)
+        if side == :both
+          [true, true]
+        else
+          [side == :left, side == :right]
+        end
+      end
+
+      def final_pos(src, pos, increment, newlines, whitespace)
+        pos = move_pos(src, pos, increment, true, /[ \t]/)
+        pos = move_pos(src, pos, increment, newlines, /\n/)
+        move_pos(src, pos, increment, whitespace, /\s/)
+      end
+
+      def move_pos(src, pos, step, condition, regexp)
+        offset = step == -1 ? -1 : 0
+        pos += step while condition && src[pos + offset] =~ regexp
+        pos < 0 ? 0 : pos
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module RuboCop
       def investigate(processed_source)
         @modifier_locations = processed_source
                               .tokens
-                              .select { |t| t.type == :kRESCUE_MOD }
+                              .select(&:rescue_modifier?)
                               .map(&:pos)
       end
 

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

@@ -17,17 +17,18 @@ module RuboCop
       private
 
       def each_missing_space(tokens)
-        tokens.each_cons(2) do |t1, t2|
-          next unless kind(t1)
-          next unless space_missing?(t1, t2)
-          next unless space_required_before?(t2)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token1)
+          next unless space_missing?(token1, token2)
+          next unless space_required_before?(token2)
 
-          yield t1
+          yield token1
         end
       end
 
-      def space_missing?(t1, t2)
-        t1.line == t2.line && t2.column == t1.column + offset
+      def space_missing?(token1, token2)
+        token1.line == token2.line &&
+          token2.column == token1.column + offset
       end
 
       def space_required_before?(token)

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

@@ -5,6 +5,8 @@ module RuboCop
     # Common functionality for cops checking for space before
     # punctuation.
     module SpaceBeforePunctuation
+      include RangeHelp
+
       MSG = 'Space found before %<token>s.'.freeze
 
       def investigate(processed_source)
@@ -17,20 +19,20 @@ module RuboCop
       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)
+        tokens.each_cons(2) do |token1, token2|
+          next unless kind(token2)
+          next unless space_missing?(token1, token2)
+          next if space_required_after?(token1)
 
-          pos_before_punctuation = range_between(t1.end_pos,
-                                                 t2.begin_pos)
+          pos_before_punctuation = range_between(token1.end_pos,
+                                                 token2.begin_pos)
 
-          yield t2, pos_before_punctuation
+          yield token2, pos_before_punctuation
         end
       end
 
-      def space_missing?(t1, t2)
-        t1.line == t2.line && t2.begin_pos > t1.end_pos
+      def space_missing?(token1, token2)
+        token1.line == token2.line && token2.begin_pos > token1.end_pos
       end
 
       def space_required_after?(token)

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

@@ -16,14 +16,15 @@ module RuboCop
 
       def non_eligible_node?(node)
         node.nonempty_line_count > 3 ||
-          !node.modifier_form? && commented?(node.loc.end)
+          !node.modifier_form? &&
+            processed_source.commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)
         body.nil? ||
           body.empty_source? ||
           body.begin_type? ||
-          commented?(body.source_range)
+          processed_source.commented?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -48,14 +49,6 @@ module RuboCop
       def max_line_length
         config.for_cop('Metrics/LineLength')['Max']
       end
-
-      def commented?(source)
-        comment_lines.include?(source.line)
-      end
-
-      def comment_lines
-        @comment_lines ||= processed_source.comments.map { |c| c.location.line }
-      end
     end
   end
 end

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

@@ -4,6 +4,8 @@ module RuboCop
   module Cop
     # Common functionality for checking and correcting surrounding whitespace.
     module SurroundingSpace
+      include RangeHelp
+
       NO_SPACE_COMMAND = 'Do not use'.freeze
       SPACE_COMMAND = 'Use'.freeze
 
@@ -51,14 +53,6 @@ module RuboCop
         end
       end
 
-      def tokens(node)
-        @tokens ||= {}
-        @tokens[node.object_id] ||= processed_source.tokens.select do |token|
-          token.end_pos <= node.source_range.end_pos &&
-            token.begin_pos >= node.source_range.begin_pos
-        end
-      end
-
       def no_space_offenses(node, # rubocop:disable Metrics/ParameterLists
                             left_token,
                             right_token,
@@ -105,6 +99,42 @@ module RuboCop
         add_offense(node, location: range,
                           message: format(message, command: command))
       end
+
+      def empty_offenses(node, left, right, message)
+        range = range_between(left.begin_pos, right.end_pos)
+        if offending_empty_space?(empty_config, left, right)
+          empty_offense(node, range, message, 'Use one')
+        end
+        return unless offending_empty_no_space?(empty_config, left, right)
+        empty_offense(node, range, message, 'Do not use')
+      end
+
+      def empty_offense(node, range, message, command)
+        add_offense(node, location: range,
+                          message: format(message, command: command))
+      end
+
+      def empty_brackets?(left_bracket_token, right_bracket_token)
+        left_index = processed_source.tokens.index(left_bracket_token)
+        right_index = processed_source.tokens.index(right_bracket_token)
+        right_index && left_index == right_index - 1
+      end
+
+      def offending_empty_space?(config, left_token, right_token)
+        config == 'space' && !space_between?(left_token, right_token)
+      end
+
+      def offending_empty_no_space?(config, left_token, right_token)
+        config == 'no_space' && !no_space_between?(left_token, right_token)
+      end
+
+      def space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos + 1 == right_bracket_token.begin_pos
+      end
+
+      def no_space_between?(left_bracket_token, right_bracket_token)
+        left_bracket_token.end_pos == right_bracket_token.begin_pos
+      end
     end
   end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by TrailingBody cops
+    module TrailingBody
+      def trailing_body?(node)
+        body = node.to_a.reverse[0]
+        body && node.multiline? &&
+          body_on_first_line?(node, body)
+      end
+
+      def body_on_first_line?(node, body)
+        node.source_range.first_line == body.source_range.first_line
+      end
+
+      def first_part_of(body)
+        if body.begin_type?
+          body.children.first.source_range
+        else
+          body.source_range
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module RuboCop
     # Style/TrailingCommaInLiteral
     module TrailingComma
       include ConfigurableEnforcedStyle
+      include RangeHelp
 
       MSG = '%<command>s comma after the last %<unit>s.'.freeze
 
@@ -35,6 +36,17 @@ module RuboCop
         avoid_comma(kind, comma_pos, extra_avoid_comma_info)
       end
 
+      def check_literal(node, kind)
+        return if node.children.empty?
+        # A braceless hash is the last parameter of a method call and will be
+        # checked as such.
+        return unless brackets?(node)
+
+        check(node, node.children, kind,
+              node.children.last.source_range.end_pos,
+              node.loc.end.begin_pos)
+      end
+
       def extra_avoid_comma_info
         case style
         when :comma
@@ -111,8 +123,8 @@ module RuboCop
         items.each_cons(2).none? { |a, b| on_same_line?(a, b) }
       end
 
-      def on_same_line?(a, b)
-        a.last_line == b.line
+      def on_same_line?(range1, range2)
+        range1.last_line == range2.line
       end
 
       def avoid_comma(kind, comma_begin_pos, extra_info)
@@ -152,7 +164,7 @@ module RuboCop
       end
 
       # By default, there's no reason to avoid auto-correct.
-      def avoid_autocorrect?(_)
+      def avoid_autocorrect?(_nodes)
         false
       end
     end

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

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality shared by Uncommunicative cops
+    module UncommunicativeName
+      CASE_MSG = 'Only use lowercase characters for %<name_type>s.'.freeze
+      NUM_MSG = 'Do not end %<name_type>s with a number.'.freeze
+      LENGTH_MSG = '%<name_type>s must be longer than %<min>s ' \
+                   'characters.'.freeze
+      FORBIDDEN_MSG = 'Do not use %<name>s as a name for a ' \
+                      '%<name_type>s.'.freeze
+
+      def check(node, args)
+        args.each do |arg|
+          name = arg.children.first.to_s
+          next if arg.restarg_type? && name.empty?
+          next if allowed_names.include?(name)
+          range = arg_range(arg, name.size)
+          issue_offenses(node, range, name)
+        end
+      end
+
+      private
+
+      def issue_offenses(node, range, name)
+        forbidden_offense(node, range, name) if forbidden_names.include?(name)
+        case_offense(node, range) if uppercase?(name)
+        length_offense(node, range) unless long_enough?(name)
+        return if allow_nums
+        num_offense(node, range) if ends_with_num?(name)
+      end
+
+      def case_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(CASE_MSG, name_type: name_type(node)))
+      end
+
+      def uppercase?(name)
+        name =~ /[[:upper:]]/
+      end
+
+      def name_type(node)
+        @name_type ||= begin
+          case node.type
+          when :block then 'block parameter'
+          when :def, :defs then 'method parameter'
+          end
+        end
+      end
+
+      def num_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(NUM_MSG, name_type: name_type(node)))
+      end
+
+      def ends_with_num?(name)
+        name[-1] =~ /\d/
+      end
+
+      def length_offense(node, range)
+        add_offense(node, location: range,
+                          message: format(LENGTH_MSG,
+                                          name_type: name_type(node).capitalize,
+                                          min: min_length))
+      end
+
+      def long_enough?(name)
+        name.size >= min_length
+      end
+
+      def arg_range(arg, length)
+        begin_pos = arg.source_range.begin_pos
+        Parser::Source::Range.new(processed_source.buffer,
+                                  begin_pos,
+                                  begin_pos + length)
+      end
+
+      def forbidden_offense(node, range, name)
+        add_offense(
+          node,
+          location: range,
+          message: format(FORBIDDEN_MSG, name: name, name_type: name_type(node))
+        )
+      end
+
+      def allowed_names
+        cop_config['AllowedNames']
+      end
+
+      def forbidden_names
+        cop_config['ForbiddenNames']
+      end
+
+      def allow_nums
+        cop_config['AllowNamesEndingInNumbers']
+      end
+
+      def min_length
+        cop_config['MinNameLength']
+      end
+    end
+  end
+end