rubocop 0.42.0 → 0.43.0

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

@@ -14,23 +14,33 @@ module RuboCop
         ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn,
                             :gvasgn, :ivasgn, :masgn].freeze
 
+        def on_if(node)
+          return unless eligible_node?(node)
+
+          add_offense(node, :keyword, message(node.loc.keyword.source))
+        end
+
+        private
+
+        def autocorrect(node)
+          ->(corrector) { corrector.replace(node.source_range, oneline(node)) }
+        end
+
+        def eligible_node?(node)
+          !non_eligible_if?(node) && !node.chained? &&
+            !nested_conditional?(node) && single_line_as_modifier?(node)
+        end
+
+        def non_eligible_if?(node)
+          ternary?(node) || modifier_if?(node) ||
+            elsif?(node) || if_else?(node)
+        end
+
         def message(keyword)
           "Favor modifier `#{keyword}` usage when having a single-line body." \
           ' Another good alternative is the usage of control flow `&&`/`||`.'
         end
 
-        def on_if(node)
-          # discard ternary ops, if/else and modifier if/unless nodes
-          return if ternary?(node)
-          return if modifier_if?(node)
-          return if elsif?(node)
-          return if if_else?(node)
-          return if node.chained?
-          return unless fit_within_line_as_modifier_form?(node)
-          return if nested_conditional?(node)
-          add_offense(node, :keyword, message(node.loc.keyword.source))
-        end
-
         def parenthesize?(node)
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression
@@ -51,15 +61,9 @@ module RuboCop
           source =~ /\s*\(\s*$/
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.source_range, oneline(node)) }
-        end
-
-        private
-
         # returns false if the then or else children are conditionals
         def nested_conditional?(node)
-          node.children[1, 2].any? { |child| child && child.type == :if }
+          node.children[1, 2].compact.any?(&:if_type?)
         end
 
         def oneline(node)

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

@@ -35,9 +35,9 @@ module RuboCop
         def on_if(node)
           return unless modifier_if?(node)
           _cond, body, _else = if_node_parts(node)
-          if body.type == :if
-            add_offense(node, :keyword, message(node.loc.keyword.source))
-          end
+          return unless body.if_type?
+
+          add_offense(node, :keyword, message(node.loc.keyword.source))
         end
       end
     end

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

@@ -21,6 +21,8 @@ module RuboCop
         include IfNode
         include AccessModifierNode
 
+        SPECIAL_MODIFIERS = %w(private protected).freeze
+
         def on_rescue(node)
           _begin_node, *rescue_nodes, else_node = *node
           rescue_nodes.each do |rescue_node|
@@ -65,19 +67,11 @@ module RuboCop
           check_indentation(node.loc.keyword, members.first)
 
           return unless members.any? && members.first.begin_type?
-          style =
-            config.for_cop('Style/IndentationConsistency')['EnforcedStyle']
-          return unless style == 'rails'
+          return unless indentation_consistency_style == 'rails'
 
-          special = %w(protected private) # Extra indentation step after these.
-          previous_modifier = nil
-          members.first.children.each do |m|
-            if modifier_node?(m) && special.include?(m.source)
-              previous_modifier = m
-            elsif previous_modifier
-              check_indentation(previous_modifier.source_range, m, style)
-              previous_modifier = nil
-            end
+          each_member(members) do |member, previous_modifier|
+            check_indentation(previous_modifier, member,
+                              indentation_consistency_style)
           end
         end
 
@@ -121,7 +115,7 @@ module RuboCop
           _condition, *branches = *node
           latest_when = nil
           branches.compact.each do |b|
-            if b.type == :when
+            if b.when_type?
               # TODO: Revert to the original expression once the fix in Rubinius
               #   is released.
               #
@@ -162,6 +156,26 @@ module RuboCop
 
         private
 
+        def each_member(members)
+          previous_modifier = nil
+          members.first.children.each do |member|
+            if special_modifier?(member)
+              previous_modifier = member
+            elsif previous_modifier
+              yield member, previous_modifier.source_range
+              previous_modifier = nil
+            end
+          end
+        end
+
+        def special_modifier?(node)
+          modifier_node?(node) && SPECIAL_MODIFIERS.include?(node.source)
+        end
+
+        def indentation_consistency_style
+          config.for_cop('Style/IndentationConsistency')['EnforcedStyle']
+        end
+
         def check_assignment(node, rhs)
           # If there are method calls chained to the right hand side of the
           # assignment, we let rhs be the receiver of those method calls before
@@ -208,7 +222,7 @@ module RuboCop
         def offense(body_node, indentation, style)
           # This cop only auto-corrects the first statement in a def body, for
           # example.
