rubocop 0.37.2 → 0.38.0

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

@@ -15,7 +15,7 @@ module RuboCop
                             'called `%s`.'.freeze
         MSG_REGEX = '`%s` should match `%s`.'.freeze
 
-        SNAKE_CASE = /^[\da-z_]+$/
+        SNAKE_CASE = /^[\da-z_.?!]+$/
 
         def investigate(processed_source)
           file_path = processed_source.buffer.name
@@ -44,12 +44,8 @@ module RuboCop
 
         private
 
-        def snake_case?(basename)
-          basename.split('.').all? { |fragment| fragment =~ SNAKE_CASE }
-        end
-
         def shebang?(line)
-          line.start_with?('#!')
+          line && line.start_with?('#!')
         end
 
         def expect_matching_definition?
@@ -62,7 +58,7 @@ module RuboCop
 
         def filename_good?(basename)
           basename = basename.sub(/\.[^\.]+$/, '')
-          regex ? basename =~ regex : snake_case?(basename)
+          basename =~ (regex || SNAKE_CASE)
         end
 
         def find_class_or_module(node, namespace)

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

@@ -8,8 +8,6 @@ module RuboCop
       # anonymous functions and uses of the 1.9 lambda syntax for multi-line
       # anonymous functions.
       class Lambda < Cop
-        include AutocorrectUnlessChangingAST
-
         SINGLE_MSG = 'Use the new lambda literal syntax ' \
                      '`->(params) {...}`.'.freeze
         SINGLE_NO_ARG_MSG = 'Use the new lambda literal syntax ' \
@@ -26,7 +24,7 @@ module RuboCop
           block_method, args, = *node
 
           return unless block_method == TARGET
-          selector = block_method.loc.selector.source
+          selector = block_method.source
           length = lambda_length(node)
 
           if selector != '->' && length == 1
@@ -53,10 +51,14 @@ module RuboCop
           end_line - start_line + 1
         end
 
-        def correction(node)
-          lambda do |corrector|
-            block_method, _args = *node
+        def autocorrect(node)
+          block_method, _args = *node
+          selector = block_method.source
 
+          # Don't autocorrect if this would change the meaning of the code
+          return if selector == '->' && arg_to_unparenthesized_call?(node)
+
+          lambda do |corrector|
             if block_method.source == 'lambda'
               autocorrect_old_to_new(corrector, node)
             else
@@ -102,6 +104,15 @@ module RuboCop
         def lambda_arg_string(args)
           args.children.map(&:source).join(', ')
         end
+
+        def arg_to_unparenthesized_call?(node)
+          parent = node.parent
+          return false unless parent && parent.send_type?
+          return false if parenthesized_call?(parent)
+
+          index = parent.children.index { |c| c.equal?(node) }
+          index >= 2
+        end
       end
     end
   end

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

@@ -9,7 +9,7 @@ module RuboCop
         MSG = 'Do not use parentheses for method calls with ' \
               'no arguments.'.freeze
 
-        ASGN_NODES = [:lvasgn, :masgn] + Util::SHORTHAND_ASGN_NODES
+        ASGN_NODES = [:lvasgn, :masgn] + SHORTHAND_ASGN_NODES
 
         def on_send(node)
           _receiver, method_name, *args = *node

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

@@ -71,10 +71,6 @@ module RuboCop
         def arguments?(args)
           !args.children.empty?
         end
-
-        def parentheses?(args)
-          args.loc.begin
-        end
       end
     end
   end

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

@@ -89,12 +89,18 @@ module RuboCop
           outer_expr = "(#{outer_expr})" if outer_cond.or_type? &&
                                             operator == '&&'.freeze
           inner_expr = inner_cond.source
-          inner_expr = "(#{inner_expr})" if inner_cond.or_type?
+
+          inner_expr = "(#{inner_expr})" if requires_parens?(inner_cond)
           inner_expr = "!#{inner_expr}" unless outer_keyword == inner_keyword
 
           "#{outer_node.loc.keyword.source} " \
           "#{outer_expr} #{operator} #{inner_expr}"
         end
+
+        def requires_parens?(node)
+          node.or_type? ||
+            !(RuboCop::Node::COMPARISON_OPERATORS & node.children).empty?
+        end
       end
     end
   end

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

@@ -34,10 +34,6 @@ module RuboCop
 
         private
 
-        def parenthesized_call?(send)
-          send.loc.begin && send.loc.begin.is?('(')
-        end
-
         def rspec_matcher?(parent, send)
           parent.method_args.one? && # .to, .not_to, etc
             RSPEC_MATCHERS.include?(send.method_name) &&

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

@@ -6,10 +6,16 @@ module RuboCop
     module Style
       # This cop checks for uses if the keyword *not* instead of !.
       class Not < Cop
-        include AutocorrectUnlessChangingAST
-
         MSG = 'Use `!` instead of `not`.'.freeze
 
+        OPPOSITE_METHODS = {
+          :== => :!=,
+          :!= => :==,
+          :<= => :>,
+          :> => :<=,
+          :< => :>=,
+          :>= => :< }.freeze
+
         def on_send(node)
           return unless node.keyword_not?
 
