bullematic 0.1.0 → 0.2.0

data/lib/bullematic/cli.rb

@@ -0,0 +1,185 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "json"
+require "tempfile"
+
+module Bullematic
+  class CLI
+    class << self
+      # @rbs argv: Array[String]
+      # @rbs return: Integer
+      def run(argv)
+        command = argv.shift
+        case command
+        when "record" then record(command_args(argv))
+        when "plan" then apply(dry_run: true)
+        when "apply" then apply(dry_run: false)
+        when "verify" then verify(command_args(argv))
+        when "fix" then fix(argv)
+        when "doctor" then doctor
+        else
+          warn "Usage: bullematic record -- COMMAND | plan | apply | verify [-- COMMAND] | fix [--verify] -- COMMAND | doctor"
+          1
+        end
+      rescue Error, SystemCallError, JSON::ParserError => error
+        warn "bullematic: #{error.message}"
+        1
+      end
+
+      private
+
+      # @rbs argv: Array[String]
+      # @rbs return: Array[String]
+      def command_args(argv)
+        argv = argv.dup
+        argv.shift if argv.first == "--"
+        argv
+      end
+
+      # @rbs command: Array[String]
+      # @rbs return: Integer
+      def record(command)
+        raise Error, "record requires a command" if command.empty?
+
+        evidence_path = EvidenceStore.path
+        EvidenceStore.clear(evidence_path)
+        write_command(evidence_path, command)
+        run_command(command, evidence_path)
+      end
+
+      # @rbs dry_run: bool
+      # @rbs return: Integer
+      def apply(dry_run:)
+        load_application
+        configure(dry_run)
+        detections = EvidenceStore.read.select { |detection| detection.type == :n_plus_one }
+        raise Error, "no recorded N+1 evidence in #{EvidenceStore.path}" if detections.empty?
+
+        record_file = ENV.delete(EvidenceStore::ENV_KEY)
+        begin
+          detections.each { |detection| Fixer.queue(detection) }
+        ensure
+          ENV[EvidenceStore::ENV_KEY] = record_file if record_file
+        end
+        stats = Fixer.apply_fixes
+        operation = dry_run ? :planned : :fixed
+        raise Error, "#{stats[:errors]} error(s) while applying fixes" if stats[:errors].positive?
+        raise Error, "no safe fixes were #{operation}" if stats[operation].zero?
+
+        0
+      end
+
+      # @rbs argv: Array[String]
+      # @rbs return: Integer
+      def fix(argv)
+        separator = argv.index("--") || argv.length
+        verify_index = argv.first(separator).index("--verify")
+        verify_after = argv.delete_at(verify_index) if verify_index
+        command = command_args(argv)
+        status = record(command)
+        return status unless status.zero?
+
+        status = apply(dry_run: false)
+        return status unless status.zero? && verify_after
+
+        verify(command)
+      end
+
+      # @rbs command: Array[String]
+      # @rbs return: Integer
+      def verify(command)
+        load_application
+        configure(true)
+        original = EvidenceStore.read.select { |detection| detection.type == :n_plus_one }
+        raise Error, "no recorded N+1 evidence in #{EvidenceStore.path}" if original.empty?
+
+        command = read_command(EvidenceStore.path) if command.empty?
+        raise Error, "verify requires a recorded command" if command.empty?
+
+        Tempfile.create(["bullematic-verify", ".jsonl"]) do |file|
+          file.close
+          status = run_command(command, file.path)
+          return status unless status.zero?
+
+          remaining = EvidenceStore.read(file.path).count { |detection| detection.type == :n_plus_one }
+          raise Error, "#{remaining} N+1 warning(s) remain" unless remaining.zero?
+        end
+
+        puts "Bullematic verification passed"
+        0
+      end
+
+      #: () -> Integer
+      def doctor
+        require "bullet"
+        require "prism"
+        raise Error, "unsupported Bullet notification API" unless Notifier.compatible?
+
+        bullet_spec = Gem.loaded_specs.fetch("bullet") #: untyped
+        prism_spec = Gem.loaded_specs.fetch("prism") #: untyped
+        bullet_version = bullet_spec.version
+        prism_version = prism_spec.version
+        puts "Bullematic #{VERSION}; Bullet #{bullet_version}; Prism #{prism_version}: compatible"
+        0
+      end
+
+      # @rbs command: Array[String]
+      # @rbs evidence_path: String
+      # @rbs return: Integer
+      def run_command(command, evidence_path)
+        environment = { "BULLEMATIC" => "1", EvidenceStore::ENV_KEY => evidence_path }
+        system(environment, *command) ? 0 : ($?&.exitstatus || 1)
+      end
+
+      #: () -> void
+      def load_application
+        environment = File.expand_path("config/environment.rb")
+        require environment if File.file?(environment)
+      end
+
+      # @rbs dry_run: bool
+      # @rbs return: void
+      def configure(dry_run)
+        Bullematic.configure do |config|
+          config.auto_fix = true
+          config.dry_run = dry_run
+          config.backup = true
+        end
+      end
+
+      # @rbs evidence_path: String
+      # @rbs command: Array[String]
+      # @rbs return: void
+      def write_command(evidence_path, command)
+        path = "#{evidence_path}.command.json"
+        raise Error, "symlink command files are unsupported" if File.symlink?(path)
+
+        open_command(path, File::WRONLY | File::CREAT | File::TRUNC) do |file|
+          file.chmod(0o600)
+          file.write(JSON.generate(command))
+        end
+      end
+
+      # @rbs evidence_path: String
+      # @rbs return: Array[String]
+      def read_command(evidence_path)
+        path = "#{evidence_path}.command.json"
+        raise Error, "symlink command files are unsupported" if File.symlink?(path)
+        return [] unless File.file?(path)
+
+        value = open_command(path, File::RDONLY) { |file| JSON.parse(file.read) }
+        value.is_a?(Array) && value.all?(String) ? value : []
+      end
+
+      #: (String, Integer) { (File) -> untyped } -> untyped
+      def open_command(path, flags, &block)
+        flags |= File::NOFOLLOW if File.const_defined?(:NOFOLLOW)
+        File.open(path, flags, 0o600, &block)
+      rescue Errno::ELOOP
+        raise Error, "symlink command files are unsupported"
+      end
+
+    end
+  end
+end

