bullematic 0.1.0

data/lib/bullematic/ast/finder.rb

@@ -0,0 +1,175 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "set"
+
+module Bullematic
+  module AST
+    class Finder
+      QUERY_METHODS = %i[all where find find_by first last order limit offset].freeze #: Array[Symbol]
+
+      # @rbs!
+      #   type query_location = { node: untyped, location: untyped, receiver: untyped, method_name: Symbol }
+
+      QueryLocation = Struct.new(:node, :location, :receiver, :method_name, keyword_init: true)
+
+      # @rbs @parse_result: untyped
+
+      # @rbs!
+      #   attr_reader parse_result: untyped
+      attr_reader :parse_result
+
+      # @rbs parse_result: untyped
+      # @rbs return: void
+      def initialize(parse_result)
+        @parse_result = parse_result
+      end
+
+      # @rbs model_class_name: String
+      # @rbs line_number: Integer?
+      # @rbs return: Array[QueryLocation]
+      def find_model_queries(model_class_name, line_number: nil)
+        queries = [] #: Array[QueryLocation]
+        visit_node(parse_result.value, queries, model_class_name, line_number)
+        queries
+      end
+
+      # @rbs line_number: Integer
+      # @rbs return: QueryLocation?
+      def find_query_at_line(line_number)
+        queries = [] #: Array[QueryLocation]
+        visit_all_queries(parse_result.value, queries, line_number)
+        queries.first
+      end
+
+      private
+
+      # @rbs node: untyped
+      # @rbs queries: Array[QueryLocation]
+      # @rbs model_class_name: String
+      # @rbs target_line: Integer?
+      # @rbs skip_nodes: Set[Integer]
+      # @rbs return: void
+      def visit_node(node, queries, model_class_name, target_line, skip_nodes = Set.new)
+        return unless node.respond_to?(:child_nodes)
+        return if skip_nodes.include?(node.object_id)
+
+        case node
+        when Prism::InstanceVariableWriteNode
+          if check_assignment_node(node, queries, model_class_name, target_line)
+            mark_descendant_calls(node.value, skip_nodes)
+          end
+        when Prism::CallNode
+          check_call_node(node, queries, model_class_name, target_line)
+        end
+
+        node.child_nodes.compact.each do |child|
+          visit_node(child, queries, model_class_name, target_line, skip_nodes)
+        end
+      end
+
+      # @rbs node: untyped
+      # @rbs skip_nodes: Set[Integer]
+      # @rbs return: void
+      def mark_descendant_calls(node, skip_nodes)
+        return unless node.respond_to?(:child_nodes)
+
+        skip_nodes.add(node.object_id) if node.is_a?(Prism::CallNode)
+
+        node.child_nodes.compact.each do |child|
+          mark_descendant_calls(child, skip_nodes)
+        end
+      end
+
+      # @rbs node: untyped
+      # @rbs queries: Array[QueryLocation]
+      # @rbs target_line: Integer?
+      # @rbs return: void
+      def visit_all_queries(node, queries, target_line)
+        return unless node.respond_to?(:child_nodes)
+
+        if node.is_a?(Prism::CallNode) && query_method?(node.name)
+          node_line = node.location.start_line
+          if target_line.nil? || node_line == target_line
+            queries << QueryLocation.new(
+              node: node,
+              location: node.location,
+              receiver: find_root_receiver(node),
+              method_name: node.name
+            )
+          end
+        end
+
+        node.child_nodes.compact.each do |child|
+          visit_all_queries(child, queries, target_line)
+        end
+      end
+
+      # @rbs node: untyped
+      # @rbs queries: Array[QueryLocation]
+      # @rbs model_class_name: String
+      # @rbs target_line: Integer?
+      # @rbs return: void
+      def check_call_node(node, queries, model_class_name, target_line)
+        return unless query_method?(node.name)
+        return if target_line && node.location.start_line != target_line
+
+        root_receiver = find_root_receiver(node)
+        return unless model_constant?(root_receiver, model_class_name)
+
+        queries << QueryLocation.new(
+          node: node,
+          location: node.location,
+          receiver: root_receiver,
+          method_name: node.name
+        )
+      end
+
+      # @rbs node: untyped
+      # @rbs queries: Array[QueryLocation]
+      # @rbs model_class_name: String
+      # @rbs target_line: Integer?
+      # @rbs return: bool
+      def check_assignment_node(node, queries, model_class_name, target_line)
+        return false if target_line && node.location.start_line != target_line
+
+        value = node.value
+        return false unless value.is_a?(Prism::CallNode)
+
+        root_receiver = find_root_receiver(value)
+        return false unless model_constant?(root_receiver, model_class_name)
+
+        queries << QueryLocation.new(
+          node: value,
+          location: value.location,
+          receiver: root_receiver,
+          method_name: value.name
+        )
+        true
+      end
+
+      # @rbs node: untyped
+      # @rbs return: untyped
+      def find_root_receiver(node)
+        current = node
+        current = current.receiver while current.is_a?(Prism::CallNode) && current.receiver
+        current
+      end
+
+      # @rbs node: untyped
+      # @rbs model_class_name: String
+      # @rbs return: bool
+      def model_constant?(node, model_class_name)
+        return false unless node.is_a?(Prism::ConstantReadNode)
+
+        node.name.to_s == model_class_name
+      end
+
+      # @rbs method_name: Symbol
+      # @rbs return: bool
+      def query_method?(method_name)
+        QUERY_METHODS.include?(method_name)
+      end
+    end
+  end
+end

