rubocop 0.45.0 → 0.46.0

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

@@ -18,19 +18,17 @@ module RuboCop
               'name its argument `other`.'.freeze
 
         OP_LIKE_METHODS = [:eql?, :equal?].freeze
-
         BLACKLISTED = [:+@, :-@, :[], :[]=, :<<, :`].freeze
 
-        TARGET_ARGS = [s(:args, s(:arg, :other)),
-                       s(:args, s(:arg, :_other))].freeze
+        def_node_matcher :op_method_candidate?, <<-PATTERN
+          (def $_ (args $(arg [!:other !:_other])) _)
+        PATTERN
 
         def on_def(node)
-          name, args, _body = *node
-          return unless op_method?(name) &&
-                        args.children.one? &&
-                        !TARGET_ARGS.include?(args)
-
-          add_offense(args.children.first, :expression, format(MSG, name))
+          op_method_candidate?(node) do |name, arg|
+            return unless op_method?(name)
+            add_offense(arg, :expression, format(MSG, name))
+          end
         end
 
         def op_method?(name)

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

@@ -184,7 +184,7 @@ module RuboCop
         class GenericCorrector
           include AutocorrectAlignment
 
-          attr_reader :config, :node, :correction, :correction_range
+          attr_reader :config, :node
 
           def initialize(node, config, new_elements)
             @node = node

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

@@ -8,17 +8,13 @@ module RuboCop
       class Proc < Cop
         MSG = 'Use `proc` instead of `Proc.new`.'.freeze
 
-        TARGET = s(:send, s(:const, nil, :Proc), :new)
+        def_node_matcher :proc_new?,
+                         '(block $(send (const nil :Proc) :new) ...)'
 
         def on_block(node)
-          # We're looking for
-          # (block
-          #   (send
-          #     (const nil :Proc) :new)
-          #   ...)
-          block_method, = *node
-
-          add_offense(block_method, :expression) if block_method == TARGET
+          proc_new?(node) do |block_method|
+            add_offense(block_method, :expression)
+          end
         end
 
         def autocorrect(node)

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

@@ -16,14 +16,13 @@ module RuboCop
 
         MSG = 'Freezing immutable objects is pointless.'.freeze
 
-        def on_send(node)
-          receiver, method_name, *args = *node
-
-          return unless method_name == :freeze &&
-                        args.empty? &&
-                        immutable_literal?(receiver)
+        def_node_matcher :freezing?, '(send $_ :freeze)'
 
-          add_offense(node, :expression)
+        def on_send(node)
+          freezing?(node) do |receiver|
+            return unless immutable_literal?(receiver)
+            add_offense(node, :expression)
+          end
         end
 
         def autocorrect(node)

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

@@ -8,10 +8,13 @@ module RuboCop
         MSG = 'Prefer `Object#__send__` or `Object#public_send` to ' \
               '`send`.'.freeze
 
+        def_node_matcher :sending?, '(send _ :send $...)'
+
         def on_send(node)
-          _receiver, method_name, *args = *node
-          return unless method_name == :send && !args.empty?
-          add_offense(node, :selector)
+          sending?(node) do |args|
+            return if args.empty?
+            add_offense(node, :selector)
+          end
         end
       end
     end

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

@@ -54,7 +54,7 @@ module RuboCop
         end
 
         def check_left_brace(inner, left_brace, args_delimiter)
-          if inner =~ /^\S/
+          if inner =~ /\A\S/
             no_space_inside_left_brace(left_brace, args_delimiter)
           else
             space_inside_left_brace(left_brace, args_delimiter)

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

@@ -7,10 +7,10 @@ module RuboCop
       class SpecialGlobalVars < Cop
         include ConfigurableEnforcedStyle
 
-        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module, ' \
-        'or `%s` over `%s`.'.freeze
+        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module ' \
+        '(don\'t forget to require it), or `%s` over `%s`.'.freeze
         MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
-        'over `%s`.'.freeze
+        '(don\'t forget to require it) over `%s`.'.freeze
         MSG_REGULAR = 'Prefer `%s` over `%s`.'.freeze
 
         ENGLISH_VARS = { # rubocop:disable Style/MutableConstant

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

@@ -13,23 +13,30 @@ module RuboCop
       #   something.map(&:upcase)
       class SymbolProc < Cop
         MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
+        SUPER_TYPES = [:super, :zsuper].freeze
 
-        PROC_NODE = s(:send, s(:const, nil, :Proc), :new)
+        def_node_matcher :proc_node?, '(send (const nil :Proc) :new)'
+        def_node_matcher :symbol_proc?, <<-PATTERN
+          (block
+            ${(send ...) (super ...) zsuper}
+            $(args (arg _))
+            $(send lvar $_))
+        PATTERN
 
         def on_block(node)
-          block_send_or_super, block_args, block_body = *node
-          block_method_name = resolve_block_method_name(block_send_or_super)
-
-          # TODO: Rails-specific handling that we should probably make
-          # configurable - https://github.com/bbatsov/rubocop/issues/1485
-          # we should ignore lambdas & procs
-          return if block_send_or_super == PROC_NODE
-          return if [:lambda, :proc].include?(block_method_name)
-          return if ignored_method?(block_method_name)
-          return unless can_shorten?(block_args, block_body)
-
-          _receiver, method_name, _args = *block_body
-          offense(node, method_name, block_method_name)
+          symbol_proc?(node) do |send_or_super, block_args, block_body, method|
+            block_method_name = resolve_block_method_name(send_or_super)
+
+            # TODO: Rails-specific handling that we should probably make
+            # configurable - https://github.com/bbatsov/rubocop/issues/1485
+            # we should ignore lambdas & procs
+            return if proc_node?(send_or_super)
+            return if [:lambda, :proc].include?(block_method_name)
+            return if ignored_method?(block_method_name)
+            return unless can_shorten?(block_args, block_body)
+
+            offense(node, method, block_method_name)
+          end
         end
 
         def autocorrect(node)
@@ -114,9 +121,6 @@ module RuboCop
         end
 
         def can_shorten?(block_args, block_body)
-          return false unless shortenable_args?(block_args) &&
-                              shortenable_body?(block_body)
-
           argument_matches_receiver?(block_args, block_body)
         end
 
@@ -130,33 +134,8 @@ module RuboCop
           block_arg_name == receiver_name
         end
 
-        # The block body must have a single send without arguments to an
-        # lvar type.
-        # E.g.: `foo { |bar| bar.baz }`
-        def shortenable_body?(block_body)
-          return false unless block_body && block_body.send_type?
-
-          receiver, _, args = *block_body
-
-          return false if args
-
-          receiver && receiver.lvar_type?
-        end
-
-        # The block must have a single, shortenable argument.
-        # E.g.: `foo { |bar| ... }`
-        def shortenable_args?(block_args)
-          block_args.children.one? && !non_shortenable_args?(block_args)
-        end
-
         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)
+          SUPER_TYPES.include?(node.type)
         end
       end
     end

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

@@ -34,17 +34,32 @@ module RuboCop
       #   foo = (bar?) ? a : b
       #   foo = (bar.baz) ? a : b
       #   foo = (bar && baz) ? a : b
+      #
+      # @example
+      #
+      #   EnforcedStyle: require_parentheses_when_complex
+      #
+      #   @bad
+      #   foo = (bar?) ? a : b
+      #   foo = (bar.baz?) ? a : b
+      #   foo = bar && baz ? a : b
+      #
+      #   @good
+      #   foo = bar? ? a : b
+      #   foo = bar.baz ? a : b
+      #   foo = (bar && baz) ? a : b
       class TernaryParentheses < Cop
         include IfNode
         include SafeAssignment
         include ConfigurableEnforcedStyle
 
         MSG = '%s parentheses for ternary conditions.'.freeze
+        MSG_COMPLEX = '%s parentheses for ternary expressions with' \
+          ' complex conditions.'.freeze
 
         def on_if(node)
-          return unless ternary?(node)
-
-          add_offense(node, node.source_range, message) if offense?(node)
+          return unless ternary?(node) && !infinite_loop? && offense?(node)
+          add_offense(node, node.source_range, message(node))
         end
 
         private
@@ -52,39 +67,74 @@ module RuboCop
         def offense?(node)
           condition, = *node
 
-          (require_parentheses? && !parenthesized?(condition) ||
-            !require_parentheses? && parenthesized?(condition)) &&
-            !(safe_assignment?(condition) && safe_assignment_allowed?) &&
-            !infinite_loop?
+          if safe_assignment?(condition)
+            !safe_assignment_allowed?
+          else
+            parens = parenthesized?(condition)
+            case style
+            when :require_parentheses_when_complex
+              complex_condition?(condition) ? !parens : parens
+            else
+              require_parentheses? ? !parens : parens
+            end
+          end
         end
 
         def autocorrect(node)
           condition, = *node
 
+          return nil if parenthesized?(condition) &&
+                        (safe_assignment?(condition) ||
+                        unsafe_autocorrect?(condition))
+
           lambda do |corrector|
-            if require_parentheses?
+            if parenthesized?(condition)
+              corrector.remove(condition.loc.begin)
+              corrector.remove(condition.loc.end)
+            else
               corrector.insert_before(condition.source_range, '(')
               corrector.insert_after(condition.source_range, ')')
-            else
-              unless safe_assignment?(condition) ||
-                     unsafe_autocorrect?(condition)
-                corrector.remove(condition.loc.begin)
-                corrector.remove(condition.loc.end)
-              end
             end
           end
         end
 
-        def message
-          verb = require_parentheses? ? 'Use' : 'Omit'
+        # If the condition is parenthesized we recurse and check for any
+        # complex expressions within it.
+        def complex_condition?(condition)
+          if condition.type == :begin
+            condition.to_a.any? { |x| complex_condition?(x) }
+          else
+            non_complex_type?(condition) ? false : true
+          end
+        end
 
-          format(MSG, verb)
+        # Anything that is not a variable, constant, or method/.method call
+        # will be counted as a complex expression.
+        def non_complex_type?(condition)
+          condition.variable? || condition.const_type? ||
+            (condition.send_type? && !operator?(condition.method_name)) ||
+            condition.defined_type?
+        end
+
+        def message(node)
+          if require_parentheses_when_complex?
+            condition, = *node
+            omit = parenthesized?(condition) ? 'Only use' : 'Use'
+            format(MSG_COMPLEX, omit)
+          else
+            verb = require_parentheses? ? 'Use' : 'Omit'
+            format(MSG, verb)
+          end
         end
 
         def require_parentheses?
           style == :require_parentheses
         end
 
+        def require_parentheses_when_complex?
+          style == :require_parentheses_when_complex
+        end
+
         def redundant_parentheses_enabled?
           @config.for_cop('RedundantParentheses')['Enabled']
         end
@@ -109,7 +159,6 @@ module RuboCop
 
         def unparenthesized_method_call?(child)
           argument = method_call_argument(child)
-
           argument && argument !~ /^\(/
         end
 

data/lib/rubocop/cop/util.rb

@@ -24,7 +24,7 @@ module RuboCop
 
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
-      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZS0-9]/
+      LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGhHkpPRwWXsSzZ0-9]/
 
       module_function
 

data/lib/rubocop/cop/variable_force/assignment.rb

@@ -23,6 +23,8 @@ module RuboCop
           @node = node
           @variable = variable
           @referenced = false
+
+          super
         end
 
         def name

data/lib/rubocop/cop/variable_force/locatable.rb

@@ -21,6 +21,12 @@ module RuboCop
         NON_FOR_LOOP_TYPES = LOOP_TYPES - [FOR_LOOP_TYPE]
         NON_FOR_LOOP_TYPES_CHILD_INDEX = 1
 
+        def initialize(*)
+          @branch_point_node = @branch_body_node = nil
+
+          super()
+        end
+
         def node
           raise '#node must be declared!'
         end
@@ -64,9 +70,7 @@ module RuboCop
 
         # Inner if, case, rescue, or ensure node.
         def branch_point_node
-          if instance_variable_defined?(:@branch_point_node)
-            return @branch_point_node
-          end
+          return @branch_point_node if @branch_point_node
 
           set_branch_point_and_body_nodes!
           @branch_point_node
@@ -74,9 +78,7 @@ module RuboCop
 
         # A child node of #branch_point_node this assignment belongs.
         def branch_body_node
-          if instance_variable_defined?(:@branch_body_node)
-            return @branch_body_node
-          end
+          return @branch_body_node if @branch_body_node
 
           set_branch_point_and_body_nodes!
           @branch_body_node

data/lib/rubocop/cop/variable_force/reference.rb

@@ -24,6 +24,8 @@ module RuboCop
 
           @node = node
           @scope = scope
+
+          super
         end
 
         # There's an implicit variable reference by the zero-arity `super`:

data/lib/rubocop/formatter/base_formatter.rb

@@ -77,8 +77,7 @@ module RuboCop
       #   all target file paths to be inspected
       #
       # @return [void]
-      def started(target_files)
-      end
+      def started(target_files); end
 
       # @api public
       #
@@ -91,8 +90,7 @@ module RuboCop
       #   file specific information, currently this is always empty.
       #
       # @return [void]
-      def file_started(file, options)
-      end
+      def file_started(file, options); end
 
       # @api public
       #
@@ -107,8 +105,7 @@ module RuboCop
       # @return [void]
       #
       # @see RuboCop::Cop::Offense
-      def file_finished(file, offenses)
-      end
+      def file_finished(file, offenses); end
 
       # @api public
       #
@@ -120,8 +117,7 @@ module RuboCop
       #   unless RuboCop is interrupted by user.
       #
       # @return [void]
-      def finished(inspected_files)
-      end
+      def finished(inspected_files); end
     end
   end
 end