@@ -18,9 +24,25 @@ module RuboCop
 
         private
 
-        def correction(node)
-          new_source = node.source.sub(/not\s*/, '!')
-          ->(corrector) { corrector.replace(node.source_range, new_source) }
+        def autocorrect(node)
+          range = range_with_surrounding_space(node.loc.selector, :right)
+          child = node.children.first
+
+          if child.send_type? && OPPOSITE_METHODS.key?(child.method_name)
+            lambda do |corrector|
+              corrector.remove(range)
+              corrector.replace(child.loc.selector,
+                                OPPOSITE_METHODS[child.method_name].to_s)
+            end
+          elsif child.and_type? || child.or_type? || child.binary_operation? ||
+                ternary_op?(child)
+            lambda do |corrector|
+              corrector.replace(range, '!(')
+              corrector.insert_after(node.source_range, ')')
+            end
+          else
+            ->(corrector) { corrector.replace(range, '!') }
+          end
         end
       end
     end

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

@@ -20,6 +20,27 @@ module RuboCop
 
           add_offense(node, :expression, format(MSG, condition))
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, replacement(node))
+          end
+        end
+
+        def replacement(node)
+          cond, body, else_clause = *node
+          ternary = "#{cond.source} ? #{body.source} : #{else_clause.source}"
+
+          return ternary unless node.parent
+          return "(#{ternary})" if [:and, :or].include?(node.parent.type)
+
+          if node.parent.send_type?
+            _receiver, method_name, = *node.parent
+            return "(#{ternary})" if operator?(method_name)
+          end
+
+          ternary
+        end
       end
     end
   end

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

@@ -58,7 +58,15 @@ module RuboCop
 
         def check_send(begin_node, node)
           if node.unary_operation?
-            offense(begin_node, 'an unary operation') unless begin_node.chained?
+            return if begin_node.chained?
+
+            # parens are not redundant in `(!recv.method arg)`
+            node = node.children.first while node.unary_operation?
+            if node.send_type?
+              return unless method_call_with_redundant_parentheses?(node)
+            end
+
+            offense(begin_node, 'an unary operation')
           else
             return unless method_call_with_redundant_parentheses?(node)
             offense(begin_node, 'a method call')

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

@@ -12,14 +12,23 @@ module RuboCop
         RAISE_MSG = 'Use `raise` instead of `fail` to ' \
                     'rethrow exceptions.'.freeze
 
+        def_node_matcher :kernel_call?, '(send (const nil :Kernel) %1 ...)'
+        def_node_search :custom_fail_methods,
+                        '{(def :fail ...) (defs _ :fail ...)}'
+
+        def investigate(processed_source)
+          ast = processed_source.ast
+          @custom_fail_defined = ast && custom_fail_methods(ast).any?
+        end
+
         def on_rescue(node)
           return unless style == :semantic
 
           begin_node, *rescue_nodes, _else_node = *node
-          check_for(:raise, begin_node)
+          check_scope(:raise, begin_node)
 
           rescue_nodes.each do |rescue_node|
-            check_for(:fail, rescue_node)
+            check_scope(:fail, rescue_node)
             allow(:raise, rescue_node)
           end
         end
@@ -27,11 +36,12 @@ module RuboCop
         def on_send(node)
           case style
           when :semantic
-            check_for(:raise, node) unless ignored_node?(node)
+            check_send(:raise, node) unless ignored_node?(node)
           when :only_raise
-            check_for(:raise, node)
+            return if @custom_fail_defined
+            check_send(:fail, node)
           when :only_fail
-            check_for(:fail, node)
+            check_send(:raise, node)
           end
         end
 
@@ -62,35 +72,27 @@ module RuboCop
           end
         end
 
-        def check_for(method_name, node)
+        def check_scope(method_name, node)
           return unless node
 
-          if style == :semantic
-            each_command_or_kernel_call(method_name, node) do |send_node|
-              next if ignored_node?(send_node)
+          each_command_or_kernel_call(method_name, node) do |send_node|
+            next if ignored_node?(send_node)
 
-              add_offense(send_node, :selector, message(method_name))
-              ignore_node(send_node)
-            end
-          elsif command_or_kernel_call?(method_name == :raise ? :fail : :raise,
-                                        node)
-            add_offense(node, :selector, message(method_name))
+            add_offense(send_node, :selector, message(method_name))
+            ignore_node(send_node)
           end
         end
 
-        def command_or_kernel_call?(name, node)
-          node.command?(name) || kernel_call?(name, node)
-        end
-
-        def kernel_call?(name, node)
-          return false unless node.type == :send
-          receiver, selector, _args = *node
+        def check_send(method_name, node)
+          return unless node
 
-          return false unless name == selector
-          return false unless receiver.const_type?
+          if command_or_kernel_call?(method_name, node)
+            add_offense(node, :selector, message(method_name))
+          end
+        end
 
