devformance 0.1.0

data/lib/devformance/test_framework/minitest.rb

@@ -0,0 +1,71 @@
+require_relative "base"
+
+module Devformance
+  module TestFramework
+    class Minitest < Base
+      def file_pattern
+        "test/integration/*_test.rb"
+      end
+
+      def discover_files
+        @discover_files ||= Dir.glob(root_path.join(file_pattern)).sort
+      end
+
+      def run_command(file_path, coverage: false)
+        [ "bundle", "exec", "rails", "test", "-vc", file_path ]
+      end
+
+      def runner_command
+        "bundle exec rails test -vc"
+      end
+
+      def parse_summary(output)
+        if output =~ /(\d+)\s+tests?,\s+(\d+)\s+assertions?,\s+(\d+)\s+failures?(?:,\s+(\d+)\s+errors?)?(?:,\s+(\d+)\s+skips?)?/m
+          tests     = $1.to_i
+          failures  = $3.to_i
+          errors    = $4.to_i rescue 0
+          skips     = $5.to_i rescue 0
+          passes    = tests - failures - errors - skips
+          { examples: tests, failures: failures + errors, pending: skips, passes: passes }
+        elsif output =~ /(\d+)\s+runs?,\s+(\d+)\s+assertions?,\s+(\d+)\s+failures?(?:,\s+(\d+)\s+errors?)?(?:,\s+(\d+)\s+skips?)?/m
+          runs      = $1.to_i
+          failures  = $3.to_i
+          errors    = $4.to_i rescue 0
+          skips     = $5.to_i rescue 0
+          passes    = runs - failures - errors - skips
+          { examples: runs, failures: failures + errors, pending: skips, passes: passes }
+        else
+          { examples: 0, failures: 0, pending: 0, passes: 0 }
+        end
+      end
+
+      def classify_line(line)
+        if line.match?(/(\d+)\s+tests?,\s+(\d+)\s+assertions?/)
+          "summary"
+        elsif line.match?(/^\s*\.+\s/) || line.include?("PASS")
+          "pass"
+        elsif line.match?(/^\s*[FE]+\s/) || line.include?("FAIL") || line.include?("ERROR")
+          "fail"
+        elsif line.include?("SKIP")
+          "pending"
+        elsif line.match?(/Line Coverage:\s*([\d.]+)%/)
+          "coverage"
+        else
+          "info"
+        end
+      end
+
+      def extract_coverage(line)
+        line.match(/Line Coverage:\s*([\d.]+)%/)&.[](1)&.to_f
+      end
+
+      def name
+        "Minitest"
+      end
+
+      def test_terminal_command(file_path)
+        "bundle exec rails test #{file_path}"
+      end
+    end
+  end
+end

data/lib/devformance/test_framework/registry.rb

@@ -0,0 +1,24 @@
+require_relative "base"
+require_relative "rspec"
+require_relative "minitest"
+require_relative "detector"
+
+module Devformance
+  module TestFramework
+    class Registry
+      FRAMEWORKS = {
+        "rspec"    => RSpec,
+        "minitest" => Minitest,
+        "test"     => Minitest
+      }.freeze
+
+      def self.for_name(name)
+        FRAMEWORKS[name.to_s.downcase]
+      end
+
+      def self.all_frameworks
+        FRAMEWORKS.values.uniq
+      end
+    end
+  end
+end

data/lib/devformance/test_framework/rspec.rb

@@ -0,0 +1,60 @@
+require_relative "base"
+
+module Devformance
+  module TestFramework
+    class RSpec < Base
+      def file_pattern
+        "spec/**/*_spec.rb"
+      end
+
+      def discover_files
+        @discover_files ||= Dir.glob(root_path.join(file_pattern)).sort
+      end
+
+      def run_command(file_path, coverage: false)
+        [ "bundle", "exec", "rspec", file_path, "--format", "documentation" ]
+      end
+
+      def runner_command
+        "bundle exec rspec"
+      end
+
+      def parse_summary(output)
+        if output =~ /(\d+)\s+examples?,\s+(\d+)\s+failures?(?:,\s+(\d+)\s+pending)?/m
+          examples = $1.to_i
+          failures = $2.to_i
+          pending  = $3.to_i rescue 0
+          { examples: examples, failures: failures, pending: pending, passes: examples - failures - pending }
+        else
+          { examples: 0, failures: 0, pending: 0, passes: 0 }
+        end
+      end
+
+      def classify_line(line)
+        if line.match?(/(\d+)\s+examples?,\s+(\d+)\s+failures?/)
+          "summary"
+        elsif line.match?(/^\s*[·.]\s/) || line.strip.start_with?(".")
+          "pass"
+        elsif line.match?(/^\s*[F!]\s/) || line.strip.start_with?("F")
+          "fail"
+        elsif line.match?(/^\s*\*\s/) || line.strip.start_with?("*")
+          "pending"
+        elsif line.include?("ERROR") || line.include?("Error:")
+          "error"
+        elsif line.match?(/^\s{3,}/)
+          "pass"
+        else
+          "info"
+        end
+      end
+
+      def name
+        "RSpec"
+      end
+
+      def test_terminal_command(file_path)
+        "bundle exec rspec #{file_path} --format documentation"
+      end
+    end
+  end
+end

