rubocop 0.31.0 → 0.35.0

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

@@ -7,14 +7,37 @@ module RuboCop
       # where the opening brace and the first key are on separate lines. The
       # other keys' indentations are handled by the AlignHash cop.
       #
-      # Hash literals that are arguments in a method call with parentheses, and
-      # where the opening curly brace of the hash is on the same line as the
-      # opening parenthesis of the method call, shall have their first key
-      # indented one step (two spaces) more than the position inside the
-      # opening parenthesis.
+      # By default, Hash literals that are arguments in a method call with
+      # parentheses, and where the opening curly brace of the hash is on the
+      # same line as the opening parenthesis of the method call, shall have
+      # their first key indented one step (two spaces) more than the position
+      # inside the opening parenthesis.
       #
       # Other hash literals shall have their first key indented one step more
       # than the start of the line where the opening curly brace is.
+      #
+      # This default style is called 'special_inside_parentheses'. Alternative
+      # styles are 'consistent' and 'align_braces'. Here are examples:
+      #
+      #     # special_inside_parentheses
+      #     hash = {
+      #       key: :value
+      #     }
+      #     but_in_a_method_call({
+      #                            its_like: :this
+      #                          })
+      #     # consistent
+      #     hash = {
+      #       key: :value
+      #     }
+      #     and_in_a_method_call({
+      #       no: :difference
+      #     })
+      #     # align_braces
+      #     and_now_for_something = {
+      #                               completely: :different
+      #                             }
+      #
       class IndentHash < Cop
         include AutocorrectAlignment
         include ConfigurableEnforcedStyle
@@ -62,13 +85,16 @@ module RuboCop
         end
 
         def check_right_brace(right_brace, left_brace, left_parenthesis)
+          # if the right brace is on the same line as the last value, accept
           return if right_brace.source_line[0...right_brace.column] =~ /\S/
 
           expected_column = base_column(left_brace, left_parenthesis)
           @column_delta = expected_column - right_brace.column
           return if @column_delta == 0
 
-          msg = if style == :special_inside_parentheses && left_parenthesis
+          msg = if style == :align_braces
+                  'Indent the right brace the same as the left brace.'
+                elsif style == :special_inside_parentheses && left_parenthesis
                   'Indent the right brace the same as the first position ' \
                   'after the preceding left parenthesis.'
                 else
@@ -93,15 +119,24 @@ module RuboCop
         end
 
         def check_first_pair(first_pair, left_brace, left_parenthesis, offset)
-          column = first_pair.loc.expression.column
+          actual_column = first_pair.loc.expression.column
           expected_column = base_column(left_brace, left_parenthesis) +
                             configured_indentation_width + offset
-          @column_delta = expected_column - column
+          @column_delta = expected_column - actual_column
 
           if @column_delta == 0
-            correct_style_detected
+            # which column was actually used as 'base column' for indentation?
+            # (not the column which we think should be the 'base column',
+            # but the one which has actually been used for that purpose)
+            base_column = actual_column - configured_indentation_width - offset
+            styles = detected_styles(base_column, left_parenthesis, left_brace)
+            if styles.size > 1
+              ambiguous_style_detected(*styles)
+            else
+              correct_style_detected
+            end
           else
-            incorrect_style_detected(column, offset, first_pair,
+            incorrect_style_detected(actual_column, offset, first_pair,
                                      left_parenthesis, left_brace)
           end
         end
@@ -110,17 +145,29 @@ module RuboCop
                                      left_parenthesis, left_brace)
           add_offense(first_pair, :expression,
                       message(base_description(left_parenthesis))) do
-            if column == unexpected_column(left_brace, left_parenthesis,
-                                           offset)
-              opposite_style_detected
-            else
-              unrecognized_style_detected
-            end
+            base_column = column - configured_indentation_width - offset
+            styles = detected_styles(base_column, left_parenthesis, left_brace)
+            ambiguous_style_detected(*styles)
           end
         end
 
