rubocop 0.42.0 → 0.52.1

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

@@ -1,15 +1,29 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
-    # Common functionality for checking surrounding space.
+    # Common functionality for checking and correcting surrounding whitespace.
     module SurroundingSpace
-      def space_between?(t1, _t2)
-        # Check if the range between the tokens starts with a space. It can
-        # contain other characters, e.g. a unary plus, but it must start with
-        # space.
-        t1.pos.source_buffer.source.match(/\G\s/, t1.pos.end_pos)
+      NO_SPACE_COMMAND = 'Do not use'.freeze
+      SPACE_COMMAND = 'Use'.freeze
+
+      private
+
+      def side_space_range(range:, side:)
+        buffer = @processed_source.buffer
+        src = buffer.source
+
+        begin_pos = range.begin_pos
+        end_pos = range.end_pos
+        if side == :left
+          begin_pos = reposition(src, begin_pos, -1)
+          end_pos -= 1
+        end
+        if side == :right
+          begin_pos += 1
+          end_pos = reposition(src, end_pos, 1)
+        end
+        Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
       def index_of_first_token(node)
@@ -30,12 +44,67 @@ module RuboCop
         @token_table ||= begin
           table = {}
           @processed_source.tokens.each_with_index do |t, ix|
-            table[t.pos.line] ||= {}
-            table[t.pos.line][t.pos.column] = ix
+            table[t.line] ||= {}
+            table[t.line][t.column] = ix
           end
           table
         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,
+                            message,
+                            start_ok: false,
+                            end_ok: false)
+        if extra_space?(left_token, :left) && !start_ok
+          space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
+        end
+        return if !extra_space?(right_token, :right) || end_ok
+        space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
+      end
+
+      def space_offenses(node, # rubocop:disable Metrics/ParameterLists
+                         left_token,
+                         right_token,
+                         message,
+                         start_ok: false,
+                         end_ok: false)
+        unless extra_space?(left_token, :left) || start_ok
+          space_offense(node, left_token, :none, message, SPACE_COMMAND)
+        end
+        return if extra_space?(right_token, :right) || end_ok
+        space_offense(node, right_token, :none, message, SPACE_COMMAND)
+      end
+
+      def extra_space?(token, side)
+        return false unless token
+        if side == :left
+          String(token.space_after?) == ' '
+        else
+          String(token.space_before?) == ' '
+        end
+      end
+
+      def reposition(src, pos, step)
+        offset = step == -1 ? -1 : 0
+        pos += step while src[pos + offset] =~ /[ \t]/
+        pos < 0 ? 0 : pos
+      end
+
+      def space_offense(node, token, side, message, command)
+        range = side_space_range(range: token.pos, side: side)
+        add_offense(node, location: range,
+                          message: format(message, command: command))
+      end
     end
   end
 end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target rails version.
+    module TargetRailsVersion
+      def minimum_target_rails_version(version)
+        @minimum_target_rails_version = version
+      end
+
+      def support_target_rails_version?(version)
+        @minimum_target_rails_version <= version
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking target ruby version.
+    module TargetRubyVersion
+      def minimum_target_ruby_version(version)
+        @minimum_target_ruby_version = version
+      end
+
+      def support_target_ruby_version?(version)
+        @minimum_target_ruby_version <= version
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking for too many lines.
+    module TooManyLines
+      include ConfigurableMax
+      include CodeLength
+
+      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'.freeze
+
+      private
+
+      def message(length, max_length)
+        format(MSG, label: cop_label, length: length, max: max_length)
+      end
+
+      def code_length(node)
+        body = extract_body(node)
+        lines = body && body.source.lines || []
+
+        lines.count { |line| !irrelevant_line(line) }
+      end
+
+      def extract_body(node)
+        case node.type
+        when :block, :def
+          _receiver_or_method, _args, body = *node
+        when :defs
+          _self, _method, _args, body = *node
+        else
+          body = node
+        end
+
+        body
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,15 +7,16 @@ module RuboCop
     module TrailingComma
       include ConfigurableEnforcedStyle
 
