rubocop 0.49.1 → 0.52.0

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

@@ -5,33 +5,38 @@ 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
 
+      def autocorrect(pos_before_punctuation)
+        ->(corrector) { corrector.remove(pos_before_punctuation) }
+      end
+
       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)
 
-          pos_before_punctuation = range_between(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?
@@ -39,10 +44,6 @@ module RuboCop
         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

@@ -13,12 +13,15 @@ module RuboCop
       end
 
       def non_eligible_node?(node)
-        line_count(node) > 3 ||
+        node.nonempty_line_count > 3 ||
           !node.modifier_form? && commented?(node.loc.end)
       end
 
       def non_eligible_body?(body)
-        empty_body?(body) || body.begin_type? || commented?(body.source_range)
+        body.nil? ||
+          body.empty? ||
+          body.begin_type? ||
+          commented?(body.source_range)
       end
 
       def non_eligible_condition?(condition)
@@ -27,7 +30,7 @@ module RuboCop
 
       def modifier_fits_on_single_line?(node)
         modifier_length = length_in_modifier_form(node, node.condition,
-                                                  body_length(node.body))
+                                                  node.body.length)
 
         modifier_length <= max_line_length
       end
@@ -41,20 +44,7 @@ module RuboCop
       end
 
       def max_line_length
-        cop_config['MaxLineLength'] ||
-          config.for_cop('Metrics/LineLength')['Max']
-      end
-
-      def line_count(node)
-        node.source.lines.grep(/\S/).size
-      end
-
-      def empty_body?(body)
-        !body || body_length(body).zero?
-      end
-
-      def body_length(body)
-        body.source_range ? body.source_range.size : 0
+        config.for_cop('Metrics/LineLength')['Max']
       end
 
       def commented?(source)

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

@@ -14,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

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

@@ -12,7 +12,7 @@ module RuboCop
         if style == :single_quotes
           !double_quotes_required?(src)
         else
-          src !~ /" | \\ | \#(@|\{)/x
+          src !~ /" | \\[^'] | \#(@|\{)/x
         end
       end
 

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

@@ -2,13 +2,26 @@
 
 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
+
+      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)
@@ -29,12 +42,86 @@ 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)
+        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 no_space_corrector(corrector, left_token, right_token)
+        if left_token.space_after?
+          range = side_space_range(range: left_token.pos, side: :right)
+          corrector.remove(range)
+        end
+        return unless right_token.space_before?
+        range = side_space_range(range: right_token.pos, side: :left)
+        corrector.remove(range)
+      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 space_corrector(corrector, left_token, right_token)
+        unless left_token.space_after?
+          corrector.insert_after(left_token.pos, ' ')
+        end
+        return if right_token.space_before?
+        corrector.insert_before(right_token.pos, ' ')
+      end
+
+      private
+
+      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/too_many_lines.rb

@@ -7,12 +7,12 @@ module RuboCop
       include ConfigurableMax
       include CodeLength
 
-      MSG = '%s has too many lines. [%d/%d]'.freeze
+      MSG = '%<label>s has too many lines. [%<length>d/%<max>d]'.freeze
 
       private
 
       def message(length, max_length)
-        format(MSG, cop_label, length, max_length)
+        format(MSG, label: cop_label, length: length, max: max_length)
       end
 
       def code_length(node)

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

@@ -7,7 +7,18 @@ 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 autocorrect(range)
+        return unless range
+
+        lambda do |corrector|
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
+          end
+        end
+      end
 
       def style_parameter_name
         'EnforcedStyleForMultiline'
@@ -116,9 +127,13 @@ module RuboCop
       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)
@@ -128,9 +143,13 @@ module RuboCop
         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, range,
-                    format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
+        add_offense(range, location: range, message: msg)
       end
 
       def autocorrect_range(item)
@@ -145,17 +164,6 @@ module RuboCop
       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

@@ -5,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
@@ -20,7 +22,8 @@ module RuboCop
           return if variable.referenced?
 
           message = message(variable)
-          add_offense(variable.declaration_node, :name, message)
+          add_offense(variable.declaration_node, location: :name,
+                                                 message: message)
         end
 
         def autocorrect(node)
@@ -28,7 +31,8 @@ module RuboCop
 
           if node.blockarg_type?
             lambda do |corrector|
-              range = range_with_surrounding_space(node.source_range, :left)
+              range = range_with_surrounding_space(range: node.source_range,
+                                                   side: :left)
               range = range_with_surrounding_comma(range, :left)
               corrector.remove(range)
             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,16 +1,48 @@
 # 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
 
@@ -34,3 +66,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Style/AsciiComments