rubocop 0.34.2 → 0.35.0

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

@@ -6,6 +6,8 @@ module RuboCop
       # This cop looks for uses of block comments (=begin...=end).
       class BlockComments < Cop
         MSG = 'Do not use block comments.'
+        BEGIN_LENGTH = "=begin\n".length
+        END_LENGTH = "\n=end".length
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
@@ -33,9 +35,9 @@ module RuboCop
 
         def parts(comment)
           expr = comment.loc.expression
-          eq_begin = expr.resize("=begin\n".length)
+          eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = Parser::Source::Range.new(expr.source_buffer,
-                                             expr.end_pos - "\n=end".length,
+                                             expr.end_pos - END_LENGTH,
                                              expr.end_pos)
           contents = Parser::Source::Range.new(expr.source_buffer,
                                                eq_begin.end_pos,

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

@@ -25,32 +25,55 @@ module RuboCop
         def on_block(node)
           return if ignored_node?(node)
 
-          if proper_block_style?(node)
-            correct_style_detected
-          else
-            add_offense(node, :begin) { opposite_style_detected }
-          end
+          return if proper_block_style?(node)
+
+          add_offense(node, :begin)
         end
 
         private
 
-        def message(node)
+        def line_count_based_message(node)
+          block_length = Util.block_length(node)
+
+          if block_length > 0
+            'Avoid using `{...}` for multi-line blocks.'
+          else
+            'Prefer `{...}` over `do...end` for single-line blocks.'
+          end
+        end
+
+        def semantic_message(node)
           block_begin = node.loc.begin.source
+
+          if block_begin == '{'
+            'Prefer `do...end` over `{...}` for procedural blocks.'
+          else
+            'Prefer `{...}` over `do...end` for functional blocks.'
+          end
+        end
+
+        def braces_for_chaining_message(node)
           block_length = Util.block_length(node)
 
-          case style
-          when :line_count_based
-            if block_length > 0
-              'Avoid using `{...}` for multi-line blocks.'
+          if block_length > 0
+            if return_value_chaining?(node)
+              'Prefer `{...}` over `do...end` for multi-line chained blocks.'
             else
-              'Prefer `{...}` over `do...end` for single-line blocks.'
+              'Prefer `do...end` for multi-line blocks without chaining.'
             end
+          else
+            'Prefer `{...}` over `do...end` for single-line blocks.'
+          end
+        end
+
+        def message(node)
+          case style
+          when :line_count_based
+            line_count_based_message(node)
           when :semantic
-            if block_begin == '{'
-              'Prefer `do...end` over `{...}` for procedural blocks.'
-            else
-              'Prefer `{...}` over `do...end` for functional blocks.'
-            end
+            semantic_message(node)
+          when :braces_for_chaining
+            braces_for_chaining_message(node)
           end
         end
 
@@ -90,6 +113,8 @@ module RuboCop
             line_count_based_block_style?(node)
           when :semantic
             semantic_block_style?(node)
+          when :braces_for_chaining
+            braces_for_chaining_style?(node)
           end
         end
 
@@ -117,6 +142,21 @@ module RuboCop
           end
         end
 
+        def braces_for_chaining_style?(node)
+          block_length = Util.block_length(node)
+          block_begin = node.loc.begin.source
+
+          if block_length > 0
+            block_begin == (return_value_chaining?(node) ? '{' : 'do')
+          else
+            block_begin == '{'
+          end
+        end
+
+        def return_value_chaining?(node)
+          node.parent && node.parent.send_type? && node.parent.loc.dot
+        end
+
         def extract_method_name_from_block(block)
           node, _args, _body = *block
           _receiver, method_name, *_args = *node
@@ -148,8 +188,7 @@ module RuboCop
           if node.parent.begin_type?
             return_value_used?(node.parent)
           else
-            Util::ASGN_NODES.include?(node.parent.type) ||
-              node.parent.send_type?
+            node.parent.assignment? || node.parent.send_type?
           end
         end
 

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

@@ -15,7 +15,7 @@ module RuboCop
           _receiver, method_name, *args = *node
 
           # Discard attr writer methods.
-          return if method_name.to_s.end_with?('=')
+          return if node.asgn_method_call?
           # Discard operator methods.
           return if operator?(method_name)
 

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

@@ -47,7 +47,7 @@ module RuboCop
         def check_backtick_literal(node)
           return if style == :backticks && !contains_disallowed_backtick?(node)
           return if style == :mixed &&
-                    single_line?(node) &&
+                    node.single_line? &&
                     !contains_disallowed_backtick?(node)
 
           add_offense(node, :expression, MSG_USE_PERCENT_X)
@@ -56,7 +56,7 @@ module RuboCop
         def check_percent_x_literal(node)
           return if style == :backticks && contains_disallowed_backtick?(node)
           return if style == :percent_x
-          return if style == :mixed && multi_line?(node)
+          return if style == :mixed && node.multiline?
           return if style == :mixed && contains_disallowed_backtick?(node)
 
           add_offense(node, :expression, MSG_USE_BACKTICKS)
@@ -87,14 +87,6 @@ module RuboCop
           node.loc.begin.source == '`'
         end
 
-        def single_line?(node)
-          !multi_line?(node)
-        end
-
-        def multi_line?(node)
-          block_length(node) > 1
-        end
-
         def preferred_delimiters
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%x'].split(//)

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

@@ -68,10 +68,12 @@ module RuboCop
         end
 
         def autocorrect(token)
-          fail 'An AutocorrectNotice must be defined in ' \
+          fail Warning, 'An AutocorrectNotice must be defined in ' \
             'your RuboCop config' if autocorrect_notice.empty?
-          fail "AutocorrectNotice '#{autocorrect_notice}' must match " \
-            "Notice /#{notice}/" unless autocorrect_notice =~ Regexp.new(notice)
+          regex = Regexp.new(notice)
+          fail Warning, "AutocorrectNotice '#{autocorrect_notice}' must " \
+            "match Notice /#{notice}/" unless autocorrect_notice =~ regex
+
           lambda do |corrector|
             if token.nil?
               range = Parser::Source::Range.new('', 0, 0)

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

@@ -47,18 +47,21 @@ module RuboCop
           end
         end
 
+        # 'Const = Class.new' or 'Const = Module.new' are module definitions
+        mod_new = '(send (const nil {:Class :Module}) :new ...)'
+        def_node_matcher :module_definition?,
+                         "{class
+                           module
+                           (casgn _ _ {#{mod_new} (block #{mod_new} ...)})}"
+
         def namespace?(body_node)
           return false unless body_node
 
           case body_node.type
           when :begin
-            body_node.children.all? do |node|
-              [:class, :module].include?(node.type)
-            end
-          when :class, :module
-            true
+            body_node.children.all? { |node| module_definition?(node) }
           else
-            false
+            module_definition?(body_node)
           end
         end
 

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

@@ -46,6 +46,12 @@ module RuboCop
 
           dot_line = node.loc.dot.line
 
+          # don't register an offense if there is a line comment between
+          # the dot and the selector
+          # otherwise, we might break the code while "correcting" it
+          # (even if there is just an extra blank line, treat it the same)
+          return true if (selector_line - dot_line) > 1
+
           case style
           when :leading then dot_line == selector_line
           when :trailing then dot_line != selector_line

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

@@ -22,22 +22,11 @@ module RuboCop
       class DoubleNegation < Cop
         MSG = 'Avoid the use of double negation (`!!`).'
 
-        def on_send(node)
-          return unless not_node?(node)
-
-          receiver, _method_name, *_args = *node
-
-          add_offense(node, :selector) if not_node?(receiver)
-        end
+        def_node_matcher :double_negative?, '(send (send _ :!) :!)'
 
-        private
-
-        def not_node?(node)
-          _receiver, method_name, *args = *node
-
-          # ! does not take any arguments
-          args.empty? && method_name == :! &&
-            node.loc.selector.is?('!')
+        def on_send(node)
+          return unless double_negative?(node) && node.loc.selector.is?('!')
+          add_offense(node, :selector)
         end
       end
     end

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

@@ -7,6 +7,9 @@ module RuboCop
       # returned at the end and so could be replace by each_with_object without
       # the need to return the object at the end.
       #
+      # However, we can't replace with each_with_object if the accumulator
+      # parameter is assigned to within the block.
+      #
       # @example
       #   # bad
       #   [1, 2].inject({}) { |a, e| a[e] = e; a }
@@ -23,16 +26,26 @@ module RuboCop
           # filter out super and zsuper nodes
           return unless method.type == :send
 
-          _, method_name, method_args = *method
+          _, method_name, method_arg = *method
 
           return unless METHODS.include? method_name
-          return if method_args && method_args.type == :sym
+          return if method_arg && BASIC_LITERALS.include?(method_arg.type)
 
           return_value = return_value(body)
           return unless return_value
 
           return unless first_argument_returned?(args, return_value)
 
+          # if the accumulator parameter is assigned to in the block,
+          # then we can't convert to each_with_object
+          first_arg, = *args
+          accumulator_var, = *first_arg
+          return if body.each_descendant.any? do |n|
+            next unless n.assignment?
+            lhs, _rhs = *n
+            lhs.equal?(accumulator_var)
+          end
+
           add_offense(method, :selector, format(MSG, method_name))
         end
 
@@ -47,8 +60,8 @@ module RuboCop
 
         def first_argument_returned?(args, return_value)
           first_arg, = *args
-          accumulator_var = *first_arg
-          return_var = *return_value
+          accumulator_var, = *first_arg
+          return_var, = *return_value
 
           accumulator_var == return_var
         end

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

@@ -16,7 +16,7 @@ module RuboCop
 
           return unless nodes.all?(&method(:def_node?))
           return if blank_lines_between?(*nodes)
-          return if nodes.all?(&method(:single_line_def?)) &&
+          return if nodes.all?(&:single_line?) &&
                     cop_config['AllowAdjacentOneLineDefs']
 
           add_offense(node, :keyword)
@@ -45,10 +45,6 @@ module RuboCop
           processed_source.lines[line_range]
         end
 
-        def single_line_def?(node)
-          def_start(node) == def_end(node)
-        end
-
         def def_start(node)
           node.loc.keyword.line
         end

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

@@ -16,7 +16,9 @@ module RuboCop
 
         MSG_MISSING = 'Missing utf-8 encoding comment.'
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
-        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
+        SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
           return if processed_source.buffer.source.empty?
@@ -31,10 +33,14 @@ module RuboCop
         end
 
         def autocorrect(node)
-          encoding = cop_config['AutoCorrectEncodingComment']
+          encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
           if encoding && encoding =~ ENCODING_PATTERN
             lambda do |corrector|
-              corrector.replace(node.pos, "#{encoding}\n#{node.pos.source}")
+              if encoding_line_number(processed_source) == 0
+                corrector.insert_before(node.pos, "#{encoding}\n")
+              else
+                corrector.insert_after(node.pos, "\n#{encoding}")
+              end
             end
           else
             fail "#{encoding} does not match #{ENCODING_PATTERN}"
@@ -58,7 +64,7 @@ module RuboCop
 
         def encoding_line_number(processed_source)
           line_number = 0
-          line_number += 1 if processed_source[line_number].start_with?('#!')
+          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
           line_number
         end
       end

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

@@ -22,7 +22,6 @@ module RuboCop
 
         def investigate(processed_source)
           ast = processed_source.ast
-          ignored_ranges = ast ? ignored_ranges(ast) : []
 
           processed_source.tokens.each_cons(2) do |t1, t2|
             next if t2.type == :tNL
@@ -30,10 +29,15 @@ module RuboCop
             next if t2.pos.begin_pos - 1 <= t1.pos.end_pos
             next if allow_for_alignment? && aligned_with_something?(t2)
             start_pos = t1.pos.end_pos
+            next if ignored_ranges(ast).find { |r| r.include?(start_pos) }
+
             end_pos = t2.pos.begin_pos - 1
             range = Parser::Source::Range.new(processed_source.buffer,
                                               start_pos, end_pos)
-            add_offense(range, range, MSG) unless ignored_ranges.include?(range)
+            # Unary + doesn't appear as a token and needs special handling.
+            next if unary_plus_non_offense?(range)
+
+            add_offense(range, range, MSG)
           end
         end
 
@@ -43,19 +47,25 @@ module RuboCop
 
         private
 
+        def unary_plus_non_offense?(range)
+          range.resize(range.size + 1).source =~ /^ ?\+$/
+        end
+
         # Returns an array of ranges that should not be reported. It's the
-        # extra spaces between the separators (: or =>) and values in a hash,
-        # since those are handled by the Style/AlignHash cop.
+        # extra spaces between the keys and values in a hash, since those are
+        # handled by the Style/AlignHash cop.
         def ignored_ranges(ast)
-          ranges = []
-          on_node(:pair, ast) do |pair|
-            _, value = *pair
-            ranges <<
-              Parser::Source::Range.new(processed_source.buffer,
-                                        pair.loc.operator.end_pos,
-                                        value.loc.expression.begin_pos - 1)
+          return [] unless ast
+
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              key, value = *pair
+              r = key.loc.expression.end_pos...value.loc.expression.begin_pos
+              ranges << r
+            end
+            ranges
           end
-          ranges
         end
 
         def allow_for_alignment?
@@ -122,7 +132,7 @@ module RuboCop
               whole_line_comments = processed_source.comments.select do |c|
                 begins_its_line?(c.loc.expression)
               end
-              whole_line_comments.map(&:loc).map(&:line)
+              whole_line_comments.map { |c| c.loc.line }
             end
         end
 

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first element in a
+      # multi-line array.
+      #
+      # @example
+      #
+      #     # bad
+      #     [ :a,
+      #       :b]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b]
+      #
+      class FirstArrayElementLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first element of a ' \
+              'multi-line array.'
+
+        def on_array(node)
+          return if !node.loc.begin && !assignment_on_same_line?(node)
+
+          check_children_line_break(node, node.children)
+        end
+
+        private
+
+        def assignment_on_same_line?(node)
+          source = node.loc.expression.source_line[0...node.loc.column]
+          source =~ /\s*\=\s*$/
+        end
+      end
+    end
+  end
+end