-      MSG = '%s comma after the last %s'.freeze
+      MSG = '%<command>s comma after the last %<unit>s.'.freeze
 
-      def parameter_name
+      private
+
+      def style_parameter_name
         'EnforcedStyleForMultiline'
       end
 
       def check(node, items, kind, begin_pos, end_pos)
-        sb = node.source_range.source_buffer
-        after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
+        after_last_item = range_between(begin_pos, end_pos)
 
         return if heredoc?(after_last_item.source)
 
@@ -25,15 +25,14 @@ module RuboCop
         if comma_offset && !inside_comment?(after_last_item, comma_offset)
           check_comma(node, kind, after_last_item.begin_pos + comma_offset)
         elsif should_have_comma?(style, node)
-          put_comma(node, items, kind, sb)
+          put_comma(node, items, kind)
         end
       end
 
       def check_comma(node, kind, comma_pos)
         return if should_have_comma?(style, node)
 
-        avoid_comma(kind, comma_pos, node.source_range.source_buffer,
-                    extra_avoid_comma_info)
+        avoid_comma(kind, comma_pos, extra_avoid_comma_info)
       end
 
       def extra_avoid_comma_info
@@ -87,7 +86,7 @@ module RuboCop
         items = elements(node).map(&:source_range)
         return false if items.empty?
         items << node.loc.begin << node.loc.end
-        (items.map(&:first_line) + items.map(&:last_line)).uniq.count > 1
+        (items.map(&:first_line) + items.map(&:last_line)).uniq.size > 1
       end
 
       def elements(node)
@@ -98,8 +97,7 @@ module RuboCop
           # For each argument, if it is a multi-line hash without braces,
           # then promote the hash elements to method arguments
           # for the purpose of determining multi-line-ness.
-          if a.hash_type? && a.loc.first_line != a.loc.last_line &&
-             !brackets?(a)
+          if a.hash_type? && a.multiline? && !a.braces?
             a.children
           else
             a
@@ -117,45 +115,46 @@ module RuboCop
         a.last_line == b.line
       end
 
-      def avoid_comma(kind, comma_begin_pos, sb, extra_info)
-        range = Parser::Source::Range.new(sb, comma_begin_pos,
-                                          comma_begin_pos + 1)
+      def avoid_comma(kind, comma_begin_pos, extra_info)
+        range = range_between(comma_begin_pos, comma_begin_pos + 1)
         article = kind =~ /array/ ? 'an' : 'a'
-        add_offense(range, range,
-                    format(MSG, 'Avoid', format(kind, article)) +
-                    "#{extra_info}.")
+        msg = format(
+          MSG,
+          command: 'Avoid',
+          unit: format(kind, article: article) + extra_info.to_s
+        )
+
+        add_offense(range, location: range, message: msg)
       end
 
-      def put_comma(node, items, kind, sb)
+      def put_comma(node, items, kind)
+        return if avoid_autocorrect?(elements(node))
+
         last_item = items.last
-        return if last_item.type == :block_pass
+        return if last_item.block_pass_type?
+
+        range = autocorrect_range(last_item)
+        msg = format(
+          MSG,
+          command: 'Put a',
+          unit: format(kind, article: 'a multiline')
+        )
+
+        add_offense(range, location: range, message: msg)
+      end
 
-        last_expr = last_item.source_range
-        ix = last_expr.source.rindex("\n") || 0
-        ix += last_expr.source[ix..-1] =~ /\S/
-        range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
-                                          last_expr.end_pos)
-        autocorrect_range = avoid_autocorrect?(elements(node)) ? nil : range
+      def autocorrect_range(item)
+        expr = item.source_range
+        ix = expr.source.rindex("\n") || 0
+        ix += expr.source[ix..-1] =~ /\S/
 
