rubocop 0.35.1 → 0.36.0

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common code for ordinary arrays with [] that can be written with %
     # syntax.
     module ArraySyntax
-      def array_of?(element_type, node)
+      def bracketed_array_of?(element_type, node)
         return false unless square_brackets?(node)
 
         array_elems = node.children

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,7 +10,8 @@ module RuboCop
       SPACE = ' '.freeze
 
       def configured_indentation_width
-        config.for_cop('IndentationWidth')['Width']
+        cop_config['IndentationWidth'] ||
+          config.for_cop('IndentationWidth')['Width']
       end
 
       def indentation(node)
@@ -24,10 +26,11 @@ module RuboCop
         base_column ||= items.first.loc.column unless items.empty?
         prev_line = -1
         items.each do |current|
-          if current.loc.line > prev_line && start_of_line?(current.loc)
+          if current.loc.line > prev_line &&
+             begins_its_line?(current.source_range)
             @column_delta = base_column - current.loc.column
             if @column_delta != 0
-              expr = current.loc.expression
+              expr = current.source_range
               if offenses.any? { |o| within?(expr, o.location) }
                 # If this offense is within a line range that is already being
                 # realigned by autocorrect, we report the offense without
@@ -44,10 +47,6 @@ module RuboCop
         end
       end
 
-      def start_of_line?(loc)
-        loc.expression.source_line[0...loc.column].blank?
-      end
-
       def autocorrect(arg)
         return unless arg
 
@@ -74,28 +73,24 @@ module RuboCop
       def autocorrect_line(corrector, line_begin_pos, expr, column_delta,
                            heredoc_ranges)
         range = calculate_range(expr, line_begin_pos, column_delta)
-        # We must not change indentation of heredoc stings.
+        # We must not change indentation of heredoc strings.
         return if heredoc_ranges.any? { |h| within?(range, h) }
 
         if column_delta > 0
           unless range.source == "\n"
             corrector.insert_before(range, ' ' * column_delta)
           end
-        else
-          remove(range, corrector) if range.source =~ /\A[ \t]+\z/
+        elsif range.source =~ /\A[ \t]+\z/
+          remove(range, corrector)
         end
       end
 
       def heredoc_ranges(arg)
         return [] unless arg.is_a?(Parser::AST::Node)
 
-        heredoc_ranges = []
-        arg.each_node(:dstr) do |n|
-          if n.loc.respond_to?(:heredoc_body)
-            heredoc_ranges << n.loc.heredoc_body.join(n.loc.heredoc_end)
-          end
-        end
-        heredoc_ranges
+        arg.each_node(:dstr)
+           .select { |n| n.loc.respond_to?(:heredoc_body) }
+           .map { |n| n.loc.heredoc_body.join(n.loc.heredoc_end) }
       end
 
       def block_comment_within?(expr)
@@ -133,11 +128,10 @@ module RuboCop
       end
 
       def each_line(expr)
-        offset = 0
+        line_begin_pos = expr.begin_pos
         expr.source.each_line do |line|
-          line_begin_pos = expr.begin_pos + offset
           yield line_begin_pos
-          offset += line.length
+          line_begin_pos += line.length
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,11 +13,11 @@ module RuboCop
     module AutocorrectUnlessChangingAST
       def autocorrect(node)
         current_buffer_src = processed_source.buffer.source
-        replaced_range = node.loc.expression
+        replaced_range = node.source_range
         pre = current_buffer_src[0...replaced_range.begin_pos]
         post = current_buffer_src[replaced_range.end_pos..-1]
         new_buffer_src = pre + rewrite_node(node) + post
-        new_processed_src = ProcessedSource.new(new_buffer_src)
+        new_processed_src = parse(new_buffer_src, processed_source.buffer.name)
 
         # Make the correction only if it doesn't change the AST for the buffer.
         return if !new_processed_src.ast ||
@@ -29,7 +30,7 @@ module RuboCop
       private
 
       def rewrite_node(node)
-        ps = ProcessedSource.new(node.loc.expression.source)
+        ps = parse(node.source)
         c = correction(ps.ast)
         Corrector.new(ps.buffer, [c]).rewrite
       end
