rubocop 0.39.0 → 0.40.0

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

@@ -6,6 +6,8 @@ module RuboCop
     module Style
       # This cop checks for uses if the keyword *not* instead of !.
       class Not < Cop
+        include IfNode
+
         MSG = 'Use `!` instead of `not`.'.freeze
 
         OPPOSITE_METHODS = {
@@ -14,7 +16,8 @@ module RuboCop
           :<= => :>,
           :> => :<=,
           :< => :>=,
-          :>= => :< }.freeze
+          :>= => :<
+        }.freeze
 
         def on_send(node)
           return unless node.keyword_not?
@@ -35,7 +38,7 @@ module RuboCop
                                 OPPOSITE_METHODS[child.method_name].to_s)
             end
           elsif child.and_type? || child.or_type? || child.binary_operation? ||
-                ternary_op?(child)
+                ternary?(child)
             lambda do |corrector|
               corrector.replace(range, '!(')
               corrector.insert_after(node.source_range, ')')

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

@@ -12,7 +12,7 @@ module RuboCop
         include Parentheses
 
         def on_if(node)
-          return if ternary_op?(node)
+          return if ternary?(node)
           process_control_op(node)
         end
 
@@ -41,7 +41,7 @@ module RuboCop
         end
 
         def modifier_op?(node)
-          return false if ternary_op?(node)
+          return false if ternary?(node)
           return true if node.type == :rescue
 
           [:if, :while, :until].include?(node.type) &&

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

@@ -4,10 +4,48 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks the args passed to `fail` and `raise`.
+      # This cop checks the args passed to `fail` and `raise`. For exploded
+      # style (default), it recommends passing the exception class and message
+      # to `raise`, rather than construct an instance of the error. It will
+      # still allow passing just a message, or the construction of an error
+      # with more than one argument.
+      #
+      # The exploded style works identically, but with the addition that it
+      # will also suggest constructing error objects when the exception is
+      # passed multiple arguments.
+      #
+      # @example
+      #
+      #   # EnforcedStyle: exploded
+      #
+      #   # bad
+      #   raise StandardError.new("message")
+      #
+      #   # good
+      #   raise StandardError, "message"
+      #   fail "message"
+      #   raise RuntimeError.new(arg1, arg2, arg3)
+      #
+      # @example
+      #
+      #   # EnforcedStyle: compact
+      #
+      #   # bad
+      #   raise StandardError, "message"
+      #   raise RuntimeError, arg1, arg2, arg3
+      #
+      #   # good
+      #   raise StandardError.new("message")
+      #   raise RuntimeError.new(arg1, arg2, arg3)
+      #   fail "message"
       class RaiseArgs < Cop
         include ConfigurableEnforcedStyle
 
+        EXPLODED_MSG = 'Provide an exception class and message ' \
+          'as arguments to `%s`.'.freeze
+        COMPACT_MSG = 'Provide an exception object ' \
+          'as an argument to `%s`.'.freeze
+
         def on_send(node)
           return unless node.command?(:raise) || node.command?(:fail)
 
@@ -21,6 +59,33 @@ module RuboCop
 
         private
 
+        def autocorrect(node)
+          _scope, method, *args = *node
+
+          new_exception = if style == :compact
+                            correction_exploded_to_compact(args)
+                          else
+                            correction_compact_to_exploded(args)
+                          end
+          replacement = "#{method} #{new_exception}"
+
+          ->(corrector) { corrector.replace(node.source_range, replacement) }
+        end
+
+        def correction_compact_to_exploded(node)
+          exception_node, _new, message_node = *node.first
+
+          "#{exception_node.const_name}, #{message_node.source}"
+        end
+
+        def correction_exploded_to_compact(node)
+          exception_node, *message_nodes = *node
+
+          messages = message_nodes.map(&:source).join(', ')
+
+          "#{exception_node.const_name}.new(#{messages})"
+        end
+
         def check_compact(node)
           _receiver, selector, *args = *node
 
@@ -55,12 +120,10 @@ module RuboCop
         end
 
         def message(method)
-          case style
-          when :compact
-            "Provide an exception object as an argument to `#{method}`."
-          when :exploded
-            'Provide an exception class and message as ' \
-            "arguments to `#{method}`."
+          if style == :compact
+            format(COMPACT_MSG, method)
+          else
+            format(EXPLODED_MSG, method)
           end
         end
       end

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

@@ -6,36 +6,50 @@ module RuboCop
     module Style
       # This cop checks for RuntimeError as the argument of raise/fail.
       #
-      # Currently it checks for code like this:
+      # It checks for code like this:
       #
       # @example
-      #
+      #   # Bad
       #   raise RuntimeError, 'message'