data/lib/bullematic/configuration.rb

@@ -5,14 +5,16 @@ require "logger"
 
 module Bullematic
   class Configuration
+    VALID_FIX_STRATEGIES = %i[includes preload eager_load].freeze #: Array[Symbol]
+
     # @rbs skip: to avoid empty array warning
     DEFAULTS = { #: Hash[Symbol, untyped]
       enabled: true,
-      auto_fix: true,
+      auto_fix: false,
       target_paths: %w[app/controllers app/models app/services],
       skip_paths: [],
-      dry_run: false,
-      backup: false,
+      dry_run: true,
+      backup: true,
       fix_strategy: :includes,
       logger: nil,
       debug: false
@@ -39,7 +41,8 @@ module Bullematic
     #   attr_accessor debug: bool
     #   attr_writer logger: Logger?
     attr_accessor :enabled, :auto_fix, :target_paths, :skip_paths,
-                  :dry_run, :backup, :fix_strategy, :debug
+                  :dry_run, :backup, :debug
+    attr_reader :fix_strategy
     attr_writer :logger
 
     #: () -> void
@@ -52,6 +55,14 @@ module Bullematic
       @logger ||= default_logger
     end
 
+    # @rbs strategy: Symbol
+    # @rbs return: Symbol
+    def fix_strategy=(strategy)
+      raise ArgumentError, "invalid fix strategy: #{strategy.inspect}" unless VALID_FIX_STRATEGIES.include?(strategy)
+
+      @fix_strategy = strategy
+    end
+
     private
 
     #: () -> Logger

data/lib/bullematic/detection.rb

@@ -1,6 +1,9 @@
 # rbs_inline: enabled
 # frozen_string_literal: true
 
+require "pathname"
+require "digest"
+
 module Bullematic
   class Detection
     # @rbs @type: Symbol
@@ -10,6 +13,8 @@ module Bullematic
     # @rbs @source_file: String?
     # @rbs @line_number: Integer?
     # @rbs @method_name: String?
+    # @rbs @context_id: untyped
+    # @rbs @source_digest: String?
 
     # @rbs!
     #   attr_reader type: Symbol
@@ -19,20 +24,60 @@ module Bullematic
     #   attr_reader source_file: String?
     #   attr_reader line_number: Integer?
     #   attr_reader method_name: String?
+    #   attr_reader context_id: untyped
+    #   attr_reader source_digest: String?
     attr_reader :type, :base_class, :associations, :call_stack,
-                :source_file, :line_number, :method_name
+                :source_file, :line_number, :method_name, :context_id, :source_digest
 
     # @rbs type: Symbol
     # @rbs base_class: untyped
     # @rbs associations: untyped
     # @rbs call_stack: Array[String]
+    # @rbs context_id: untyped
+    # @rbs source_digest: String?
     # @rbs return: void
-    def initialize(type:, base_class:, associations:, call_stack:)
+    def initialize(type:, base_class:, associations:, call_stack:, context_id: nil, source_digest: nil)
       @type = type
       @base_class = base_class
       @associations = normalize_associations(associations)
       @call_stack = call_stack
+      @context_id = context_id
       parse_source_location
+      @source_digest = source_digest || current_source_digest
+    end
+
+    # @rbs data: Hash[String, untyped]
+    # @rbs return: Detection
+    def self.from_h(data)
+      type = data.fetch("type").to_s.to_sym
+      associations = data.fetch("associations")
+      call_stack = data.fetch("call_stack")
+      raise ArgumentError, "invalid evidence type" unless %i[n_plus_one unused_eager_loading].include?(type)
+      raise ArgumentError, "invalid evidence associations" unless associations.is_a?(Array)
+      raise ArgumentError, "invalid evidence call stack" unless call_stack.is_a?(Array)
+      source_digest = data["source_digest"]
+      raise ArgumentError, "invalid evidence source digest" unless source_digest.is_a?(String) && source_digest.match?(/\A[0-9a-f]{64}\z/)
+
+      new(
+        type: type,
+        base_class: data.fetch("base_class"),
+        associations: associations,
+        call_stack: call_stack,
+        context_id: data["context_id"],
+        source_digest: source_digest
+      )
+    end
+
+    # @rbs return: Hash[String, untyped]
+    def to_h
+      {
+        "type" => type.to_s,
+        "base_class" => model_class_name,
+        "associations" => associations.map(&:to_s),
+        "call_stack" => call_stack.map(&:to_s),
+        "context_id" => context_id,
+        "source_digest" => source_digest
+      }
     end
 
     #: () -> String
@@ -44,16 +89,25 @@ module Bullematic
     def fixable?
       !source_file.nil? &&
         !source_file.empty? &&
+        !associations.empty? &&
         target_path? &&
         !skip_path?
     end
 
+    #: () -> Array[untyped]
+    def fingerprint
+      [type, context_id, source_file, line_number, model_class_name, associations.sort]
+    end
+
     private
 
     # @rbs assocs: untyped
     # @rbs return: Array[Symbol]
     def normalize_associations(assocs)
-      Array(assocs).map(&:to_sym)
+      values = Array(assocs) #: Array[untyped]
+      values.filter_map do |association|
+        association.to_sym if association.is_a?(String) || association.is_a?(Symbol)
+      end.uniq
     end
 
     #: () -> void
@@ -63,19 +117,19 @@ module Bullematic
 
       target_paths = config.target_paths
 
-      @call_stack.each do |frame|
-        next unless frame.is_a?(String)
+      @call_stack.each do |raw_frame|
+        frame = raw_frame.to_s
 
-        match = frame.match(/\A(.+):(\d+)(?::in `(.+)')?/)
+        match = frame.match(/\A(.+):(\d+)(?::in [`'](.+)')?\z/)
         next unless match
 
         filepath = match[1]
         line = match[2].to_i
         method = match[3]
 
-        next unless filepath && target_paths.any? { |path| filepath.include?(path) }
+        next unless filepath && path_in?(filepath, target_paths)
 
-        @source_file = filepath
+        @source_file = absolute_path(filepath).to_s
         @line_number = line
         @method_name = method
         break
@@ -89,9 +143,7 @@ module Bullematic
       config = Bullematic.configuration
       return false unless config
 
-      config.target_paths.any? do |path|
-        source_file&.include?(path)
-      end
+      path_in?(source_file, config.target_paths)
     end
 
     #: () -> bool
@@ -101,9 +153,54 @@ module Bullematic
       config = Bullematic.configuration
       return false unless config
 
-      config.skip_paths.any? do |path|
-        source_file&.include?(path)
+      path_in?(source_file, config.skip_paths)
+    end
+
+    # @rbs filepath: String
+    # @rbs paths: Array[String]
+    # @rbs return: bool
+    def path_in?(filepath, paths)
+      source = expand_path(filepath)
+
+      paths.any? do |path|
+        next false unless path.is_a?(String) && !path.empty?
+
+        target = expand_path(path)
+        source == target || source.to_s.start_with?("#{target}#{File::SEPARATOR}")
+      end
+    end
+
+    # @rbs path: String
+    # @rbs return: Pathname
+    def expand_path(path)
+      expanded = absolute_path(path)
+      return expanded unless expanded.exist?
+
+      begin
+        expanded.realpath
+      rescue Errno::ENOENT, Errno::EACCES
+        expanded
       end
     end
+
+    # @rbs path: String
+    # @rbs return: Pathname
+    def absolute_path(path)
+      pathname = Pathname.new(path)
+      return pathname if path.match?(%r{\A[A-Za-z]:[\\/]})
+      return pathname.expand_path if pathname.absolute?
+
+      root = defined?(Rails) && Rails.respond_to?(:root) && Rails.root ? Rails.root : Dir.pwd
+      Pathname.new(root).join(pathname).expand_path
+    end
+
+    # @rbs return: String?
+    def current_source_digest
+      return unless source_file && File.file?(source_file)
+
+      Digest::SHA256.hexdigest(File.binread(source_file))
+    rescue Errno::ENOENT, Errno::EACCES
+      nil
+    end
   end
 end

data/lib/bullematic/evidence_store.rb

@@ -0,0 +1,78 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Bullematic
+  class EvidenceStore
+    ENV_KEY = "BULLEMATIC_RECORD_FILE"
+    DEFAULT_PATH = ".bullematic/evidence.jsonl"
+
+    class << self
+      #: () -> bool
+      def recording?
+        !ENV[ENV_KEY].to_s.empty?
+      end
+
+      #: () -> String
+      def path
+        File.expand_path(ENV.fetch(ENV_KEY, DEFAULT_PATH))
+      end
+
+      # @rbs detection: Detection
+      # @rbs filepath: String
+      # @rbs return: void
+      def append(detection, filepath = path)
+        FileUtils.mkdir_p(File.dirname(filepath))
+        reject_symlink!(filepath)
+        open_evidence(filepath, File::WRONLY | File::CREAT | File::APPEND) do |file|
+          file.flock(File::LOCK_EX)
+          file.puts(JSON.generate(detection.to_h))
+        end
+      end
+
+      # @rbs filepath: String
+      # @rbs return: void
+      def clear(filepath = path)
+        FileUtils.mkdir_p(File.dirname(filepath))
+        reject_symlink!(filepath)
+        open_evidence(filepath, File::WRONLY | File::CREAT | File::TRUNC) {}
+      end
+
+      # @rbs filepath: String
+      # @rbs return: Array[Detection]
+      def read(filepath = path)
+        reject_symlink!(filepath)
+        return [] unless File.file?(filepath)
+
+        detections = open_evidence(filepath, File::RDONLY) do |file|
+          file.each_line.filter_map do |line|
+            next if line.strip.empty?
+
+            Detection.from_h(JSON.parse(line))
+          end
+        end
+        detections.uniq(&:fingerprint)
+      rescue JSON::ParserError, KeyError, ArgumentError, TypeError => error
+        raise Error, "invalid evidence file #{filepath}: #{error.message}"
+      end
+
+      private
+
+      # @rbs filepath: String
+      # @rbs return: void
+      def reject_symlink!(filepath)
+        raise Error, "symlink evidence files are unsupported" if File.symlink?(filepath)
+      end
+
+      #: (String, Integer) { (File) -> untyped } -> untyped
+      def open_evidence(filepath, flags, &block)
+        flags |= File::NOFOLLOW if File.const_defined?(:NOFOLLOW)
+        File.open(filepath, flags, 0o600, &block)
+      rescue Errno::ELOOP
+        raise Error, "symlink evidence files are unsupported"
+      end
+    end
+  end
+end