bullematic 0.1.0 → 0.2.0

data/lib/bullematic/fixer.rb

@@ -1,37 +1,49 @@
 # rbs_inline: enabled
 # frozen_string_literal: true
 
-require "fileutils"
+require "digest"
+require "tempfile"
+require "tmpdir"
 
 module Bullematic
   class Fixer
     class << self
       #: () -> Array[Detection]
       def detection_queue
-        @detection_queue ||= [] #: Array[Detection]
+        queue_mutex.synchronize { queue_store.dup }
       end
 
       # @rbs detection: Detection
       # @rbs return: void
       def queue(detection)
-        detection_queue << detection
+        if EvidenceStore.recording?
+          EvidenceStore.append(detection)
+          return
+        end
+
+        queue_mutex.synchronize do
+          queue_store << detection unless queue_store.any? { |queued| queued.fingerprint == detection.fingerprint }
+        end
       end
 
       #: () -> void
       def clear
-        @detection_queue = [] #: Array[Detection]
+        queue_mutex.synchronize { @detection_queue = [] }
       end
 
-      #: () -> void
+      #: () -> Hash[Symbol, Integer]
       def apply_fixes
-        return if detection_queue.empty?
-
         logger = BullematicLogger.new
+        pending = drain_queue
+        return logger.stats if pending.empty?
 
-        grouped = detection_queue.group_by(&:source_file)
+        grouped = pending.group_by(&:source_file)
 
         grouped.each do |filepath, detections|
-          next unless filepath
+          unless filepath
+            detections.each { |detection| logger.log_skip("(unknown)", detection, "source unavailable") }
+            next
+          end
 
           process_file(filepath, detections, logger)
         rescue ParseError, FixError => e
@@ -42,44 +54,84 @@ module Bullematic
         end
 
         logger.log_summary
-        clear
+        logger.stats
       end
 
       private
 
+      #: () -> Array[Detection]
+      def queue_store
+        @detection_queue ||= [] #: Array[Detection]
+      end
+
+      #: () -> Mutex
+      def queue_mutex
+        @queue_mutex ||= Mutex.new
+      end
+
+      #: () -> Array[Detection]
+      def drain_queue
+        queue_mutex.synchronize do
+          pending = queue_store
+          @detection_queue = []
+          pending
+        end
+      end
+
       # @rbs filepath: String
       # @rbs detections: Array[Detection]
       # @rbs logger: BullematicLogger
       # @rbs return: void
       def process_file(filepath, detections, logger)
-        return unless File.exist?(filepath)
+        detections = detections.reject do |detection|
+          unsafe = !detection.fixable?
+          logger.log_skip(filepath, detection, "outside configured fix scope") if unsafe
+          unsafe
+        end
+        return if detections.empty?
+
+        unless File.exist?(filepath)
+          detections.each { |detection| logger.log_skip(filepath, detection, "source file not found") }
+          return
+        end
+
+        original_source = File.binread(filepath)
+        expected_digest = Digest::SHA256.digest(original_source)
+        current_hexdigest = Digest::SHA256.hexdigest(original_source)
+        detections = detections.reject do |detection|
+          stale = detection.source_digest && detection.source_digest != current_hexdigest
+          logger.log_skip(filepath, detection, "source changed since detection") if stale
+          stale
+        end
+        return if detections.empty?
 
-        original_source = File.read(filepath)
-        parse_result = AST::Parser.parse_file(filepath)
+        parse_result = AST::Parser.new(original_source, filepath: filepath).parse
         finder = AST::Finder.new(parse_result)
         rewriter = AST::Rewriter.new(original_source)
+        changed = [] #: Array[Detection]
 
-        detections.each do |detection|
-          location = find_query_location(finder, detection)
-
-          if location.nil?
-            logger.log_skip(filepath, detection, "could not locate query")
-            next
+        build_requests(finder, detections, logger, filepath).each do |request|
+          detection = request[:detection]
+          result = rewriter.add_includes(request[:location], request[:associations])
+          if result == :changed
+            changed << detection
+          else
+            logger.log_skip(filepath, detection, result.to_s.tr("_", " "))
           end
