rubocop 0.26.1 → 0.27.0

data/lib/rubocop/cop/metrics/block_nesting.rb

@@ -10,6 +10,7 @@ module RuboCop
       # The maximum level of nesting allowed is configurable.
       class BlockNesting < Cop
         include ConfigurableMax
+        include IfNode
 
         NESTING_BLOCKS = [
           :case, :if, :while, :while_post,
@@ -26,10 +27,7 @@ module RuboCop
 
         def check_nesting_level(node, max, current_level)
           if NESTING_BLOCKS.include?(node.type)
-            unless node.loc.respond_to?(:keyword) &&
-                   node.loc.keyword.is?('elsif')
-              current_level += 1
-            end
+            current_level += 1 unless elsif?(node)
             if current_level > max
               self.max = current_level
               unless part_of_ignored_node?(node)

data/lib/rubocop/cop/metrics/class_length.rb

@@ -23,7 +23,7 @@ module RuboCop
           class_body_line_numbers = line_range(node).to_a[1...-1]
 
           target_line_numbers = class_body_line_numbers -
-                                  line_numbers_of_inner_classes(node)
+                                line_numbers_of_inner_classes(node)
 
           target_line_numbers.reduce(0) do |length, line_number|
             source_line = processed_source[line_number]

data/lib/rubocop/cop/metrics/line_length.rb

@@ -29,13 +29,10 @@ module RuboCop
                                    max
                                  end
 
-            range = source_range(processed_source.buffer,
-                                 index + 1,
+            range = source_range(processed_source.buffer, index + 1,
                                  excessive_position...(line.length))
 
-            add_offense(nil, range, message) do
-              self.max = line.length
-            end
+            add_offense(nil, range, message) { self.max = line.length }
           end
         end
 

data/lib/rubocop/cop/metrics/method_length.rb

@@ -7,12 +7,12 @@ module RuboCop
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class MethodLength < Cop
-        include OnMethod
+        include OnMethodDef
         include CodeLength
 
         private
 
-        def on_method(node, _method_name, _args, _body)
+        def on_method_def(node, _method_name, _args, _body)
           check_code_length(node)
         end
 

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

@@ -6,6 +6,10 @@ module RuboCop
     # the left or to the right, amount being determined by the instance
     # variable @column_delta.
     module AutocorrectAlignment
+      def configured_indentation_width
+        config.for_cop('IndentationWidth')['Width']
+      end
+
       def check_alignment(items, base_column = nil)
         base_column ||= items.first.loc.column unless items.empty?
         prev_line = -1
@@ -26,33 +30,38 @@ module RuboCop
         heredoc_ranges = heredoc_ranges(arg)
         expr = arg.respond_to?(:loc) ? arg.loc.expression : arg
 
-        # We can't use the instance variable inside the lambda. That would
-        # just give each lambda the same reference and they would all get
-        # the last value of @column_delta. A local variable fixes the
-        # problem.
+        # We can't use the instance variable inside the lambda. That would just
+        # give each lambda the same reference and they would all get the last
+        # value of @column_delta. A local variable fixes the problem.
         column_delta = @column_delta
 
         fail CorrectionNotPossible if block_comment_within?(expr)
 
         @corrections << lambda do |corrector|
           each_line(expr) do |line_begin_pos|
-            range = calculate_range(expr, line_begin_pos, column_delta)
-            # We must not change indentation of heredoc stings.
-            next 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 =~ /^[ \t]+$/
-            end
+            autocorrect_line(corrector, line_begin_pos, expr, column_delta,
+                             heredoc_ranges)
           end
         end
       end
 
       private
 
+      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.
+        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 =~ /^[ \t]+$/
+        end
+      end
+
       def heredoc_ranges(arg)
         return [] unless arg.is_a?(Parser::AST::Node)
 

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

@@ -7,7 +7,6 @@ module RuboCop
     # abstract syntax tree, it is not done.
     module AutocorrectUnlessChangingAST
       def autocorrect(node)
-        c = correction(node)
         new_source = rewrite_node(node)
 
         # Make the correction only if it doesn't change the AST. Regenerate the
@@ -17,7 +16,11 @@ module RuboCop
           fail CorrectionNotPossible
         end
 
-        @corrections << c
+        if syntax_error?(node.loc.expression, new_source)
+          fail CorrectionNotPossible
+        end
+
+        @corrections << correction(node)
       end
 
       private
@@ -31,6 +34,16 @@ module RuboCop
         c = correction(processed_source.ast)
         Corrector.new(processed_source.buffer, [c]).rewrite
       end
+
+      # Return true if the change would introduce a syntax error in the buffer
+      # source.
+      def syntax_error?(replaced_range, new_source)
+        current_buffer_src = processed_source.buffer.source
+        pre = current_buffer_src[0...replaced_range.begin_pos]
+        post = current_buffer_src[replaced_range.end_pos..-1]
+        new_buffer_src = pre + new_source + post
+        !ProcessedSource.new(new_buffer_src).valid_syntax?
+      end
     end
   end
 end

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

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Common functionality for checking if presence/absence of empty lines
+      # around some kind of body matches the configuration.
+      module EmptyLinesAroundBody
+        include ConfigurableEnforcedStyle
+
+        MSG_EXTRA = 'Extra empty line detected at %s body %s.'
+        MSG_MISSING = 'Empty line missing at %s body %s.'
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            case style
+            when :no_empty_lines then corrector.remove(range)
+            when :empty_lines    then corrector.insert_before(range, "\n")
+            end
+          end
+        end
+
+        private
+
+        def check(node)
+          start_line = node.loc.keyword.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          check_source(start_line, end_line)
+        end
+
+        def check_source(start_line, end_line)
+          case style
+          when :no_empty_lines
+            check_both(start_line, end_line, MSG_EXTRA) do |line|
+              line.empty?
+            end
+          when :empty_lines
+            check_both(start_line, end_line, MSG_MISSING) do |line|
+              !line.empty?
+            end
+          end
+        end
+
+        def check_both(start_line, end_line, msg, &block)
+          kind = self.class::KIND
+          check_line(start_line, format(msg, kind, 'beginning'), &block)
+          check_line(end_line - 2, format(msg, kind, 'end'), &block)
+        end
+
+        def check_line(line, msg)
+          return unless yield processed_source.lines[line]
+
+          offset = style == :empty_lines && msg.include?('end.') ? 2 : 1
+          range = source_range(processed_source.buffer, line + offset, 0)
+          add_offense(range, range, msg)
+        end
+      end
+    end
+  end
+end

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

@@ -23,7 +23,7 @@ module RuboCop
         kw_loc = node.loc.keyword
 
         if kw_loc.line != end_loc.line &&
-            kw_loc.column != end_loc.column + offset
+           kw_loc.column != end_loc.column + offset
           add_offense(nil, end_loc,
                       format(MSG, end_loc.line, end_loc.column,
                              alignment_base, kw_loc.line, kw_loc.column)) do

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

@@ -5,7 +5,9 @@ module RuboCop
     # Common functionality for checking if nodes.
     module IfNode
       def modifier_if?(node)
-        node.loc.respond_to?(:end) && node.loc.end.nil?
+        node.loc.respond_to?(:keyword) &&
+          %w(if unless).include?(node.loc.keyword.source) &&
+          node.loc.respond_to?(:end) && node.loc.end.nil?
       end
 
       def ternary_op?(node)

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

@@ -4,19 +4,19 @@ module RuboCop
   module Cop
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include OnMethod
+      include OnMethodDef
       include ConfigurableMax
 
       private
 
-      def on_method(node, method_name, _args, _body)
+      def on_method_def(node, method_name, _args, _body)
         max = cop_config['Max']
         complexity = complexity(node)
         return unless complexity > max
 
         add_offense(node, :keyword,
                     format(self.class::MSG, method_name, complexity, max)) do
-          self.max = complexity
+          self.max = complexity.ceil
         end
       end
 

data/lib/rubocop/cop/mixin/{on_method.rb → on_method_def.rb}

@@ -3,15 +3,15 @@
 module RuboCop
   module Cop
     # Common functionality for checking instance methods and singeton methods.
-    module OnMethod
+    module OnMethodDef
       def on_def(node)
         method_name, args, body = *node
-        on_method(node, method_name, args, body)
+        on_method_def(node, method_name, args, body)
       end
 
       def on_defs(node)
         _scope, method_name, args, body = *node
-        on_method(node, method_name, args, body)
+        on_method_def(node, method_name, args, body)
       end
 
       private

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

@@ -10,8 +10,8 @@ module RuboCop
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|
           next unless kind(t1) && t1.pos.line == t2.pos.line &&
-            t2.pos.column == t1.pos.column + offset &&
-            ![:tRPAREN, :tRBRACK].include?(t2.type)
+                      t2.pos.column == t1.pos.column + offset &&
+                      ![:tRPAREN, :tRBRACK].include?(t2.type)
 
           add_offense(t1, t1.pos, format(MSG, kind(t1)))
         end

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

@@ -10,7 +10,7 @@ module RuboCop
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|
           next unless kind(t2) && t1.pos.line == t2.pos.line &&
-            t2.pos.begin_pos > t1.pos.end_pos
+                      t2.pos.begin_pos > t1.pos.end_pos
           buffer = processed_source.buffer
           pos_before_punctuation = Parser::Source::Range.new(buffer,
                                                              t1.pos.end_pos,

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

@@ -27,13 +27,13 @@ module RuboCop
         cond_length = cond.loc.expression.size
         space = 1
         total = indentation + body_length + space + kw_length + space +
-          cond_length
+                cond_length
         total <= max_line_length && !body_has_comment?(body)
       end
 
       def max_line_length
         cop_config && cop_config['MaxLineLength'] ||
-        config.for_cop('Metrics/LineLength')['Max']
+          config.for_cop('Metrics/LineLength')['Max']
       end
 
       def length(node)

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    # Common functionality for cops checking single/double quotes.
+    module StringLiteralsHelp
+      include StringHelp
+
+      def wrong_quotes?(node, style)
+        src = node.loc.expression.source
+        return false if src.start_with?('%') || src.start_with?('?')
+        if style == :single_quotes
+          src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
+        else
+          src !~ /" | \\/x
+        end
+      end
+
+      def autocorrect(node)
+        @corrections << lambda do |corrector|
+          replacement = node.loc.begin.is?('"') ? "'" : '"'
+          corrector.replace(node.loc.begin, replacement)
+          corrector.replace(node.loc.end, replacement)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/delegate.rb

@@ -29,13 +29,13 @@ module RuboCop
       #     foo.bar
       #   end
       class Delegate < Cop
-        include OnMethod
+        include OnMethodDef
 
         MSG = 'Use `delegate` to define delegations.'
 
         private
 
-        def on_method(node, method_name, args, body)
+        def on_method_def(node, method_name, args, body)
           return unless trivial_delegate?(method_name, args, body)
           return if private_or_protected_delegation(node)
           add_offense(node, :keyword, MSG)

data/lib/rubocop/cop/style/access_modifier_indentation.rb

@@ -73,13 +73,13 @@ module RuboCop
         end
 
         def expected_indent_offset
-          style == :outdent ? 0 : IndentationWidth::CORRECT_INDENTATION
+          style == :outdent ? 0 : configured_indentation_width
         end
 
         # An offset that is not expected, but correct if the configuration is
         # changed.
         def unexpected_indent_offset
-          IndentationWidth::CORRECT_INDENTATION - expected_indent_offset
+          configured_indentation_width - expected_indent_offset
         end
       end
     end

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

@@ -18,11 +18,11 @@ module RuboCop
       #   # good
       #   def attribute ...
       class AccessorMethodName < Cop
-        include OnMethod
+        include OnMethodDef
 
         private
 
-        def on_method(node, method_name, args, _body)
+        def on_method_def(node, method_name, args, _body)
           if bad_reader_name?(method_name.to_s, args)
             add_offense(node, :name,
                         'Do not prefix reader method names with `get_`.')

data/lib/rubocop/cop/style/align_hash.rb

@@ -41,7 +41,7 @@ module RuboCop
             separator_delta = separator_delta(first_pair, current_separator,
                                               key_delta)
             value_delta = value_delta(first_pair, current_pair) -
-              key_delta - separator_delta
+                          key_delta - separator_delta
 
             { key: key_delta, separator: separator_delta, value: value_delta }
           end
@@ -106,7 +106,8 @@ module RuboCop
             first_key, _ = *first_pair
             _, current_value = *current_pair
             correct_value_column = first_key.loc.column +
-              spaced_separator(current_pair).length + @max_key_width
+                                   spaced_separator(current_pair).length +
+                                   @max_key_width
             correct_value_column - current_value.loc.column
           end
 
@@ -148,7 +149,8 @@ module RuboCop
 
         def on_send(node)
           return unless (last_child = node.children.last) &&
-            hash?(last_child) && ignore_last_argument_hash?(last_child)
+                        hash?(last_child) &&
+                        ignore_last_argument_hash?(last_child)
 
           ignore_node(last_child)
         end
@@ -162,15 +164,20 @@ module RuboCop
             new_alignment('EnforcedHashRocketStyle')
           @alignment_for_colons ||= new_alignment('EnforcedColonStyle')
 
-          first_pair = node.children.first
-
           unless @alignment_for_hash_rockets.checkable_layout(node) &&
-              @alignment_for_colons.checkable_layout(node)
+                 @alignment_for_colons.checkable_layout(node)
             return
           end
 
+          check_pairs(node)
+        end
+
+        private
+
+        def check_pairs(node)
+          first_pair = node.children.first
           @column_deltas = alignment_for(first_pair)
-            .deltas_for_first_pair(first_pair, node)
+                           .deltas_for_first_pair(first_pair, node)
           add_offense(first_pair, :expression) unless good_alignment?
 
           node.children.each_cons(2) do |prev, current|
@@ -180,8 +187,6 @@ module RuboCop
           end
         end
 
-        private
-
         def ignore_last_argument_hash?(node)
           case cop_config['EnforcedLastArgumentHashStyle']
           when 'always_inspect'  then false
@@ -199,12 +204,11 @@ module RuboCop
           node.loc.begin
         end
 
-        # Returns true if the hash spans multiple lines, and each key-value
-        # pair following the first is on a new line.
+        # Returns true if the hash spans multiple lines
         def multiline?(node)
           return false unless node.loc.expression.source.include?("\n")
 
-          return false if node.children[1..-1].find do |child|
+          return false if node.children[1..-1].all? do |child|
             !begins_its_line?(child.loc.expression)
           end