rubocop 0.13.1 → 0.14.0

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

@@ -13,24 +13,49 @@ module Rubocop
       #  # good
       #  lambda.call(x, y)
       class LambdaCall < Cop
-        MSG = 'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
-
         def on_send(node)
           _receiver, selector, = *node
 
-          # lambda.() does not have a selector
-          return unless selector == :call && node.loc.selector.nil?
+          # we care only about `call` methods
+          return unless selector == :call
 
-          convention(node, :expression)
+          if style == :call && node.loc.selector.nil?
+            # lambda.() does not have a selector
+            convention(node, :expression)
+          elsif style == :braces && node.loc.selector
+            convention(node, :expression)
+          end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            receiver_node, = *node
-            expr = node.loc.expression
-            receiver = receiver_node.loc.expression.source
-            replacement = expr.source.sub("#{receiver}.", "#{receiver}.call")
-            corrector.replace(expr, replacement)
+            if style == :call
+              receiver_node, = *node
+              expr = node.loc.expression
+              receiver = receiver_node.loc.expression.source
+              replacement = expr.source.sub("#{receiver}.", "#{receiver}.call")
+              corrector.replace(expr, replacement)
+            else
+              corrector.remove(node.loc.selector)
+            end
+          end
+        end
+
+        def message(node)
+          if style == :call
+            'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'
+          else
+            'Prefer the use of `lambda.(...)` over `lambda.call(...)`.'
+          end
+        end
+
+        private
+
+        def style
+          case cop_config['EnforcedStyle']
+          when 'call' then :call
+          when 'braces' then :braces
+          else fail 'Unknown style selected!'
           end
         end
       end

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

