rubocop 0.36.0 → 0.37.0

data/lib/rubocop/cop/lint/duplicated_key.rb

@@ -13,20 +13,13 @@ module RuboCop
       class DuplicatedKey < Cop
         MSG = 'Duplicated key in hash literal.'.freeze
 
-        LITERALS = [:sym, :str, :float, :int].freeze
-
         def on_hash(node)
           keys = []
 
           hash_pairs = *node
           hash_pairs.each do |pair|
             key, _value = *pair
-            if keys.include?(key) && LITERALS.include?(key.type)
-              add_offense(key, :expression)
-            elsif keys.include?(key) && key.type == :array
-              key.children.each do |child|
-                return false unless LITERALS.include?(child.type)
-              end
+            if keys.include?(key) && key.recursive_basic_literal?
               add_offense(key, :expression)
             end
             keys << key

data/lib/rubocop/cop/lint/format_parameter_mismatch.rb

@@ -68,7 +68,7 @@ module RuboCop
                             receiver_node
                           end
 
-          relevant_node.source.scan(NAMED_FIELD_REGEX).size > 0
+          !relevant_node.source.scan(NAMED_FIELD_REGEX).empty?
         end
 
         def node_with_splat_args?(node)

data/lib/rubocop/cop/lint/literal_in_interpolation.rb

@@ -17,6 +17,7 @@ module RuboCop
             final_node = begin_node.children.last
             next unless final_node
             next if special_keyword?(final_node)
+            next if final_node.xstr_type?
             next unless final_node.literal?
 
             add_offense(final_node, :expression)
@@ -37,7 +38,23 @@ module RuboCop
         end
 
         def autocorrected_value(node)
