rubocop 0.34.2 → 0.35.0

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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for nested use of if, unless, while and until in their
+      # modifier form.
+      #
+      # @example
+      #
+      #   # bad
+      #   something if a if b
+      #
+      #   # good
+      #   something if b && a
+      class NestedModifier < Cop
+        include IfNode
+
+        MSG = 'Avoid using nested modifiers.'
+
+        def on_while(node)
+          check(node)
+        end
+
+        def on_until(node)
+          check(node)
+        end
+
+        def on_if(node)
+          check(node)
+        end
+
+        def check(node)
+          return if part_of_ignored_node?(node)
+          return unless modifier?(node)
+
+          ancestor = node.ancestors.first
+          return unless ancestor &&
+                        [:if, :while, :until].include?(ancestor.type) &&
+                        modifier?(ancestor)
+
+          add_offense(node, :keyword)
+          ignore_node(node)
+        end
+
+        def modifier?(node)
+          modifier_if?(node) || modifier_while_or_until?(node)
+        end
+
+        def modifier_while_or_until?(node)
+          node.loc.respond_to?(:keyword) &&
+            %w(while until).include?(node.loc.keyword.source) &&
+            node.loc.respond_to?(:end) && node.loc.end.nil?
+        end
+
+        def autocorrect(node)
+          return unless node.if_type?
+
+          ancestor = node.ancestors.first
+          return unless ancestor.if_type?
+
+          autocorrect_if_unless(ancestor, node)
+        end
+
+        def autocorrect_if_unless(outer_node, inner_node)
+          outer_cond, = *outer_node
+
+          range =
+            Parser::Source::Range.new(inner_node.loc.expression.source_buffer,
+                                      inner_node.loc.keyword.begin_pos,
+                                      outer_cond.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, new_expression(outer_node, inner_node))
+          end
+        end
+
+        def new_expression(outer_node, inner_node)
+          outer_cond, = *outer_node
+          inner_cond, = *inner_node
+
+          outer_keyword = outer_node.loc.keyword.source
+          inner_keyword = inner_node.loc.keyword.source
+
+          operator = outer_keyword == 'if' ? '&&' : '||'
+
+          inner_expr = inner_cond.loc.expression.source
+          inner_expr = "(#{inner_expr})" if inner_cond.or_type?
+          inner_expr = "!#{inner_expr}" unless outer_keyword == inner_keyword
+
+          "#{outer_node.loc.keyword.source} " \
+          "#{outer_cond.loc.expression.source} #{operator} #{inner_expr}"
+        end
+      end
+    end
+  end
+end

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

@@ -98,6 +98,24 @@ module RuboCop
           offense_begin_pos = offense_node.loc.expression.begin
           offense_begin_pos.join(condition_expression.loc.expression)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            cond, if_body, else_body = *node
+            if if_body.nil?
+              opposite_kw = 'if'
+              body = else_body
+            else
+              opposite_kw = 'unless'
+              body = if_body
+            end
+            next_code = 'next ' << opposite_kw << ' ' <<
+                        cond.loc.expression.source << "\n"
+            corrector.insert_before(node.loc.expression, next_code)
+            corrector.replace(node.loc.expression,
+                              body.loc.expression.source)
+          end
+        end
       end
     end
   end

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

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require 'tsort'
+
 module RuboCop
   module Cop
     module Style
@@ -45,21 +47,27 @@ module RuboCop
           # allow mass assignment when using splat
           return if (left_elements + right_elements).any?(&:splat_type?)
 
-          # a, b = b, a
-          return if swapping_variables?(left_elements, right_elements)
+          order = find_valid_order(left_elements, right_elements)
+          # For `a, b = b, a` or similar, there is no valid order
+          return if order.nil?
 
           add_offense(node, :expression)
         end
 
         def autocorrect(node)
           lambda do |corrector|
+            left, right = *node
+            left_elements = *left
+            right_elements = [*right].compact
+            order = find_valid_order(left_elements, right_elements)
+
             assignment_corrector =
               if modifier_statement?(node.parent)
-                ModifierCorrector.new(node, config)
+                ModifierCorrector.new(node, config, order)
               elsif rescue_modifier?(node.parent)
-                RescueCorrector.new(node, config)
+                RescueCorrector.new(node, config, order)
               else
