rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,12 +5,11 @@ module RuboCop
     class VariableForce
       # This class represents each assignment of a variable.
       class Assignment
-        include Locatable
+        include Branchable
 
         MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
-        REFERENCE_PENETRABLE_BRANCH_TYPES = %w(rescue_main ensure_main).freeze
 
-        attr_reader :node, :variable, :referenced
+        attr_reader :node, :variable, :referenced, :references
         alias referenced? referenced
 
         def initialize(node, variable)
@@ -24,6 +22,7 @@ module RuboCop
           @node = node
           @variable = variable
           @referenced = false
+          @references = []
         end
 
         def name
@@ -34,7 +33,8 @@ module RuboCop
           @variable.scope
         end
 
-        def reference!
+        def reference!(node)
+          @references << node
           @referenced = true
         end
 
@@ -42,10 +42,6 @@ module RuboCop
           @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

data/lib/rubocop/cop/variable_force/branch.rb

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # Namespace for branch classes for each control structure.
+      module Branch
+        def self.of(target_node, scope: nil)
+          ([target_node] + target_node.ancestors).each do |node|
+            return nil unless node.parent
+            return nil unless scope.include?(node)
+            klass = CLASSES_BY_TYPE[node.parent.type]
+            next unless klass
+            branch = klass.new(node, scope)
+            return branch if branch.branched?
+          end
+
+          nil
+        end
+
+        # rubocop:disable Metrics/BlockLength
+
+        # Abstract base class for branch classes.
+        # A branch represents a conditional branch in a scope.
+        #
+        # @example
+        #   def some_scope
+        #     do_something     # no branch
+        #
+        #     if foo
+        #       do_something   # branch A
+        #       do_something   # branch A
+        #     else
+        #       do_something   # branch B
+        #       if bar
+        #         do_something # branch C (whose parent is branch B)
+        #       end
+        #     end
+        #
+        #     do_something     # no branch
+        #   end
+        Base = Struct.new(:child_node, :scope) do
+          # rubocop:enable Metrics/BlockLength
+
+          def self.classes
+            @classes ||= []
+          end
+
+          def self.inherited(subclass)
+            classes << subclass
+          end
+
+          def self.type
+            name.split('::').last.gsub(/(.)([A-Z])/, '\1_\2').downcase.to_sym
+          end
+
+          def self.define_predicate(name, child_index: nil)
+            define_method(name) do
+              target_node = control_node.children[child_index]
+
+              # We don't use Kernel#Array here
+              # because it invokes Node#to_a rather than wrapping with an array.
+              if target_node.is_a?(Array)
+                target_node.any? { |node| node.equal?(child_node) }
+              else
+                target_node.equal?(child_node)
+              end
+            end
+          end
+
+          def control_node
+            child_node.parent
+          end
+
+          def parent
+            return @parent if instance_variable_defined?(:@parent)
+            @branch = Branch.of(control_node, scope: scope)
+          end
+
+          def each_ancestor(include_self: false, &block)
+            unless block_given?
+              return to_enum(__method__, include_self: include_self)
+            end
+
+            yield self if include_self
+            scan_ancestors(&block)
+            self
+          end
+
+          def branched?
+            !always_run?
+          end
+
+          def always_run?
+            raise NotImplementedError
+          end
+
+          def may_jump_to_other_branch?
+            false
+          end
+
+          def may_run_incompletely?
+            false
+          end
+
+          def exclusive_with?(other)
+            return false unless other
+            return false if may_jump_to_other_branch?
+
+            other.each_ancestor(include_self: true) do |other_ancestor|
+              if control_node.equal?(other_ancestor.control_node)
+                return !child_node.equal?(other_ancestor.child_node)
+              end
+            end
+
+            if parent
+              parent.exclusive_with?(other)
+            else
+              false
+            end
+          end
+
+          def ==(other)
+            return false unless other
+            control_node.equal?(other.control_node) &&
+              child_node.equal?(other.child_node)
+          end
+
+          alias_method :eql?, :==
+
+          def hash
+            control_node.object_id.hash ^ child_node.object_id.hash
+          end
+
+          private
+
+          def scan_ancestors
+            branch = self
+
+            while (branch = branch.parent)
+              yield branch
+            end
+          end
+        end
+
+        # Mix-in module for simple conditional control structures.
+        module SimpleConditional
+          def conditional_clause?
+            raise NotImplementedError
+          end
+
+          def always_run?
+            conditional_clause?
+          end
+        end
+
+        # if conditional_clause
+        #   truthy_body
+        # else
+        #   falsey_body
+        # end
+        #
+        # unless conditional_clause
+        #   falsey_body
+        # else
+        #   truthy_body
+        # end
+        class If < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :truthy_body?,        child_index: 1
+          define_predicate :falsey_body?,        child_index: 2
+        end
+
+        # while conditional_clause
+        #   loop_body
+        # end
+        class While < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # until conditional_clause
+        #   loop_body
+        # end
+        class Until < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # begin
+        #   loop_body
+        # end while conditional_clause
+        class WhilePost < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # begin
+        #   loop_body
+        # end until conditional_clause
+        class UntilPost < Base
+          include SimpleConditional
+
+          define_predicate :conditional_clause?, child_index: 0
+          define_predicate :loop_body?,          child_index: 1
+        end
+
+        # case target
+        # when /pattern/ # when_clause
+        # else
+        #   else_body
+        # end
+        class Case < Base
+          define_predicate :target?,      child_index: 0
+          define_predicate :when_clause?, child_index: 1..-2
+          define_predicate :else_body?,   child_index: -1
+
+          def always_run?
+            target?
+          end
+        end
+
+        # for element in collection
+        #   loop_body
+        # end
+        class For < Base
+          define_predicate :element?,    child_index: 0
+          define_predicate :collection?, child_index: 1
+          define_predicate :loop_body?,  child_index: 2
+
+          def always_run?
+            element? || collection?
+          end
+        end
+
+        # Mix-in module for logical operator control structures.
+        module LogicalOperator
+          def always_run?
+            left_body?
+          end
+        end
+
+        # left_body && right_body
+        class And < Base
+          include LogicalOperator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body || right_body
+        class Or < Base
+          include LogicalOperator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # Mix-in module for exception handling control structures.
+        module ExceptionHandler
+          def may_jump_to_other_branch?
+            main_body?
+          end
+
+          def may_run_incompletely?
+            main_body?
+          end
+        end
+
+        #   begin
+        #     main_body
+        #   rescue StandardError => error # rescue_clause
+        #   else
+        #     else_body
+        #   end
+        class Rescue < Base
+          include ExceptionHandler
+
+          define_predicate :main_body?,     child_index: 0
+          define_predicate :rescue_clause?, child_index: 1..-2
+          define_predicate :else_body?,     child_index: -1
+
+          def always_run?
+            false
+          end
+        end
+
+        #   begin
+        #     main_body
+        #   ensure
+        #     ensure_body
+        #   end
+        class Ensure < Base
+          include ExceptionHandler
+
+          define_predicate :main_body?,   child_index: 0
+          define_predicate :ensure_body?, child_index: -1
+
+          def always_run?
+            ensure_body?
+          end
+        end
+
+        CLASSES_BY_TYPE = Base.classes.each_with_object({}) do |klass, classes|
+          classes[klass.type] = klass
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/variable_force/branchable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # Mix-in module for classes which own a node and need branch information
+      # of the node. The user classes must implement #node and #scope.
+      module Branchable
+        def branch
+          return @branch if instance_variable_defined?(:@branch)
+          @branch = Branch.of(node, scope: scope)
+        end
+
+        def run_exclusively_with?(other)
+          return false if !branch || !other.branch
+          branch.exclusive_with?(other.branch)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,7 +5,7 @@ module RuboCop
     class VariableForce
       # This class represents each reference of a variable.
       class Reference