-          _, constant = *receiver
-          constant == :Kernel
+        def command_or_kernel_call?(name, node)
+          node.command?(name) || kernel_call?(node, name)
         end
 
         def allow(method_name, node)

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

@@ -31,7 +31,7 @@ module RuboCop
 
         DO = 'do'.freeze
         ACCEPT_LEFT_PAREN =
-          %w(break next not return super yield defined?).freeze
+          %w(break defined? next not rescue return super yield).freeze
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
@@ -187,11 +187,15 @@ module RuboCop
         end
 
         def preceded_by_operator?(node, _range)
-          ancestor = node.ancestors.first
-          return false unless ancestor
-          return true if ancestor.and_type? || ancestor.or_type?
-          return false unless ancestor.send_type?
-          operator?(ancestor.method_name)
+          # regular dotted method calls bind more tightly than operators
+          # so we need to climb up the AST past them
+          while (ancestor = node.parent)
+            return true if ancestor.and_type? || ancestor.or_type?
+            return false unless ancestor.send_type?
+            return true if operator?(ancestor.method_name)
+            node = ancestor
+          end
+          false
         end
 
         def autocorrect(range)

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

@@ -17,6 +17,7 @@ module RuboCop
           # If one part of that continued string contains interpolations,
           # then it will be parsed as a nested `dstr` node
           return unless consistent_multiline?
+          return if node.loc.is_a?(Parser::Source::Map::Heredoc)
 
           children = node.children
           return unless children.all? { |c| c.str_type? || c.dstr_type? }

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

@@ -18,6 +18,30 @@ module RuboCop
 
           add_offense(node, :expression)
         end
+
+        def autocorrect(node)
+          condition, = *node
+          body_range = range_between_condition_and_else(node, condition)
+          else_range = range_between_else_and_end(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, 'if'.freeze)
+            corrector.replace(body_range, else_range.source)
+            corrector.replace(else_range, body_range.source)
+          end
+        end
+
+        def range_between_condition_and_else(node, condition)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    condition.source_range.end_pos,
+                                    node.loc.else.begin_pos)
+        end
+
+        def range_between_else_and_end(node)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.loc.else.end_pos,
+                                    node.loc.end.begin_pos)
+        end
       end
     end
   end

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

@@ -61,24 +61,37 @@ module RuboCop
         end
 
         def autocorrect(node)
-          loc = node.loc
           embedded_node = node.children.first
-          embedded_loc = embedded_node.loc
 
           if variable_interpolation?(embedded_node)
-            replacement = "#{embedded_loc.expression.source}.to_s"
-            ->(corrector) { corrector.replace(loc.expression, replacement) }
+            autocorrect_variable_interpolation(embedded_node, node)
           elsif single_variable_interpolation?(embedded_node)
-            variable_loc = embedded_node.children.first.loc
-            replacement = "#{variable_loc.expression.source}.to_s"
-            ->(corrector) { corrector.replace(loc.expression, replacement) }
+            autocorrect_single_variable_interpolation(embedded_node, node)
           else
-            lambda do |corrector|
-              corrector.replace(loc.begin, '')
-              corrector.replace(loc.end, '')
-              corrector.replace(embedded_loc.begin, '(')
-              corrector.replace(embedded_loc.end, ').to_s')
-            end
+            autocorrect_other(embedded_node, node)
+          end
+        end
+
+        def autocorrect_variable_interpolation(embedded_node, node)
+          replacement = "#{embedded_node.loc.expression.source}.to_s"
+          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+        end
+
+        def autocorrect_single_variable_interpolation(embedded_node, node)
+          variable_loc = embedded_node.children.first.loc
+          replacement = "#{variable_loc.expression.source}.to_s"
+          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+        end
+
+        def autocorrect_other(embedded_node, node)
+          loc = node.loc
+          embedded_loc = embedded_node.loc
+
+          lambda do |corrector|
+            corrector.replace(loc.begin, '')
+            corrector.replace(loc.end, '')
+            corrector.replace(embedded_loc.begin, '(')
+            corrector.replace(embedded_loc.end, ').to_s')
           end
         end
       end

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

@@ -21,7 +21,7 @@ module RuboCop
       #   "foobar".empty?
       #   !hash.empty?
       class ZeroLengthPredicate < Cop
-        ZERO_MSG = 'Use `empty?` instead of `%s == 0`.'.freeze
+        ZERO_MSG = 'Use `empty?` instead of `%s %s %s`.'.freeze
         NONZERO_MSG = 'Use `!empty?` instead of `%s %s %s`.'.freeze
 
         def on_send(node)
@@ -41,8 +41,10 @@ module RuboCop
         end
 
         def_node_matcher :zero_length_predicate, <<-END
-          {(send (send _ ${:length :size}) :== (int 0))
-           (send (int 0) :== (send _ ${:length :size}))}
+          {(send (send _ ${:length :size}) $:== (int $0))
+           (send (int $0) $:== (send _ ${:length :size}))
+           (send (send _ ${:length :size}) $:<  (int $1))
+           (send (int $1) $:> (send _ ${:length :size}))}
         END
 
         def_node_matcher :nonzero_length_predicate, <<-END