data/lib/devformance/test_helper.rb

@@ -0,0 +1,42 @@
+require "simplecov"
+
+module Devformance
+  module TestHelper
+    def self.setup_coverage!
+      return if defined?(@coverage_setup_done)
+      return unless ENV["COVERAGE"] == "true" || ENV["SIMPLECOV"] == "true"
+
+      @coverage_setup_done = true
+
+      SimpleCov.start do
+        add_filter "/vendor/"
+        add_filter "/spec/"
+
+        unless ENV["DEVMETRICS_INCLUDE_TESTS"] == "true"
+          add_filter "/test/"
+        end
+
+        add_filter "/config/"
+        add_filter "/db/"
+
+        if defined?(Devformance) && Devformance.configuration
+          minimum_coverage Devformance.configuration.coverage_minimum_coverage || 80
+          coverage_dir Devformance.configuration.coverage_dir || "coverage"
+        end
+      end
+    end
+
+    def self.coverage_summary
+      return nil unless defined?(SimpleCov) && SimpleCov.result
+
+      result = SimpleCov.result
+      return nil if result.total_lines.zero?
+
+      {
+        overall: result.covered_percent.round(1),
+        lines: { covered: result.covered_lines, total: result.total_lines },
+        branches: { covered: result.covered_branches, total: result.total_branches }
+      }
+    end
+  end
+end

data/lib/devformance/version.rb

@@ -0,0 +1,3 @@
+module Devformance
+  Version = "0.1.0"
+end

data/lib/devformance.rb