-        include Locatable
+        include Branchable
 
         VARIABLE_REFERENCE_TYPES = (
           [VARIABLE_REFERENCE_TYPE] +

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -16,14 +15,18 @@ module RuboCop
           block:  0..0
         }.freeze
 
-        attr_reader :node, :variables
+        attr_reader :node, :variables, :naked_top_level
+        alias naked_top_level? naked_top_level
 
         def initialize(node)
-          # Accept any node type for top level scope
-          unless SCOPE_TYPES.include?(node.type) || !node.parent
-            raise ArgumentError,
-                  "Node type must be any of #{SCOPE_TYPES}, " \
-                  "passed #{node.type}"
+          unless SCOPE_TYPES.include?(node.type)
+            # Accept any node type for top level scope
+            if node.parent
+              raise ArgumentError,
+                    "Node type must be any of #{SCOPE_TYPES}, " \
+                    "passed #{node.type}"
+            end
+            @naked_top_level = true
           end
           @node = node
           @variables = {}
@@ -34,45 +37,47 @@ module RuboCop
         end
 
         def name
-          # TODO: Add an else clause
-          case @node.type
-          when :def  then @node.children[0]
-          when :defs then @node.children[1]
-          end
+          @node.method_name
         end
 
         def body_node
-          child_index = case @node.type
-                        when :module, :sclass     then 1
-                        when :def, :class, :block then 2
-                        when :defs                then 3
-                        end
+          if naked_top_level?
+            node
+          else
+            child_index = case node.type
+                          when :module, :sclass     then 1
+                          when :def, :class, :block then 2
+                          when :defs                then 3
+                          end
 
