rubocop 0.10.0 → 0.11.0

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

@@ -0,0 +1,34 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cops checks for use of `extend self` in a module.
+      #
+      # @example
+      #
+      # module Test
+      #   extend self
+      #
+      #   ...
+      # end
+      class ModuleFunction < Cop
+        MSG = 'Use `module_function` instead of `extend self`.'
+
+        TARGET_NODE = s(:send, nil, :extend, s(:self))
+
+        def on_module(node)
+          _name, body = *node
+
+          if body && body.type == :begin
+            body.children.each do |body_node|
+              if body_node == TARGET_NODE
+                add_offence(:convention, body_node.loc.expression, MSG)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,18 +5,16 @@ module Rubocop
     module Style
       # Checks for uses of the `then` keyword in multi-line if statements.
       #
-      # This is considered bad practice:
-      # @example
+      # @example This is considered bad practice:
       #
-      # if cond then
-      # end
+      #   if cond then
+      #   end
       #
-      # While if statements can contain `then` on the same line:
-      # @example
+      # @example If statements can contain `then` on the same line:
       #
-      # if cond then a
-      # elsif cond then b
-      # end
+      #   if cond then a
+      #   elsif cond then b
+      #   end
       class MultilineIfThen < Cop
         include IfThenElse
 

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

@@ -9,14 +9,14 @@ module Rubocop
       #
       # @example
       #
-      # def test
-      #   begin
-      #     ala
-      #     bala
-      #   rescue StandardError => e
-      #     something
+      #   def test
+      #     begin
+      #       ala
+      #       bala
+      #     rescue StandardError => e
+      #       something
+      #     end
       #   end
-      # end
       class RedundantBegin < Cop
         MSG = 'Redundant `begin` block detected.'
 

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

@@ -5,20 +5,18 @@ module Rubocop
     module Style
       # This cop checks for redundant `return` expressions.
       #
-      # Currently it checks for code like this:
-      #
       # @example
       #
-      # def test
-      #   return something
-      # end
+      #   def test
+      #     return something
+      #   end
       #
-      # def test
-      #   one
-      #   two
-      #   three
-      #   return something
-      # end
+      #   def test
+      #     one
+      #     two
+      #     three
+      #     return something
+      #   end
       #
       # It should be extended to handle methods whose body is if/else
       # or a case expression with a default branch.

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

@@ -68,7 +68,11 @@ module Rubocop
         end
 
         def keyword?(method_name)
-          [:class, :for].include?(method_name)
+          [:alias, :and, :begin, :break, :case, :class, :def, :defined, :do,
+           :else, :elsif, :end, :ensure, :false, :for, :if, :in, :module,
+           :next, :nil, :not, :or, :redo, :rescue, :retry, :return, :self,
+           :super, :then, :true, :undef, :unless, :until, :when, :while,
+           :yield].include?(method_name)
         end
 
         def allow_self(node)

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

@@ -8,9 +8,10 @@ module Rubocop
       # value of the configuration parameter MaxSlashes.
       class RegexpLiteral < Cop
         def on_regexp(node)
