testlint_sdk/runtime_coverage/

ruby.rs

use crate::platform::{process_exists, signal_process, ProcessSignal};
use crate::runtime_coverage::{CoverageSummary, RuntimeCoverageResult};
use std::fs;
use std::path::Path;
use std::process::Command;
use std::thread;
use std::time::Duration;

pub struct RubyRuntimeCoverage;

impl Default for RubyRuntimeCoverage {
    fn default() -> Self {
        Self::new()
    }
}

impl RubyRuntimeCoverage {
    pub fn new() -> Self {
        RubyRuntimeCoverage
    }

    /// Attach to a running Ruby process and collect coverage continuously
    pub fn attach_and_collect(&self, pid: u32) -> Result<RuntimeCoverageResult, String> {
        println!("💎 Attaching coverage to Ruby process PID: {}", pid);
        println!("📊 Collecting coverage continuously (press Ctrl+C to stop)...");

        // Check if process exists
        self.check_process_exists(pid)?;

        // Create a Ruby script that will inject SimpleCov into the target process
        let inject_script = self.create_injection_script(pid)?;

        // Run the injection script
        println!("💉 Injecting SimpleCov into process...");
        let output = Command::new("ruby")
            .arg(&inject_script)
            .output()
            .map_err(|e| format!("Failed to run injection script: {}", e))?;

        if !output.status.success() {
            let stderr = String::from_utf8_lossy(&output.stderr);
            return Err(format!(
                "Coverage injection failed: {}\n{}",
                stderr, "Install debase for Ruby injection: gem install debase"
            ));
        }

        println!("✓ Coverage injected successfully");
        println!("⏳ Collecting coverage... Press Ctrl+C to stop");

        // Wait for Ctrl+C
        use std::sync::atomic::{AtomicBool, Ordering};
        use std::sync::Arc;

        let running = Arc::new(AtomicBool::new(true));
        let r = running.clone();

        ctrlc::set_handler(move || {
            r.store(false, Ordering::SeqCst);
        })
        .expect("Error setting Ctrl-C handler");

        let start_time = std::time::Instant::now();

        while running.load(Ordering::SeqCst) {
            thread::sleep(Duration::from_millis(100));
        }

        let duration_secs = start_time.elapsed().as_secs();

        // Signal the process to save coverage (send SIGUSR1 on Unix, file trigger on Windows)
        println!("\n📝 Signaling process to save coverage data...");

        #[cfg(unix)]
        {
            signal_process(pid, ProcessSignal::User1)?;
        }

        #[cfg(windows)]
        {
            // On Windows, create a trigger file that the injected code watches for
            let trigger_file = std::env::temp_dir().join(format!("coverage_trigger_{}.txt", pid));
            fs::write(&trigger_file, "save")?;
            println!(
                "ℹ️  Created trigger file (Windows alternative to SIGUSR1): {}",
                trigger_file.display()
            );
        }

        // Wait a bit for coverage to be saved
        thread::sleep(Duration::from_secs(2));

        // Find and parse the coverage file
        let coverage_file = self.find_coverage_file(pid)?;
        let summary = self.parse_coverage_summary(&coverage_file)?;

        // Clean up injection script
        let _ = fs::remove_file(&inject_script);

        Ok(RuntimeCoverageResult {
            language: "Ruby".to_string(),
            pid,
            duration_secs,
            coverage_file,
            summary,
        })
    }

    /// Check if the process exists
    fn check_process_exists(&self, pid: u32) -> Result<(), String> {
        if !process_exists(pid)? {
            return Err(format!("Process {} not found", pid));
        }
        Ok(())
    }