+      #
+      #   # Bad
+      #   raise RuntimeError.new('message')
+      #
+      #   # Good
+      #   raise 'message'
       class RedundantException < Cop
-        MSG = 'Redundant `RuntimeError` argument can be removed.'.freeze
-
-        TARGET_NODE = s(:const, nil, :RuntimeError)
+        MSG_1 = 'Redundant `RuntimeError` argument can be removed.'.freeze
+        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
+                'just the message.'.freeze
 
         def on_send(node)
-          return unless node.command?(:raise) || node.command?(:fail)
-
-          _receiver, _selector, *args = *node
-
-          return unless args.size == 2
-
-          first_arg, = *args
-
-          add_offense(first_arg, :expression) if first_arg == TARGET_NODE
+          exploded?(node) { return add_offense(node, :expression, MSG_1) }
+          compact?(node) { add_offense(node, :expression, MSG_2) }
         end
 
-        # switch `raise RuntimeError, 'message'` to `raise 'message'`
+        # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
+        # `raise RuntimeError.new('message')` to `raise 'message'`.
         def autocorrect(node)
-          start_range = node.source_range.begin
-          no_comma = range_with_surrounding_comma(node.source_range.end, :right)
-          comma_range = start_range.join(no_comma)
-          final_range = range_with_surrounding_space(comma_range, :right)
-          ->(corrector) { corrector.replace(final_range, '') }
+          exploded?(node) do |command, message|
+            return lambda do |corrector|
+              corrector.replace(node.source_range,
+                                "#{command} #{message.source}")
+            end
+          end
+          compact?(node) do |new_call, message|
+            lambda do |corrector|
+              corrector.replace(new_call.source_range, message.source)
+            end
+          end
         end
+
+        def_node_matcher :exploded?, <<-PATTERN
+          (send nil ${:raise :fail} (const nil :RuntimeError) $_)
+        PATTERN
+
+        def_node_matcher :compact?, <<-PATTERN
+          (send nil {:raise :fail} $(send (const nil :RuntimeError) :new $_))
+        PATTERN
       end
     end
   end

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

@@ -42,7 +42,13 @@ module RuboCop
             # don't flag `rescue(ExceptionClass)`
             rescue?(node) ||
             # don't flag `method (arg) { }`
-            (arg_in_call_with_block?(node) && !parentheses?(parent))
+            (arg_in_call_with_block?(node) && !parentheses?(parent)) ||
+            # don't flag
+            # ```
+            # { a: (1
+            #      ), }
+            # ```
+            allowed_array_or_hash_element?(node)
         end
 
         def check(begin_node)
@@ -83,6 +89,26 @@ module RuboCop
           node.parent && node.parent.keyword?
         end
 
+        def allowed_array_or_hash_element?(node)
+          (hash_element?(node) || array_element?(node)) &&
+            only_closing_paren_before_comma?(node)
+        end
+
+        def hash_element?(node)
+          node.parent && node.parent.pair_type?
+        end
+
+        def array_element?(node)
+          node.parent && node.parent.array_type?
+        end
+
+        def only_closing_paren_before_comma?(node)
+          source_buffer = node.source_range.source_buffer
+          line_range = source_buffer.line_range(node.loc.end.line)
+
+          line_range.source =~ /^\s*\)\s*,/
+        end
+
         def disallowed_literal?(node)
           node.literal? && !ALLOWED_LITERALS.include?(node.type)
         end

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

@@ -5,29 +5,33 @@ module RuboCop
   module Cop
     module Style
       # Checks for colon (:) not followed by some kind of space.
+      # N.B. this cop does not handle spaces after a ternary operator, which are
+      # instead handled by Style/SpaceAroundOperators.
       class SpaceAfterColon < Cop
         include IfNode
 
         MSG = 'Space missing after colon.'.freeze
 
         def on_pair(node)
-          oper = node.loc.operator
-          return unless oper.is?(':') && followed_by_space?(oper)
+          colon = node.loc.operator
 
-          add_offense(oper, oper)
-        end
+          return unless colon.is?(':')
 
-        def on_if(node)
-          return unless ternary_op?(node)
+          add_offense(colon, colon) unless followed_by_space?(colon)
+        end
 
-          colon = node.loc.colon
-          return unless followed_by_space?(colon)
+        def on_kwoptarg(node)
+          # We have no direct reference to the colon source range following an
+          # optional keyword argument's name, so must construct one.
+          colon = node.loc.name.end.resize(1)
 
-          add_offense(colon, colon)
+          add_offense(colon, colon) unless followed_by_space?(colon)
         end
 
+        private
+
         def followed_by_space?(colon)
-          colon.source_buffer.source[colon.end_pos] =~ /\S/
+          colon.source_buffer.source[colon.end_pos] =~ /\s/
         end
 
         def autocorrect(range)

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