-
-          rewriter.add_includes(location, detection.associations)
-          logger.log_fix(filepath, detection)
         end
 
         new_source = rewriter.rewrite
 
         return if new_source == original_source
 
+        AST::Parser.new(new_source, filepath: filepath).parse
+
         if Bullematic.configuration&.dry_run
           logger.log_dry_run(filepath, original_source, new_source)
+          changed.each { |detection| logger.log_plan(filepath, detection) }
         else
-          backup_file(filepath) if Bullematic.configuration&.backup
-          File.write(filepath, new_source)
+          atomic_write(filepath, new_source, expected_digest)
+          changed.each { |detection| logger.log_fix(filepath, detection) }
         end
       end
 
@@ -87,23 +139,198 @@ module Bullematic
       # @rbs detection: Detection
       # @rbs return: AST::Finder::QueryLocation?
       def find_query_location(finder, detection)
-        queries = finder.find_model_queries(
+        return nil unless detection.line_number
+
+        queries = finder.find_model_queries_for_variables_at_line(
           detection.model_class_name,
-          line_number: detection.line_number
+          detection.line_number,
+          detection.associations
         )
+        queries.one? ? queries.first : nil
+      end
+
+      # @rbs finder: AST::Finder
+      # @rbs detections: Array[Detection]
+      # @rbs logger: BullematicLogger
+      # @rbs filepath: String
+      # @rbs return: Array[Hash[Symbol, untyped]]
+      def build_requests(finder, detections, logger, filepath)
+        requests = [] #: Array[Hash[Symbol, untyped]]
+        unresolved = [] #: Array[Detection]
 
-        return queries.first unless queries.empty?
+        detections.each do |detection|
+          unless valid_associations?(detection)
+            logger.log_skip(filepath, detection, "invalid association")
+            next
+          end
 
-        return nil unless detection.line_number
+          location = find_query_location(finder, detection)
+          if location
+            requests << { detection: detection, location: location, associations: detection.associations }
+          else
+            unresolved << detection
+          end
+        end
+
+        consumed = [] #: Array[Detection]
+        requests.each do |request|
+          request[:associations] = association_tree(request[:detection], unresolved, consumed, [], finder)
+        end
+        (unresolved - consumed).each { |detection| logger.log_skip(filepath, detection, "could not locate query") }
+        requests
+      end
+
+      # @rbs detection: Detection
+      # @rbs return: bool
+      def valid_associations?(detection)
+        model = constantize_model(detection.model_class_name)
+        return false unless model&.respond_to?(:reflect_on_association)
+
+        detection.associations.all? do |association|
+          reflection = model.reflect_on_association(association)
+          reflection && !reflection.polymorphic?
+        end
+      rescue NameError
+        false
+      end
+
+      # @rbs detection: Detection
+      # @rbs candidates: Array[Detection]
+      # @rbs consumed: Array[Detection]
+      # @rbs seen: Array[String]
+      # @rbs finder: AST::Finder
+      # @rbs return: Array[untyped]
+      def association_tree(detection, candidates, consumed, seen, finder)
+        return detection.associations if seen.include?(detection.model_class_name)
+
+        detection.associations.map do |association|
+          child = nested_detection(detection, association, candidates - consumed, finder)
+          next association unless child
 
-        finder.find_query_at_line(detection.line_number)
+          consumed << child
+          nested = association_tree(child, candidates, consumed, seen + [detection.model_class_name], finder)
+          { association => nested.one? ? nested.first : nested }
+        end
+      end
+
+      # @rbs parent: Detection
+      # @rbs association: Symbol
+      # @rbs candidates: Array[Detection]
+      # @rbs finder: AST::Finder
+      # @rbs return: Detection?
+      def nested_detection(parent, association, candidates, finder)
+        return nil unless parent.context_id
+
+        model = constantize_model(parent.model_class_name)
+        return nil unless model&.respond_to?(:reflect_on_association)
+
+        reflection = model.reflect_on_association(association)
+        return nil unless reflection && !reflection.polymorphic?
+
+        child_class_name = reflection.klass.name
+        return nil unless parent.associations.one? do |parent_association|
+          candidate = model.reflect_on_association(parent_association)
+          candidate && !candidate.polymorphic? && candidate.klass.name == child_class_name
+        end
+
+        matches = candidates.select do |candidate|
+          candidate.context_id == parent.context_id &&
+            same_execution_location?(parent, candidate) &&
+            candidate.model_class_name == child_class_name
+        end
+        return nil unless matches.one?
+
+        child = matches.first
+        finder.nested_association?(association, child.associations, child.line_number) ? child : nil
+      rescue NameError
+        nil
+      end
+
+      # @rbs detection: Detection
+      # @rbs return: String?
+      def normalized_method(detection)
+        detection.method_name&.split(" in ")&.last&.sub(/\Ablock /, "")&.split("#")&.last
+      end
+
+      # @rbs left: Detection
+      # @rbs right: Detection
+      # @rbs return: bool
+      def same_execution_location?(left, right)
+        left_method = normalized_method(left)
+        right_method = normalized_method(right)
+        return left_method == right_method if left_method && right_method
+
+        left.line_number == right.line_number
+      end
+
+      # @rbs name: String
+      # @rbs return: untyped
+      def constantize_model(name)
+        normalized = name.delete_prefix("::")
+        return nil unless normalized.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/)
+
+        normalized.split("::").reduce(Object) { |scope, constant| scope.const_get(constant, false) }
+      end
+
+      # @rbs filepath: String
+      # @rbs source: String
+      # @rbs expected_digest: String
+      # @rbs return: void
+      def atomic_write(filepath, source, expected_digest)
+        raise FixError, "symlink sources are unsupported" if File.symlink?(filepath)
+        raise FixError, "read-only sources are unsupported" if (File.stat(filepath).mode & 0o222).zero?
+
+        lock_name = "bullematic-#{Digest::SHA256.hexdigest(File.expand_path(filepath))}.lock"
+        File.open(File.join(Dir.tmpdir, lock_name), File::RDWR | File::CREAT, 0o600) do |lock|
+          lock.flock(File::LOCK_EX)
+          current_source = File.binread(filepath)
+          raise FixError, "source changed while planning fix" unless Digest::SHA256.digest(current_source) == expected_digest
+
+          mode = File.stat(filepath).mode
+          backup_file(filepath, current_source, mode) if Bullematic.configuration&.backup
+          Tempfile.create([".bullematic", ".tmp"], File.dirname(filepath)) do |tempfile|
+            tempfile.binmode
+            tempfile.write(source)
+            tempfile.flush
+            tempfile.fsync
+            File.chmod(mode, tempfile.path)
+            tempfile.close
+            File.rename(tempfile.path, filepath)
+          end
+          begin
+            File.open(File.dirname(filepath), File::RDONLY, &:fsync)
+          rescue Errno::EACCES, Errno::EINVAL, Errno::EISDIR
+            # Directory fsync is unavailable on some filesystems and Windows.
+          end
+        end
       end
 
       # @rbs filepath: String