-          child_index ? @node.children[child_index] : @node
+            node.children[child_index]
+          end
+        end
+
+        def include?(target_node)
+          !belong_to_outer_scope?(target_node) &&
+            !belong_to_inner_scope?(target_node)
         end
 
         def each_node(&block)
           return to_enum(__method__) unless block_given?
+          yield node if naked_top_level?
           scan_node(node, &block)
         end
 
         private
 
         def scan_node(node, &block)
-          yield node unless node.parent
-
           node.each_child_node do |child_node|
-            next if belong_to_another_scope?(child_node)
+            next unless include?(child_node)
             yield child_node
             scan_node(child_node, &block)
           end
         end
 
-        def belong_to_another_scope?(node)
-          belong_to_outer_scope?(node) || belong_to_inner_scope?(node)
-        end
-
         def belong_to_outer_scope?(target_node)
+          return true if !naked_top_level? && target_node.equal?(node)
+          return true if ancestor_node?(target_node)
           return false unless target_node.parent.equal?(node)
           indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
           return false unless indices
@@ -80,12 +85,18 @@ module RuboCop
         end
 
         def belong_to_inner_scope?(target_node)
-          return false if target_node.parent.equal?(node)
+          return false if !target_node.parent || target_node.parent.equal?(node)
           return false unless SCOPE_TYPES.include?(target_node.parent.type)
           indices = OUTER_SCOPE_CHILD_INDICES[target_node.parent.type]
           return true unless indices
           !indices.include?(target_node.sibling_index)
         end
+
+        def ancestor_node?(target_node)
+          node.each_ancestor.any? do |ancestor_node|
+            ancestor_node.equal?(target_node)
+          end
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -42,19 +41,20 @@ module RuboCop
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
-          consumed_branch_ids = Set.new
+          consumed_branches = Set.new
 
           @assignments.reverse_each do |assignment|
-            next if consumed_branch_ids.include?(assignment.branch_id)
+            next if consumed_branches.include?(assignment.branch)
 
             unless assignment.run_exclusively_with?(reference)
-              assignment.reference!
+              assignment.reference!(node)
             end
 
-            break unless assignment.inside_of_branch?
-            break if assignment.branch_id == reference.branch_id
-            next if assignment.reference_penetrable?
-            consumed_branch_ids << assignment.branch_id
+            break if !assignment.branch || assignment.branch == reference.branch
+
+            unless assignment.branch.may_run_incompletely?
+              consumed_branches << assignment.branch
+            end
           end
         end
 
@@ -83,19 +83,19 @@ module RuboCop
         end
 
         def method_argument?
-          argument? && [:def, :defs].include?(@scope.node.type)
+          argument? && %i[def defs].include?(@scope.node.type)
         end
 
         def block_argument?
-          argument? && @scope.node.type == :block
+          argument? && @scope.node.block_type?
         end
 
         def keyword_argument?
-          [:kwarg, :kwoptarg].include?(@declaration_node.type)
+          %i[kwarg kwoptarg].include?(@declaration_node.type)
         end
 
         def explicit_block_local_variable?
-          @declaration_node.type == :shadowarg
+          @declaration_node.shadowarg_type?
         end
       end
     end

data/lib/rubocop/cop/variable_force/variable_table.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -99,7 +98,7 @@ module RuboCop
             variable = scope.variables[name]
             return variable if variable
             # Only block scope allows referencing outer scope variables.
-            return nil unless scope.node.type == :block
+            return nil unless scope.node.block_type?
           end
 
           nil
@@ -112,14 +111,14 @@ module RuboCop
         def accessible_variables
           scope_stack.reverse_each.each_with_object([]) do |scope, variables|
             variables.concat(scope.variables.values)
-            break variables unless scope.node.type == :block
+            break variables unless scope.node.block_type?
           end
         end
 
         private
 
         def mark_variable_as_captured_by_block_if_so(variable)
-          return unless current_scope.node.type == :block
+          return unless current_scope.node.block_type?
           return if variable.scope == current_scope
           variable.capture_with_block!
         end