    /// Create a Ruby script that injects SimpleCov into the target process
    fn create_injection_script(&self, pid: u32) -> Result<String, String> {
        let temp_dir = std::env::temp_dir();
        let script_path = temp_dir.join(format!("coverage_inject_{}.rb", pid));
        let script_path_str = script_path.to_string_lossy().to_string();

        let script_content = format!(
            r#"#!/usr/bin/env ruby
# Runtime coverage injection script for Ruby
# Injects SimpleCov into a running Ruby process

require 'socket'

PID = {}

# Ruby code to inject into the target process
COVERAGE_CODE = <<~RUBY
  require 'simplecov'
  require 'json'

  SimpleCov.start do
    coverage_dir 'coverage'
    command_name "runtime-pid-#{{Process.pid}}"
  end

  # Enable Ruby's built-in Coverage if SimpleCov isn't starting it
  Coverage.start unless Coverage.running?

  puts "[Coverage] SimpleCov started for PID #{{Process.pid}}"

  # Save coverage on SIGUSR1
  Signal.trap('USR1') do
    puts "[Coverage] Saving coverage data..."
    result = Coverage.result

    # Save to JSON format
    coverage_file = ".coverage.#{{Process.pid}}.json"
    File.write(coverage_file, JSON.pretty_generate(result))
    puts "[Coverage] Coverage saved to #{{coverage_file}}"

    # Try to use SimpleCov formatter too
    begin
      SimpleCov.result.format!
      puts "[Coverage] SimpleCov HTML report generated"
    rescue => e
      puts "[Coverage] SimpleCov format error: #{{e.message}}"
    end
  end

  # Also save on exit
  at_exit do
    result = Coverage.result
    coverage_file = ".coverage.#{{Process.pid}}.json"
    File.write(coverage_file, JSON.pretty_generate(result))
  end
RUBY

def inject_via_debugger
  begin
    require 'debase'

    puts "Injecting coverage into PID #{{PID}} using debase..."

    # Create temp file with coverage code
    require 'tmpdir'
    File.write(File.join(Dir.tmpdir, "cov_inject_#{{PID}}.rb"), COVERAGE_CODE)

    # This is a simplified approach - real implementation would use
    # Ruby debugger protocol to inject code into running process
    puts "Note: Ruby runtime injection requires manual setup."
    puts "For production use, consider:"
    puts "  1. Start app with SimpleCov from beginning"
    puts "  2. Use pry-remote or debugging gems"
    puts "  3. Use file-based coverage triggers"

    # Write signal script
    signal_script = <<~SCRIPT
      Process.kill('USR1', #{{PID}})
    SCRIPT

    File.write(File.join(Dir.tmpdir, "signal_#{{PID}}.rb"), signal_script)

    return true
  rescue LoadError
    puts "debase not installed"
    return false
  end
end

def inject_via_gdb
  # For MRI Ruby, we can try using gdb similar to Python
  puts "Attempting GDB injection for Ruby process " + PID.to_s + "..."

  # Simplified: Just notify user that gdb injection is complex
  puts "Note: GDB injection for Ruby requires manual steps."
  puts "For production use, start your Ruby app with SimpleCov enabled."

  return false
end

# Try debugger approach first, fall back to gdb
unless inject_via_debugger
  unless inject_via_gdb
    puts "ERROR: Failed to inject coverage."
    puts "Install debase: gem install debase "
    puts "or start your Ruby app with SimpleCov from the beginning"
    exit 1
  end
end

puts "Coverage collection running continuously..."
puts "Process will save coverage when receiving SIGUSR1 signal "
"#,
            pid
        );

        fs::write(&script_path, script_content)
            .map_err(|e| format!("Failed to create injection script: {}", e))?;

        // Make executable
        #[cfg(unix)]
        {
            Command::new("chmod")
                .args(["+x", &script_path_str])
                .output()
                .map_err(|e| format!("Failed to make script executable: {}", e))?;
        }

        Ok(script_path_str)
    }

    /// Find the coverage file generated by the process
    fn find_coverage_file(&self, pid: u32) -> Result<String, String> {
        let coverage_file = format!(".coverage.{}.json", pid);

        if Path::new(&coverage_file).exists() {
            return Ok(coverage_file);
        }

        // Try SimpleCov's default location
        let simplecov_file = "coverage/.resultset.json".to_string();
        if Path::new(&simplecov_file).exists() {
            return Ok(simplecov_file);
        }

        Err(format!(
            "Coverage file not found. Expected .coverage.{}.json or coverage/.resultset.json",
            pid
        ))
    }

    /// Parse coverage summary from coverage file
    fn parse_coverage_summary(&self, coverage_file: &str) -> Result<CoverageSummary, String> {
        println!("📊 Parsing coverage report...");

        let content = fs::read_to_string(coverage_file)
            .map_err(|e| format!("Failed to read coverage file: {}", e))?;

        let data: serde_json::Value =
            serde_json::from_str(&content).map_err(|e| format!("Failed to parse JSON: {}", e))?;

        let mut total_lines = 0;
        let mut covered_lines = 0;

        // Parse Ruby Coverage format: {"file.rb": [1, 0, 2, null, ...]}
        // or SimpleCov format with nested structure
        if let Some(obj) = data.as_object() {
            for (_filename, coverage) in obj {
                if let Some(lines) = coverage.as_array() {
                    for line_hits in lines {
                        if let Some(hits) = line_hits.as_u64() {
                            total_lines += 1;
                            if hits > 0 {
                                covered_lines += 1;
                            }
                        } else if let Some(hits) = line_hits.as_i64() {
                            if hits >= 0 {
                                total_lines += 1;
                                if hits > 0 {
                                    covered_lines += 1;
                                }
                            }
                        }
                    }
                }
            }
        }

        let coverage_percentage = if total_lines > 0 {
            (covered_lines as f64 / total_lines as f64) * 100.0
        } else {
            0.0
        };

        Ok(CoverageSummary {
            total_lines,
            covered_lines,
            coverage_percentage,
            total_branches: None,
            covered_branches: None,
            branch_percentage: None,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_runtime_coverage_new() {
        let coverage = RubyRuntimeCoverage::new();
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }

    #[test]
    fn test_runtime_coverage_default() {
        let coverage = RubyRuntimeCoverage;
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }
}