+      # @rbs source: String
+      # @rbs mode: Integer
       # @rbs return: void
-      def backup_file(filepath)
+      def backup_file(filepath, source, mode)
         backup_path = "#{filepath}.bullematic.bak"
-        FileUtils.cp(filepath, backup_path)
+        raise FixError, "symlink backup files are unsupported" if File.symlink?(backup_path)
+        if File.exist?(backup_path)
+          raise FixError, "backup path is not a regular file" unless File.file?(backup_path)
+
+          return
+        end
+
+        flags = File::WRONLY | File::CREAT | File::EXCL
+        flags |= File::NOFOLLOW if File.const_defined?(:NOFOLLOW)
+        begin
+          File.open(backup_path, flags, mode & 0o777) do |backup|
+            backup.binmode
+            backup.write(source)
+            backup.flush
+            backup.fsync
+          end
+        rescue Errno::EEXIST, Errno::ELOOP
+          raise FixError, "symlink backup files are unsupported" if File.symlink?(backup_path)
+          raise FixError, "backup path is not a regular file" unless File.file?(backup_path)
+        end
       end
     end
   end

data/lib/bullematic/integrations/minitest.rb

@@ -7,6 +7,8 @@ module Bullematic
       class << self
         #: () -> void
         def setup
+          Bullematic::Fixer.clear
+
           ::Minitest.after_run do
             Bullematic::Fixer.apply_fixes if Bullematic.configuration&.enabled && Bullematic.configuration&.auto_fix
           end