data/lib/bullematic/ast/parser.rb

@@ -0,0 +1,58 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "prism"
+
+module Bullematic
+  module AST
+    class Parser
+      # @rbs @source_code: String
+      # @rbs @filepath: String?
+
+      class << self
+        #: () -> Hash[String, untyped]
+        def cache
+          @cache ||= {} #: Hash[String, untyped]
+        end
+
+        #: () -> void
+        def clear_cache
+          @cache = {} #: Hash[String, untyped]
+        end
+
+        # @rbs filepath: String
+        # @rbs return: untyped
+        def parse_file(filepath)
+          return cache[filepath] if cache.key?(filepath)
+
+          result = Prism.parse_file(filepath)
+          raise ParseError, result.errors.map(&:message).join("\n") if result.failure?
+
+          cache[filepath] = result
+          result
+        end
+      end
+
+      # @rbs!
+      #   attr_reader source_code: String
+      #   attr_reader filepath: String?
+      attr_reader :source_code, :filepath
+
+      # @rbs source_code: String
+      # @rbs filepath: String?
+      # @rbs return: void
+      def initialize(source_code, filepath: nil)
+        @source_code = source_code
+        @filepath = filepath
+      end
+
+      #: () -> untyped
+      def parse
+        result = Prism.parse(@source_code, filepath: @filepath)
+        raise ParseError, result.errors.map(&:message).join("\n") if result.failure?
+
+        result
+      end
+    end
+  end
+end

data/lib/bullematic/ast/rewriter.rb

