File Writing

/**
 * Utility for writing files under a specific directory
 */
class FileWriter {
  /**
   * Create a new FileWriter instance
   * @param {string} baseDir - The base directory under which files should be written
   * @throws {Error} If baseDir is not specified
   */
  constructor(baseDir);

  /**
   * Returns a FileWriter that is rooted at the supplied subdirectory
   * @param {string} subdir - The subdirectory under which to root the returned FileWriter
   * @returns {FileWriter} New FileWriter instance for the subdirectory
   * @throws {Error} If subdir is an absolute path
   */
  writerForDir(subdir);

  /**
   * Copies a file from a source directory to a destination name
   * @param {string} source - Path to source file
   * @param {string} dest - Relative path to destination file
   * @param {string} [header] - Optional text to prepend to destination
   * @throws {Error} If dest is an absolute path
   */
  copyFile(source, dest, header);

  /**
   * Returns a content writer for writing content to the supplied file
   * @param {string|null} file - Relative path to file, or "-"/null for console
   * @returns {ContentWriter} Content writer instance
   * @throws {Error} If file is an absolute path
   */
  writeFile(file);
}

const { FileWriter } = require('istanbul-lib-report/lib/file-writer');

// Create file writer for reports directory
const writer = new FileWriter('coverage-reports');

// Create content writer for a file
const fileWriter = writer.writeFile('summary.txt');
fileWriter.println('Coverage Summary');
fileWriter.close();

// Write to console
const consoleWriter = writer.writeFile(null); // or "-"
consoleWriter.println('Writing to console');

// Create subdirectory writer
const htmlWriter = writer.writerForDir('html');
const indexWriter = htmlWriter.writeFile('index.html');

// Copy file with header
writer.copyFile('/templates/style.css', 'css/style.css', '/* Auto-generated */\\n');

/**
 * Start capturing stdout report output (useful for tests)
 */
static startCapture();

/**
 * Stop capturing stdout report output
 */
static stopCapture();

/**
 * Get captured stdout output
 * @returns {string} Captured output
 */
static getOutput();

/**
 * Reset captured output buffer
 */
static resetOutput();

const { FileWriter } = require('istanbul-lib-report/lib/file-writer');

// Basic capture for testing
FileWriter.startCapture();

const writer = new FileWriter('test-dir');
const consoleWriter = writer.writeFile(null);
consoleWriter.println('Test output');

const captured = FileWriter.getOutput(); // "Test output\\n"
FileWriter.stopCapture();
FileWriter.resetOutput();

// Advanced: Capture during report generation for testing
function testReportGeneration() {
  FileWriter.startCapture();
  
  try {
    // Generate report that writes to console
    const context = libReport.createContext({ 
      dir: 'coverage',
      coverageMap 
    });
    
    // Your report generation code here
    const consoleWriter = context.getWriter().writeFile(null);
    consoleWriter.println('Coverage Summary:');
    consoleWriter.println('Lines: 85%');
    
    // Verify output in tests
    const output = FileWriter.getOutput();
    console.assert(output.includes('Coverage Summary:'));
    console.assert(output.includes('Lines: 85%'));
    
    return output;
  } finally {
    FileWriter.stopCapture();
    FileWriter.resetOutput();
  }
}

// Integration testing pattern
function captureReportOutput(reportGenerator) {
  FileWriter.startCapture();
  
  try {
    reportGenerator();
    return FileWriter.getOutput();
  } finally {
    FileWriter.stopCapture();
    FileWriter.resetOutput();
  }
}

/**
 * Base class for writing content
 */
class ContentWriter {
  /**
   * Returns the colorized version of a string
   * @param {string} str - The string to colorize
   * @param {string} clazz - One of "high", "medium", or "low"
   * @returns {string} The colorized form of the string
   */
  colorize(str, clazz);

  /**
   * Writes a string appended with a newline to the destination
   * @param {string} str - The string to write
   */
  println(str);

  /**
   * Writes a string to the destination (abstract method)
   * @param {string} str - The string to write
   */
  write(str);

  /**
   * Closes this content writer
   */
  close();
}

/**
 * A content writer that writes to a file
 */
class FileContentWriter extends ContentWriter {
  /**
   * Create a file content writer
   * @param {number} fd - The file descriptor
   */
  constructor(fd);

  /**
   * Write string to file
   * @param {string} str - String to write
   */
  write(str);

  /**
   * Close the file descriptor
   */
  close();
}

/**
 * A content writer that writes to the console
 */
class ConsoleWriter extends ContentWriter {
  /**
   * Write string to console
   * @param {string} str - String to write
   */
  write(str);

  /**
   * Colorize string for console output
   * @param {string} str - String to colorize
   * @param {string} clazz - Color class: "high" (green), "medium" (yellow), "low" (red)
   * @returns {string} Colorized string with ANSI escape codes if supported
   */
  colorize(str, clazz);
}

// Using content writers directly
const contentWriter = writer.writeFile('report.txt');

// Basic writing
contentWriter.write('Coverage: ');
contentWriter.println('85%');

// Colorized output (useful for console)
const consoleWriter = writer.writeFile(null);
const colorized = consoleWriter.colorize('85%', 'high'); // Green if terminal supports color
consoleWriter.println(`Coverage: ${colorized}`);

// Always close when done
contentWriter.close();

type ColorClass = 'high' | 'medium' | 'low';

interface ContentWriter {
  write(str: string): void;
  println(str: string): void;
  colorize(str: string, clazz: ColorClass): string;
  close(): void;
}

interface FileWriter {
  baseDir: string;
  writerForDir(subdir: string): FileWriter;
  copyFile(source: string, dest: string, header?: string): void;
  writeFile(file: string | null): ContentWriter;
}