rubocop 0.12.0 → 0.13.0

data/lib/rubocop/cop/variable_inspector/assignment.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      # This class represents each assignment of a variable.
+      class Assignment
+        include Locatable
+
+        MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
+        REFERENCE_PENETRABLE_BRANCH_TYPES = %w(rescue_main ensure_main).freeze
+
+        attr_reader :node, :variable, :referenced
+        alias_method :referenced?, :referenced
+
+        def initialize(node, variable)
+          unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
+            fail ArgumentError,
+                 "Node type must be any of #{VARIABLE_ASSIGNMENT_TYPES}, " +
+                 "passed #{node.type}"
+          end
+
+          @node = node
+          @variable = variable
+          @referenced = false
+        end
+
+        def name
+          @node.children.first
+        end
+
+        def scope
+          @variable.scope
+        end
+
+        def reference!
+          @referenced = true
+        end
+
+        def used?
+          @variable.captured_by_block? || @referenced
+        end
+
+        def reference_penetrable?
+          REFERENCE_PENETRABLE_BRANCH_TYPES.include?(branch_type)
+        end
+
+        def regexp_named_capture?
+          @node.type == REGEXP_NAMED_CAPTURE_TYPE
+        end
+
+        def operator_assignment?
+          return false unless meta_assignment_node
+          OPERATOR_ASSIGNMENT_TYPES.include?(meta_assignment_node.type)
+        end
+
+        def multiple_assignment?
+          return false unless meta_assignment_node
+          meta_assignment_node.type == MULTIPLE_ASSIGNMENT_TYPE
+        end
+
+        def operator
+          assignment_node = meta_assignment_node || @node
+          assignment_node.loc.operator.source
+        end
+
+        def meta_assignment_node
+          if instance_variable_defined?(:@meta_assignment_node)
+            return @meta_assignment_node
+          end
+
+          @meta_assignment_node = nil
+
+          return unless parent_node
+
+          if OPERATOR_ASSIGNMENT_TYPES.include?(parent_node.type) &&
+             parent_node.children.index(@node) == 0
+            return @meta_assignment_node = parent_node
+          end
+
+          return unless grantparent_node
+
+          if parent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE &&
+             grantparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
+            return @meta_assignment_node = grantparent_node
+          end
+
+          nil
+        end
+
+        private
+
+        def parent_node
+          ancestor_nodes_in_scope.last
+        end
+
+        def grantparent_node
+          ancestor_nodes_in_scope[-2]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_inspector/locatable.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      # This module provides a way to locate the conditional branch the node is
+      # in. This is intended to be used as mix-in.
+      module Locatable
+        BRANCH_TYPES = [:if, :case].freeze
+        CONDITION_INDEX_OF_BRANCH_NODE = 0
+
+        LOGICAL_OPERATOR_TYPES = [:and, :or].freeze
+        LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE = 0
+
+        ENSURE_TYPE = :ensure
+        ENSURE_INDEX_OF_ENSURE_NODE = 1
+
+        def node
+          fail '#node must be declared!'
+        end
+
+        def scope
+          fail '#scope must be declared!'
+        end
+
+        def inside_of_branch?
+          !branch_point_node.nil?
+        end
+
+        def branch_id
+          return nil unless inside_of_branch?
+          @branch_id ||= [branch_point_node.object_id, branch_type].join('_')
+        end
+
+        def branch_type
+          return nil unless inside_of_branch?
+          @branch_type ||= [branch_point_node.type, branch_body_name].join('_')
+        end
+
+        # Inner if, case, rescue, or ensure node.
+        def branch_point_node
+          if instance_variable_defined?(:@branch_point_node)
+            return @branch_point_node
+          end
+
+          set_branch_point_and_body_nodes!
+          @branch_point_node
+        end
+
+        # A child node of #branch_point_node this assignment belongs.
+        def branch_body_node
+          if instance_variable_defined?(:@branch_body_node)
+            return @branch_body_node
+          end
+
+          set_branch_point_and_body_nodes!
+          @branch_body_node
+        end
+
+        def ancestor_nodes_in_scope
+          @ancestor_nodes_in_scope ||= scope.ancestors_of_node(@node)
+        end
+
+        private
+
+        def branch_body_name
+          case branch_point_node.type
+          when :if
+            if_body_name
+          when :case
+            case_body_name
+          when *LOGICAL_OPERATOR_TYPES
+            logical_operator_body_name
+          when RESCUE_TYPE
+            rescue_body_name
+          when ENSURE_TYPE
+            ensure_body_name
+          else
+            fail InvalidBranchBodyError
+          end
+        rescue InvalidBranchBodyError
+          raise InvalidBranchBodyError,
+                "Invalid body index #{body_index} of #{branch_point_node.type}"
+        end
+
+        def if_body_name
+          case body_index
+          when 1 then 'true'
+          when 2 then 'false'
+          else fail InvalidBranchBodyError
+          end
+        end
+
+        def case_body_name
+          if branch_body_node.type == :when
+            "when#{body_index - 1}"
+          else
+            'else'
+          end
+        end
+
+        def logical_operator_body_name
+          case body_index
+          when 1 then 'right'
+          else fail InvalidBranchBodyError
+          end
+        end
+
+        def rescue_body_name
+          if body_index == 0
+            'main'
+          elsif branch_body_node.type == :resbody
+            "rescue#{body_index - 1}"
+          else
+            'else'
+          end
+        end
+
+        def ensure_body_name
+          case body_index
+          when 0 then 'main'
+          else fail InvalidBranchBodyError
+          end
+        end
+
+        def body_index
+          branch_point_node.children.index(branch_body_node)
+        end
+
+        def set_branch_point_and_body_nodes!
+          ancestors_and_self_nodes = ancestor_nodes_in_scope + [@node]
+
+          ancestors_and_self_nodes.reverse.each_cons(2) do |child, parent|
+            next unless branch?(parent, child)
+            @branch_point_node = parent
+            @branch_body_node = child
+            break
+          end
+        end
+
+        def branch?(parent_node, child_node)
+          child_index = parent_node.children.index(child_node)
+
+          case parent_node.type
+          when *BRANCH_TYPES
+            child_index != CONDITION_INDEX_OF_BRANCH_NODE
+          when *LOGICAL_OPERATOR_TYPES
+            child_index != LEFT_SIDE_INDEX_OF_LOGICAL_OPERATOR_NODE
+          when RESCUE_TYPE
+            true
+          when ENSURE_TYPE
+            child_index != ENSURE_INDEX_OF_ENSURE_NODE
+          else
+            false
+          end
+        end
+
+        class InvalidBranchBodyError < StandardError; end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_inspector/reference.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      # This class represents each reference of a variable.
+      class Reference
+        include Locatable
+
+        VARIABLE_REFERENCE_TYPES = (
+          [VARIABLE_REFERENCE_TYPE] +
+          OPERATOR_ASSIGNMENT_TYPES +
+          [ZERO_ARITY_SUPER_TYPE]
+        ).freeze
+
+        attr_reader :node, :scope
+
+        def initialize(node, scope)
+          unless VARIABLE_REFERENCE_TYPES.include?(node.type)
+            fail ArgumentError,
+                 "Node type must be any of #{VARIABLE_REFERENCE_TYPES}, " +
+                 "passed #{node.type}"
+          end
+
+          @node = node
+          @scope = scope
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_inspector/scope.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      # 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, :variables
+
+        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
+          @variables = {}
+        end
+
+        def ==(other)
+          @node.equal?(other.node)
+        end
+
+        def body_node
+          child_index = case @node.type
+                        when :module, :sclass, :begin then 1
+                        when :def, :class, :block     then 2
+                        when :defs                    then 3
+                        end
+
+          @node.children[child_index]
+        end
+
+        def ancestors_of_node(target_node)
+          ASTScanner.scan(@node) do |scanning_node, ancestor_nodes|
+            return ancestor_nodes[1..-1] if scanning_node.equal?(target_node)
+          end
+
+          fail "Node #{target_node} is not found in scope #{@node}"
+        end
+
+        # This class provides a ways to scan AST with tracking ancestor nodes.
+        class ASTScanner
+          def self.scan(node, &block)
+            new.scan(node, &block)
+          end
+
+          def initialize
+            @ancestor_nodes = []
+          end
+
+          def scan(node, &block)
+            @ancestor_nodes.push(node)
+
+            node.children.each do |child|
+              next unless child.is_a?(Parser::AST::Node)
+              yield child, @ancestor_nodes
+              scan(child, &block)
+            end
+
+            @ancestor_nodes.pop
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_inspector/variable.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+
+module Rubocop
+  module Cop
+    module VariableInspector
+      # A Variable represents existance of a local variable.
+      # This holds a variable declaration node,
+      # and some states of the variable.
+      class Variable
+        VARIABLE_DECLARATION_TYPES =
+          (VARIABLE_ASSIGNMENT_TYPES + DECLARATION_TYPES).freeze
+
+        attr_reader :name, :declaration_node, :scope,
+                    :assignments, :captured_by_block
+        alias_method :captured_by_block?, :captured_by_block
+
+        def initialize(name, declaration_node, scope)
+          unless VARIABLE_DECLARATION_TYPES.include?(declaration_node.type)
+            fail ArgumentError,
+                 "Node type must be any of #{VARIABLE_DECLARATION_TYPES}, " +
+                 "passed #{declaration_node.type}"
+          end
+
+          @name = name.to_sym
+          @declaration_node = declaration_node
+          @scope = scope
+
+          @assignments = []
+          @captured_by_block = false
+        end
+
+        def assign(node)
+          @assignments << Assignment.new(node, self)
+        end
+
+        def referenced?
+          @assignments.any?(&:referenced?)
+        end
+
+        def reference!(node)
+          reference = Reference.new(node, @scope)
+          consumed_branch_ids = Set.new
+
+          @assignments.reverse_each do |assignment|
+            next if consumed_branch_ids.include?(assignment.branch_id)
+
+            assignment.reference!
+
+            if assignment.inside_of_branch?
+              break if assignment.branch_id == reference.branch_id
+
+              unless assignment.reference_penetrable?
+                consumed_branch_ids << assignment.branch_id
+              end
+            else
+              break
+            end
+          end
+        end
+
+        def capture_with_block!
+          @captured_by_block = true
+        end
+
+        # This is a convenient way to check whether the variable is used
+        # in its entire variable lifetime.
+        # For more precise usage check, refer Assignment#used?.
+        #
+        # Once the variable is captured by a block, we have no idea
+        # when, where and how many times the block would be invoked
+        # and it means we cannot track the usage of the variable.
+        # So we consider it's used to suppress false positive offences.
+        def used?
+          @captured_by_block || referenced?
+        end
+
+        def method_argument?
+          METHOD_ARGUMENT_DECLARATION_TYPES.include?(@declaration_node.type)
+        end
+
+        def block_local_variable?
+          @declaration_node.type == BLOCK_LOCAL_VARIABLE_DECLARATION_TYPE
+        end
+      end
+    end
+  end
+end