@@ -13,7 +13,7 @@ module Rubocop
           convention(node, :begin) if args.empty? && node.loc.begin
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.remove(node.loc.begin)
             corrector.remove(node.loc.end)

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for methods called on a do...end block. The point of
+      # this check is that it's easy to miss the call tacked on to the block
+      # when reading code.
+      #
+      # @example
+      #
+      # a do
+      #   b
+      # end.c
+      class MethodCalledOnDoEndBlock < Cop
+        MSG = 'Avoid chaining a method call on a do...end block.'
+
+        def on_block(node)
+          method, _args, _body = *node
+          # If the method that is chained on the do...end block is itself a
+          # method with a block, we allow it. It's pretty safe to assume that
+          # these calls are not missed by anyone reading code. We also want to
+          # avoid double reporting of offences checked by the
+          # MultilineBlockChain cop.
+          ignore_node(method)
+        end
+
+        def on_send(node)
+          return if ignored_node?(node)
+          receiver, _method_name, *_args = *node
+          if receiver && receiver.type == :block && receiver.loc.end.is?('end')
+            range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
+                                              receiver.loc.end.begin_pos,
+                                              node.loc.expression.end_pos)
+            convention(nil, range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -28,25 +28,14 @@ module Rubocop
         private
 
         def check(node)
-          method_length = calculate_length(node.loc.expression.source)
+          method_length = Util.source_length(node.loc.expression.source,
+                                             count_comments?)
 
           if method_length > max_length
             message = sprintf(MSG, method_length, max_length)
             convention(node, :keyword, message)
           end
         end
-
-        def calculate_length(source)
-          lines = source.lines.to_a[1...-1]
-
-          return 0 unless lines
-
-          lines.reject!(&:blank?)
-
-          lines.reject! { |line| line =~ /^\s*#/ } unless count_comments?
-
-          lines.size
-        end
       end
     end
   end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop makes sure that all methods use the configured style,
+      # snake_case or camelCase, for their names. Some special arrangements
+      # have to be made for operator methods.
+      class MethodName < Cop
+        include ConfigurableNaming
+
+        def on_def(node)
+          check(node, name_of_instance_method(node))
+        end
+
+        def on_defs(node)
+          check(node, name_of_singleton_method(node))
+        end
+
+        def name_of_instance_method(def_node)
+          expr = def_node.loc.expression
+          match = /^def(\s+)([\w]+[!?=]?\b)/.match(expr.source)
+          return unless match
+          space, method_name = match.captures
+          begin_pos = expr.begin_pos + 'def'.length + space.length
+          Parser::Source::Range.new(expr.source_buffer, begin_pos,
+                                    begin_pos + method_name.length)
+        end
+
+        def name_of_singleton_method(defs_node)
+          scope, method_name, _args, _body = *defs_node
+          after_dot(defs_node, method_name.length,
+                    "def\s+" + Regexp.escape(scope.loc.expression.source))
+        end
+
+        def message(style)
+          format('Use %s for methods.', style)
+        end
+      end
+    end
+  end
+end

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

@@ -30,6 +30,10 @@ module Rubocop
 
           if enough_digits?(value)
             int = integer_part(node)
+
+            # TODO: handle non-decimal literals as well
+            return if int.start_with?('0')
+
             if int =~ /\d{4}/ || int =~ /_\d{1,2}_/
               convention(node, :expression)
             end

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

@@ -12,7 +12,7 @@ module Rubocop
           convention(node, :expression)
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             backref, = *node
 

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

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks the args passed to `fail` and `raise`.
+      class RaiseArgs < Cop
+        def on_send(node)
+          return unless command?(:raise, node) || command?(:fail, node)
+
+          case style
+          when :compact
+            check_compact(node)
+          when :exploded
+            check_exploded(node)
+          end
+        end
+
+        private
+
+        def check_compact(node)
+          _receiver, selector, *args = *node
+
+          return unless args.size > 1
+
+          convention(node, :expression, message(selector))
+        end
+
+        def check_exploded(node)
+          _receiver, selector, *args = *node
+
+          return unless args.size == 1
+
+          arg, = *args
+
+          if arg.type == :send && arg.loc.selector.is?('new')
+            convention(node, :expression, message(selector))
+          end
+        end
+
+        def style
+          case cop_config['EnforcedStyle']
+          when 'compact' then :compact
+          when 'exploded' then :exploded
+          else fail 'Unknown style selected!'
+          end
+        end
+
+        def message(method)
+          case style
+          when :compact
+            "Provide an exception object as an argument to #{method}."
+          when :exploded
+            "Provide an exception class and message as arguments to #{method}."
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for RuntimeError as the argument of raise/fail.
+      #
+      # Currently it checks for code like this:
+      #
+      # @example
+      #
+      #   raise RuntimeError, 'message'
+      class RedundantException < Cop
+        MSG = 'Redundant `RuntimeError` argument can be removed.'
+
+        TARGET_NODE = s(:const, nil, :RuntimeError)
+
+        def on_send(node)
+          return unless command?(:raise, node) || command?(:fail, node)
+
+          _receiver, _selector, *args = *node
+
+          return unless args.size == 2
+
+          first_arg, = *args
+
+          convention(first_arg, :expression) if first_arg == TARGET_NODE
+        end
+      end
+    end
+  end
+end

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

@@ -37,10 +37,12 @@ module Rubocop
 
         private
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            corrector.replace(node.loc.expression,
-                              node.loc.expression.source.sub('return ', ''))
+            expr = node.loc.expression
+            replacement = expr.source.sub(/return\s*/, '')
+            replacement = "[#{replacement}]" if node.children.size > 1
+            corrector.replace(expr, replacement)
           end
         end
 
@@ -48,16 +50,23 @@ module Rubocop
           return unless node
 
           if node.type == :return
-            convention(node, :keyword)
+            check_return_node(node)
           elsif node.type == :begin
             expressions = *node
             last_expr = expressions.last
 
             if last_expr && last_expr.type == :return
-              convention(last_expr, :keyword)
+              check_return_node(last_expr)
             end
           end
         end
+
+        def check_return_node(node)
+          return if cop_config['AllowMultipleReturnValues'] &&
+            node.children.size > 1
+
+          convention(node, :keyword)
+        end
       end
     end
   end

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

@@ -101,7 +101,7 @@ module Rubocop
           end
         end
 
-        def autocorrect_action(node)
+        def autocorrect(node)
           @corrections << lambda do |corrector|
             corrector.replace(node.loc.expression,
                               node.loc.expression.source.gsub(/self\./, ''))

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

@@ -11,6 +11,15 @@ module Rubocop
         def investigate(processed_source)
           return unless processed_source.ast
 
+          unless cop_config['AllowAsExpressionSeparator']
+            check_for_expr_separator(processed_source)
+          end
+          check_for_line_terminator(processed_source)
+        end
+
+        private
+
+        def check_for_expr_separator(processed_source)
           on_node(:begin, processed_source.ast) do |node|
             exprs = node.children
 
@@ -30,12 +39,13 @@ module Rubocop
                 convention(nil,
                            source_range(processed_source.buffer,
                                         processed_source[0...(line - 1)],
-                                        column, 1),
-                           MSG)
+                                        column, 1))
               end
             end
           end
