rubocop 0.8.3 → 0.9.0

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for trailing whitespace in the source code.
+      class TrailingWhitespace < Cop
+        MSG = 'Trailing whitespace detected.'
+
+        def inspect(source_buffer, source, tokens, ast, comments)
+          source.each_with_index do |line, index|
+            if line =~ /.*[ \t]+$/
+              add_offence(:convention,
+                          source_range(source_buffer, source[0...index],
+                                       line.rstrip.length,
+                                       line.length - line.rstrip.length),
+                          MSG)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for trivial reader/writer methods, that could
+      # have been created with the attr_* family of functions automatically.
+      class TrivialAccessors < Cop
+        MSG = 'Use attr_%s to define trivial %s methods.'
+
+        def on_def(node)
+          method_name, args, body = *node
+
+          kind = if body && body.type == :ivar
+                   'reader'
+                 elsif args.children.size == 1 &&
+                       body && body.type == :ivasgn &&
+                       body.children[1] && body.children[1].type == :lvar &&
+                       method_name != :initialize
+                   'writer'
+                 end
+          if kind
+            add_offence(:convention, node.loc.keyword,
+                        sprintf(MSG, kind, kind))
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop looks for *unless* expressions with *else* clauses.
+      class UnlessElse < Cop
+        MSG = 'Never use unless with else. Rewrite these with the ' +
+          'positive case first.'
+
+        def on_if(node)
+          loc = node.loc
+
+          # discard ternary ops and modifier if/unless nodes
+          return unless loc.respond_to?(:keyword) && loc.respond_to?(:else)
+
+          if loc.keyword.is?('unless') && loc.else
+            add_offence(:convention, loc.expression, MSG)
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for variable interpolation (like "#@ivar").
+      class VariableInterpolation < Cop
+        MSG = 'Replace interpolated var %s with expression #{%s}.'
+
+        def on_dstr(node)
+          var_nodes(node.children).each do |v|
+            var = (v.type == :nth_ref ? '$' : '') + v.to_a[0].to_s
+
+            if node.loc.expression.source.include?("##{var}")
+              add_offence(:convention,
+                          v.loc.expression,
+                          sprintf(MSG, var, var))
+            end
+          end
+
+          super
+        end
+
+        private
+
+        def var_nodes(nodes)
+          nodes.select { |n| [:ivar, :cvar, :gvar, :nth_ref].include?(n.type) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for *when;* uses in *case* expressions.
+      class WhenThen < Cop
+        MSG = 'Never use "when x;". Use "when x then" instead.'
+
+        def on_when(node)
+          if node.loc.begin && node.loc.begin.is?(';')
+            add_offence(:convention, node.loc.begin, MSG)
+            do_autocorrect(node)
+          end
+
+          super
+        end
+
+        def autocorrect_action(node)
+          replace(node.loc.begin, ' then')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # Checks for uses of `do` in multi-line `while/until` statements.
+      class WhileUntilDo < Cop
+        def on_while(node)
+          handle(node)
+
+          super
+        end
+
+        def on_until(node)
+          handle(node)
+
+          super
+        end
+
+        def handle(node)
+          length = node.loc.expression.source.lines.to_a.size
+
+          if length > 1
+            if node.loc.begin && node.loc.begin.is?('do')
+              add_offence(:convention,
+                          node.loc.begin,
+                          error_message(node.type))
+              do_autocorrect(node)
+            end
+          end
+        end
+
+        private
+
+        def error_message(node_type)
+          format('Never use `do` with multi-line `%s`.', node_type)
+        end
+
+        def autocorrect_action(node)
+          remove(node.loc.begin)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module Style
+      # This cop checks for array literals made up of word-like
+      # strings, that are not using the %w() syntax.
+      class WordArray < Cop
+        MSG = 'Use %w or %W for array of words.'
+
+        def on_array(node)
+          return unless node.loc.begin && node.loc.begin.is?('[')
+
+          array_elems = node.children
+
+          # no need to check empty arrays
+          return unless array_elems && array_elems.size > 1
+
+          string_array = array_elems.all? { |e| e.type == :str }
+
+          if string_array && !complex_content?(array_elems)
+            add_offence(:convention, node.loc.expression, MSG)
+          end
+
+          super
+        end
+
+        private
+
+        def complex_content?(arr_sexp)
+          arr_sexp.each do |s|
+            source = s.loc.expression.source
+            unless source.start_with?('?') # %W(\r \n) can replace [?\r, ?\n]
+              str_content = Util.strip_quotes(source)
+              return true unless str_content =~ /\A[\w-]+\z/
+            end
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/util.rb

@@ -2,6 +2,7 @@
 
 module Rubocop
   module Cop
+    # This module contains a collection of useful utility methods.
     module Util
       module_function
 

data/lib/rubocop/cop/variable_inspector.rb

@@ -0,0 +1,280 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    # This module provides a way to track local variables and scopes of Ruby.
+    # This is intended to be used as mix-in, and the user class may override
+    # some of hook methods.
+    module VariableInspector
+      VARIABLE_ASSIGNMENT_TYPES = [:lvasgn].freeze
+      ARGUMENT_DECLARATION_TYPES = [
+        :arg, :optarg, :restarg, :blockarg,
+        :kwarg, :kwoptarg, :kwsplatarg,
+        :shadowarg
+      ].freeze
+      VARIABLE_DECLARATION_TYPES =
+        (VARIABLE_ASSIGNMENT_TYPES + ARGUMENT_DECLARATION_TYPES).freeze
+      VARIABLE_USE_TYPES = [:lvar].freeze
+      SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
+
+      # A VariableEntry represents existance of a local variable.
+      # This holds a variable declaration node,
+      # and some states of the variable.
+      class VariableEntry
+        attr_reader :node
+        attr_accessor :used
+        alias_method :used?, :used
+
+        def initialize(node)
+          unless VARIABLE_DECLARATION_TYPES.include?(node.type)
+            fail ArgumentError,
+                 "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " +
+                 "passed #{node.type}"
+          end
+          @node = node
+          @used = false
+        end
+
+        def name
+          @node.children.first
+        end
+      end
+
+      # A Scope represents a context of local variable visibility.
+      # This is a place where local variables belong to.
+      # A scope instance holds a scope node and variable entries.
+      class Scope
+        attr_reader :node, :variable_entries
+
+        def initialize(node)
+          # Accept begin node for top level scope.
+          unless SCOPE_TYPES.include?(node.type) || node.type == :begin
+            fail ArgumentError,
+                 "Node type must be any of #{SCOPE_TYPES}, " +
+                 "passed #{node.type}"
+          end
+          @node = node
+          @variable_entries = {}
+        end
+      end
+
+      # A VariableTable manages the lifetime of all scopes and local variables
+      # in a program.
+      # This holds scopes as stack structure, and provides a way to add local
+      # variables to current scope and find local variables by considering
+      # variable visibility of the current scope.
+      class VariableTable
+        def initialize(hook_receiver = nil)
+          @hook_receiver = hook_receiver
+        end
+
+        def invoke_hook(hook_name, *args)
+          @hook_receiver.send(hook_name, *args) if @hook_receiver
+        end
+
+        def scope_stack
+          @scope_stack ||= []
+        end
+
+        def push_scope(scope_node)
+          scope = Scope.new(scope_node)
+          invoke_hook(:before_entering_scope, scope)
+          scope_stack.push(scope)
+          invoke_hook(:after_entering_scope, scope)
+          scope
+        end
+
+        def pop_scope
+          scope = current_scope
+          invoke_hook(:before_leaving_scope, scope)
+          scope_stack.pop
+          invoke_hook(:after_leaving_scope, scope)
+          scope
+        end
+
+        def current_scope
+          scope_stack.last
+        end
+
+        def current_scope_level
+          scope_stack.count
+        end
+
+        def add_variable_entry(variable_declaration_node)
+          entry = VariableEntry.new(variable_declaration_node)
+          invoke_hook(:before_declaring_variable, entry)
+          current_scope.variable_entries[entry.name] = entry
+          invoke_hook(:after_declaring_variable, entry)
+          entry
+        end
+
+        def find_variable_entry(variable_name)
+          scope_stack.reverse_each do |scope|
+            entry = scope.variable_entries[variable_name]
+            return entry if entry
+            # Only block scope allows referencing outer scope variables.
+            return nil unless scope.node.type == :block
+          end
+          nil
+        end
+      end
+
+      # This provides a way to scan all nodes only in current scope.
+      class NodeScanner
+        def self.scan_nodes_in_scope(origin_node, &block)
+          new.scan_nodes_in_scope(origin_node, &block)
+        end
+
+        def initialize
+          @node_index = -1
+        end
+
+        def scan_nodes_in_scope(origin_node, &block)
+          origin_node.children.each do |child|
+            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
+            end
+          end
+        end
+      end
+
+      def variable_table
+        @variable_table ||= VariableTable.new(self)
+      end
+
+      # Starting point.
+      def inspect_variables(root_node)
+        return unless root_node
+
+        # Wrap with begin node if it's standalone node.
+        unless root_node.type == :begin
+          root_node = Parser::AST::Node.new(:begin, [root_node])
+        end
+
+        inspect_variables_in_scope(root_node)
+      end
+
+      # This is called for each scope recursively.
+      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
+
+          process_node(node)
+        end
+
+        variable_table.pop_scope
+      end
+
+      def process_node(node)
+        case node.type
+        when *ARGUMENT_DECLARATION_TYPES
+          variable_table.add_variable_entry(node)
+        when *VARIABLE_ASSIGNMENT_TYPES
+          variable_name = node.children.first
+          variable_entry = variable_table.find_variable_entry(variable_name)
+          if variable_entry
+            variable_entry.used = true
+          else
+            variable_table.add_variable_entry(node)
+          end
+        when *VARIABLE_USE_TYPES
+          variable_name = node.children.first
+          variable_entry = variable_table.find_variable_entry(variable_name)
+          unless variable_entry
+            fail "Using undeclared local variable \"#{variable_name}\" " +
+                 "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
+      end
+
+      # Hooks
+
+      def before_entering_scope(scope)
+      end
+
+      def after_entering_scope(scope)
+      end
+
+      def before_leaving_scope(scope)
+      end
+
+      def after_leaving_scope(scope)
+      end
+
+      def before_declaring_variable(variable_entry)
+      end
+
+      def after_declaring_variable(variable_entry)
+      end
+    end
+  end
+end