@@ -46,7 +47,7 @@ module RuboCop
       #
       class InlineBeginNodes < Parser::AST::Processor
         def on_begin(node)
-          node.children.one? ? node.children[0] : node
+          node.children.one? ? process(node.children[0]) : super
         end
       end
 

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

@@ -1,36 +1,41 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for checking assignment nodes.
     module CheckAssignment
-      TYPES = Util::ASGN_NODES - [:casgn, :op_asgn]
-      TYPES.each do |type|
+      Util::ASGN_NODES.each do |type|
         define_method("on_#{type}") do |node|
-          _lhs, rhs = *node
-          check_assignment(node, rhs)
+          check_assignment(node, extract_rhs(node))
         end
       end
 
-      def on_casgn(node)
-        _scope, _lhs, rhs = *node
-        check_assignment(node, rhs)
-      end
-
-      def on_op_asgn(node)
-        _lhs, _op, rhs = *node
-        check_assignment(node, rhs)
-      end
-
       def on_send(node)
         # we only want to indent relative to the receiver
         # when the method called looks like a setter
         return unless node.asgn_method_call?
 
         # This will match if, case, begin, blocks, etc.
-        rhs = node.children.last
+        rhs = extract_rhs(node)
         check_assignment(node, rhs) if rhs.is_a?(AST::Node)
       end
+
+      private
+
+      def extract_rhs(node)
+        if node.casgn_type?
+          _scope, _lhs, rhs = *node
+        elsif node.op_asgn_type?
+          _lhs, _op, rhs = *node
+        elsif Util::ASGN_NODES.include?(node.type)
+          _lhs, rhs = *node
+        elsif node.send_type?
+          rhs = node.children.last
+        end
+
+        rhs
+      end
     end
   end
 end

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

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

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -49,47 +50,48 @@ module RuboCop
 
       def no_acceptable_style!
         self.config_to_allow_offenses = { 'Enabled' => false }
+        Formatter::DisabledConfigFormatter.detected_styles[cop_name] = []
       end
 
       def detected_style
-        config_to_allow_offenses[parameter_name]
+        Formatter::DisabledConfigFormatter.detected_styles[cop_name] ||= nil
       end
 
       def detected_style=(style)
+        Formatter::DisabledConfigFormatter.detected_styles[cop_name] = style
+
         if style.nil?
           no_acceptable_style!
         elsif style.is_a?(Array)
           if style.empty?
             no_acceptable_style!
-          elsif style.one?
-            config_to_allow_offenses[parameter_name] = style[0]
           else
-            config_to_allow_offenses[parameter_name] = style
+            config_to_allow_offenses[parameter_name] = style[0]
           end
         else
           config_to_allow_offenses[parameter_name] = style
         end
       end
 
-      alias_method :conflicting_styles_detected, :no_acceptable_style!
-      alias_method :unrecognized_style_detected, :no_acceptable_style!
+      alias conflicting_styles_detected no_acceptable_style!
+      alias unrecognized_style_detected no_acceptable_style!
 
       def style
-        s = cop_config[parameter_name]
-        if cop_config['SupportedStyles'].include?(s)
-          s.to_sym
-        else
-          fail "Unknown style #{s} selected!"
-        end
+        s = cop_config[parameter_name].to_sym
+        return s if supported_styles.include?(s)
+        fail "Unknown style #{s} selected!"
       end
 
       def alternative_style
-        a = cop_config['SupportedStyles'].map(&:to_sym)
-        if a.size != 2
+        if supported_styles.size != 2
           fail 'alternative_style can only be used when there are exactly ' \
                '2 SupportedStyles'
         end
-        style == a.first ? a.last : a.first
+        (supported_styles - [style]).first
+      end
+
+      def supported_styles
+        @supported_styles ||= cop_config['SupportedStyles'].map(&:to_sym)
       end
 
       def parameter_name

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,6 +32,9 @@ module RuboCop
       # the method has the same name as a class defined in the class/module.
       def class_emitter_method?(node, name)
         return false unless node.defs_type?
+        # a class emitter method may be defined inside `def self.included`,
+        # `def self.extended`, etc.
+        node = node.parent while node.parent && node.parent.defs_type?
         return false unless node.parent
 
         node.parent.children.compact.any? do |c|

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -8,8 +9,8 @@ module RuboCop
       module EmptyLinesAroundBody
         include ConfigurableEnforcedStyle
 
