rubbycop 0.49.0

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    class VariableForce
+      # This class represents each assignment of a variable.
+      class Assignment
+        include Branchable
+
+        MULTIPLE_LEFT_HAND_SIDE_TYPE = :mlhs
+
+        attr_reader :node, :variable, :referenced
+        alias referenced? referenced
+
+        def initialize(node, variable)
+          unless VARIABLE_ASSIGNMENT_TYPES.include?(node.type)
+            raise 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 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
+          unless instance_variable_defined?(:@meta_assignment_node)
+            @meta_assignment_node =
+              operator_assignment_node || multiple_assignment_node
+          end
+
+          @meta_assignment_node
+        end
+
+        private
+
+        def operator_assignment_node
+          return nil unless node.parent
+          return nil unless OPERATOR_ASSIGNMENT_TYPES.include?(node.parent.type)
+          return nil unless node.sibling_index.zero?
+          node.parent
+        end
+
+        def multiple_assignment_node
+          grandparent_node = node.parent ? node.parent.parent : nil
+          return nil unless grandparent_node
+          return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
+          return nil unless node.parent.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+          grandparent_node
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,318 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+
+        # rubbycop: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
+          # rubbycop: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/rubbycop/cop/variable_force/branchable.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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/rubbycop/cop/variable_force/reference.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    class VariableForce
+      # This class represents each reference of a variable.
+      class Reference
+        include Branchable
+
+        VARIABLE_REFERENCE_TYPES = (
+          [VARIABLE_REFERENCE_TYPE] +
+          OPERATOR_ASSIGNMENT_TYPES +
+          [ZERO_ARITY_SUPER_TYPE, SEND_TYPE]
+        ).freeze
+
+        attr_reader :node, :scope
+
+        def initialize(node, scope)
+          unless VARIABLE_REFERENCE_TYPES.include?(node.type)
+            raise ArgumentError,
+                  "Node type must be any of #{VARIABLE_REFERENCE_TYPES}, " \
+                  "passed #{node.type}"
+          end
+
+          @node = node
+          @scope = scope
+        end
+
+        # There's an implicit variable reference by the zero-arity `super`:
+        #
+        #     def some_method(foo)
+        #       super
+        #     end
+        #
+        # Another case is `binding`:
+        #
+        #     def some_method(foo)
+        #       do_something(binding)
+        #     end
+        #
+        # In these cases, the variable `foo` is not explicitly referenced,
+        # but it can be considered used implicitly by the `super` or `binding`.
+        def explicit?
+          ![ZERO_ARITY_SUPER_TYPE, SEND_TYPE].include?(@node.type)
+        end
+      end
+    end
+  end
+end