-          slashes = node.loc.expression.source[1...-1].scan(/\//).size
+          slashes = node.loc.expression.source.count('/')
           max = RegexpLiteral.max_slashes
           msg = if node.loc.begin.is?('/')
+                  slashes -= 2 # subtract delimiters
                   error_message('') if slashes > max
                 else
                   error_message('only ') if slashes <= max

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for uses of `fail` and `raise`.
+      class SignalException < Cop
+        FAIL_MSG = 'Use `fail` instead of `raise` to signal exceptions.'
+        RAISE_MSG = 'Use `raise` instead of `fail` to rethrow exceptions.'
+
+        def on_rescue(node)
+          begin_node, rescue_node = *node
+
+          check_for_raise(begin_node)
+          check_for_fail(rescue_node)
+        end
+
+        def check_for_raise(node)
+          return unless node
+
+          on_node(:send, node, :rescue) do |send_node|
+            if command?(:raise, send_node)
+              add_offence(:convention, send_node.loc.selector, FAIL_MSG)
+            end
+          end
+        end
+
+        def check_for_fail(node)
+          return unless node
+
+          on_node(:send, node, :rescue) do |send_node|
+            if command?(:fail, send_node)
+              add_offence(:convention, send_node.loc.selector, RAISE_MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -17,8 +17,8 @@ module Rubocop
           # regex matches IF there is a ' or there is a \\ in the string that
           # is not preceeded/followed by another \\ (e.g. "\\x34") but not
           # "\\\\"
-          if node.loc.expression.source !~ /('|([^\\]|\A)\\([^\\]|\Z))/ &&
-              node.loc.begin.is?('"')
+          if node.loc.expression.source !~ /' | (?<! \\) \\{2}* \\ (?! \\)/x &&
+              node.loc.begin && node.loc.begin.is?('"')
             add_offence(:convention, node.loc.expression, MSG)
             do_autocorrect(node)
           end

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

@@ -14,7 +14,18 @@ module Rubocop
           self.class.config['AllowCamelCase']
         end
 
+        def on_send(node)
+          receiver, method_name, *args = *node
+          # Arguments to Module#private_constant are symbols referring to
+          # existing constants, so they will start with an upper case letter.
+          # We ignore these symbols.
+          if receiver.nil? && method_name == :private_constant
+            args.each { |a| ignore_node(a) }
+          end
+        end
+
         def on_sym(node)
+          return if ignored_node?(node)
           sym_name = node.to_a[0]
           return unless sym_name =~ /^[a-zA-Z]/
           return if sym_name =~ SNAKE_CASE

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

@@ -43,27 +43,39 @@ module Rubocop
           TrivialAccessors.config['AllowPredicates']
         end
 
+        def whitelist
+          whitelist = TrivialAccessors.config['Whitelist']
+          Array(whitelist).map(&:to_sym) + [:initialize]
+        end
+
         def predicate?(method_name)
           method_name[-1] == '?'
         end
 
         def trivial_reader?(method_name, args, body)
-          return false unless args.children.size == 0
-
-          return false unless body && body.type == :ivar
-
-          return false if allow_predicates? && predicate?(method_name)
+          looks_like_trivial_reader?(args, body) &&
+            !allowed_method?(method_name, body)
+        end
 
-          exact_name_match? ? names_match?(method_name, body) : true
+        def looks_like_trivial_reader?(args, body)
+          args.children.size == 0 && body && body.type == :ivar
         end
 
         def trivial_writer?(method_name, args, body)
-          return false unless args.children.size == 1 &&
+          looks_like_trivial_writer?(args, body) &&
+            !allowed_method?(method_name, body)
+        end
+
+        def looks_like_trivial_writer?(args, body)
+          args.children.size == 1 &&
             body && body.type == :ivasgn &&
-            body.children[1] && body.children[1].type == :lvar &&
-            method_name != :initialize
+            body.children[1] && body.children[1].type == :lvar
+        end
 
-          exact_name_match? ? names_match?(method_name, body) : true
+        def allowed_method?(method_name, body)
+          allow_predicates? && predicate?(method_name) ||
+            whitelist.include?(method_name) ||
+            exact_name_match? && !names_match?(method_name, body)
         end
 
         def names_match?(method_name, body)

data/lib/rubocop/cop/variable_inspector.rb

@@ -122,29 +122,105 @@ module Rubocop
 
       # This provides a way to scan all nodes only in current scope.
       class NodeScanner
+        TWISTED_SCOPE_NODE_TYPES = [:block, :sclass, :defs].freeze
+        POST_CONDITION_LOOP_NODE_TYPES = [:while_post, :until_post].freeze
+
         def self.scan_nodes_in_scope(origin_node, &block)
-          new.scan_nodes_in_scope(origin_node, &block)
+          instance = new(block)
+          instance.scan_nodes_in_scope(origin_node)
         end
 
-        def initialize
-          @node_index = -1
+        def initialize(callback)
+          @callback = callback
         end
 
-        def scan_nodes_in_scope(origin_node, &block)
-          origin_node.children.each do |child|
-            next unless child.is_a?(Parser::AST::Node)
+        def scan_nodes_in_scope(origin_node, yield_origin_node = false)
+          @callback.call(origin_node) if yield_origin_node
 
+          origin_node.children.each_with_index do |child, index|
+            next unless child.is_a?(Parser::AST::Node)
             node = child
-            @node_index += 1
-
-            catch(:skip_children) do
-              yield node, @node_index
 
-              # Do not go into inner scope.
-              unless SCOPE_TYPES.include?(node.type)
-                scan_nodes_in_scope(node, &block)
-              end
+            if index == 0 &&
+               TWISTED_SCOPE_NODE_TYPES.include?(origin_node.type)
+              next
             end
+
+            @callback.call(node)
+
+            scan_children(node)
+          end
+        end
+
+        def scan_children(node)
+          case node.type
+          when *POST_CONDITION_LOOP_NODE_TYPES
+            # Loop body nodes need to be scanned first.
+            #
+            # Ruby:
+            #   begin
+            #     foo = 1
+            #   end while foo > 10
+            #   puts foo
+            #
+            # AST:
+            #   (begin
+            #     (while-post
+            #       (send
+            #         (lvar :foo) :>
+            #         (int 10))
+            #       (kwbegin
+            #         (lvasgn :foo
+            #           (int 1))))
+            #     (send nil :puts
+            #       (lvar :foo)))
+            scan_nodes_in_scope(node.children[1], true)
+            scan_nodes_in_scope(node.children[0], true)
+          when *TWISTED_SCOPE_NODE_TYPES
+            # The variable foo belongs to the top level scope,
+            # but in AST, it's under the block node.
+            #
+            # Ruby:
+            #   some_method(foo = 1) do
+            #   end
+            #   puts foo
+            #
+            # AST:
+            #   (begin
+            #     (block
+            #       (send nil :some_method
+            #         (lvasgn :foo
+            #           (int 1)))
+            #       (args) nil)
+            #     (send nil :puts
+            #       (lvar :foo)))
+            #
+            # So the the method argument nodes need to be processed
+            # in current scope.
+            #
+            # Same thing.
+            #
+            # Ruby:
+            #   instance = Object.new
+            #   class << instance
+            #     foo = 1
+            #   end
+            #
+            # AST:
+            #   (begin
+            #     (lvasgn :instance
+            #       (send
+            #         (const nil :Object) :new))
+            #     (sclass
+            #       (lvar :instance)
+            #       (begin
+            #         (lvasgn :foo
+            #           (int 1))
+            scan_nodes_in_scope(node.children.first, true)
+          when *SCOPE_TYPES
+            # Do not go into inner scope.
+          else
+            scan_nodes_in_scope(node)
           end
         end
       end
@@ -169,16 +245,8 @@ module Rubocop
       def inspect_variables_in_scope(scope_node)
         variable_table.push_scope(scope_node)
 
-        NodeScanner.scan_nodes_in_scope(scope_node) do |node, index|
-          if scope_node.type == :block && index == 0 && node.type == :send
-            # Avoid processing method argument nodes of outer scope
-            # in current block scope.
-            # See #process_node.
-            throw :skip_children
-          elsif [:sclass, :defs].include?(scope_node.type) && index == 0
-            throw :skip_children
-          end
-
+        NodeScanner.scan_nodes_in_scope(scope_node) do |node|
+          # puts "scope:#{variable_table.current_scope_level} node:#{node}"
           process_node(node)
         end
 
@@ -202,53 +270,6 @@ module Rubocop
                  "at #{node.loc.expression}, #{node.inspect}"
           end
           variable_entry.used = true
-        when :block
-          # The variable foo belongs to the top level scope,
-          # but in AST, it's under the block node.
-          #
-          # Ruby:
-          #   some_method(foo = 1) do
-          #   end
-          #   puts foo
-          #
-          # AST:
-          #   (begin
-          #     (block
-          #       (send nil :some_method
-          #         (lvasgn :foo
-          #           (int 1)))
-          #       (args) nil)
-          #     (send nil :puts
-          #       (lvar :foo)))
-          #
-          # So the nodes of the method argument need to be processed
-          # in current scope before dive into the block scope.
-          NodeScanner.scan_nodes_in_scope(node.children.first) do |n|
-            process_node(n)
-          end
-          # Now go into the block scope.
-          inspect_variables_in_scope(node)
-        when :sclass, :defs
-          # Same thing.
-          #
-          # Ruby:
-          #   instance = Object.new
-          #   class << instance
-          #     foo = 1
-          #   end
-          #
-          # AST:
-          #   (begin
-          #     (lvasgn :instance
-          #       (send
-          #         (const nil :Object) :new))
-          #     (sclass
-          #       (lvar :instance)
-          #       (begin
-          #         (lvasgn :foo
-          #           (int 1))
-          process_node(node.children.first)
-          inspect_variables_in_scope(node)
         when *SCOPE_TYPES
           inspect_variables_in_scope(node)
         end