@@ -8,6 +8,11 @@ module RuboCop
       class SpaceAfterComma < Cop
         include SpaceAfterPunctuation
 
+        def space_style_before_rcurly
+          cfg = config.for_cop('Style/SpaceInsideHashLiteralBraces')
+          cfg['EnforcedStyle'] || 'space'
+        end
+
         def kind(token)
           'comma' if token.type == :tCOMMA
         end

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

@@ -16,13 +16,12 @@ module RuboCop
         MSG = 'Do not leave space between `!` and its argument.'.freeze
 
         def on_send(node)
-          _receiver, method_name, *_args = *node
+          receiver, method_name, *_args = *node
 
           return unless method_name == :!
-          return unless node.source =~ /^!\s+\w+/
+          return unless receiver.loc.column - node.loc.column > 1
 
-          # TODO: Improve source range to highlight the redundant whitespace.
-          add_offense(node, :selector)
+          add_offense(node, :expression)
         end
 
         def autocorrect(node)

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

@@ -8,6 +8,11 @@ module RuboCop
       class SpaceAfterSemicolon < Cop
         include SpaceAfterPunctuation
 
+        def space_style_before_rcurly
+          cfg = config.for_cop('Style/SpaceInsideBlockBraces')
+          cfg['EnforcedStyle'] || 'space'
+        end
+
         def kind(token)
           'semicolon' if token.type == :tSEMI
         end

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

@@ -7,6 +7,7 @@ module RuboCop
       # Checks that operators have space around them, except for **
       # which should not have surrounding space.
       class SpaceAroundOperators < Cop
+        include IfNode
         include PrecedingFollowingAlignment
         include HashNode # any_pairs_on_the_same_line?
 
@@ -22,7 +23,7 @@ module RuboCop
         end
 
         def on_if(node)
-          return unless node.loc.respond_to?(:question)
+          return unless ternary?(node)
           _, if_branch, else_branch = *node
 
           check_operator(node.loc.question, if_branch.source_range)

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

@@ -43,9 +43,11 @@ module RuboCop
           Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
 
         ENGLISH_VARS.merge!(
-          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }])
+          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
+        )
         PERL_VARS.merge!(
-          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }])
+          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
+        )
         ENGLISH_VARS.each { |_, v| v.freeze }.freeze
         PERL_VARS.each { |_, v| v.freeze }.freeze
 

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

@@ -16,7 +16,7 @@ module RuboCop
       #   # require_no_parentheses - bad
       #   ->(a,b,c) { a + b + c }
       #
-      #   # require_parentheses - good
+      #   # require_no_parentheses - good
       #   ->a,b,c { a + b + c}
       class StabbyLambdaParentheses < Cop
         include ConfigurableEnforcedStyle

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

@@ -17,8 +17,7 @@ module RuboCop
           add_offense(node, :selector,
                       format(MSG,
                              preferred_method(method_name),
-                             method_name)
-                     )
+                             method_name))
         end
 
         def autocorrect(node)

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

@@ -113,7 +113,7 @@ module RuboCop
         def can_shorten?(block_args, block_body)
           # something { |x, y| ... }
           return false unless block_args.children.size == 1
-          return false if block_args.children.first.blockarg_type?
+          return false if non_shortenable_args?(block_args)
           return false unless block_body && block_body.type == :send
 
           receiver, _method_name, args = *block_body
@@ -131,6 +131,12 @@ module RuboCop
         def super?(node)
           [:super, :zsuper].include?(node.type)
         end
+
+        def non_shortenable_args?(block_args)
+          # something { |&x| ... }
+          # something { |*x| ... }
+          [:blockarg, :restarg].include?(block_args.children.first.type)
+        end
       end
     end
   end

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

@@ -40,6 +40,31 @@ module RuboCop
           check(node, args, 'parameter of %s method call',
                 args.last.source_range.end_pos, node.source_range.end_pos)
         end
+
+        private
+
+        def avoid_autocorrect?(args)
+          hash_with_braces?(args.last) && braces_will_be_removed?(args)
+        end
+
+        def hash_with_braces?(node)
+          node.hash_type? && node.loc.begin
+        end
+
+        # Returns true if running with --auto-correct would remove the braces
+        # of the last argument.
+        def braces_will_be_removed?(args)
+          brace_config = config.for_cop('Style/BracesAroundHashParameters')
+          return false unless brace_config['Enabled']
+          return false if brace_config['AutoCorrect'] == false
+
+          brace_style = brace_config['EnforcedStyle']
+          return true if brace_style == 'no_braces'
+
+          return false unless brace_style == 'context_dependent'
+
+          args.size == 1 || !args[-2].hash_type?
+        end
       end
     end
   end