rubocop 0.46.0 → 0.47.0

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

@@ -8,6 +8,10 @@ module RuboCop
         include PercentLiteral
         include ConfigurableEnforcedStyle
 
+        LOWER_CASE_Q_MSG = 'Do not use `%Q` unless interpolation is ' \
+                           'needed.  Use `%q`.'.freeze
+        UPPER_CASE_Q_MSG = 'Use `%Q` instead of `%q`.'.freeze
+
         def on_str(node)
           process(node, '%Q', '%q')
         end
@@ -15,23 +19,22 @@ module RuboCop
         private
 
         def on_percent_literal(node)
-          if style == :lower_case_q
-            if type(node) == '%Q'
-              check(node,
-                    'Do not use `%Q` unless interpolation is needed.  ' \
-                    'Use `%q`.')
-            end
-          elsif type(node) == '%q'
-            check(node, 'Use `%Q` instead of `%q`.')
-          end
-        end
+          return if correct_literal_style?(node)
 
-        def check(node, msg)
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
           return if node.children != parse(corrected(node.source)).ast.children
 
-          add_offense(node, :begin, msg)
+          add_offense(node, :begin, message)
+        end
+
+        def correct_literal_style?(node)
+          style == :lower_case_q && type(node) == '%q' ||
+            style == :upper_case_q && type(node) == '%Q'
+        end
+
+        def message
+          style == :lower_case_q ? LOWER_CASE_Q_MSG : UPPER_CASE_Q_MSG
         end
 
         def autocorrect(node)

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

@@ -14,7 +14,8 @@ module RuboCop
       class RedundantFreeze < Cop
         include FrozenStringLiteral
 
-        MSG = 'Freezing immutable objects is pointless.'.freeze
+        MSG = 'Do not freeze immutable objects, as freezing them has no ' \
+              'effect.'.freeze
 
         def_node_matcher :freezing?, '(send $_ :freeze)'
 
@@ -38,7 +39,7 @@ module RuboCop
           return false unless node
           return true if node.immutable_literal?
           FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
-            frozen_string_literals_enabled?(processed_source)
+            frozen_string_literals_enabled?
         end
       end
     end

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

@@ -37,7 +37,8 @@ module RuboCop
             hash_literal_as_first_arg?(node) ||
             rescue?(node) ||
             allowed_method_call?(node) ||
-            allowed_array_or_hash_element?(node)
+            allowed_array_or_hash_element?(node) ||
+            allowed_multiple_expression?(node)
         end
 
         def allowed_ancestor?(node)
@@ -50,6 +51,13 @@ module RuboCop
           arg_in_call_with_block?(node) && !parentheses?(node.parent)
         end
 
+        def allowed_multiple_expression?(node)
+          return false if node.children.size == 1
+          ancestor = node.ancestors.first
+          return false unless ancestor
+          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
+        end
+
         def empty_parentheses?(node)
           # Don't flag `()`
           node.children.empty?
@@ -66,7 +74,9 @@ module RuboCop
           if keyword_with_redundant_parentheses?(node)
             return offense(begin_node, 'a keyword')
           end
-          return offense(begin_node, 'a literal') if disallowed_literal?(node)
+          if disallowed_literal?(begin_node, node)
+            return offense(begin_node, 'a literal')
+          end
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
           check_send(begin_node, node) if node.send_type?
@@ -126,8 +136,21 @@ module RuboCop
           line_range.source =~ /^\s*\)\s*,/
         end
 
-        def disallowed_literal?(node)
-          node.literal? && !ALLOWED_LITERALS.include?(node.type)
+        def disallowed_literal?(begin_node, node)
+          node.literal? &&
+            !ALLOWED_LITERALS.include?(node.type) &&
+            !raised_to_power_negative_numeric?(begin_node, node)
+        end
+
+        def raised_to_power_negative_numeric?(begin_node, node)
+          return false unless node.numeric_type?
+
+          siblings = begin_node.parent && begin_node.parent.children
+          return false if siblings.nil?
+          next_sibling = siblings[begin_node.sibling_index + 1]
+          base_value = node.children.first
+
+          base_value < 0 && next_sibling == :**
         end
 
         def keyword_with_redundant_parentheses?(node)

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

@@ -22,7 +22,6 @@ module RuboCop
       # or a case expression with a default branch.
       class RedundantReturn < Cop
         include OnMethodDef
-        include IfNode
 
         MSG = 'Redundant `return` detected.'.freeze
 
@@ -39,17 +38,13 @@ module RuboCop
             if node.children.size > 1
               add_brackets(corrector, node)
             elsif return_value.hash_type?