-        add_offense(autocorrect_range, range,
-                    format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
+        range_between(expr.begin_pos + ix, expr.end_pos)
       end
 
       # By default, there's no reason to avoid auto-correct.
       def avoid_autocorrect?(_)
         false
       end
-
-      def autocorrect(range)
-        return unless range
-
-        lambda do |corrector|
-          case range.source
-          when ',' then corrector.remove(range)
-          else          corrector.insert_after(range, ',')
-          end
-        end
-      end
     end
   end
 end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,6 +5,8 @@ module RuboCop
     module Lint
       # Common functionality for cops handling unused arguments.
       module UnusedArgument
+        extend NodePattern::Macros
+
         def join_force?(force_class)
           force_class == VariableForce
         end
@@ -16,26 +17,15 @@ module RuboCop
           end
         end
 
+        private
+
         def check_argument(variable)
           return if variable.should_be_unused?
           return if variable.referenced?
 
           message = message(variable)
-          add_offense(variable.declaration_node, :name, message)
-        end
-
-        def autocorrect(node)
-          return if [:kwarg, :kwoptarg].include?(node.type)
-
-          if node.blockarg_type?
-            lambda do |corrector|
-              range = range_with_surrounding_space(node.source_range, :left)
-              range = range_with_surrounding_comma(range, :left)
-              corrector.remove(range)
-            end
-          else
-            ->(corrector) { corrector.insert_before(node.loc.name, '_') }
-          end
+          add_offense(variable.declaration_node, location: :name,
+                                                 message: message)
         end
       end
     end

data/lib/rubocop/cop/naming/accessor_method_name.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that accessor methods are named properly.
+      #
+      # @example
+      #   # bad
+      #   def set_attribute(value)
+      #   end
+      #
+      #   # good
+      #   def attribute=(value)
+      #   end
+      #
+      #   # bad
+      #   def get_attribute
+      #   end
+      #
+      #   # good
+      #   def attribute
+      #   end
+      class AccessorMethodName < Cop
+        MSG_READER = 'Do not prefix reader method names with `get_`.'.freeze
+        MSG_WRITER = 'Do not prefix writer method names with `set_`.'.freeze
+
+        def on_def(node)
+          return unless bad_reader_name?(node) || bad_writer_name?(node)
+
+          add_offense(node, location: :name)
+        end
+        alias on_defs on_def
+
+        private
+
+        def message(node)
+          if bad_reader_name?(node)
+            MSG_READER
+          elsif bad_writer_name?(node)
+            MSG_WRITER
+          end
+        end
+
+        def bad_reader_name?(node)
+          node.method_name.to_s.start_with?('get_') && !node.arguments?
+        end
+
+        def bad_writer_name?(node)
+          node.method_name.to_s.start_with?('set_') && node.arguments.one?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/{style → naming}/ascii_identifiers.rb

@@ -1,17 +1,48 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
+# rubocop:disable Style/AsciiComments
+
 module RuboCop
   module Cop
-    module Style
+    module Naming
       # This cop checks for non-ascii characters in identifier names.
+      #
+      # @example
+      #   # bad
+      #   def καλημερα # Greek alphabet (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def こんにちはと言う # Japanese character (non-ascii)
+      #   end
+      #
+      #   # bad
+      #   def hello_🍣 # Emoji (non-ascii)
+      #   end
+      #
+      #   # good
+      #   def say_hello
+      #   end
+      #
+      #   # bad
+      #   신장 = 10 # Hangul character (non-ascii)
+      #
+      #   # good
+      #   height = 10
+      #
+      #   # bad
+      #   params[:عرض_gteq] # Arabic character (non-ascii)
+      #
+      #   # good
+      #   params[:width_gteq]
+      #
       class AsciiIdentifiers < Cop
         MSG = 'Use only ascii symbols in identifiers.'.freeze
 
         def investigate(processed_source)
           processed_source.tokens.each do |token|
             next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
-            add_offense(token, first_offense_range(token))
+            add_offense(token, location: first_offense_range(token))
           end
         end
 
@@ -25,8 +56,7 @@ module RuboCop
                            identifier.text.index(first_offense)
           end_position   = start_position + first_offense.length
 
-          Parser::Source::Range.new(identifier.pos.source_buffer,
-                                    start_position, end_position)
+          range_between(start_position, end_position)
         end
 
         def first_non_ascii_chars(string)
@@ -36,3 +66,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Style/AsciiComments

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop makes sure that certain binary operator methods have their
+      # sole  parameter named `other`.
+      #
+      # @example
+      #
+      #   # bad
+      #   def +(amount); end
+      #
+      #   # good
+      #   def +(other); end
+      class BinaryOperatorParameterName < Cop
+        MSG = 'When defining the `%<opr>s` operator, ' \
+              'name its argument `other`.'.freeze
+
+        OP_LIKE_METHODS = %i[eql? equal?].freeze
+        BLACKLISTED = %i[+@ -@ [] []= << `].freeze
+
+        def_node_matcher :op_method_candidate?, <<-PATTERN
+          (def [#op_method? $_] (args $(arg [!:other !:_other])) _)
+        PATTERN
+
+        def on_def(node)
+          op_method_candidate?(node) do |name, arg|
+            add_offense(arg, message: format(MSG, opr: name))
+          end
+        end
+
+        private
+
+        def op_method?(name)
+          return false if BLACKLISTED.include?(name)
+          name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/class_and_module_camel_case.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cops checks for class and module names with
+      # an underscore in them.
+      #
+      # @example
+      #   # bad
+      #   class My_Class
+      #   end
+      #   module My_Module
+      #   end
+      #
+      #   # good
+      #   class MyClass
+      #   end
+      #   module MyModule
+      #   end
+      class ClassAndModuleCamelCase < Cop
+        MSG = 'Use CamelCase for classes and modules.'.freeze
+
+        def on_class(node)
+          return unless node.loc.name.source =~ /_/
+
+          add_offense(node, location: :name)
+        end
+        alias on_module on_class
+      end
+    end
+  end
+end

data/lib/rubocop/cop/naming/constant_name.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Naming
+      # This cop checks whether constant names are written using
+      # SCREAMING_SNAKE_CASE.
+      #
+      # To avoid false positives, it ignores cases in which we cannot know
+      # for certain the type of value that would be assigned to a constant.
+      #
+      # @example
+      #   # bad
+      #   InchInCm = 2.54
+      #   INCHinCM = 2.54
+      #   Inch_In_Cm = 2.54
+      #
+      #   # good
+      #   INCH_IN_CM = 2.54
+      class ConstantName < Cop
+        MSG = 'Use SCREAMING_SNAKE_CASE for constants.'.freeze
+        # Use POSIX character classes, so we allow accented characters rather
+        # than just standard ASCII characters
+        SNAKE_CASE = /^[[:digit:][:upper:]_]+$/
+
+        def_node_matcher :class_or_struct_return_method?, <<-PATTERN
+          (send
+            (const _ {:Class :Struct}) :new
+            ...)
+        PATTERN
+
+        def on_casgn(node)
+          _scope, const_name, value = *node
+
+          # We cannot know the result of method calls like
+          # NewClass = something_that_returns_a_class
+          # It's also ok to assign a class constant another class constant,
+          # `Class.new(...)` or `Struct.new(...)`
+          # SomeClass = SomeOtherClass
+          # SomeClass = Class.new(...)
+          # SomeClass = Struct.new(...)
+          return if value && %i[block const casgn].include?(value.type) ||
+                    allowed_method_call_on_rhs?(value) ||
+                    class_or_struct_return_method?(value)
+
+          add_offense(node, location: :name) if const_name !~ SNAKE_CASE
+        end
+
+        private
+
+        def allowed_method_call_on_rhs?(node)
+          node && node.send_type? &&
+            (node.receiver.nil? || !node.receiver.literal?)
+        end
+      end
+    end
+  end
+end