@@ -0,0 +1,153 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Bullematic
+  module AST
+    class Rewriter
+      # @rbs!
+      #   type modification = { type: Symbol, offset: Integer, byte_length: Integer, new_text: String, associations: Array[Symbol] }
+
+      Modification = Struct.new(:type, :offset, :byte_length, :new_text, :associations, keyword_init: true)
+
+      # @rbs @source: String
+      # @rbs @modifications: Array[Modification]
+
+      # @rbs!
+      #   attr_reader source: String
+      #   attr_reader modifications: Array[Modification]
+      attr_reader :source, :modifications
+
+      # @rbs source: String
+      # @rbs return: void
+      def initialize(source)
+        @source = source.dup
+        @modifications = []
+      end
+
+      # @rbs query_location: Finder::QueryLocation
+      # @rbs associations: Array[Symbol]
+      # @rbs return: void
+      def add_includes(query_location, associations)
+        return if already_has_includes?(query_location, associations)
+
+        strategy = Bullematic.configuration&.fix_strategy || :includes
+        insert_point = find_insert_point(query_location)
+
+        assoc_string = format_associations(associations)
+        new_text = ".#{strategy}(#{assoc_string})"
+
+        @modifications << Modification.new(
+          type: :insert,
+          offset: insert_point,
+          byte_length: 0,
+          new_text: new_text,
+          associations: associations
+        )
+      end
+
+      #: () -> String
+      def rewrite
+        return @source if @modifications.empty?
+
+        sorted = @modifications.sort_by { |m| -m.offset }
+
+        result = @source.dup
+        sorted.each do |mod|
+          case mod.type
+          when :insert
+            result.insert(mod.offset, mod.new_text)
+          when :replace
+            result[mod.offset, mod.byte_length] = mod.new_text
+          when :delete
+            result[mod.offset, mod.byte_length] = ""
+          end
+        end
+
+        result
+      end
+
+      private
+
+      # @rbs query_location: Finder::QueryLocation
+      # @rbs return: Integer
+      def find_insert_point(query_location)
+        node = query_location.node
+        receiver = query_location.receiver
+
+        if receiver.is_a?(Prism::ConstantReadNode)
+          receiver.location.end_offset
+        else
+          find_chain_insert_point(node)
+        end
+      end
+
+      # @rbs node: untyped
+      # @rbs return: Integer
+      def find_chain_insert_point(node)
+        current = node
+        current = current.receiver while current.is_a?(Prism::CallNode) && current.receiver.is_a?(Prism::CallNode)
+
+        if current.receiver
+          current.receiver.location.end_offset
+        else
+          current.location.start_offset
+        end
+      end
+
+      # @rbs query_location: Finder::QueryLocation
+      # @rbs associations: Array[Symbol]
+      # @rbs return: bool
+      def already_has_includes?(query_location, associations)
+        existing = find_existing_includes(query_location.node)
+        return false if existing.empty?
+
+        associations.all? { |assoc| existing.include?(assoc) }
+      end
+
+      # @rbs node: untyped
+      # @rbs return: Array[Symbol]
+      def find_existing_includes(node)
+        includes = [] #: Array[Symbol]
+        current = node
+
+        while current.is_a?(Prism::CallNode)
+          if %i[includes preload eager_load].include?(current.name)
+            includes.concat(extract_associations_from_call(current))
+          end
+          current = current.receiver
+        end
+
+        includes
+      end
+
+      # @rbs call_node: untyped
+      # @rbs return: Array[Symbol]
+      def extract_associations_from_call(call_node)
+        return [] unless call_node.arguments
+
+        associations = [] #: Array[Symbol]
+        call_node.arguments.arguments.each do |arg|
+          case arg
+          when Prism::SymbolNode
+            associations << arg.value.to_sym
+          when Prism::ArrayNode
+            arg.elements.each do |elem|
+              associations << elem.value.to_sym if elem.is_a?(Prism::SymbolNode)
+            end
+          end
+        end
+        associations
+      end
+
+      # @rbs associations: Array[Symbol]
+      # @rbs return: String
+      def format_associations(associations)
+        if associations.size == 1
+          ":#{associations.first}"
+        else
+          associations.map { |a| ":#{a}" }.join(", ")
+        end
+      end
+    end
+  end
+end

data/lib/bullematic/configuration.rb