+        end
 
+        def check_for_line_terminator(processed_source)
           tokens_for_lines = processed_source.tokens.group_by do |token|
             token.pos.line
           end
@@ -46,8 +56,7 @@ module Rubocop
               convention(nil,
                          source_range(processed_source.buffer,
                                       processed_source[0...(line - 1)],
-                                      column, 1),
-                         MSG)
+                                      column, 1))
             end
           end
         end

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

@@ -9,38 +9,87 @@ module Rubocop
         RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
 
         def on_rescue(node)
-          begin_node, rescue_node = *node
+          if style == :semantic
+            begin_node, rescue_node = *node
 
-          check_for_raise(begin_node)
-          check_for_fail(rescue_node)
+            check_for(:raise, begin_node)
+            check_for(:fail, rescue_node)
+            allow(:raise, rescue_node)
+          end
         end
 
-        def autocorrect_action(node)
+        def on_send(node)
+          case style
+          when :semantic
+            check_for(:raise, node) unless ignored_node?(node)
+          when :raise
+            check_for(:raise, node)
+          when :fail
+            check_for(:fail, node)
+          end
+        end
+
+        def autocorrect(node)
           @corrections << lambda do |corrector|
-            name = command?(:raise, node) ? 'fail' : 'raise'
+            name =
+              case style
+              when :semantic then command?(:raise, node) ? 'fail' : 'raise'
+              when :raise then 'raise'
+              when :fail then 'fail'
+              end
+
             corrector.replace(node.loc.selector, name)
           end
         end
 
         private
 
-        def check_for_raise(node)
+        def style
+          case cop_config['EnforcedStyle']
+          when 'only_raise' then :raise
+          when 'only_fail' then :fail
+          when 'semantic' then :semantic
+          else fail 'Unknown style selected!'
+          end
+        end
+
+        def message(method_name)
+          case style
+          when :semantic
+            method_name == :fail ? RAISE_MSG : FAIL_MSG
+          when :raise
+            'Always use `raise` to signal exceptions.'
+          when :fail
+            'Always use `fail` to signal exceptions.'
+          end
+        end
+
+        def check_for(method_name, node)
           return unless node
 
-          on_node(:send, node, :rescue) do |send_node|
-            if command?(:raise, send_node)
-              convention(send_node, :selector, FAIL_MSG)
+          if style == :semantic
+            each_command(method_name, node) do |send_node|
+              convention(send_node, :selector, message(method_name))
+              ignore_node(send_node)
+            end
+          else
+            _receiver, selector, _args = *node
+
+            if [:raise, :fail].include?(selector) && selector != method_name
+              convention(node, :selector, message(method_name))
             end
           end
         end
 
-        def check_for_fail(node)
-          return unless node
+        def allow(method_name, node)
+          each_command(method_name, node) do |send_node|
+            ignore_node(send_node)
+          end
+        end
 
+        def each_command(method_name, node)
           on_node(:send, node, :rescue) do |send_node|
-            if command?(:fail, send_node)
-              convention(send_node, :selector, RAISE_MSG)
-            end
+            yield send_node if command?(method_name, send_node)
           end
         end
       end