+        def detected_styles(column, left_parenthesis, left_brace)
+          styles = []
+          if column == (left_brace.source_line =~ /\S/)
+            styles << :consistent
+            styles << :special_inside_parentheses unless left_parenthesis
+          end
+          if left_parenthesis && column == left_parenthesis.column + 1
+            styles << :special_inside_parentheses
+          end
+          styles << :align_braces if column == left_brace.column
+          styles
+        end
+
         def base_column(left_brace, left_parenthesis)
-          if left_parenthesis && style == :special_inside_parentheses
+          if style == :align_braces
+            left_brace.column
+          elsif left_parenthesis && style == :special_inside_parentheses
             left_parenthesis.column + 1
           else
             left_brace.source_line =~ /\S/
@@ -129,32 +176,15 @@ module RuboCop
 
         # Returns the description of what the correct indentation is based on.
         def base_description(left_parenthesis)
-          if left_parenthesis && style == :special_inside_parentheses
+          if style == :align_braces
+            'the position of the opening brace'
+          elsif left_parenthesis && style == :special_inside_parentheses
             'the first position after the preceding left parenthesis'
           else
             'the start of the line where the left curly brace is'
           end
         end
 
-        # Returns the "unexpected column", which is the column that would be
-        # correct if the configuration was changed.
-        def unexpected_column(left_brace, left_parenthesis, offset)
-          # Set a crazy value by default, indicating that there's no other
-          # configuration that can be chosen to make the used indentation
-          # accepted.
-          unexpected_base_column = -1000
-
-          if left_parenthesis
-            unexpected_base_column = if style == :special_inside_parentheses
-                                       left_brace.source_line =~ /\S/
-                                     else
-                                       left_parenthesis.column + 1
-                                     end
-          end
-
-          unexpected_base_column + configured_indentation_width + offset
-        end
-
         def message(base_description)
           format('Use %d spaces for indentation in a hash, relative to %s.',
                  configured_indentation_width, base_description)

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

@@ -13,6 +13,7 @@ module RuboCop
       #    end
       #   end
       class IndentationWidth < Cop # rubocop:disable Metrics/ClassLength
+        include EndKeywordAlignment
         include AutocorrectAlignment
         include OnMethodDef
         include CheckAssignment
@@ -82,10 +83,11 @@ module RuboCop
         def on_send(node)
           super
           receiver, method_name, *args = *node
-          return unless visibility_and_def_on_same_line?(receiver, method_name,
-                                                         args)
+          return unless modifier_and_def_on_same_line?(receiver, method_name,
+                                                       args)
+
+          *_, body = *args.first
 
-          _method_name, _args, body = *args.first
           def_end_config = config.for_cop('Lint/DefEndAlignment')
           style = if def_end_config['Enabled']
                     def_end_config['AlignWith']
@@ -157,11 +159,7 @@ module RuboCop
           return if ternary_op?(node)
           return if modifier_if?(node)
 
-          case node.loc.keyword.source
-          when 'if', 'elsif' then _condition, body, else_clause = *node
-          when 'unless'      then _condition, else_clause, body = *node
-          else                    _condition, body = *node
-          end
+          _condition, body, else_clause = if_node_parts(node)
 
           check_if(node, body, else_clause, base.loc) if body
         end
@@ -177,7 +175,7 @@ module RuboCop
 
           end_config = config.for_cop('Lint/EndAlignment')
           style = end_config['Enabled'] ? end_config['AlignWith'] : 'keyword'
-          base = style == 'variable' ? node : rhs
+          base = variable_alignment?(node.loc, rhs, style.to_sym) ? node : rhs
 
           case rhs.type
           when :if            then on_if(rhs, base)
@@ -215,13 +213,36 @@ module RuboCop
             body_node = body_node.children.first
           end
 
+          # Since autocorrect changes a number of lines, and not only the line
+          # where the reported offending range is, we avoid auto-correction if
+          # this cop has already found other offenses is the same
+          # range. Otherwise, two corrections can interfere with each other,
+          # resulting in corrupted code.
+          node = if autocorrect? && other_offense_in_same_range?(body_node)
+                   nil
+                 else
+                   body_node
+                 end
+
           indentation_name = style == 'normal' ? '' : "#{style} "