@@ -0,0 +1,196 @@
+begin
+  require "devformance/version"
+  require "devformance/engine"
+rescue LoadError
+  # Running as standalone app - engine/version not available
+end
+
+require "cgi"
+require "benchmark"
+require "json"
+require "securerandom"
+
+# Optional dependencies — loaded if present in host app
+%w[importmap-rails turbo-rails stimulus-rails propshaft bullet].each do |dep|
+  begin
+    require dep
+  rescue LoadError
+    # Optional dependency not available
+  end
+end
+
+require_relative "devformance/compatibility"
+require_relative "devformance/test_framework/registry"
+require_relative "devformance/test_helper"
+
+module Devformance
+  class Configuration
+    attr_accessor :log_file_path, :slow_query_threshold_ms, :preferred_framework, :coverage_enabled
+    attr_accessor :coverage_dir, :coverage_minimum_coverage
+
+    VALID_FRAMEWORKS = %i[rspec minitest].freeze
+
+    def initialize
+      @log_file_path = "devformance.log"
+      @slow_query_threshold_ms = 100
+      @preferred_framework = :rspec
+      @coverage_enabled = true
+      @coverage_dir = "coverage"
+      @coverage_minimum_coverage = 80
+    end
+
+    def preferred_framework=(value)
+      normalized = value.is_a?(Symbol) ? value : value.to_sym.downcase if value
+      if normalized && !VALID_FRAMEWORKS.include?(normalized)
+        raise ArgumentError, "Invalid framework: #{value}. Valid options: #{VALID_FRAMEWORKS.join(', ')}"
+      end
+      @preferred_framework = normalized
+    end
+
+    def framework_adapter
+      return nil unless @preferred_framework
+
+      framework_class = Devformance::TestFramework::Registry.for_name(@preferred_framework.to_s)
+      return nil unless framework_class && defined?(Rails)
+
+      framework_class.new(Rails.root)
+    end
+
+    def coverage?
+      @coverage_enabled != false
+    end
+  end
+
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def setup
+      yield(configuration)
+    end
+
+    def log_path
+      # Use Rails.root if defined (host app), otherwise current dir
+      if defined?(Rails) && Rails.root
+        Rails.root.join(configuration.log_file_path)
+      else
+        Pathname.new(configuration.log_file_path)
+      end
+    end
+  end
+
+  module PerformanceHelpers
+    def self.setup_test_run!
+      return unless ENV["DEVMETRICS_TRACKING"] == "true"
+
+      # Clear and initialize the log file
+      File.write(Devformance.log_path, "--- Devformance Performance Run: #{Time.current} ---\n")
+
+      @total_tests = 0
+      @passed_tests = 0
+      @failed_tests = 0
+      @start_time = Time.current
+
+      # SQL subscriptions
+      ActiveSupport::Notifications.subscribe("sql.active_record") do |_, start, finish, _, payload|
+        next if payload[:sql] =~ /\A\s*(BEGIN|COMMIT|ROLLBACK|SAVEPOINT|RELEASE|SET|SHOW|pragma)/i
+        next if payload[:name]&.match?(/SCHEMA|ActiveRecord/)
+
+        duration = ((finish - start) * 1000).round(2)
+        if duration > Devformance.configuration.slow_query_threshold_ms
+          Thread.current[:devformance_slow_queries] ||= []
+          Thread.current[:devformance_slow_queries] << { sql: payload[:sql].squish.truncate(100), duration: duration }
+        end
+      end
+
+      # Controller processing subscriptions
+      ActiveSupport::Notifications.subscribe("process_action.action_controller") do |_, start, finish, _, payload|
+        Thread.current[:devformance_current_action] = {
+          controller: payload[:controller],
+          action: payload[:action],
+          duration: ((finish - start) * 1000).round(2),
+          db_runtime: payload[:db_runtime]&.round(2)
+        }
+      end
+
+      if defined?(Bullet)
+        Bullet.enable = true
+        Bullet.bullet_logger = true
+      end
+    end
+
+    def self.log_example_result(example)
+      return unless ENV["DEVMETRICS_TRACKING"] == "true"
+      @total_tests += 1
+      if example.exception
+        @failed_tests += 1
+      else
+        @passed_tests += 1
+      end
+
+      action_data = Thread.current[:devformance_current_action] || {}
+      slow_queries = Thread.current[:devformance_slow_queries] || []
+
+      n_plus_one_count = 0
+      if defined?(Bullet) && Bullet.notification_collector.notifications_present?
+        n_plus_one_count = Bullet.notification_collector.collection.size
+      end
+
+      log_row = {
+        timestamp: Time.current.strftime("%H:%M:%S"),
+        controller: action_data[:controller] || "N/A",
+        action: action_data[:action] || "N/A",
+        duration_ms: action_data[:duration] || 0.0,
+        slow_queries: slow_queries.size,
+        n_plus_one_issues: n_plus_one_count,
+        status: example.exception ? "FAILED" : "PASSED",
+        example: example.full_description.truncate(100)
+      }
+
+      File.open(Devformance.log_path, "a") { |f| f.puts(log_row.to_json) }
+
+      # Reset state for next example
+      Thread.current[:devformance_current_action] = nil
+      Thread.current[:devformance_slow_queries] = nil
+      Bullet.notification_collector.clear if defined?(Bullet)
+    end
+
+    def self.finish_test_run!
+      return unless ENV["DEVMETRICS_TRACKING"] == "true" && @start_time
+
+      total_duration = (Time.current - @start_time).round(3)
+
+      summary = {
+        type: "SUMMARY",
+        total_time_s: total_duration,
+        total_tests: @total_tests,
+        passed: @passed_tests,
+        failed: @failed_tests,
+        timestamp: Time.current.to_s
+      }
+
+      File.open(Devformance.log_path, "a") do |f|
+        f.puts "\n--- Summary ---"
+        f.puts summary.to_json
+      end
+    end
+  end
+end
+
+# Auto-configure RSpec if present
+if defined?(RSpec) && RSpec.respond_to?(:configure)
+  RSpec.configure do |config|
+    config.before(:suite) do
+      ::Devformance::PerformanceHelpers.setup_test_run!
+    end
+
+    config.after(:each) do |example|
+      ::Devformance::PerformanceHelpers.log_example_result(example)
+    end
+
+    config.after(:suite) do
+      ::Devformance::PerformanceHelpers.finish_test_run!
+    end
+  end
+end

data/lib/generators/devformance/install/install_generator.rb

