super-pro-sys 0.0.1

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

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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, :references, :reassigned
+
+        alias referenced? referenced
+        alias reassigned? reassigned
+
+        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
+          @references = []
+          @reassigned = false
+        end
+
+        def name
+          @node.children.first
+        end
+
+        def scope
+          @variable.scope
+        end
+
+        def reference!(node)
+          @references << node
+          @referenced = true
+        end
+
+        def reassigned!
+          return if referenced?
+
+          @reassigned = true
+        end
+
+        def used?
+          (!reassigned? && @variable.captured_by_block?) || @referenced
+        end
+
+        def regexp_named_capture?
+          @node.type == REGEXP_NAMED_CAPTURE_TYPE
+        end
+
+        def exception_assignment?
+          node.parent&.resbody_type? && node.parent.exception_variable == node
+        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 rest_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.type == REST_ASSIGNMENT_TYPE
+        end
+
+        def for_assignment?
+          return false unless meta_assignment_node
+
+          meta_assignment_node.for_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 ||
+                                    rest_assignment_node ||
+                                    for_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
+          return nil unless (candidate_mlhs_node = node.parent)
+
+          # In `(foo, bar), *baz`, the splat node must be traversed as well.
+          candidate_mlhs_node = candidate_mlhs_node.parent if candidate_mlhs_node.splat_type?
+
+          return nil unless candidate_mlhs_node.mlhs_type?
+          return nil unless (grandparent_node = node.parent.parent)
+          if (node = find_multiple_assignment_node(grandparent_node))
+            return node
+          end
+          return nil unless grandparent_node.type == MULTIPLE_ASSIGNMENT_TYPE
+
+          grandparent_node
+        end
+
+        def rest_assignment_node
+          return nil unless node.parent
+          return nil unless node.parent.type == REST_ASSIGNMENT_TYPE
+
+          node.parent
+        end
+
+        def for_assignment_node
+          return unless (parent_node = node.parent)
+          return parent_node if parent_node.for_type?
+
+          grandparent_node = parent_node.parent
+          return grandparent_node if parent_node.mlhs_type? && grandparent_node&.for_type?
+
+          nil
+        end
+
+        def find_multiple_assignment_node(grandparent_node)
+          return unless grandparent_node.type == MULTIPLE_LEFT_HAND_SIDE_TYPE
+
+          parent = grandparent_node.parent
+          return parent if parent.type == MULTIPLE_ASSIGNMENT_TYPE
+
+          find_multiple_assignment_node(parent)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,355 @@
+# 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
+
+        # 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
+          def self.classes
+            @classes ||= []
+          end
+
+          def self.inherited(subclass)
+            super
+            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)
+
+            @parent = Branch.of(control_node, scope: scope)
+          end
+
+          def each_ancestor(include_self: false, &block)
+            return to_enum(__method__, include_self: include_self) unless block
+
+            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, control_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
+
+        # case target
+        # in pattern # in_pattern
+        # else
+        #   else_body
+        # end
+        class CaseMatch < Base
+          define_predicate :target?,     child_index: 0
+          define_predicate :in_pattern?, 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 operator control structures.
+        module Operator
+          def always_run?
+            left_body?
+          end
+        end
+
+        # left_body && right_body
+        class And < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body &&= right_body
+        class AndAsgn < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body || right_body
+        class Or < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # left_body ||= right_body
+        class OrAsgn < Base
+          include Operator
+
+          define_predicate :left_body?,  child_index: 0
+          define_predicate :right_body?, child_index: 1
+        end
+
+        # e.g. left_body += right_body
+        class OpAsgn < Base
+          include Operator
+
+          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.to_h do |klass|
+          [klass.type, klass]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# 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/rubocop-1.88.1/lib/rubocop/cop/variable_force/reference.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  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

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    class VariableForce
+      # 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
+        OUTER_SCOPE_CHILD_INDICES = {
+          defs:   0..0,
+          module: 0..0,
+          class:  0..1,
+          sclass: 0..0,
+          block:  0..0
+        }.freeze
+
+        attr_reader :node, :variables, :naked_top_level
+
+        alias naked_top_level? naked_top_level
+
+        def initialize(node)
+          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 = {}
+        end
+
+        def ==(other)
+          @node.equal?(other.node)
+        end
+
+        def name
+          @node.method_name
+        end
+
+        def body_node
+          if naked_top_level?
+            node
+          else
+            child_index = case node.type
+                          when :module, :sclass then 1
+                          when :def, :class, :block, :numblock, :itblock then 2
+                          when :defs then 3
+                          end
+
+            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
+
+          yield node if naked_top_level?
+          scan_node(node, &block)
+        end
+
+        private
+
+        def scan_node(node, &block)
+          node.each_child_node do |child_node|
+            next unless include?(child_node)
+
+            yield child_node
+            scan_node(child_node, &block)
+          end
+        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
+
+          indices.include?(target_node.sibling_index)
+        end
+
+        def belong_to_inner_scope?(target_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? { |ancestor_node| ancestor_node.equal?(target_node) }
+        end
+      end
+    end
+  end
+end