@@ -0,0 +1,66 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "logger"
+
+module Bullematic
+  class Configuration
+    # @rbs skip: to avoid empty array warning
+    DEFAULTS = { #: Hash[Symbol, untyped]
+      enabled: true,
+      auto_fix: true,
+      target_paths: %w[app/controllers app/models app/services],
+      skip_paths: [],
+      dry_run: false,
+      backup: false,
+      fix_strategy: :includes,
+      logger: nil,
+      debug: false
+    }.freeze
+
+    # @rbs @enabled: bool
+    # @rbs @auto_fix: bool
+    # @rbs @target_paths: Array[String]
+    # @rbs @skip_paths: Array[String]
+    # @rbs @dry_run: bool
+    # @rbs @backup: bool
+    # @rbs @fix_strategy: Symbol
+    # @rbs @debug: bool
+    # @rbs @logger: Logger?
+
+    # @rbs!
+    #   attr_accessor enabled: bool
+    #   attr_accessor auto_fix: bool
+    #   attr_accessor target_paths: Array[String]
+    #   attr_accessor skip_paths: Array[String]
+    #   attr_accessor dry_run: bool
+    #   attr_accessor backup: bool
+    #   attr_accessor fix_strategy: Symbol
+    #   attr_accessor debug: bool
+    #   attr_writer logger: Logger?
+    attr_accessor :enabled, :auto_fix, :target_paths, :skip_paths,
+                  :dry_run, :backup, :fix_strategy, :debug
+    attr_writer :logger
+
+    #: () -> void
+    def initialize
+      DEFAULTS.each { |key, value| public_send(:"#{key}=", value.dup) }
+    end
+
+    #: () -> Logger
+    def logger
+      @logger ||= default_logger
+    end
+
+    private
+
+    #: () -> Logger
+    def default_logger
+      if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
+        ::Logger.new(Rails.root.join("log", "bullematic.log"))
+      else
+        ::Logger.new($stdout)
+      end
+    end
+  end
+end

data/lib/bullematic/detection.rb