-              add_braces(corrector, return_value) unless braces?(return_value)
+              add_braces(corrector, return_value) unless return_value.braces?
             end
             return_kw = range_with_surrounding_space(node.loc.keyword, :right)
             corrector.remove(return_kw)
           end
         end
 
-        def braces?(arg)
-          arg.loc.begin
-        end
-
         def add_brackets(corrector, node)
           kids = node.children.map(&:source_range)
           corrector.insert_before(kids.first, '[')
@@ -104,9 +99,10 @@ module RuboCop
         end
 
         def check_if_node(node)
-          return if modifier_if?(node) || ternary?(node)
+          return if node.modifier_form? || node.ternary?
+
+          _cond, if_node, else_node = *node.node_parts
 
-          _cond, if_node, else_node = if_node_parts(node)
           check_branch(if_node) if if_node
           check_branch(else_node) if else_node
         end

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

@@ -44,12 +44,14 @@ module RuboCop
       #   # use safe navigation
       #   foo.to_i if foo
       class SafeNavigation < Cop
-        include IfNode
+        extend TargetRubyVersion
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'.freeze
         NIL_METHODS = nil.methods.freeze
 
+        minimum_target_ruby_version 2.3
+
         def_node_matcher :safe_navigation_candidate, <<-PATTERN
           {
             (if
@@ -71,7 +73,8 @@ module RuboCop
         PATTERN
 
         def on_if(node)
-          return if ternary?(node)
+          return if node.ternary?
+
           check_node(node)
         end
 
@@ -85,15 +88,19 @@ module RuboCop
 
         def check_node(node)
           return if target_ruby_version < 2.3
-          return if if_else?(node)
-          return if elsif?(node)
+          return if allowed_if_condition?(node)
           checked_variable, receiver, method = extract_parts(node)
           return unless receiver == checked_variable
           return if NIL_METHODS.include?(method)
           return unless method =~ /\w+[=!?]?/
+
           add_offense(node, :expression)
         end
 
+        def allowed_if_condition?(node)
+          node.if_type? && (node.else? || node.elsif?)
+        end
+
         def extract_parts(node)
           if cop_config['ConvertCodeThatCanStartToReturnNil']
             safe_navigation_candidate(node) ||
@@ -104,8 +111,8 @@ module RuboCop
         end
 
         def autocorrect(node)
-          if node.loc.respond_to?(:keyword) && node.loc.keyword.is?('unless')
-            _check, _else, body = *node
+          if node.if_type?
+            _check, body, = *node.node_parts
           else
             _check, body = *node
           end

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

@@ -7,14 +7,12 @@ module RuboCop
       # 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)
-          colon = node.loc.operator
+          return unless node.colon?
 
-          return unless colon.is?(':')
+          colon = node.loc.operator
 
           add_offense(colon, colon) unless followed_by_space?(colon)
         end

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

@@ -33,7 +33,7 @@ module RuboCop
 
         private
 
-        def parameter_name
+        def style_parameter_name
           'EnforcedStyleInsidePipes'
         end
 

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

@@ -6,28 +6,21 @@ 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?
 
         def on_pair(node)
-          return unless node.loc.operator.is?('=>')
+          return unless node.hash_rocket?
 
-          align_hash_config = config.for_cop('Style/AlignHash')
-          return if align_hash_config['EnforcedHashRocketStyle'] == 'table' &&
-                    !any_pairs_on_the_same_line?(node.parent)
+          return if hash_table_style? && !node.parent.pairs_on_same_line?
 
-          _, right = *node
-
-          check_operator(node.loc.operator, right.source_range)
+          check_operator(node.loc.operator, node.source_range)
         end
 
         def on_if(node)
-          return unless ternary?(node)
-          _, if_branch, else_branch = *node
+          return unless node.ternary?
 
-          check_operator(node.loc.question, if_branch.source_range)
-          check_operator(node.loc.colon, else_branch.source_range)
+          check_operator(node.loc.question, node.if_branch.source_range)
+          check_operator(node.loc.colon, node.else_branch.source_range)
         end
 
         def on_resbody(node)
@@ -130,6 +123,15 @@ module RuboCop
             end
           end
         end
+
+        def align_hash_cop_config
+          config.for_cop('Style/AlignHash')
+        end
+
+        def hash_table_style?
+          align_hash_cop_config &&
+            align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
+        end
       end
     end
   end

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

@@ -14,9 +14,7 @@ module RuboCop
           _receiver, method_name, *_args = *node
           return unless preferred_methods[method_name]
           add_offense(node, :selector,
-                      format(MSG,
-                             preferred_method(method_name),
-                             method_name))
+                      format(MSG, preferred_method(method_name), method_name))
         end
 
         def autocorrect(node)

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

@@ -19,7 +19,7 @@ module RuboCop
         def on_array(node)
           if bracketed_array_of?(:sym, node)
             check_bracketed_array(node)
-          elsif percent_array?(node)
+          elsif node.percent_literal?(:symbol)
             check_percent_array(node)
           end
         end
@@ -39,10 +39,6 @@ module RuboCop
 
         private
 
-        def percent_array?(node)
-          node.loc.begin && node.loc.begin.source =~ /\A%[iI]/
-        end
-
         def check_bracketed_array(node)
           return if comments_in_array?(node)
           return if symbols_contain_spaces?(node)

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

@@ -49,7 +49,6 @@ module RuboCop
       #   foo = bar.baz ? a : b
       #   foo = (bar && baz) ? a : b
       class TernaryParentheses < Cop
-        include IfNode
         include SafeAssignment
         include ConfigurableEnforcedStyle
 
@@ -58,14 +57,15 @@ module RuboCop
           ' complex conditions.'.freeze
 
         def on_if(node)
-          return unless ternary?(node) && !infinite_loop? && offense?(node)
+          return unless node.ternary? && !infinite_loop? && offense?(node)
+
           add_offense(node, node.source_range, message(node))
         end
 
         private
 
         def offense?(node)
-          condition, = *node
+          condition = node.condition
 
           if safe_assignment?(condition)
             !safe_assignment_allowed?
@@ -81,7 +81,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          condition, = *node
+          condition = node.condition
 
           return nil if parenthesized?(condition) &&
                         (safe_assignment?(condition) ||
@@ -118,8 +118,7 @@ module RuboCop
 
         def message(node)
           if require_parentheses_when_complex?
-            condition, = *node
-            omit = parenthesized?(condition) ? 'Only use' : 'Use'
+            omit = parenthesized?(node.condition) ? 'Only use' : 'Use'
             format(MSG_COMPLEX, omit)
           else
             verb = require_parentheses? ? 'Use' : 'Omit'

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

@@ -43,11 +43,8 @@ module RuboCop
         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
+          args.last.hash_type? && args.last.braces? &&
+            braces_will_be_removed?(args)
         end
 
         # Returns true if running with --auto-correct would remove the braces

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

@@ -31,7 +31,7 @@ module RuboCop
         include TrailingComma
 
         def on_array(node)
-          check_literal(node, 'item of %s array') if square_brackets?(node)
+          check_literal(node, 'item of %s array') if node.square_brackets?
         end
 
         def on_hash(node)

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

@@ -9,11 +9,7 @@ module RuboCop
               'positive case first.'.freeze
 
         def on_if(node)
-          loc = node.loc
-
-          # discard ternary ops and modifier if/unless nodes
-          return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
-          return unless loc.keyword.is?('unless'.freeze) && loc.else
+          return unless node.unless? && node.else?
 
           add_offense(node, :expression)
         end

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

@@ -8,13 +8,15 @@ module RuboCop
         MSG = 'Do not use `when x;`. Use `when x then` instead.'.freeze
 
         def on_when(node)
-          return unless node.loc.begin && node.loc.begin.is?(';')
+          return if node.multiline? || node.then? || !node.body
 
           add_offense(node, :begin)
         end
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.begin, ' then') }
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
         end
       end
     end

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