-          if body_node.type == :begin && !parentheses?(body_node)
+          if body_node.begin_type? && !parentheses?(body_node)
             body_node = body_node.children.first
           end
 
@@ -268,11 +282,11 @@ module RuboCop
           begin_pos = expr.begin_pos
           ind = expr.begin_pos - indentation
           pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind
-          Parser::Source::Range.new(expr.source_buffer, pos.begin, pos.end)
+          range_between(pos.begin, pos.end)
         end
 
         def starts_with_access_modifier?(body_node)
-          body_node.type == :begin && modifier_node?(body_node.children.first)
+          body_node.begin_type? && modifier_node?(body_node.children.first)
         end
 
         def configured_indentation_width

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

@@ -38,26 +38,29 @@ module RuboCop
 
         def autocorrect(node)
           if node.while_post_type? || node.until_post_type?
-            _, body = *node
-            return lambda do |corrector|
-              corrector.replace(body.loc.begin, 'loop do')
-              corrector.remove(body.loc.end.end.join(node.source_range.end))
-            end
+            replace_begin_end_with_modifier(node)
+          elsif node.modifier_form?
+            replace_source(node.source_range, modifier_replacement(node))
+          else
+            replace_source(non_modifier_range(node), 'loop do')
           end
+        end
 
-          if node.modifier_form?
-            range = node.source_range
-            replacement = modifier_replacement(node)
-          else
-            range = non_modifier_range(node)
-            replacement = 'loop do'
+        private
+
+        def replace_begin_end_with_modifier(node)
+          _, body = *node
+
+          lambda do |corrector|
+            corrector.replace(body.loc.begin, 'loop do')
+            corrector.remove(body.loc.end.end.join(node.source_range.end))
           end
+        end
 
+        def replace_source(range, replacement)
           ->(corrector) { corrector.replace(range, replacement) }
         end
 
-        private
-
         def modifier_replacement(node)
           _, body = *node
           if node.single_line?

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

@@ -9,29 +9,34 @@ module RuboCop
       class InitialIndentation < Cop
         MSG = 'Indentation of first line in file detected.'.freeze
 
-        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.zero?
-
-          with_space = range_with_surrounding_space(first_token.pos, :left,
-                                                    !: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)
+        def investigate(_processed_source)
+          token = first_token
+          space_before(token) { |space| add_offense(space, token.pos) }
         end
 
         def autocorrect(range)
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def first_token
+          processed_source.tokens.find { |t| !t.text.start_with?('#') }
+        end
+
+        def space_before(token)
+          return unless token
+          return if token.pos.column.zero?
+
+          token_with_space =
+            range_with_surrounding_space(token.pos, :left, false)
+          # 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 token_with_space == token.pos
+
+          yield range_between(token_with_space.begin_pos, token.pos.begin_pos)
+        end
       end
     end
   end

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

@@ -4,13 +4,26 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for inline comments.
+      # This cop checks for trailing inline comments.
+      #
+      # @example
+      #
+      #   # good
+      #   foo.each do |f|
+      #     # Standalone comment
+      #     f.bar
+      #   end
+      #
+      #   # bad
+      #   foo.each do |f|
+      #     f.bar # Trailing inline comment
+      #   end
       class InlineComment < Cop
-        MSG = 'Avoid inline comments.'.freeze
+        MSG = 'Avoid trailing inline comments.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            next unless comment.inline?
+            next if comment_line?(processed_source[comment.loc.line - 1])
             add_offense(comment, :expression)
           end
         end

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

@@ -92,10 +92,9 @@ module RuboCop
 
           selector = block_method.source
 
-          if offending_selector?(node, selector)
-            add_offense(node, block_method.source_range,
-                        message(node, selector))
-          end
+          return unless offending_selector?(node, selector)
+
+          add_offense(node, block_method.source_range, message(node, selector))
         end
 
         def offending_selector?(node, selector)
@@ -166,23 +165,36 @@ module RuboCop
 
         def needs_whitespace?(block_method, args, node)
           selector_end = block_method.loc.selector.end.end_pos
-          args_begin   = args.loc.begin && args.loc.begin.begin_pos
-          args_end     = args.loc.end && args.loc.end.end_pos
           block_begin  = node.loc.begin.begin_pos
-          (block_begin == args_end && selector_end == args_begin) ||
+
+          (block_begin == end_pos(args) && selector_end == begin_pos(args)) ||
             (block_begin == selector_end)
         end
 
+        def begin_pos(node)
+          node.loc.begin && node.loc.begin.begin_pos
+        end
+
+        def end_pos(node)
+          node.loc.end && node.loc.end.end_pos
+        end
+
         def lambda_arg_string(args)
           args.children.map(&:source).join(', ')
         end
 