@@ -17,19 +19,31 @@ module Bullematic
         #: () -> void
         def setup
           super
+          @bullematic_request_started = false
           return unless Bullematic.enabled?
 
-          Bullet.start_request if defined?(Bullet) && Bullet.enable?
-          Bullematic::Fixer.clear
+          if defined?(Bullet) && Bullet.enable?
+            Bullet.start_request
+            @bullematic_request_started = true
+          end
         end
 
         #: () -> void
         def teardown
-          if Bullematic.enabled? && defined?(Bullet) && Bullet.enable?
-            Bullematic::Notifier.process_notifications if Bullet.notification?
-            Bullet.end_request
+          begin
+            if @bullematic_request_started
+              begin
+                if Bullematic.enabled? && Bullet.enable?
+                  Bullematic::Notifier.process_notifications(context_id: object_id)
+                end
+              ensure
+                Bullet.end_request
+                @bullematic_request_started = false
+              end
+            end
+          ensure
+            super
           end
-          super
         end
       end
     end

data/lib/bullematic/integrations/rails.rb

@@ -4,12 +4,22 @@
 module Bullematic
   module Integrations
     class Railtie < ::Rails::Railtie
+      BULLET_MIDDLEWARE_INITIALIZER = Bullet::BulletRailtie.initializers.find do |initializer|
+        initializer.name.start_with?("bullet.")
+      end&.name
+
       initializer "bullematic.configure" do |_app|
         Bullematic.setup_bullet_hook if Rails.env.development? || Rails.env.test?
       end
 
-      initializer "bullematic.middleware" do |app|
-        app.middleware.use Bullematic::Middleware if Rails.env.development?
+      initializer "bullematic.middleware", after: BULLET_MIDDLEWARE_INITIALIZER do |app|
+        next unless Rails.env.development?
+
+        if defined?(Bullet::Rack)
+          app.middleware.insert_after Bullet::Rack, Bullematic::Middleware
+        else
+          app.middleware.use Bullematic::Middleware
+        end
       end
     end
   end
@@ -26,15 +36,19 @@ module Bullematic
     # @rbs env: Hash[String, untyped]
     # @rbs return: untyped
     def call(env)
-      return @app.call(env) unless Bullematic.enabled?
-
-      Bullematic::Fixer.clear
-
-      response = @app.call(env)
+      @app.call(env)
+    ensure
+      capture_notifications(env)
+    end
 
-      Bullematic::Fixer.apply_fixes if Bullematic.configuration&.auto_fix
+    private
 
-      response
+    # @rbs env: Hash[String, untyped]
+    # @rbs return: void
+    def capture_notifications(env)
+      if Bullematic.enabled? && EvidenceStore.recording? && defined?(Bullet)
+        Bullematic::Notifier.process_notifications(context_id: env.object_id)
+      end
     end
   end
 end

data/lib/bullematic/integrations/rspec.rb

@@ -8,17 +8,29 @@ module Bullematic
         #: () -> void
         def setup
           ::RSpec.configure do |config|
-            config.before(:each) do
+            config.before(:suite) do
+              Bullematic::Fixer.clear
+            end
+
+            config.before(:each) do |example|
+              example.metadata[:bullematic_request_started] = false
               if Bullematic.enabled?