-                GenericCorrector.new(node, config)
+                GenericCorrector.new(node, config, order)
               end
 
             corrector.replace(assignment_corrector.correction_range,
@@ -69,10 +77,45 @@ module RuboCop
 
         private
 
-        def swapping_variables?(left_elements, right_elements)
-          left_elements.any? do |le|
-            right_elements.any? do |re|
-              re.loc.expression.is?(le.loc.expression.source)
+        def find_valid_order(left_elements, right_elements)
+          # arrange left_elements in an order such that no corresponding right
+          # element refers to a left element earlier in the sequence
+          # this can be done using an algorithm called a "topological sort"
+          # fortunately for us, Ruby's stdlib contains an implementation
+          assignments = left_elements.zip(right_elements)
+
+          begin
+            AssignmentSorter.new(assignments).tsort
+          rescue TSort::Cyclic
+            nil
+          end
+        end
+
+        # Helper class necessitated by silly design of TSort prior to Ruby 2.1
+        # Newer versions have a better API, but that doesn't help us
+        class AssignmentSorter
+          include TSort
+          extend RuboCop::NodePattern::Macros
+
+          def_node_matcher :var_name, '{(casgn _ $_) (_ $_)}'
+          def_node_search :uses_var?, '{({lvar ivar cvar gvar} %) (const _ %)}'
+
+          def initialize(assignments)
+            @assignments = assignments
+          end
+
+          def tsort_each_node
+            @assignments.each { |a| yield a }
+          end
+
+          def tsort_each_child(assignment)
+            # yield all the assignments which must come after `assignment`
+            # (due to dependencies on the previous value of the assigned var)
+            my_lhs, _my_rhs = *assignment
+
+            @assignments.each do |other|
+              _other_lhs, other_rhs = *other
+              yield other if uses_var?(other_rhs, var_name(my_lhs))
             end
           end
         end
@@ -101,9 +144,10 @@ module RuboCop
 
           attr_reader :config, :node, :correction, :correction_range
 
-          def initialize(node, config)
+          def initialize(node, config, new_elements)
             @node = node
             @config = config
+            @new_elements = new_elements
           end
 
           def correction
@@ -117,11 +161,9 @@ module RuboCop
           protected
 
           def assignment
-            left, right = *node
-            l_vars = extract_sources(left)
-            r_vars = extract_sources(right)
-            groups = l_vars.zip(r_vars)
-            groups.map { |pair| pair.join(' = ') }
+            @new_elements.map do |lhs, rhs|
+              "#{lhs.loc.expression.source} = #{rhs.loc.expression.source}"
+            end
           end
 
           private

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

@@ -23,10 +23,11 @@ module RuboCop
         private
 
         def on_method_def(node, method_name, _args, _body)
-          predicate_prefices.each do |prefix|
+          predicate_prefixes.each do |prefix|
             method_name = method_name.to_s
             next unless method_name.start_with?(prefix)
             next if method_name == expected_name(method_name, prefix)
+            next if predicate_whitelist.include?(method_name)
             add_offense(
               node,
               :name,
@@ -53,9 +54,13 @@ module RuboCop
           cop_config['NamePrefixBlacklist']
         end
 
-        def predicate_prefices
+        def predicate_prefixes
           cop_config['NamePrefix']
         end
+
+        def predicate_whitelist
+          cop_config['NameWhitelist']
+        end
       end
     end
   end

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

@@ -47,7 +47,7 @@ module RuboCop
         def check_slash_literal(node)
           return if style == :slashes && !contains_disallowed_slash?(node)
           return if style == :mixed &&
-                    single_line?(node) &&
+                    node.single_line? &&
                     !contains_disallowed_slash?(node)
 
           add_offense(node, :expression, MSG_USE_PERCENT_R)
@@ -56,7 +56,7 @@ module RuboCop
         def check_percent_r_literal(node)
           return if style == :slashes && contains_disallowed_slash?(node)
           return if style == :percent_r
-          return if style == :mixed && multi_line?(node)
+          return if style == :mixed && node.multiline?
           return if style == :mixed && contains_disallowed_slash?(node)
 
           add_offense(node, :expression, MSG_USE_SLASHES)
@@ -83,14 +83,6 @@ module RuboCop
           node.loc.begin.source == '/'
         end
 
-        def single_line?(node)
-          !multi_line?(node)
-        end
-
-        def multi_line?(node)
-          block_length(node) > 1
-        end
-
         def preferred_delimiters
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%r'].split(//)

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

@@ -34,12 +34,14 @@ module RuboCop
             c.loc.line == node.loc.expression.line
           end
           lambda do |corrector|
-            if body.type == :begin
-              body.children.each do |part|
-                break_line_before(part.loc.expression, node, corrector, 1)
+            if body
+              if body.type == :begin
+                body.children.each do |part|
+                  break_line_before(part.loc.expression, node, corrector, 1)
+                end
+              else
+                break_line_before(body.loc.expression, node, corrector, 1)
               end
-            else
-              break_line_before(body.loc.expression, node, corrector, 1)
             end
 
             break_line_before(node.loc.end, node, corrector, 0)

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

@@ -20,7 +20,7 @@ module RuboCop
           _receiver, method_name, *args = *node
           return if args.empty?
           return if operator?(method_name)
-          return if method_name.to_s.end_with?('=')
+          return if node.asgn_method_call?
 
           arg1 = args.first.loc.expression
           return if arg1.line > node.loc.line

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

@@ -57,6 +57,8 @@ module RuboCop
 
         def check_operator(op)
           with_space = range_with_surrounding_space(op)
+          return if with_space.source.start_with?("\n")
+
           if op.is?('**')
             unless with_space.is?('**')
               add_offense(with_space, op,

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

@@ -5,8 +5,10 @@ module RuboCop
     module Style
       # This cop looks for uses of Perl-style global variables.
       class SpecialGlobalVars < Cop
-        MSG_BOTH = 'Prefer `%s` from the English library, or `%s` over `%s`.'
-        MSG_ENGLISH = 'Prefer `%s` from the English library over `%s`.'
+        MSG_BOTH = 'Prefer `%s` from the stdlib \'English\' module, ' \
+        'or `%s` over `%s`.'
+        MSG_ENGLISH = 'Prefer `%s` from the stdlib \'English\' module ' \
+        'over `%s`.'
         MSG_REGULAR = 'Prefer `%s` over `%s`.'
 
         PREFERRED_VARS = {

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

@@ -0,0 +1,108 @@
+# encoding: utf-8
+module RuboCop
+  module Cop
+    module Style
+      # Check for parentheses around stabby lambda arguments.
+      # There are two different styles. Defaults to `require_parentheses`.
+      #
+      # @example
+      #   # require_parentheses - bad
+      #   ->a,b,c { a + b + c }
+      #
+      #   # require_parentheses - good
+      #   ->(a,b,c) { a + b + c}
+      #
+      #   # require_no_parentheses - bad
+      #   ->(a,b,c) { a + b + c }
+      #
+      #   # require_parentheses - good
+      #   ->a,b,c { a + b + c}
+      class StabbyLambdaParentheses < Cop
+        MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
+
+        include ConfigurableEnforcedStyle
+
+        def on_send(node)
+          return unless lambda_with_args?(node)
+
+          if style == :require_parentheses
+            if parentheses?(node)
+              correct_style_detected
+            else
+              missing_parentheses(node)
+            end
+          elsif parentheses?(node)
+            unwanted_parentheses(node)
+          else
+            correct_style_detected
+          end
+        end
+
+        def autocorrect(node)
+          if style == :require_parentheses
+            missing_parentheses_corrector(node)
+          elsif style == :require_no_parentheses
+            unwanted_parentheses_corrector(node)
+          end
+        end
+
+        private
+
+        def missing_parentheses(node)
+          add_offense(node_args(node), :expression, MSG_REQUIRE) do
+            opposite_style_detected
+          end
+        end
+
+        def unwanted_parentheses(node)
+          add_offense(node_args(node), :expression, MSG_NO_REQUIRE) do
+            opposite_style_detected
+          end
+        end
+
+        def missing_parentheses_corrector(node)
+          lambda do |corrector|
+            args_loc = node_args(node).loc.expression
+
+            corrector.insert_before(args_loc, '(')
+            corrector.insert_after(args_loc, ')')
+          end
+        end
+
+        def unwanted_parentheses_corrector(node)
+          lambda do |corrector|
+            args_loc = node_args(node).loc
+
+            corrector.replace(args_loc.begin, '')
+            corrector.remove(args_loc.end)
+          end
+        end
+
+        def lambda_with_args?(node)
+          lambda_node?(node) && args?(node)
+        end
+
+        def lambda_node?(node)
+          _nil, call = *node
+          call == :lambda
+        end
+
+        def node_args(node)
+          _call, args, _body = *node.parent
+          args
+        end
+
+        def args?(node)
+          args = node_args(node)
+          args.children.count > 0
+        end
+
+        def parentheses?(node)
+          args = node_args(node)
+          args.loc.begin
+        end
+      end
+    end
+  end
+end