-        MSG_EXTRA = 'Extra empty line detected at %s body %s.'
-        MSG_MISSING = 'Empty line missing at %s body %s.'
+        MSG_EXTRA = 'Extra empty line detected at %s body %s.'.freeze
+        MSG_MISSING = 'Empty line missing at %s body %s.'.freeze
 
         def autocorrect(range)
           lambda do |corrector|
@@ -22,10 +23,14 @@ module RuboCop
 
         private
 
-        def check(node)
+        def check(node, body)
+          # When style is `empty_lines`, if the body is empty, we don't enforce
+          # the presence OR absence of an empty line
+          # But if style is `no_empty_lines`, there must not be an empty line
+          return unless body || style == :no_empty_lines
+
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
-
           return if start_line == end_line
 
           check_source(start_line, end_line)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,31 +7,32 @@ module RuboCop
     module EndKeywordAlignment
       include ConfigurableEnforcedStyle
 
-      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'
+      MSG = '`end` at %d, %d is not aligned with `%s` at %d, %d.'.freeze
 
       private
 
-      def check_offset_of_node(node)
-        check_offset(node, node.loc.keyword.source, 0)
+      def check_end_kw_in_node(node)
+        check_end_kw_alignment(node, style => node.loc.keyword)
       end
 
-      def check_offset(node, alignment_base, offset)
+      def check_end_kw_alignment(node, align_ranges)
         return if ignored_node?(node)
 
         end_loc = node.loc.end
         return unless end_loc # Discard modifier forms of if/while/until.
 
-        kw_loc = node.loc.keyword
+        matching = align_ranges.select do |_, range|
+          range.line == end_loc.line || range.column == end_loc.column
+        end
 
-        if kw_loc.line != end_loc.line &&
-           kw_loc.column != end_loc.column + offset
-          add_offense(node, end_loc,
-                      format(MSG, end_loc.line, end_loc.column,
-                             alignment_base, kw_loc.line, kw_loc.column)) do
-            opposite_style_detected
-          end
-        else
+        if matching.key?(style)
           correct_style_detected
+        else
+          align_with = align_ranges[style]
+          msg = format(MSG, end_loc.line, end_loc.column, align_with.source,
+                       align_with.line, align_with.column)
+          add_offense(node, end_loc, msg)
+          style_detected(matching.keys)
         end
       end
 
@@ -47,15 +49,21 @@ module RuboCop
         rhs.loc.line > whole_expression.line
       end
 
-      def align(node, alignment_node)
-        source_buffer = node.loc.expression.source_buffer
+      def align(node, align_to)
+        source_buffer = node.source_range.source_buffer
         begin_pos = node.loc.end.begin_pos
         whitespace = Parser::Source::Range.new(source_buffer,
                                                begin_pos - node.loc.end.column,
                                                begin_pos)
         return false unless whitespace.source.strip.empty?
 
-        column = alignment_node ? alignment_node.loc.expression.column : 0
+        column = if !align_to
+                   0
+                 elsif align_to.respond_to?(:loc)
+                   align_to.source_range.column
+                 else
+                   align_to.column
+                 end
 
         ->(corrector) { corrector.replace(whitespace, ' ' * column) }
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
     # element in a multi-line collection.
     module FirstElementLineBreak
       def autocorrect(node)
-        ->(corrector) { corrector.insert_before(node.loc.expression, "\n") }
+        ->(corrector) { corrector.insert_before(node.source_range, "\n") }
       end
 
       private
@@ -20,7 +21,7 @@ module RuboCop
       end
 
       def method_uses_parens?(node, limit)
-        source = node.loc.expression.source_line[0...limit.loc.column]
+        source = node.source_range.source_line[0...limit.loc.column]
         source =~ /\s*\(\s*$/
       end
 

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking hash nodes.
+    module HashNode
+      def any_pairs_on_the_same_line?(node)
+        node.children.butfirst.any? do |pair|
+          !Util.begins_its_line?(pair.loc.expression)
+        end
+      end
+    end
+  end
+end