-          add_offense(body_node, offending_range(body_node, indentation),
+          add_offense(node, offending_range(body_node, indentation),
                       format("Use #{configured_indentation_width} (not %d) " \
                              "spaces for #{indentation_name}indentation.",
                              indentation))
         end
 
+        # Returns true if the given node is within another node that has
+        # already been marked for auto-correction by this cop.
+        def other_offense_in_same_range?(node)
+          expr = node.loc.expression
+          @offense_ranges ||= []
+
+          return true if @offense_ranges.any? { |r| within?(expr, r) }
+
+          @offense_ranges << expr
+          false
+        end
+
         def indentation_to_check?(base_loc, body_node)
           return false unless body_node
 
@@ -235,6 +256,11 @@ module RuboCop
           first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
           return false unless body_node.loc.column == first_char_pos_on_line
 
+          if [:rescue, :ensure].include?(body_node.type)
+            block_body, = *body_node
+            return unless block_body
+          end
+
           true
         end
 

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks for indentation of the first non-blank non-comment
+      # line in a file.
+      class InitialIndentation < Cop
+        MSG = 'Indentation of first line in file detected.'
+
+        def investigate(processed_source)
+          first_token = processed_source.tokens.find do |t|
+            !t.text.start_with?('#')
+          end
+          return unless first_token
+          return if first_token.pos.column == 0
+
+          with_space = range_with_surrounding_space(first_token.pos, :left,
+                                                    nil, !:with_newline)
+          # If the file starts with a byte order mark (BOM), the column can be
+          # non-zero, but then we find out here if there's no space to the left
+          # of the first token.
+          return if with_space == first_token.pos
+
+          space = Parser::Source::Range.new(processed_source.buffer,
+                                            with_space.begin_pos,
+                                            first_token.pos.begin_pos)
+          add_offense(space, first_token.pos)
+        end
+
+        def autocorrect(range)
+          ->(corrector) { corrector.remove(range) }
+        end
+      end
+    end
+  end
+end

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

@@ -6,13 +6,14 @@ module RuboCop
       # This cop checks whether comments have a leading space
       # after the # denoting the start of the comment. The
       # leading space is not required for some RDoc special syntax,
-      # like #++, #--, #:nodoc, etc.
+      # like #++, #--, #:nodoc, etc. Neither is it required for
+      # =begin/=end comments.
       class LeadingCommentSpace < Cop
         MSG = 'Missing space after #.'
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            next unless comment.text =~ /^#+[^#\s=:+-]/
+            next unless comment.text =~ /\A#+[^#\s=:+-]/
             next if comment.text.start_with?('#!') && comment.loc.line == 1
 
             add_offense(comment, :expression)

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

@@ -7,13 +7,17 @@ module RuboCop
       class MethodCallParentheses < Cop
         MSG = 'Do not use parentheses for method calls with no arguments.'
 
+        ASGN_NODES = [:lvasgn, :masgn] + Util::SHORTHAND_ASGN_NODES
+
         def on_send(node)
           _receiver, method_name, *args = *node
 
           # methods starting with a capital letter should be skipped
           return if method_name =~ /\A[A-Z]/
+          return unless args.empty? && node.loc.begin
+          return if same_name_assignment?(node)
 
-          add_offense(node, :begin) if args.empty? && node.loc.begin
+          add_offense(node, :begin)
         end
 
         def autocorrect(node)
@@ -22,6 +26,29 @@ module RuboCop
             corrector.remove(node.loc.end)
           end
         end
+
+        private
+
+        def same_name_assignment?(node)
+          _receiver, method_name, *_args = *node
+
+          node.each_ancestor(ASGN_NODES).any? do |asgn_node|
+            if asgn_node.masgn_type?
+              mlhs_node, _mrhs_node = *asgn_node
+              asgn_node = mlhs_node.children[node.sibling_index]
+            end
+            # `obj.method = value` parses as (send ... :method= ...), and will
+            # not be returned as an `asgn_node` here
+            # however, `obj.method ||= value` parses as (or-asgn (send ...) ...)
+            # which IS an `asgn_node`
+            if asgn_node.or_asgn_type? || asgn_node.and_asgn_type?
+              asgn_node, _value = *asgn_node
+              return false if asgn_node.send_type?
+            end
+
+            asgn_node.loc.name.source == method_name.to_s
+          end
+        end
       end
     end
   end

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

@@ -10,7 +10,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         def on_method_def(node, _method_name, args, _body)
-          if style == :require_parentheses
+          if style == :require_parentheses ||
+             (style == :require_no_parentheses_except_multiline &&
+              args.multiline?)
             if arguments?(args) && !parentheses?(args)
               missing_parentheses(node, args)
             else
@@ -25,7 +27,11 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            if style == :require_parentheses
+            if node.args_type?
+              # offense is registered on args node when parentheses are unwanted
+              corrector.replace(node.loc.begin, ' ')
+              corrector.remove(node.loc.end)
+            else
               args_expr = args_node(node).loc.expression
               args_with_space = range_with_surrounding_space(args_expr, :left)
               just_space = Parser::Source::Range.new(args_expr.source_buffer,
@@ -33,9 +39,6 @@ module RuboCop
                                                      args_expr.begin_pos)
               corrector.replace(just_space, '(')
               corrector.insert_after(args_expr, ')')
-            elsif style == :require_no_parentheses
-              corrector.replace(node.loc.begin, ' ')
-              corrector.remove(node.loc.end)
             end
           end
         end
@@ -45,13 +48,13 @@ module RuboCop
         def missing_parentheses(node, args)
           add_offense(node, args.loc.expression,
                       'Use def with parentheses when there are parameters.') do
-            opposite_style_detected
+            unexpected_style_detected(:require_no_parentheses)
           end
         end
 
         def unwanted_parentheses(args)
           add_offense(args, :expression, 'Use def without parentheses.') do
-            opposite_style_detected
+            unexpected_style_detected(:require_parentheses)
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       #   b
       #     something
       #   end
-      class MultilineOperationIndentation < Cop # rubocop:disable ClassLength
+      class MultilineOperationIndentation < Cop
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment
 
@@ -98,7 +98,7 @@ module RuboCop
             article = kw =~ /^[iu]/ ? 'an' : 'a'
             "a #{kind} in #{article} `#{kw}` statement"
           else
-            'an expression' + (assignment?(node) ? ' in an assignment' : '')
+            'an expression' + (assignment_rhs?(node) ? ' in an assignment' : '')
           end
         end
 
@@ -121,15 +121,17 @@ module RuboCop
           _, method_name, *args = *send_node
           if operator?(method_name) && args.any?
             args.first.loc.expression
-          elsif send_node.loc.dot &&
-                send_node.loc.selector &&
-                send_node.loc.dot.line == send_node.loc.selector.line
-            send_node.loc.dot.join(send_node.loc.selector)
-          elsif send_node.loc.selector
-            send_node.loc.selector
-          elsif send_node.loc.dot.line == send_node.loc.begin.line
-            # lambda.(args)
-            send_node.loc.dot.join(send_node.loc.begin)
+          else
+            dot = send_node.loc.dot
+            selector = send_node.loc.selector
+            if dot && selector && dot.line == selector.line
+              dot.join(selector)
+            elsif selector
+              selector
+            elsif dot.line == send_node.loc.begin.line
+              # lambda.(args)
+              dot.join(send_node.loc.begin)
+            end
           end
         end
 
@@ -140,7 +142,7 @@ module RuboCop
 
         def should_align?(node, given_style)
           given_style == :aligned && (kw_node_with_special_indentation(node) ||
-                                      assignment?(node))
+                                      assignment_rhs?(node))
         end
 
         def kw_node_with_special_indentation(node)