-                Bullet.start_request if defined?(Bullet) && Bullet.enable?
-                Bullematic::Fixer.clear
+                if defined?(Bullet) && Bullet.enable?
+                  Bullet.start_request
+                  example.metadata[:bullematic_request_started] = true
+                end
               end
             end
 
-            config.after(:each) do
-              if Bullematic.enabled? && defined?(Bullet) && Bullet.enable?
-                Bullematic::Notifier.process_notifications if Bullet.notification?
-                Bullet.end_request
+            config.after(:each) do |example|
+              if example.metadata.delete(:bullematic_request_started)
+                begin
+                  if Bullematic.enabled? && Bullet.enable?
+                    Bullematic::Notifier.process_notifications(context_id: example.id)
+                  end
+                ensure
+                  Bullet.end_request
+                end
               end
             end
 

data/lib/bullematic/logger.rb

@@ -14,7 +14,7 @@ module Bullematic
     # @rbs return: void
     def initialize(logger = nil)
       @logger = logger || Bullematic.configuration&.logger || ::Logger.new($stdout)
-      @stats = { fixed: 0, skipped: 0, errors: 0 }
+      @stats = { fixed: 0, planned: 0, skipped: 0, errors: 0 }
     end
 
     # @rbs message: String
@@ -53,6 +53,14 @@ module Bullematic
       info("  Association: #{detection.associations.inspect}")
     end
 
+    # @rbs filepath: String
+    # @rbs detection: Detection
+    # @rbs return: void
+    def log_plan(filepath, detection)
+      @stats[:planned] += 1
+      info("Planned N+1 fix in #{filepath}:#{detection.line_number}")
+    end
+
     # @rbs filepath: String
     # @rbs detection: Detection
     # @rbs reason: String
@@ -77,27 +85,31 @@ module Bullematic
     # @rbs modified: String
     # @rbs return: void
     def log_dry_run(filepath, original, modified)
-      info("[DRY RUN] Would modify #{filepath}:")
-
       original_lines = original.lines
       modified_lines = modified.lines
-
-      modified_lines.each_with_index do |line, idx|
-        next if original_lines[idx] == line
-
-        info("  - #{original_lines[idx]&.chomp}")
-        info("  + #{line.chomp}")
-      end
+      prefix = 0
+      prefix += 1 while original_lines[prefix] == modified_lines[prefix] && prefix < original_lines.size
+      suffix = 0
+      suffix += 1 while suffix < original_lines.size - prefix && suffix < modified_lines.size - prefix &&
+                        original_lines[-suffix - 1] == modified_lines[-suffix - 1]
+      removed = original_lines.slice(prefix, original_lines.size - prefix - suffix) || []
+      added = modified_lines.slice(prefix, modified_lines.size - prefix - suffix) || []
+      diff = ["[DRY RUN] Would modify #{filepath}:\n", "--- #{filepath}\n", "+++ #{filepath}\n",
+              "@@ -#{prefix + 1},#{removed.size} +#{prefix + 1},#{added.size} @@\n"]
+      removed.each { |line| diff << "-#{line.encode('UTF-8', invalid: :replace, undef: :replace)}" }
+      added.each { |line| diff << "+#{line.encode('UTF-8', invalid: :replace, undef: :replace)}" }
+      info(diff.join)
     end
 
     #: () -> void
     def log_summary
-      info("Summary: #{@stats[:fixed]} fixed, #{@stats[:skipped]} skipped, #{@stats[:errors]} errors")
+      info("Summary: #{@stats[:fixed]} fixed, #{@stats[:planned]} planned, " \
+           "#{@stats[:skipped]} skipped, #{@stats[:errors]} errors")
     end
 
     #: () -> void
     def reset_stats
-      @stats = { fixed: 0, skipped: 0, errors: 0 }
+      @stats = { fixed: 0, planned: 0, skipped: 0, errors: 0 }
     end
   end
 end