@@ -0,0 +1,73 @@
+require "rails/generators"
+require "rails/generators/migration"
+
+module Devformance
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Installs Devformance: copies migrations and creates an initializer."
+
+      def self.next_migration_number(dir)
+        Time.now.utc.strftime("%Y%m%d%H%M%S")
+      end
+
+      def create_initializer
+        template "initializer.rb", "config/initializers/devformance.rb"
+      end
+
+      def copy_migrations
+        migration_template(
+          "create_performance_runs.rb.erb",
+          "db/migrate/create_performance_runs.rb"
+        )
+        sleep 1
+        migration_template(
+          "create_slow_queries.rb.erb",
+          "db/migrate/create_slow_queries.rb"
+        )
+        sleep 1
+        migration_template(
+          "add_run_id_to_slow_queries.rb.erb",
+          "db/migrate/add_run_id_to_slow_queries.rb"
+        )
+        sleep 1
+        migration_template(
+          "add_columns_to_slow_queries.rb.erb",
+          "db/migrate/add_columns_to_slow_queries.rb"
+        )
+        sleep 1
+        migration_template(
+          "create_devformance_runs.rb.erb",
+          "db/migrate/create_devformance_runs.rb"
+        )
+        sleep 1
+        migration_template(
+          "create_devformance_file_results.rb.erb",
+          "db/migrate/create_devformance_file_results.rb"
+        )
+      end
+
+      def mount_instructions
+        route_exists = File.read("config/routes.rb").include?("devformance")
+        if route_exists
+          say "\n  Devformance is already mounted in config/routes.rb\n", :green
+        else
+          say "\n  Add this line to your config/routes.rb:\n\n", :yellow
+          say "    mount ::Devformance::Engine, at: \"/devformance\"\n\n", :cyan
+          say "  Then visit http://localhost:3000/devformance\n\n", :green
+        end
+
+        say "  If you use RSpec, tag your request specs to instrument them:\n\n"
+        say "    require 'devformance'\n"
+        say "    RSpec.describe 'Posts API', devformance: true do\n"
+        say "      ...\n"
+        say "    end\n\n"
+
+        say "  Then run: bin/rails db:migrate\n", :green
+      end
+    end
+  end
+end

data/lib/generators/devformance/install/templates/add_columns_to_slow_queries.rb.erb

@@ -0,0 +1,7 @@
+class AddColumnsToSlowQueries < ActiveRecord::Migration[7.2]
+  def change
+    add_column :slow_queries, :sql, :text unless column_exists?(:slow_queries, :sql)
+    add_column :slow_queries, :duration_ms, :float unless column_exists?(:slow_queries, :duration_ms)
+    add_column :slow_queries, :file_key, :string unless column_exists?(:slow_queries, :file_key)
+  end
+end

data/lib/generators/devformance/install/templates/add_run_id_to_slow_queries.rb.erb

@@ -0,0 +1,10 @@
+class AddRunIdToSlowQueries < ActiveRecord::Migration[7.2]
+  def change
+    unless column_exists?(:slow_queries, :run_id)
+      add_column :slow_queries, :run_id, :string
+    end
+    unless index_exists?(:slow_queries, :run_id)
+      add_index :slow_queries, :run_id
+    end
+  end
+end

data/lib/generators/devformance/install/templates/create_devformance_file_results.rb.erb

@@ -0,0 +1,29 @@
+class CreateDevformanceFileResults < ActiveRecord::Migration[7.2]
+  def change
+    unless table_exists?(:devformance_file_results)
+      create_table :devformance_file_results do |t|
+        t.string  :run_id,           null: false
+        t.string  :file_key,         null: false
+        t.string  :file_path
+        t.integer :status,           default: 0, null: false
+        t.integer :total_tests,      default: 0
+        t.integer :passed_tests,     default: 0
+        t.integer :failed_tests,     default: 0
+        t.integer :slow_query_count, default: 0
+        t.integer :n1_count,         default: 0
+        t.float   :coverage
+        t.integer :duration_ms
+        t.string  :log_path
+
+        t.timestamps
+      end
+
+      unless index_exists?(:devformance_file_results, :run_id)
+        add_index :devformance_file_results, :run_id
+      end
+      unless index_exists?(:devformance_file_results, [:run_id, :file_key])
+        add_index :devformance_file_results, [:run_id, :file_key], unique: true
+      end
+    end
+  end
+end

data/lib/generators/devformance/install/templates/create_devformance_runs.rb.erb

@@ -0,0 +1,20 @@
+class CreateDevformanceRuns < ActiveRecord::Migration[7.2]
+  def change
+    unless table_exists?(:devformance_runs)
+      create_table :devformance_runs do |t|
+        t.string   :run_id,          null: false
+        t.integer  :status,          default: 0, null: false
+        t.datetime :started_at
+        t.datetime :finished_at
+        t.integer  :total_files,     default: 0
+        t.integer  :completed_files, default: 0
+
+        t.timestamps
+      end
+
+      unless index_exists?(:devformance_runs, :run_id)
+        add_index :devformance_runs, :run_id, unique: true
+      end
+    end
+  end
+end

