rubocop 0.31.0 → 0.35.0

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

@@ -29,16 +29,45 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
+            unless arguments?(node.children)
+              corrector.replace(node.loc.expression, 'nil')
+              next
+            end
+
+            return_value, = *node
             if node.children.size > 1
-              kids = node.children.map { |child| child.loc.expression }
-              corrector.insert_before(kids.first, '[')
-              corrector.insert_after(kids.last, ']')
+              add_brackets(corrector, node)
+            elsif return_value.hash_type?
+              add_braces(corrector, return_value) unless braces?(return_value)
             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 { |child| child.loc.expression }
+          corrector.insert_before(kids.first, '[')
+          corrector.insert_after(kids.last, ']')
+        end
+
+        def add_braces(corrector, node)
+          kids = node.children.map { |child| child.loc.expression }
+          corrector.insert_before(kids.first, '{')
+          corrector.insert_after(kids.last, '}')
+        end
+
+        def arguments?(args)
+          return false if args.empty?
+          return true if args.size > 1
+
+          !args.first.begin_type? || !args.first.children.empty?
+        end
+
         def on_method_def(_node, _method_name, _args, body)
           return unless body
 

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/rescue_ensure_alignment.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks whether the rescue and ensure keywords are aligned
+      # properly.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #     rescue
+      #     puts 'error'
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue
+      #     puts 'error'
+      #   end
+      class RescueEnsureAlignment < Cop
+        MSG = '`%s` at %d, %d is not aligned with `end` at %d, %d.'
+
+        def on_resbody(node)
+          check(node) unless modifier?(node)
+        end
+
+        def on_ensure(node)
+          check(node)
+        end
+
+        def investigate(processed_source)
+          @modifier_locations =
+            processed_source.tokens.each_with_object([]) do |token, locations|
+              next unless token.type == :kRESCUE_MOD
+              locations << token.pos
+            end
+        end
+
+        def autocorrect(node)
+          source_buffer = node.loc.keyword.source_buffer
+          begin_pos = node.loc.keyword.begin_pos
+          current_column = node.loc.keyword.column
+          whitespace = Parser::Source::Range.new(source_buffer,
+                                                 begin_pos - current_column,
+                                                 begin_pos)
+          return false unless whitespace.source.strip.empty?
+
+          new_column = ancestor_node(node).loc.end.column
+          ->(corrector) { corrector.replace(whitespace, ' ' * new_column) }
+        end
+
+        private
+
+        def check(node)
+          end_loc = ancestor_node(node).loc.end
+          return if end_loc.column == node.loc.keyword.column
+          return if end_loc.line == node.loc.keyword.line
+
+          kw_loc = node.loc.keyword
+
+          add_offense(node, kw_loc,
+                      format(MSG, kw_loc.source, kw_loc.line, kw_loc.column,
+                             end_loc.line, end_loc.column))
+        end
+
+        def modifier?(node)
+          return false unless @modifier_locations.respond_to?(:include?)
+          @modifier_locations.include?(node.loc.keyword)
+        end
+
+        def ancestor_node(node)
+          node.each_ancestor(:kwbegin, :def, :defs).first
+        end
+      end
+    end
+  end
+end

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

@@ -5,37 +5,45 @@ module RuboCop
     module Style
       # This cop checks for uses of rescue in its modifier form.
       class RescueModifier < Cop
-        include OnMethodDef
+        include AutocorrectAlignment
 
         MSG = 'Avoid using `rescue` in its modifier form.'
 
-        def on_rescue(node)
-          return if ignored_node?(node)
-
-          add_offense(node, :expression)
+        def investigate(processed_source)
+          @modifier_locations = processed_source.tokens
+                                .select { |t| t.type == :kRESCUE_MOD }
+                                .map(&:pos)
         end
 
-        def on_kwbegin(node)
-          body, *_ = *node
-          check(body)
+        def on_resbody(node)
+          return unless modifier?(node)
+          add_offense(node.parent, :expression)
         end
 
-        def on_method_def(_node, _method_name, _args, body)
-          check(body)
+        def autocorrect(node)
+          operation, rescue_modifier, = *node
+          *_, rescue_args = *rescue_modifier
+
+          correction =
+            "begin\n" <<
+            indentation(node) << operation.loc.expression.source <<
+            "\n#{offset(node)}rescue\n" <<
+            indentation(node) << rescue_args.loc.expression.source <<
+            "\n#{offset(node)}end"
+          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                            node.loc.expression.begin_pos,
+                                            node.loc.expression.end_pos)
+
+          lambda do |corrector|
+            corrector.replace(range, correction)
+          end
         end
 
-        def check(body)
-          return unless body
-
-          case body.type
-          when :rescue
-            ignore_node(body)
-          when :ensure
-            first_child = body.children.first
-            if first_child && first_child.type == :rescue
-              ignore_node(first_child)
-            end
-          end
+        private
+
+        def modifier?(node)
+          return false unless @modifier_locations.respond_to?(:include?)
+          @modifier_locations.include?(node.loc.keyword)
         end
       end
     end

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

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the use of the send method.
+      class Send < Cop
+        MSG = 'Prefer `Object#__send__` or `Object#public_send` to `send`.'
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return unless method_name == :send && args.length > 0
+          add_offense(node, :selector)
+        end
+      end
+    end
+  end
+end

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