@@ -5,6 +5,8 @@ module RuboCop
     module Style
       # Checks for uses of `do` in multi-line `while/until` statements.
       class WhileUntilDo < Cop
+        MSG = 'Do not use `do` with multi-line `%s`.'.freeze
+
         def on_while(node)
           handle(node)
         end
@@ -14,25 +16,19 @@ module RuboCop
         end
 
         def handle(node)
-          length = node.source.lines.to_a.size
-          return unless length > 1
-          return unless node.loc.begin && node.loc.begin.is?('do')
+          return unless node.multiline? && node.do?
 
-          add_offense(node, :begin, error_message(node.type))
+          add_offense(node, :begin, format(MSG, node.keyword))
         end
 
         private
 
-        def error_message(node_type)
-          format('Do not use `do` with multi-line `%s`.', node_type)
-        end
-
         def autocorrect(node)
-          condition_node, = *node
-          end_of_condition_range = condition_node.source_range.end
-          do_range = node.loc.begin
-          whitespaces_and_do_range = end_of_condition_range.join(do_range)
-          ->(corrector) { corrector.remove(whitespaces_and_do_range) }
+          do_range = node.condition.source_range.end.join(node.loc.begin)
+
+          lambda do |corrector|
+            corrector.remove(do_range)
+          end
         end
       end
     end