turbo_test_static_analysis 0.1.0

data/lib/turbo_test_static_analysis/active_record_schema/snapshot.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module ActiveRecord
+      Snapshot = Struct.new(:extensions, :tables) do
+        def initialize(*)
+          super
+          self.extensions ||= {}
+          self.tables ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/constants.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "constants/sexp_builder"
+
+module TurboTest
+  module StaticAnalysis
+    module Constants
+      def self.parse(source)
+        SexpBuilder.new(source).tap(&:parse)
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/constants/node.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module Constants
+      class Node
+        attr_reader :name, :start_pos, :parent, :children, :singleton
+        attr_accessor :end_pos, :top_level, :definition
+
+        def initialize(name:, start_pos:, end_pos:, singleton: false, definition: false)
+          @name = name
+          @children = []
+          @start_pos = start_pos
+          @end_pos = end_pos
+          @parent = nil
+          @singleton = singleton
+          @definition = definition
+          @top_level = false
+        end
+
+        def add_child(child)
+          return if child.start_pos == start_pos && child.name == name
+          return unless contains?(child)
+
+          @children << child
+          child.instance_variable_set(:@parent, self)
+          child.instance_variable_set(:@definition, definition)
+          child
+        end
+
+        def contains?(node)
+          ((@start_pos <=> node.start_pos) == -1 && (@end_pos <=> node.end_pos) == 1) ||
+            ((@start_pos <=> node.start_pos).zero? &&
+              ((@end_pos <=> node.end_pos).zero? || (@end_pos <=> node.end_pos) == 1))
+        end
+
+        def full_name
+          return @name unless @parent
+
+          [@parent.full_name, @name].compact.join("::")
+        end
+
+        def root
+          return self if parent.nil?
+
+          parent.root
+        end
+
+        def parent_is_named_singleton?
+          return false unless parent
+
+          parent.singleton && parent.name != "singleton_class"
+        end
+
+        def named_singleton_with_parent?
+          return false unless parent
+
+          singleton && name != "singleton_class"
+        end
+
+        class << self
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/constants/node_maker.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module Constants
+      module NodeMaker
+        private
+
+        def create_top_singleton_class_node(token)
+          parent = new_node_from_token(token[1], [lineno, column])
+          @class_nodes.push parent
+          node = Node.new(
+            name: "singleton_class",
+            start_pos: node_start_pos(token),
+            end_pos: [lineno, column]
+          )
+          parent.add_child node
+          node
+        end
+
+        def create_var_ref_singleton_class_node(token)
+          node = new_node_from_token(token[1], [lineno, column], singleton_class: true)
+          @class_nodes.push node
+          child = Node.new(
+            name: "singleton_class",
+            start_pos: node_start_pos(token),
+            end_pos: [lineno, column]
+          )
+          node.add_child child
+          node
+        end
+
+        def create_singleton_class_node(token)
+          new_node_from_token(token[1], [lineno, column], singleton_class: true)
+        end
+
+        def create_singleton_method_definition_with_self_node(token)
+          node = Node.new(
+            name: "self",
+            start_pos: node_start_pos(token),
+            end_pos: [lineno, column], definition: true
+          )
+          @class_nodes.push node
+          @all_nodes.unshift(node)
+        end
+
+        def create_singleton_method_definition_with_constant_node(token)
+          Node.new(
+            name: token[1][1],
+            start_pos: node_start_pos(token),
+            end_pos: [lineno, column],
+            definition: true
+          )
+        end
+
+        def add_block_node(token)
+          return unless (start_pos = token[1][3]&.last)
+
+          node = Node.new(
+            name: "block",
+            start_pos: start_pos,
+            end_pos: [lineno, column]
+          )
+          @block_nodes << node
+        end
+
+        def find_or_new_node_for_const_class_or_module_eval(token)
+          start_pos = token[1][1][1]
+          end_pos = token[1][1][2]
+          find_and_update_node([nil, [nil, start_pos, end_pos]]).tap do |node|
+            break const_class_or_module_eval_node(start_pos, end_pos) if node.nil?
+          end
+        end
+
+        def const_class_or_module_eval_node(start_pos, end_pos)
+          Node.new(
+            name: start_pos,
+            start_pos: end_pos,
+            end_pos: [lineno, column],
+            definition: true
+          )
+        end
+
+        def ident_class_or_module_eval_node(token)
+          Node.new(
+            name: token[1][1][1],
+            start_pos: token[1][1][2],
+            end_pos: [lineno, column],
+            definition: true
+          )
+        end
+
+        def new_node_from_token(token, end_pos = [0, 0], singleton_class: false)
+          name = node_name(token)
+          start_pos = node_start_pos(token)
+          Node.new(name: name, start_pos: start_pos, end_pos: end_pos, singleton: singleton_class)
+        end
+
+        def node_name(token)
+          case token[0]
+          when :@kw
+            "singleton_class"
+          when :@const
+            token[1]
+          else
+            "unknown_ref"
+          end
+        end
+
+        def node_start_pos(token)
+          start_pos = token.last
+          start_pos = start_pos.last while start_pos.last.is_a?(Array)
+          start_pos
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/constants/node_processor.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module Constants
+      module NodeProcessor
+        private
+
+        def node_key(token)
+          "#{token[1]}-#{token[2].join('-')}"
+        end
+
+        def process_module(node)
+          @var_refs.reject! do |var_ref|
+            (var_ref.name == node.name && var_ref.start_pos == node.start_pos) ||
+              node.contains?(var_ref).tap do |condition|
+                @referenced_constants[var_ref.name] = true if condition
+              end
+          end
+          @class_nodes.push node
+          assign_children(node)
+        end
+
+        def process_class_nodes
+          @class_nodes.reject! do |class_node|
+            next process_definition_class_node(class_node) if class_node.root.definition
+
+            @referenced_constants[class_node.name] = true if class_node.named_singleton_with_parent?
+            class_node.parent_is_named_singleton? || class_node.named_singleton_with_parent?
+          end
+
+          @defined_classes = class_nodes_names_without_singletons_and_unknowns
+        end
+
+        def process_definition_class_node(node)
+          container_node = @class_nodes.find do |class_node|
+            class_node != node.root && class_node.contains?(node.root)
+          end
+          return false if container_node.nil?
+
+          @referenced_constants[node.full_name] = true if node.name != "self"
+          true
+        end
+
+        def process_var_refs
+          @var_refs.each do |var_ref|
+            if @block_nodes.find { |node| node.contains?(var_ref) }
+              @referenced_constants[var_ref.name] = true
+            else
+              @referenced_top_constants[var_ref.name] = true
+            end
+          end
+        end
+
+        def class_nodes_names_without_singletons_and_unknowns
+          @class_nodes.map(&:full_name).reject do |full_name|
+            full_name.end_with?("singleton_class") || full_name.include?("unknown_ref")
+          end.uniq
+        end
+
+        def reject_unknown_constants
+          @referenced_top_constants.reject! do |key, _value|
+            key.include?("unknown_ref")
+          end
+
+          @referenced_constants.reject! do |key, _value|
+            key.include?("unknown_ref")
+          end
+        end
+
+        def assign_children(node)
+          if @referenced_top_constants.delete(node.name)
+            @all_nodes.unshift(node)
+            add_children(node)
+          else
+            add_children(node)
+            @all_nodes.unshift(node)
+          end
+        end
+
+        def add_children(node)
+          @all_nodes.reject! do |children_candidate|
+            node.contains?(children_candidate).tap do |child|
+              node.add_child(children_candidate) if child && children_candidate.definition == false
+            end
+          end
+        end
+
+        def add_const_ref(token, top_level: false)
+          node = new_node_from_token(token)
+          node.top_level = top_level
+          @const_refs[node_key(token)] = node
+        end
+
+        def add_referenced_top_constant(name)
+          @referenced_top_constants[name] = true
+        end
+
+        def find_and_update_node(token)
+          @const_refs.delete(node_key(token[1])).tap do |node|
+            node.end_pos = [lineno, column] if node
+          end
+        end
+
+        def reject_children_in_class_nodes(node)
+          @class_nodes.reject! do |class_node|
+            node.contains?(class_node).tap do |child|
+              @referenced_constants[class_node.full_name] = true if child
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/turbo_test_static_analysis/constants/sexp_builder.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "ripper"
+require_relative "node"
+require_relative "token_matcher"
+require_relative "node_maker"
+require_relative "node_processor"
+
+module TurboTest
+  module StaticAnalysis
+    module Constants
+      class SexpBuilder < Ripper::SexpBuilder
+        attr_reader :defined_classes, :referenced_top_constants, :referenced_constants
+
+        include TokenMatcher
+        include NodeMaker
+        include NodeProcessor
+
+        def initialize(path, filename = "-", lineno = 1)
+          @const_refs = {}
+          @referenced_top_constants = {}
+          @referenced_constants = {}
+          @class_nodes = []
+          @defined_classes = []
+          @all_nodes = []
+          @var_refs = []
+          @block_nodes = []
+          super
+        end
+
+        def on_sclass(token_one, token_two)
+          node = if top_const_ref?(token_one)
+                   create_top_singleton_class_node(token_one)
+                 elsif var_ref?(token_one)
+                   create_var_ref_singleton_class_node(token_one)
+                 else
+                   create_singleton_class_node(token_one)
+                 end
+          process_module(node)
+          @all_nodes.shift if top_const_ref?(token_one)
+          super
+        end
+
+        def on_module(token_one, token_two, token_three = nil)
+          process_module find_and_update_node(token_one)
+          super
+        end
+        alias on_class on_module
+
+        def on_defs(token_one, token_two, token_three, token_four, token_five)
+          if singleton_method_definition_with_self?(token_one)
+            create_singleton_method_definition_with_self_node(token_one)
+          elsif singleton_method_definition_with_constant?(token_one)
+            node = create_singleton_method_definition_with_constant_node(token_one)
+            process_module(node)
+          end
+          super
+        end
+
+        def on_top_const_ref(token)
+          add_const_ref token, top_level: true
+          add_referenced_top_constant token[1]
+          super
+        end
+
+        def on_const_ref(token)
+          add_const_ref token
+          super
+        end
+
+        def on_var_ref(token)
+          @var_refs << new_node_from_token(token, [lineno, column]) if token[0] == :@const
+          super
+        end
+        alias on_var_field on_var_ref
+
+        def on_top_const_field(token)
+          add_referenced_top_constant token[1]
+          super
+        end
+
+        def on_def(token_one, token_two, token_three)
+          super
+        end
+
+        def on_method_add_block(token_one, token_two)
+          add_block_node(token_one)
+          if const_class_or_module_eval?(token_one)
+            node = find_or_new_node_for_const_class_or_module_eval(token_one)
+            process_module node
+          elsif ident_class_or_module_eval?(token_one)
+            node = ident_class_or_module_eval_node(token_one)
+            reject_children_in_class_nodes(node)
+          end
+          super
+        end
+
+        def on_program(token_one)
+          process_class_nodes
+          process_var_refs
+          reject_unknown_constants
+          super
+        end
+      end
+    end
+  end
+end
+
+# Check https://fili.pp.ru/leaky-constants.html

data/lib/turbo_test_static_analysis/constants/token_matcher.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module TurboTest
+  module StaticAnalysis
+    module Constants
+      module TokenMatcher
+        private
+
+        def top_const_ref?(token)
+          token[0] == :top_const_ref
+        end
+
+        def var_ref?(token)
+          token[0] == :var_ref
+        end
+
+        def const_class_or_module_eval?(token)
+          token.last[0] == :@ident &&
+            %w[class_eval module_eval].include?(token.last[1]) &&
+            token[1][1][0] == :@const
+        end
+
+        def ident_class_or_module_eval?(token)
+          token.last[0] == :@ident &&
+            %w[class_eval module_eval].include?(token.last[1]) &&
+            token[1][1][0] == :@ident
+        end
+
+        def singleton_method_definition_with_self?(token)
+          token[1] &&
+            token[1][0] == :@kw &&
+            token[1][1] == "self"
+        end
+
+        def singleton_method_definition_with_constant?(token)
+          token[0] == :var_ref &&
+            token[1] &&
+            token[1][0] == :@const
+        end
+      end
+    end
+  end
+end