@@ -37,7 +37,8 @@ module RuboCop
           lambda do |corrector|
             name =
               case style
-              when :semantic then command?(:raise, node) ? 'fail' : 'raise'
+              when :semantic
+                command_or_kernel_call?(:raise, node) ? 'fail' : 'raise'
               when :only_raise then 'raise'
               when :only_fail then 'fail'
               end
@@ -63,30 +64,42 @@ module RuboCop
           return unless node
 
           if style == :semantic
-            each_command(method_name, node) do |send_node|
+            each_command_or_kernel_call(method_name, node) do |send_node|
               next if ignored_node?(send_node)
 
               add_offense(send_node, :selector, message(method_name))
               ignore_node(send_node)
             end
-          else
-            _receiver, selector, _args = *node
-
-            if [:raise, :fail].include?(selector) && selector != method_name
-              add_offense(node, :selector, message(method_name))
-            end
+          elsif command_or_kernel_call?(method_name == :raise ? :fail : :raise,
+                                        node)
+            add_offense(node, :selector, message(method_name))
           end
         end
 
+        def command_or_kernel_call?(name, node)
+          command?(name, node) || kernel_call?(name, node)
+        end
+
+        def kernel_call?(name, node)
+          return false unless node.type == :send
+          receiver, selector, _args = *node
+
+          return false unless name == selector
+          return false unless receiver.const_type?
+
+          _, constant = *receiver
+          constant == :Kernel
+        end
+
         def allow(method_name, node)
-          each_command(method_name, node) do |send_node|
+          each_command_or_kernel_call(method_name, node) do |send_node|
             ignore_node(send_node)
           end
         end
 
-        def each_command(method_name, node)
+        def each_command_or_kernel_call(method_name, node)
           on_node(:send, node, :rescue) do |send_node|
-            yield send_node if command?(method_name, send_node)
+            yield send_node if command_or_kernel_call?(method_name, send_node)
           end
         end
       end

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

@@ -6,6 +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 AutocorrectAlignment
         include OnMethodDef
 
         MSG = 'Avoid single-line method definitions.'
@@ -33,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)
@@ -55,10 +58,6 @@ module RuboCop
           )
         end
 
-        def configured_indentation_width
-          config.for_cop('IndentationWidth')['Width']
-        end
-
         def move_comment(eol_comment, node, corrector)
           text = eol_comment.loc.expression.source
           corrector.insert_before(node.loc.expression,

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/space_inside_string_interpolation.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for whitespace within string interpolations.
+      #
+      # @example
+      #   # Good if EnforcedStyle is no_space, bad if space.
+      #      var = "This is the #{no_space} example"
+      #
+      #   # Good if EnforceStyle is space, bad if no_space.
+      #      var = "This is the #{ space } example"
+      class SpaceInsideStringInterpolation < Cop
+        include ConfigurableEnforcedStyle
+
+        NO_SPACE_MSG = 'Space inside string interpolation detected.'
+        SPACE_MSG = 'Missing space around string interpolation detected.'
+
+        def on_dstr(node)
+          node.children.select { |n| n.type == :begin }.each do |begin_node|
+            final_node = begin_node.children.last
+            next unless final_node
+
+            interp = final_node.loc.expression
+            interp_with_surrounding_space = range_with_surrounding_space(interp)
+            if style == :no_space
+              if interp_with_surrounding_space != interp
+                add_offense(final_node, :expression, NO_SPACE_MSG)
+              end
+            elsif style == :space
+              if interp_with_surrounding_space.source != " #{interp.source} "
+                add_offense(final_node, :expression, SPACE_MSG)
+              end
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(node)
+          if style == :no_space
+            lambda do |corrector|
+              corrector.replace(
+                range_with_surrounding_space(node.loc.expression),
+                node.loc.expression.source
+              )
+            end
+          elsif style == :space
+            lambda do |corrector|
+              corrector.replace(
+                range_with_surrounding_space(node.loc.expression),
+                " #{node.loc.expression.source} "
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop enforces the use of consistent method names
+      # from the String class.
+      class StringMethods < Cop
+        include MethodPreference
+
+        MSG = 'Prefer `%s` over `%s`.'
+
+        def on_send(node)
+          _receiver, method_name, *_args = *node
+          return unless preferred_methods[method_name]
+          add_offense(node, :selector,
+                      format(MSG,
+                             preferred_method(method_name),
+                             method_name)
+                     )
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector,
+                              preferred_method(node.loc.selector.source))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -25,16 +25,17 @@ module RuboCop
         private
 
         def struct_constructor?(node)
-          if node && node.send_type?
-            receiver, method_name = *node
-
-            receiver &&
-              receiver.const_type? &&
-              receiver.children.last == :Struct &&
-              method_name == :new
-          else
-            false
-          end
+          return false unless node
+
+          send_node = node.block_type? ? node.children.first : node
+          return false unless send_node.send_type?
+
+          receiver, method_name = *send_node
+
+          receiver &&
+            receiver.const_type? &&
+            receiver.children.last == :Struct &&
+            method_name == :new
         end
       end
     end

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

@@ -27,7 +27,7 @@ module RuboCop
           lambda do |corrector|
             current_name = node.loc.expression.source
             corrector.replace(node.loc.expression,
-                              current_name.gsub(/["']/, ''))
+                              current_name.delete(%q('")))
           end
         end
       end