@@ -158,22 +160,17 @@ module RuboCop
           end
         end
 
-        def assignment?(node)
-          node.each_ancestor.find do |a|
-            case a.type
-            when :send
-              _receiver, method_name, *_args = *a
-              # The []= operator is the only assignment operator that is parsed
-              # as a :send node.
-              method_name == :[]=
-            when *ASGN_NODES
-              true
-            end
+        def assignment_rhs?(node)
+          node.ancestors.unshift(node).each_cons(2).any? do |child, parent|
+            return true if parent.asgn_rhs.equal?(child)
+            grandparent = parent.parent
+            return true if grandparent && grandparent.masgn_type? &&
+                           grandparent.asgn_rhs.equal?(parent)
           end
         end
 
         def not_for_this_cop?(node)
-          node.each_ancestor.find do |ancestor|
+          node.each_ancestor.any? do |ancestor|
             grouped_expression?(ancestor) ||
               inside_arg_list_parentheses?(node, ancestor)
           end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether some constant value isn't a
+      # mutable literal (e.g. array or hash).
+      #
+      # @example
+      #   # bad
+      #   CONST = [1, 2, 3]
+      #
+      #   # good
+      #   CONST = [1, 2, 3].freeze
+      class MutableConstant < Cop
+        MSG = 'Freeze mutable objects assigned to constants.'
+
+        MUTABLE_TYPES = [:array, :hash, :str, :dstr].freeze
+
+        def on_casgn(node)
+          _scope, _const_name, value = *node
+
+          return if value && !MUTABLE_TYPES.include?(value.type)
+
+          add_offense(value, :expression)
+        end
+
+        def autocorrect(node)
+          expr = node.loc.expression
+          ->(corrector) { corrector.replace(expr, "#{expr.source}.freeze") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for nested use of if, unless, while and until in their
+      # modifier form.
+      #
+      # @example
+      #
+      #   # bad
+      #   something if a if b
+      #
+      #   # good
+      #   something if b && a
+      class NestedModifier < Cop
+        include IfNode
+
+        MSG = 'Avoid using nested modifiers.'
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def on_if(node)
+          check(node)
+        end
+
+        def check(node)
+          return if part_of_ignored_node?(node)
+          return unless modifier?(node)
+
+          ancestor = node.ancestors.first
+          return unless ancestor &&
+                        [:if, :while, :until].include?(ancestor.type) &&
+                        modifier?(ancestor)
+
+          add_offense(node, :keyword)
+          ignore_node(node)
+        end
+
+        def modifier?(node)
+          modifier_if?(node) || modifier_while_or_until?(node)
+        end
+
+        def modifier_while_or_until?(node)
+          node.loc.respond_to?(:keyword) &&
+            %w(while until).include?(node.loc.keyword.source) &&
+            node.loc.respond_to?(:end) && node.loc.end.nil?
+        end
+
+        def autocorrect(node)
+          return unless node.if_type?
+
+          ancestor = node.ancestors.first
+          return unless ancestor.if_type?
+
+          autocorrect_if_unless(ancestor, node)
+        end
+
+        def autocorrect_if_unless(outer_node, inner_node)
+          outer_cond, = *outer_node
+
+          range =
+            Parser::Source::Range.new(inner_node.loc.expression.source_buffer,
+                                      inner_node.loc.keyword.begin_pos,
+                                      outer_cond.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, new_expression(outer_node, inner_node))
+          end
+        end
+
+        def new_expression(outer_node, inner_node)
+          outer_cond, = *outer_node
+          inner_cond, = *inner_node
+
+          outer_keyword = outer_node.loc.keyword.source
+          inner_keyword = inner_node.loc.keyword.source
+
+          operator = outer_keyword == 'if' ? '&&' : '||'
+
+          inner_expr = inner_cond.loc.expression.source
+          inner_expr = "(#{inner_expr})" if inner_cond.or_type?
+          inner_expr = "!#{inner_expr}" unless outer_keyword == inner_keyword
+
+          "#{outer_node.loc.keyword.source} " \
+          "#{outer_cond.loc.expression.source} #{operator} #{inner_expr}"
+        end
+      end
+    end
+  end
+end