data/lib/generators/devformance/install/templates/create_performance_runs.rb.erb

@@ -0,0 +1,14 @@
+class CreatePerformanceRuns < ActiveRecord::Migration[7.2]
+  def change
+    unless table_exists?(:performance_runs)
+      create_table :performance_runs do |t|
+        t.string :run_id
+        t.integer :total_files
+        t.integer :completed_files
+        t.string :status
+
+        t.timestamps
+      end
+    end
+  end
+end

data/lib/generators/devformance/install/templates/create_slow_queries.rb.erb

@@ -0,0 +1,13 @@
+class CreateSlowQueries < ActiveRecord::Migration[7.2]
+  def change
+    unless table_exists?(:slow_queries)
+      create_table :slow_queries do |t|
+        t.string  :model_class
+        t.integer :line_number
+        t.text    :fix_suggestion
+
+        t.timestamps
+      end
+    end
+  end
+end

data/lib/generators/devformance/install/templates/initializer.rb

@@ -0,0 +1,23 @@
+Devformance.setup do |config|
+  # Test framework to use for test runs (default: :rspec)
+  # Options: :rspec, :minitest
+  # config.preferred_framework = :rspec
+
+  # Slow query threshold in milliseconds (queries above this are logged)
+  # config.slow_query_threshold_ms = 100
+
+  # Coverage tracking (SimpleCov)
+  # Enable or disable code coverage collection
+  # config.coverage_enabled = true
+
+  # Directory where coverage reports are stored
+  # config.coverage_dir = "coverage"
+
+  # Minimum coverage percentage (for alerts/warnings)
+  # config.coverage_minimum_coverage = 80
+end
+
+# Enable coverage when running tests (optional - uncomment if desired)
+# if ENV["COVERAGE"] == "true" || ENV["SIMPLECOV"] == "true"
+#   Devformance::TestHelper.setup_coverage!
+# end

data/lib/tasks/devformance.rake

@@ -0,0 +1,45 @@
+require_relative "../../lib/devformance/test_helper"
+
+namespace :devformance do
+  desc "Run tests with coverage"
+  task :test_with_coverage, [ :framework ] do |t, args|
+    framework = args[:framework] || Devformance.configuration.preferred_framework || "auto"
+
+    puts "Running Devformance tests with coverage (#{framework})..."
+    puts ""
+
+    ENV["COVERAGE"] = "true"
+    ENV["SIMPLECOV"] = "true"
+
+    Devformance::TestHelper.setup_coverage!
+
+    if framework == "minitest" || (framework == "auto" && Devformance.configuration.framework_adapter&.name == "Minitest")
+      sh "bundle exec rails test -vc"
+    else
+      sh "bundle exec rspec"
+    end
+
+    summary = Devformance::TestHelper.coverage_summary
+    if summary
+      puts ""
+      puts "Coverage Results:"
+      puts "  Overall: #{summary[:overall]}%"
+      puts "  Lines: #{summary[:lines][:covered]}/#{summary[:lines][:total]}"
+    end
+  end
+
+  desc "Run tests (auto-detect framework)"
+  task :test do
+    Rake::Task["devformance:test_with_coverage"].invoke("auto")
+  end
+
+  desc "Run RSpec tests with coverage"
+  task :rspec do
+    Rake::Task["devformance:test_with_coverage"].invoke("rspec")
+  end
+
+  desc "Run Minitest tests with coverage"
+  task :minitest do
+    Rake::Task["devformance:test_with_coverage"].invoke("minitest")
+  end
+end

data/spec/fixtures/devformance/devformance_run.rb

@@ -0,0 +1,27 @@
+FactoryBot.define do
+  factory :devformance_run, class: "Devformance::Run" do
+    run_id { SecureRandom.hex(8) }
+    status { :pending }
+    started_at { Time.current }
+    finished_at { nil }
+    total_files { 10 }
+    completed_files { 0 }
+  end
+
+  trait :running do
+    status { :running }
+    completed_files { 3 }
+  end
+
+  trait :completed do
+    status { :completed }
+    completed_files { 10 }
+    finished_at { Time.current }
+  end
+
+  trait :failed do
+    status { :failed }
+    completed_files { 5 }
+    finished_at { Time.current }
+  end
+end