-        def arg_to_unparenthesized_call?(node)
-          parent = node.parent
+        def arg_to_unparenthesized_call?(arg_node)
+          parent = arg_node.parent
+
+          if parent && parent.pair_type?
+            arg_node = parent.parent
+            parent = arg_node.parent
+          end
+
           return false unless parent && parent.send_type?
           return false if parenthesized_call?(parent)
 
-          node.sibling_index > 1
+          arg_node.sibling_index > 1
         end
 
         def remove_unparenthesized_whitespaces(corrector, node)

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

@@ -17,6 +17,11 @@ module RuboCop
             next unless comment.text =~ /\A#+[^#\s=:+-]/
             next if comment.text.start_with?('#!') && comment.loc.line == 1
 
+            # in config.ru files, if the first line starts with #\ it is treated
+            # as options (e.g. `#\ -p 8765` sets the request port to 8765)
+            next if comment.text.start_with?('#\\') && comment.loc.line == 1 &&
+                    config_ru?(processed_source.buffer.name)
+
             add_offense(comment, :expression)
           end
         end
@@ -24,9 +29,15 @@ module RuboCop
         def autocorrect(comment)
           expr = comment.loc.expression
           b = expr.begin_pos
-          hash_mark = Parser::Source::Range.new(expr.source_buffer, b, b + 1)
+          hash_mark = range_between(b, b + 1)
           ->(corrector) { corrector.insert_after(hash_mark, ' ') }
         end
+
+        private
+
+        def config_ru?(file_path)
+          File.basename(file_path).eql?('config.ru')
+        end
       end
     end
   end

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

@@ -53,19 +53,37 @@ module RuboCop
 
         def check_token_set(index)
           predecessor, operator, successor = processed_source.tokens[index, 3]
-          return unless successor
-          return unless CONCAT_TOKEN_TYPES.include?(operator.type)
-          return unless standard_string_literal?(predecessor)
-          return unless standard_string_literal?(successor)
+
+          return unless eligible_successor?(successor) &&
+                        eligible_operator?(operator) &&
+                        eligible_predecessor?(predecessor)
+
           return if operator.pos.line == successor.pos.line
 
           next_successor = token_after_last_string(successor, index)
-          return if next_successor &&
-                    HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type)
+
+          return unless eligible_next_successor?(next_successor)
 
           add_offense(operator.pos, operator.pos)
         end
 
+        def eligible_successor?(successor)
+          successor && standard_string_literal?(successor)
+        end
+
+        def eligible_operator?(operator)
+          CONCAT_TOKEN_TYPES.include?(operator.type)
+        end
+
+        def eligible_next_successor?(next_successor)
+          !(next_successor &&
+            HIGH_PRECEDENCE_OP_TOKEN_TYPES.include?(next_successor.type))
+        end
+
+        def eligible_predecessor?(predecessor)
+          standard_string_literal?(predecessor)
+        end
+
         def token_after_last_string(successor, base_index)
           index = base_index + 3
           begin_token, end_token = COMPLEX_STRING_EDGE_TOKEN_TYPES

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

@@ -36,6 +36,16 @@ module RuboCop
         def same_name_assignment?(node)
           _receiver, method_name, *_args = *node
 
+          any_assignment?(node) do |asgn_node|
+            if asgn_node.masgn_type?
+              next variable_in_mass_assignment?(method_name, asgn_node)
+            end
+
+            asgn_node.loc.name.source == method_name.to_s
+          end
+        end
+
+        def any_assignment?(node)
           node.each_ancestor(*ASGN_NODES).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will
             # not be returned as an `asgn_node` here, however,
@@ -45,19 +55,18 @@ module RuboCop
             if asgn_node.or_asgn_type? || asgn_node.and_asgn_type? ||
                asgn_node.op_asgn_type?
               asgn_node, _value = *asgn_node
-              return false if asgn_node.send_type?
+              next if asgn_node.send_type?
             end
 
-            if asgn_node.masgn_type?
-              mlhs_node, _mrhs_node = *asgn_node
-              var_nodes = *mlhs_node
-              vars = var_nodes.map { |n| (_b = *n).first }
+            yield asgn_node
+          end
+        end
 
-              return vars.include?(method_name)
-            end
+        def variable_in_mass_assignment?(variable_name, node)
+          mlhs_node, _mrhs_node = *node
+          var_nodes = *mlhs_node
 
-            asgn_node.loc.name.source == method_name.to_s
-          end
+          var_nodes.map { |n| n.to_a.first }.include?(variable_name)
         end
 
         # don't check `lambda.()` syntax; the Style/LambdaCall cop does that