-          node.str_type? ? node.children.last : node.source
+          case node.type
+          when :str
+            node.children.last
+          when :sym
+            autocorrected_value_for_symbol(node)
+          else
+            node.source
+          end
+        end
+
+        def autocorrected_value_for_symbol(node)
+          end_pos =
+            node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
+
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.loc.begin.end_pos,
+                                    end_pos).source
         end
       end
     end

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -26,6 +26,10 @@ module RuboCop
           (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
+        def_node_matcher :class_or_module_new_call?, <<-PATTERN
+          (block (send (const nil {:Class :Module}) :new) ...)
+        PATTERN
+
         def on_method_def(node, _method_name, _args, _body)
           find_nested_defs(node) do |nested_def_node|
             add_offense(nested_def_node, :expression)
@@ -36,7 +40,7 @@ module RuboCop
           node.each_child_node do |child|
             if child.def_type? || child.defs_type?
               yield child
-            elsif !eval_call?(child)
+            elsif !(eval_call?(child) || class_or_module_new_call?(child))
               find_nested_defs(child, &block)
             end
           end

data/lib/rubocop/cop/lint/unneeded_disable.rb

@@ -128,7 +128,7 @@ module RuboCop
         def cop_range(comment, cop)
           matching_range(comment.loc.expression, cop) ||
             matching_range(comment.loc.expression, cop.split('/').last) ||
-            fail("Couldn't find #{cop} in comment: #{comment.text}")
+            raise("Couldn't find #{cop} in comment: #{comment.text}")
         end
 
         def matching_range(haystack, needle)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -22,13 +22,20 @@ module RuboCop
         SPACE * node.loc.column
       end
 
+      def display_column(range)
+        line = processed_source.lines[range.line - 1]
+        line[0, range.column].display_width
+      end
+
       def check_alignment(items, base_column = nil)
-        base_column ||= items.first.loc.column unless items.empty?
+        unless items.empty?
+          base_column ||= display_column(items.first.source_range)
+        end
         prev_line = -1
         items.each do |current|
           if current.loc.line > prev_line &&
              begins_its_line?(current.source_range)
-            @column_delta = base_column - current.loc.column
+            @column_delta = base_column - display_column(current.source_range)
             if @column_delta != 0
               expr = current.source_range
               if offenses.any? { |o| within?(expr, o.location) }

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

@@ -21,7 +21,7 @@ module RuboCop
         check_assignment(node, rhs) if rhs.is_a?(AST::Node)
       end
 
-      private
+      module_function
 
       def extract_rhs(node)
         if node.casgn_type?

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

@@ -13,8 +13,7 @@ module RuboCop
         body_line_numbers = line_range(node).to_a[1...-1]
 
         target_line_numbers = body_line_numbers -
-                              line_numbers_of_inner_thing(node, :module) -
-                              line_numbers_of_inner_thing(node, :class)
+                              line_numbers_of_inner_nodes(node, :module, :class)
 
         target_line_numbers.reduce(0) do |length, line_number|
           source_line = processed_source[line_number]
@@ -23,10 +22,10 @@ module RuboCop
         end
       end
 
-      def line_numbers_of_inner_thing(node, type)
+      def line_numbers_of_inner_nodes(node, *types)
         line_numbers = Set.new
 
-        node.each_descendant(:module, type) do |inner_node|
+        node.each_descendant(*types) do |inner_node|
           line_range = line_range(inner_node)
           line_numbers.merge(line_range)
         end

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

@@ -77,14 +77,18 @@ module RuboCop
       alias unrecognized_style_detected no_acceptable_style!
 
       def style
-        s = cop_config[parameter_name].to_sym
-        return s if supported_styles.include?(s)
-        fail "Unknown style #{s} selected!"
+        @enforced_style ||= begin
+          s = cop_config[parameter_name].to_sym
+          unless supported_styles.include?(s)
+            raise "Unknown style #{s} selected!"
+          end
+          s
+        end
       end
 
       def alternative_style
         if supported_styles.size != 2
-          fail 'alternative_style can only be used when there are exactly ' \
+          raise 'alternative_style can only be used when there are exactly ' \
                '2 SupportedStyles'
         end
         (supported_styles - [style]).first

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

@@ -9,7 +9,7 @@ module RuboCop
       include ConfigurableEnforcedStyle
 
       SNAKE_CASE = /^@{0,2}[\da-z_]+[!?=]?$/
-      CAMEL_CASE = /^@{0,2}[a-z][\da-zA-Z]+[!?=]?$/
+      CAMEL_CASE = /^@{0,2}_?[a-z][\da-zA-Z]+[!?=]?$/
 
       def check_name(node, name, name_range)
         return if operator?(name)

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

@@ -22,7 +22,8 @@ module RuboCop
         return unless end_loc # Discard modifier forms of if/while/until.
 
         matching = align_ranges.select do |_, range|
-          range.line == end_loc.line || range.column == end_loc.column
+          range.line == end_loc.line ||
+            effective_column(range) == end_loc.column
         end
 
         if matching.key?(style)

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for dealing with frozen string literals.
+    module FrozenStringLiteral
+      module_function
+
+      FROZEN_STRING_LITERAL = '# frozen_string_literal:'.freeze
+      FROZEN_STRING_LITERAL_ENABLED = '# frozen_string_literal: true'.freeze
+      FROZEN_STRING_LITERAL_TYPES = [:str, :dstr].freeze
+
+      def frozen_string_literal_comment_exists?(processed_source,
+                                                comment = FROZEN_STRING_LITERAL)
+        first_three_lines =
+          [processed_source[0], processed_source[1], processed_source[2]]
+        first_three_lines.compact!
+        first_three_lines.any? do |line|
+          line.start_with?(comment)
+        end
+      end
+
+      def frozen_string_literals_enabled?(processed_source)
+        ruby_version = processed_source.ruby_version
+        return false unless ruby_version
+        return true if ruby_version >= 3.0
+        return false unless ruby_version >= 2.3
+        frozen_string_literal_comment_exists?(
+          processed_source, FROZEN_STRING_LITERAL_ENABLED
+        )
+      end
+    end
+  end
+end

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

@@ -22,7 +22,7 @@ module RuboCop
       end
 
       def complexity(node)
-        node.each_node(self.class::COUNTED_NODES).reduce(1) do |score, n|
+        node.each_node(*self.class::COUNTED_NODES).reduce(1) do |score, n|
           score + complexity_score_for(n)
         end
       end

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

@@ -13,7 +13,7 @@ module RuboCop
         length = cop_config['MinBodyLength'] || 1
         return length if length.is_a?(Integer) && length > 0
 
-        fail 'MinBodyLength needs to be a positive integer!'
+        raise 'MinBodyLength needs to be a positive integer!'
       end
     end
   end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking that the closing brace of a literal is
+    # symmetrical with respect to the opening brace and contained elements.
+    module MultilineLiteralBraceLayout
+      def check_brace_layout(node)
+        return unless node.loc.begin # Ignore implicit literals.
+        return if children(node).empty? # Ignore empty literals.
+
+        if opening_brace_on_same_line?(node)
+          return if closing_brace_on_same_line?(node)
+
+          add_offense(node, :expression, self.class::SAME_LINE_MESSAGE)
+        else
+          return unless closing_brace_on_same_line?(node)
+
+          add_offense(node, :expression, self.class::NEW_LINE_MESSAGE)
+        end
+      end
+
+      def autocorrect(node)
+        if closing_brace_on_same_line?(node)
+          lambda do |corrector|
+            corrector.insert_before(node.loc.end, "\n".freeze)
+          end
+        else
+          range = Parser::Source::Range.new(
+            node.source_range.source_buffer,
+            children(node).last.source_range.end_pos,
+            node.loc.end.begin_pos)
+
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+
+      private
+
+      def children(node)
+        node.children
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def opening_brace_on_same_line?(node)
+        node.loc.begin.line == children(node).first.loc.first_line
+      end
+
+      # This method depends on the fact that we have guarded
+      # against implicit and empty literals.
+      def closing_brace_on_same_line?(node)
+        node.loc.end.line == children(node).last.loc.last_line
+      end
+    end
+  end
+end

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

@@ -21,7 +21,7 @@ module RuboCop
 
       def space_forbidden_before_rcurly?
         cfg = config.for_cop('Style/SpaceInsideBlockBraces')
-        style = cfg['Enabled'] ? cfg['EnforcedStyle'] : 'space'
+        style = cfg['EnforcedStyle'] || 'space'
         style == 'no_space'
       end
 

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

@@ -26,7 +26,7 @@ module RuboCop
 
       def space_required_after_lcurly?
         cfg = config.for_cop('Style/SpaceInsideBlockBraces')
-        style = cfg['Enabled'] ? cfg['EnforcedStyle'] : 'space'
+        style = cfg['EnforcedStyle'] || 'space'
         style == 'space'
       end
 

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

@@ -81,10 +81,11 @@ module RuboCop
                      node.children
                    end
 
-        # Without this check, Foo.new({}) is considered multiline, which
+        # No need to process anything if the whole node is not multiline
+        # Without the 2nd check, Foo.new({}) is considered multiline, which
         # it should not be. Essentially, if there are no elements, the
         # expression can not be multiline.
-        return if elements.empty?
+        return if !node.multiline? || elements.empty?
 
         items = elements.map(&:source_range)
         if style == :consistent_comma

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -63,6 +63,11 @@ module RuboCop
         PERCENT_I = '%i'.freeze
         PERCENT_CAPITAL_I = '%I'.freeze
 
+        def initialize(*)
+          super
+          @reordered_splat_condition = false
+        end
+
         def on_case(node)
           _case_branch, *when_branches, _else_branch = *node
           when_conditions =
@@ -85,6 +90,8 @@ module RuboCop
           if variable.array_type?
             correct_array_literal(condition, variable)
           else
+            return if @reordered_splat_condition
+            @reordered_splat_condition = true
             reorder_splat_condition(node)
           end
         end

data/lib/rubocop/cop/performance/casecmp.rb

@@ -9,43 +9,82 @@ module RuboCop
       #
       # @example
       #   @bad
-      #   'abc'.downcase == 'ABC'
+      #   'aBc'.downcase == 'abc'
       #   'abc'.upcase.eql? 'ABC'
+      #   'abc' == 'ABC'.downcase
+      #   'ABC'.eql? 'abc'.upcase
+      #   'abc'.downcase == 'abc'.downcase
       #
       #   @good
-      #   'abc'.casecmp('ABC')
+      #   'aBc'.casecmp('ABC').zero?
+      #   'abc'.casecmp('abc').zero?
+      #   'abc'.casecmp('ABC'.downcase).zero?
       class Casecmp < Cop
+        include IgnoredNode
+
         MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
+        CASE_METHODS = [:downcase, :upcase].freeze
 
         def_node_matcher :downcase_eq, <<-END
-          (send $(send _ ${:downcase :upcase}) ${:== :eql?} _)
+          (send $(send _ ${:downcase :upcase}) ${:== :eql? :!=} $_)
+        END
+
+        def_node_matcher :eq_downcase, <<-END
+          (send _ ${:== :eql? :!=} $(send _ ${:downcase :upcase}))
         END
 
         def on_send(node)
-          downcase_eq(node) do |send_downcase, case_method, eq_method|
-            range = node.loc.selector.join(send_downcase.loc.selector)
+          return if part_of_ignored_node?(node)
+
+          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
+            *_, method = *other
+            if CASE_METHODS.include?(method)
+              range = node.loc.expression
+              ignore_node(node)
+            else
+              range = node.loc.selector.join(send_downcase.loc.selector)
+            end
+
             add_offense(node, range, format(MSG, case_method, eq_method))
+            return
+          end
+
+          eq_downcase(node) do |eq_method, send_downcase, case_method|
+            range = node.loc.selector.join(send_downcase.loc.selector)
+            add_offense(node, range, format(MSG, eq_method, case_method))
           end
         end
 
         def autocorrect(node)
-          receiver, _method, arg = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            receiver.loc.selector.begin_pos,
-                                            arg.loc.begin.begin_pos)
+          downcase_eq(node) do
+            receiver, method, arg = *node
+            variable, = *receiver
+            return correction(node, receiver, method, arg, variable)
+          end
+
+          eq_downcase(node) do
+            arg, method, receiver = *node
+            variable, = *receiver
+            return correction(node, receiver, method, arg, variable)
+          end
+        end
 
+        private
+
+        def correction(node, _receiver, method, arg, variable)
           lambda do |corrector|
+            corrector.insert_before(node.loc.expression, '!') if method == :!=
+
             # we want resulting call to be parenthesized
             # if arg already includes one or more sets of parens, don't add more
             # or if method call already used parens, again, don't add more
-            if arg.loc.begin.source == '('
-              corrector.replace(range, 'casecmp')
-            elsif range.source =~ /\(/
-              corrector.replace(range, 'casecmp(')
-            else
-              corrector.replace(range, 'casecmp(')
-              corrector.insert_after(arg.source_range, ')')
-            end
+            replacement = if arg.send_type? || !parentheses?(arg)
+                            "#{variable.source}.casecmp(#{arg.source}).zero?"
+                          else
+                            "#{variable.source}.casecmp#{arg.source}.zero?"
+                          end
+
+            corrector.replace(node.loc.expression, replacement)
           end
         end
       end