@@ -0,0 +1,109 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Bullematic
+  class Detection
+    # @rbs @type: Symbol
+    # @rbs @base_class: untyped
+    # @rbs @associations: Array[Symbol]
+    # @rbs @call_stack: Array[String]
+    # @rbs @source_file: String?
+    # @rbs @line_number: Integer?
+    # @rbs @method_name: String?
+
+    # @rbs!
+    #   attr_reader type: Symbol
+    #   attr_reader base_class: untyped
+    #   attr_reader associations: Array[Symbol]
+    #   attr_reader call_stack: Array[String]
+    #   attr_reader source_file: String?
+    #   attr_reader line_number: Integer?
+    #   attr_reader method_name: String?
+    attr_reader :type, :base_class, :associations, :call_stack,
+                :source_file, :line_number, :method_name
+
+    # @rbs type: Symbol
+    # @rbs base_class: untyped
+    # @rbs associations: untyped
+    # @rbs call_stack: Array[String]
+    # @rbs return: void
+    def initialize(type:, base_class:, associations:, call_stack:)
+      @type = type
+      @base_class = base_class
+      @associations = normalize_associations(associations)
+      @call_stack = call_stack
+      parse_source_location
+    end
+
+    #: () -> String
+    def model_class_name
+      base_class.to_s
+    end
+
+    #: () -> bool
+    def fixable?
+      !source_file.nil? &&
+        !source_file.empty? &&
+        target_path? &&
+        !skip_path?
+    end
+
+    private
+
+    # @rbs assocs: untyped
+    # @rbs return: Array[Symbol]
+    def normalize_associations(assocs)
+      Array(assocs).map(&:to_sym)
+    end
+
+    #: () -> void
+    def parse_source_location
+      config = Bullematic.configuration
+      return unless config
+
+      target_paths = config.target_paths
+
+      @call_stack.each do |frame|
+        next unless frame.is_a?(String)
+
+        match = frame.match(/\A(.+):(\d+)(?::in `(.+)')?/)
+        next unless match
+
+        filepath = match[1]
+        line = match[2].to_i
+        method = match[3]
+
+        next unless filepath && target_paths.any? { |path| filepath.include?(path) }
+
+        @source_file = filepath
+        @line_number = line
+        @method_name = method
+        break
+      end
+    end
+
+    #: () -> bool
+    def target_path?
+      return false if source_file.nil?
+
+      config = Bullematic.configuration
+      return false unless config
+
+      config.target_paths.any? do |path|
+        source_file&.include?(path)
+      end
+    end
+
+    #: () -> bool
+    def skip_path?
+      return false if source_file.nil?
+
+      config = Bullematic.configuration
+      return false unless config
+
+      config.skip_paths.any? do |path|
+        source_file&.include?(path)
+      end
+    end
+  end
+end

data/lib/bullematic/fixer.rb

@@ -0,0 +1,110 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Bullematic
+  class Fixer
+    class << self
+      #: () -> Array[Detection]
+      def detection_queue
+        @detection_queue ||= [] #: Array[Detection]
+      end
+
+      # @rbs detection: Detection
+      # @rbs return: void
+      def queue(detection)
+        detection_queue << detection
+      end
+
+      #: () -> void
+      def clear
+        @detection_queue = [] #: Array[Detection]
+      end
+
+      #: () -> void
+      def apply_fixes
+        return if detection_queue.empty?
+
+        logger = BullematicLogger.new
+
+        grouped = detection_queue.group_by(&:source_file)
+
+        grouped.each do |filepath, detections|
+          next unless filepath
+
+          process_file(filepath, detections, logger)
+        rescue ParseError, FixError => e
+          logger.log_error(filepath, e)
+        rescue StandardError => e
+          logger.log_error(filepath, e)
+          raise if Bullematic.configuration&.debug
+        end
+
+        logger.log_summary
+        clear
+      end
+
+      private
+
+      # @rbs filepath: String
+      # @rbs detections: Array[Detection]
+      # @rbs logger: BullematicLogger
+      # @rbs return: void
+      def process_file(filepath, detections, logger)
+        return unless File.exist?(filepath)
+
+        original_source = File.read(filepath)
+        parse_result = AST::Parser.parse_file(filepath)
+        finder = AST::Finder.new(parse_result)
+        rewriter = AST::Rewriter.new(original_source)
+
+        detections.each do |detection|
+          location = find_query_location(finder, detection)
+
+          if location.nil?
+            logger.log_skip(filepath, detection, "could not locate query")
+            next
+          end
+
+          rewriter.add_includes(location, detection.associations)
+          logger.log_fix(filepath, detection)
+        end
+
+        new_source = rewriter.rewrite
+
+        return if new_source == original_source
+
+        if Bullematic.configuration&.dry_run
+          logger.log_dry_run(filepath, original_source, new_source)
+        else
+          backup_file(filepath) if Bullematic.configuration&.backup
+          File.write(filepath, new_source)
+        end
+      end
+
+      # @rbs finder: AST::Finder
+      # @rbs detection: Detection
+      # @rbs return: AST::Finder::QueryLocation?
+      def find_query_location(finder, detection)
+        queries = finder.find_model_queries(
+          detection.model_class_name,
+          line_number: detection.line_number
+        )
+
+        return queries.first unless queries.empty?
+
+        return nil unless detection.line_number
+
+        finder.find_query_at_line(detection.line_number)
+      end
+
+      # @rbs filepath: String
+      # @rbs return: void
+      def backup_file(filepath)
+        backup_path = "#{filepath}.bullematic.bak"
+        FileUtils.cp(filepath, backup_path)
+      end
+    end
+  end
+end

data/lib/bullematic/integrations/minitest.rb

@@ -0,0 +1,37 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Bullematic
+  module Integrations
+    module Minitest
+      class << self
+        #: () -> void
+        def setup
+          ::Minitest.after_run do
+            Bullematic::Fixer.apply_fixes if Bullematic.configuration&.enabled && Bullematic.configuration&.auto_fix
+          end
+        end
+      end
+
+      module TestHelper
+        #: () -> void
+        def setup
+          super
+          return unless Bullematic.enabled?
+
+          Bullet.start_request if defined?(Bullet) && Bullet.enable?
+          Bullematic::Fixer.clear
+        end
+
+        #: () -> void
+        def teardown
+          if Bullematic.enabled? && defined?(Bullet) && Bullet.enable?
+            Bullematic::Notifier.process_notifications if Bullet.notification?
+            Bullet.end_request
+          end
+          super
+        end
+      end
+    end
+  end
+end