rubocop 0.24.1 → 0.25.0

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

@@ -0,0 +1,73 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the multiline do end blocks have a newline
+      # after the start of the block.
+      #
+      # @example
+      #   # bad
+      #   blah do |i| foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # good
+      #   blah do |i|
+      #     foo(i)
+      #     bar(i)
+      #   end
+      #
+      #   # bad
+      #   blah { |i| foo(i)
+      #     bar(i)
+      #   }
+      #
+      #   # good
+      #   blah { |i|
+      #     foo(i)
+      #     bar(i)
+      #   }
+      class MultilineBlockLayout < Cop
+        MSG = 'Block body expression is on the same line as the block start.'
+
+        def on_block(node)
+          end_loc = node.loc.end
+          do_loc = node.loc.begin # Actually it's either do or {.
+          return if do_loc.line == end_loc.line # One-liner, no newline needed.
+
+          # A block node has three children: the block start,
+          # the arguments, and the expression. We care if the block start
+          # and the expression start on the same line.
+          last_expression = node.children.last
+          return unless last_expression
+          expression_loc = last_expression.loc
+          return unless do_loc.line == expression_loc.line
+
+          expression = last_expression.loc.expression
+          range = Parser::Source::Range.new(expression.source_buffer,
+                                            expression.begin_pos,
+                                            expression.end_pos)
+
+          add_offense(node, range)
+        end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            _method, _args, block_body = *node
+            first_node = if block_body.type == :begin
+                           block_body.children.first
+                         else
+                           block_body
+                         end
+
+            block_start_col = node.loc.expression.column
+
+            corrector.insert_before(first_node.loc.expression,
+                                    "\n  #{' ' * block_start_col}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,9 +17,9 @@ module RuboCop
       #   end
       class MultilineIfThen < Cop
         include IfNode
-        include IfThenElse
+        include OnNormalIfUnless
 
-        def offending_line(node)
+        def on_normal_if_unless(node)
           condition, body, else_clause = *node
           next_thing = if body && body.loc.expression
                          body.loc.expression.begin
@@ -34,14 +34,14 @@ module RuboCop
                                       next_thing.begin_pos)
           return unless right_after_cond.source =~ /\A\s*then\s*(#.*)?\s*\n/
 
-          node.loc.expression.begin.line
+          add_offense(node, :expression, message(node))
         end
 
         def end_position(conditional_node)
           conditional_node.loc.expression.end.end_pos
         end
 
-        def error_message(node)
+        def message(node)
           "Never use `then` for multi-line `#{node.loc.keyword.source}`."
         end
       end

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

@@ -14,7 +14,7 @@ module RuboCop
           return unless node.loc.respond_to?(:keyword)
           return if node.loc.keyword.is?('elsif')
 
-          check(node)
+          check_negative_conditional(node)
         end
 
         def message(node)

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

@@ -10,11 +10,11 @@ module RuboCop
         MSG = 'Favor `%s` over `%s` for negative conditions.'
 
         def on_while(node)
-          check(node)
+          check_negative_conditional(node)
         end
 
         def on_until(node)
-          check(node)
+          check_negative_conditional(node)
         end
 
         def message(node)

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

@@ -56,6 +56,17 @@ module RuboCop
 
         private
 
+        def min_body_length?(node)
+          (node.loc.end.line - node.loc.keyword.line) > min_body_length
+        end
+
+        def min_body_length
+          length = cop_config['MinBodyLength'] || 1
+          return length if length.is_a?(Integer) && length > 0
+
+          fail 'MinBodyLength needs to be a positive integer!'
+        end
+
         def enumerator?(method_name)
           ENUMERATORS.include?(method_name) || /\Aeach_/.match(method_name)
         end
@@ -71,6 +82,7 @@ module RuboCop
           return false if if_else?(node)
           return false unless node.type == :if
           return false if style == :skip_modifier_ifs && modifier_if?(node)
+          return false if !modifier_if?(node) && !min_body_length?(node)
 
           # The `if` node must have only `if` body since we excluded `if` with
           # `else` above.

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

@@ -6,14 +6,14 @@ module RuboCop
       # TODO: Make configurable.
       # Checks for uses of if/then/else/end on a single line.
       class OneLineConditional < Cop
-        include IfThenElse
+        include OnNormalIfUnless
 
-        def offending_line(node)
-          node.loc.expression.line unless node.loc.expression.source =~ /\n/
-        end
+        MSG = 'Favor the ternary operator (?:) ' \
+              'over if/then/else/end constructs.'
 
-        def error_message(_node)
-          'Favor the ternary operator (?:) over if/then/else/end constructs.'
+        def on_normal_if_unless(node)
+          return if node.loc.expression.source.include?("\n")
+          add_offense(node, :expression, MSG)
         end
       end
     end

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

@@ -42,14 +42,18 @@ module RuboCop
           type = type(node)
 
           opening_delimiter, closing_delimiter = preferred_delimiters(type)
-          opening_newline = new_line(node.loc.begin, node.children.first)
-          closing_newline = new_line(node.loc.end, node.children.last)
 
+          first_child, *_middle, last_child = *node
+          opening_newline = new_line(node.loc.begin, first_child)
+          expression_indentation = leading_whitespace(first_child, :expression)
+          closing_newline = new_line(node.loc.end, last_child)
+          closing_indentation = leading_whitespace(node, :end)
           expression, reg_opt = *contents(node)
+
           corrected_source =
             type + opening_delimiter + opening_newline +
-            expression +
-            closing_newline + closing_delimiter + reg_opt
+            expression_indentation + expression + closing_newline +
+            closing_indentation + closing_delimiter + reg_opt
 
           @corrections << lambda do |corrector|
             corrector.replace(
@@ -59,11 +63,10 @@ module RuboCop
           end
         end
 
-        def on_percent_literal(node, types)
+        def on_percent_literal(node)
           type = type(node)
-          return unless types.include?(type) &&
-            !uses_preferred_delimiter?(node, type) &&
-            !contains_preferred_delimiter?(node, type)
+          return if uses_preferred_delimiter?(node, type) ||
+            contains_preferred_delimiter?(node, type)
 
           add_offense(node, :expression)
         end
@@ -72,6 +75,17 @@ module RuboCop
           cop_config['PreferredDelimiters'][type].split(//)
         end
 
+        def leading_whitespace(object, part)
+          case object
+          when String
+            ''
+          when Parser::AST::Node
+            /(\s*)/.match(object.loc.send(part).source_line)[1]
+          else
+            fail "Unsupported object #{object}"
+          end
+        end
+
         def contents(node)
           first_child, *middle, last_child = *node
           last_child ||= first_child

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

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for usage of the %Q() syntax when %q() would do.
+      class PercentQLiterals < Cop
+        include PercentLiteral
+        include ConfigurableEnforcedStyle
+
+        def on_str(node)
+          process(node, '%Q', '%q')
+        end
+
+        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
+
+        def check(node, msg)
+          src = node.loc.expression.source
+          # 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 !=
+            ProcessedSource.new(corrected(src)).ast.children
+
+          add_offense(node, :begin, msg)
+        end
+
+        def autocorrect(node)
+          src = node.loc.expression.source
+
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.expression, corrected(src))
+          end
+        end
+
+        def corrected(src)
+          src.sub(src[1], src[1].swapcase)
+        end
+      end
+    end
+  end
+end

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

@@ -18,11 +18,11 @@ module RuboCop
       #   # good
       #   def value? ...
       class PredicateName < Cop
-        include CheckMethods
+        include OnMethod
 
         private
 
-        def check(node, method_name, _args, _body)
+        def on_method(node, method_name, _args, _body)
           prefix_blacklist.each do |prefix|
             next unless method_name.to_s.start_with?(prefix)
             add_offense(node, :name, message(method_name.to_s, prefix))

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

@@ -18,11 +18,11 @@ module RuboCop
       #     end
       #   end
       class RedundantBegin < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Redundant `begin` block detected.'
 
-        def check(_node, _method_name, _args, body)
+        def on_method(_node, _method_name, _args, body)
           return unless body && body.type == :kwbegin
 
           add_offense(body, :begin)

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

@@ -21,7 +21,7 @@ module RuboCop
       # It should be extended to handle methods whose body is if/else
       # or a case expression with a default branch.
       class RedundantReturn < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Redundant `return` detected.'
 
@@ -39,7 +39,7 @@ module RuboCop
           end
         end
 
-        def check(_node, _method_name, _args, body)
+        def on_method(_node, _method_name, _args, body)
           return unless body
 
           if body.type == :return

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
@@ -17,10 +17,14 @@ module RuboCop
 
         def on_kwbegin(node)
           body, *_ = *node
-          check(nil, nil, nil, body)
+          check(body)
         end
 
-        def check(_node, _method_name, _args, body)
+        def on_method(_node, _method_name, _args, body)
+          check(body)
+        end
+
+        def check(body)
           return unless body
 
           case body.type

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for single-line method definitions.
       # It can optionally accept single-line methods with no body.
       class SingleLineMethods < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Avoid single-line method definitions.'
 
@@ -16,7 +16,7 @@ module RuboCop
 
         private
 
-        def check(node, _method_name, _args, body)
+        def on_method(node, _method_name, _args, body)
           start_line = node.loc.keyword.line
           end_line = node.loc.end.line
 

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

@@ -13,12 +13,12 @@ module RuboCop
       #   # good
       #   def func(x) ... end
       class SpaceAfterMethodName < Cop
-        include CheckMethods
+        include OnMethod
 
         MSG = 'Never put a space between a method name and the opening ' \
               'parenthesis.'
 
-        def check(_node, _method_name, args, _body)
+        def on_method(_node, _method_name, args, _body)
           return unless args.loc.begin && args.loc.begin.is?('(')
           expr = args.loc.expression
           pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,

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

@@ -56,12 +56,12 @@ module RuboCop
         def braces_with_contents_inside(node, inner, sb)
           _method, args, _body = *node
           left_brace, right_brace = node.loc.begin, node.loc.end
-          pipe = args.loc.begin
+          args_delimiter = args.loc.begin # Can be ( | or nil.
 
           if inner =~ /^\S/
-            no_space_inside_left_brace(left_brace, pipe, sb)
+            no_space_inside_left_brace(left_brace, args_delimiter, sb)
           else
-            space_inside_left_brace(left_brace, pipe, sb)
+            space_inside_left_brace(left_brace, args_delimiter, sb)
           end
 
           if inner =~ /\S$/
@@ -72,11 +72,11 @@ module RuboCop
           end
         end
 
-        def no_space_inside_left_brace(left_brace, pipe, sb)
-          if pipe
-            if left_brace.end_pos == pipe.begin_pos &&
+        def no_space_inside_left_brace(left_brace, args_delimiter, sb)
+          if pipe?(args_delimiter)
+            if left_brace.end_pos == args_delimiter.begin_pos &&
                 cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.begin_pos, pipe.end_pos,
+              offense(sb, left_brace.begin_pos, args_delimiter.end_pos,
                       'Space between { and | missing.')
             end
           else
@@ -88,10 +88,10 @@ module RuboCop
           end
         end
 
-        def space_inside_left_brace(left_brace, pipe, sb)
-          if pipe
+        def space_inside_left_brace(left_brace, args_delimiter, sb)
+          if pipe?(args_delimiter)
             unless cop_config['SpaceBeforeBlockParameters']
-              offense(sb, left_brace.end_pos, pipe.begin_pos,
+              offense(sb, left_brace.end_pos, args_delimiter.begin_pos,
                       'Space between { and | detected.')
             end
           else
@@ -101,6 +101,10 @@ module RuboCop
           end
         end
 
+        def pipe?(args_delimiter)
+          args_delimiter && args_delimiter.is?('|')
+        end
+
         def space_inside_right_brace(right_brace, sb)
           brace_with_space = range_with_surrounding_space(right_brace, :left)
           space(sb, brace_with_space.begin_pos, brace_with_space.end_pos - 1,