lfify 1.1.1 → 1.2.1

package/index.cjs

@@ -1,18 +1,26 @@
 #!/usr/bin/env node
 
-const fs = require("fs").promises;
-const path = require("path");
-const micromatch = require("micromatch");
+const { readFile, readdir, rename, unlink } = require('fs/promises');
+const { createReadStream, createWriteStream } = require('fs');
+const { resolve, join, relative } = require('path');
+const { isMatch } = require('micromatch');
+const { Transform } = require('stream');
+const { pipeline } = require('stream/promises');
+
+/** @type {ReadonlyArray<string>} */
+const LOG_LEVELS = ['error', 'warn', 'info'];
 
 /**
  * @typedef {Object} Config
  * @property {string} entry - 처리할 시작 디렉토리 경로
  * @property {string[]} include - 포함할 파일 패턴 목록
  * @property {string[]} exclude - 제외할 파일 패턴 목록
+ * @property {'error'|'warn'|'info'} [logLevel] - 로그 레벨 (error: 에러만, warn: 에러+경고, info: 전체)
  */
 
 /**
  * @typedef {Object} Logger
+ * @property {function(string): void} setLogLevel - 로그 레벨 설정 ('error'|'warn'|'info')
  * @property {function(string, string): void} warn - 경고 메시지 출력
  * @property {function(string, string, Error=): void} error - 에러 메시지 출력
  * @property {function(string, string): void} info - 정보 메시지 출력
@@ -24,6 +32,7 @@ const micromatch = require("micromatch");
  * @property {string} [entry] - CLI로 지정한 entry 경로
  * @property {string[]} [include] - CLI로 지정한 include 패턴
  * @property {string[]} [exclude] - CLI로 지정한 exclude 패턴
+ * @property {'error'|'warn'|'info'} [logLevel] - CLI로 지정한 로그 레벨
  */
 
 /**
@@ -33,7 +42,8 @@ const micromatch = require("micromatch");
 const DEFAULT_CONFIG = {
   entry: './',
   include: [],
-  exclude: []
+  exclude: [],
+  logLevel: 'error',
 };
 
 /**
@@ -43,13 +53,8 @@ const DEFAULT_CONFIG = {
 const SENSIBLE_DEFAULTS = {
   entry: './',
   include: ['**/*'],
-  exclude: [
-    'node_modules/**',
-    '.git/**',
-    'dist/**',
-    'build/**',
-    'coverage/**'
-  ]
+  exclude: ['node_modules/**', '.git/**', 'dist/**', 'build/**', 'coverage/**'],
+  logLevel: 'error',
 };
 
 /**
@@ -58,18 +63,49 @@ const SENSIBLE_DEFAULTS = {
  */
 const CONFIG_SCHEMA = {
   entry: (value) => typeof value === 'string',
-  include: (value) => Array.isArray(value) && value.length > 0 && value.every(item => typeof item === 'string'),
-  exclude: (value) => Array.isArray(value) && value.length > 0 && value.every(item => typeof item === 'string'),
+  include: (value) =>
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((item) => typeof item === 'string'),
+  exclude: (value) =>
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.every((item) => typeof item === 'string'),
+  logLevel: (value) => LOG_LEVELS.includes(value),
 };
 
 /**
- * Logging utility
- * @type {Logger}
+ * Logging utility. 기본은 error만 출력. setLogLevel로 변경 가능.
+ * @type {Logger & { _level: string, setLogLevel: function(string): void }}
  */
 const logger = {
-  warn: (msg, path) => console.warn(`${msg} ${path}`),
-  error: (msg, path, err) => console.error(`${msg} ${path}`, err),
-  info: (msg, path) => console.log(`${msg} ${path}`),
+  _level: 'error',
+
+  setLogLevel(level) {
+    if (LOG_LEVELS.includes(level)) {
+      this._level = level;
+    }
+  },
+
+  error(msg, path, err) {
+    if (err !== undefined) {
+      console.error(`${msg} ${path}`, err);
+    } else {
+      console.error(`${msg} ${path}`);
+    }
+  },
+
+  warn(msg, path) {
+    if (LOG_LEVELS.indexOf(this._level) >= LOG_LEVELS.indexOf('warn')) {
+      console.warn(`${msg} ${path}`);
+    }
+  },
+
+  info(msg, path) {
+    if (LOG_LEVELS.indexOf(this._level) >= LOG_LEVELS.indexOf('info')) {
+      console.log(`${msg} ${path}`);
+    }
+  },
 };
 
 /**
@@ -80,7 +116,7 @@ const logger = {
  */
 async function readConfig(configPath) {
   try {
-    const configContent = await fs.readFile(configPath, 'utf8');
+    const configContent = await readFile(configPath, 'utf8');
     const config = JSON.parse(configContent);
 
     // Validate required fields
@@ -93,15 +129,18 @@ async function readConfig(configPath) {
     return {
       ...DEFAULT_CONFIG,
       ...config,
-      entry: path.resolve(process.cwd(), config.entry || DEFAULT_CONFIG.entry)
+      entry: resolve(process.cwd(), config.entry || DEFAULT_CONFIG.entry),
     };
   } catch (err) {
     if (err.code === 'ENOENT') {
       logger.error(`Configuration file not found: ${configPath}`, configPath);
     } else {
-      logger.error(`Error reading configuration file: ${err.message}`, configPath);
+      logger.error(
+        `Error reading configuration file: ${err.message}`,
+        configPath,
+      );
     }
-    
+
     if (require.main === module) {
       process.exit(1);
     }
@@ -120,7 +159,7 @@ async function resolveConfig(cliOptions) {
   // Try to load config file if it exists
   if (cliOptions.configPath) {
     try {
-      const configContent = await fs.readFile(cliOptions.configPath, 'utf8');
+      const configContent = await readFile(cliOptions.configPath, 'utf8');
       fileConfig = JSON.parse(configContent);
 
       // Validate config file fields
@@ -132,7 +171,10 @@ async function resolveConfig(cliOptions) {
     } catch (err) {
       if (err.code !== 'ENOENT') {
         // Re-throw parsing/validation errors
-        logger.error(`Error reading configuration file: ${err.message}`, cliOptions.configPath);
+        logger.error(
+          `Error reading configuration file: ${err.message}`,
+          cliOptions.configPath,
+        );
         throw err;
       }
       // ENOENT is okay - config file is optional now
@@ -140,17 +182,32 @@ async function resolveConfig(cliOptions) {
   }
 
   // Determine final values with precedence: CLI > config file > defaults
-  const hasCLIInclude = Array.isArray(cliOptions.include) && cliOptions.include.length > 0;
-  const hasCLIExclude = Array.isArray(cliOptions.exclude) && cliOptions.exclude.length > 0;
+  const hasCLIInclude =
+    Array.isArray(cliOptions.include) && cliOptions.include.length > 0;
+  const hasCLIExclude =
+    Array.isArray(cliOptions.exclude) && cliOptions.exclude.length > 0;
   const hasCLIEntry = typeof cliOptions.entry === 'string';
+  const hasCLILogLevel =
+    typeof cliOptions.logLevel === 'string' &&
+    LOG_LEVELS.includes(cliOptions.logLevel);
 
   const hasFileConfig = fileConfig !== null;
-  const hasFileInclude = hasFileConfig && Array.isArray(fileConfig.include) && fileConfig.include.length > 0;
-  const hasFileExclude = hasFileConfig && Array.isArray(fileConfig.exclude) && fileConfig.exclude.length > 0;
+  const hasFileInclude =
+    hasFileConfig &&
+    Array.isArray(fileConfig.include) &&
+    fileConfig.include.length > 0;
+  const hasFileExclude =
+    hasFileConfig &&
+    Array.isArray(fileConfig.exclude) &&
+    fileConfig.exclude.length > 0;
   const hasFileEntry = hasFileConfig && typeof fileConfig.entry === 'string';
+  const hasFileLogLevel =
+    hasFileConfig &&
+    fileConfig.logLevel &&
+    LOG_LEVELS.includes(fileConfig.logLevel);
 
   // Resolve each config property
-  let include, exclude, entry;
+  let include, exclude, entry, logLevel;
 
   // Include: CLI > file > default
   if (hasCLIInclude) {
@@ -179,10 +236,20 @@ async function resolveConfig(cliOptions) {
     entry = SENSIBLE_DEFAULTS.entry;
   }
 
+  // LogLevel: CLI > file > default
+  if (hasCLILogLevel) {
+    logLevel = cliOptions.logLevel;
+  } else if (hasFileLogLevel) {
+    logLevel = fileConfig.logLevel;
+  } else {
+    logLevel = SENSIBLE_DEFAULTS.logLevel;
+  }
+
   return {
-    entry: path.resolve(process.cwd(), entry),
+    entry: resolve(process.cwd(), entry),
     include,
-    exclude
+    exclude,
+    logLevel,
   };
 }
 
@@ -193,7 +260,7 @@ async function resolveConfig(cliOptions) {
 function parseArgs() {
   const args = process.argv.slice(2);
   const options = {
-    configPath: '.lfifyrc.json'
+    configPath: '.lfifyrc.json',
   };
 
   for (let i = 0; i < args.length; i++) {
@@ -230,6 +297,13 @@ function parseArgs() {
           i++;
         }
         break;
+
+      case '--log-level':
+        if (nextArg && LOG_LEVELS.includes(nextArg)) {
+          options.logLevel = nextArg;
+          i++;
+        }
+        break;
     }
   }
 
@@ -243,8 +317,8 @@ function parseArgs() {
  * @returns {boolean} - true if file should be processed
  */
 function shouldProcessFile(filePath, config) {
-  const isIncluded = micromatch.isMatch(filePath, config.include);
-  const isExcluded = micromatch.isMatch(filePath, config.exclude);
+  const isIncluded = isMatch(filePath, config.include);
+  const isExcluded = isMatch(filePath, config.exclude);
 
   return isIncluded && !isExcluded;
 }
@@ -258,23 +332,28 @@ function shouldProcessFile(filePath, config) {
  */
 async function convertCRLFtoLF(dirPath, config) {
   try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const entries = await readdir(dirPath, { withFileTypes: true });
 
     /**
      * @todo Node.js is single-threaded, if I want to convert files in parallel, I need to use worker_threads
      */
-    await Promise.all(entries.map(async entry => {
-      const fullPath = path.join(dirPath, entry.name);
-      const relativePath = path.relative(process.cwd(), fullPath).replace(/\\/g, "/");
-
-      if (entry.isDirectory()) {
-        await convertCRLFtoLF(fullPath, config);
-      } else if (entry.isFile() && shouldProcessFile(relativePath, config)) {
-        await processFile(fullPath);
-      } else {
-        logger.info(`skipped: ${relativePath}`, fullPath);
-      }
-    }));
+    await Promise.all(
+      entries.map(async (entry) => {
+        const fullPath = join(dirPath, entry.name);
+        const relativePath = relative(process.cwd(), fullPath).replace(
+          /\\/g,
+          '/',
+        );
+
+        if (entry.isDirectory()) {
+          await convertCRLFtoLF(fullPath, config);
+        } else if (entry.isFile() && shouldProcessFile(relativePath, config)) {
+          await processFile(fullPath);
+        } else {
+          logger.info(`skipped: ${relativePath}`, fullPath);
+        }
+      }),
+    );
   } catch (err) {
     logger.error(`error reading directory: ${dirPath}`, dirPath, err);
     throw err;
@@ -288,35 +367,52 @@ async function convertCRLFtoLF(dirPath, config) {
  * @throws {Error} - if there's an error reading or writing file
  */
 async function processFile(filePath) {
+  const tmpPath = `${filePath}.tmp`;
+  const crlf2lf = new Transform({
+    transform(chunk, encoding, callback) {
+      const enc = encoding === 'buffer' ? 'utf8' : encoding;
+      const prev = this._leftover ?? '';
+      this._leftover = '';
+      const str = prev + chunk.toString(enc);
+      const safe = str.endsWith('\r') ? str.slice(0, -1) : str;
+      this._leftover = str.endsWith('\r') ? '\r' : '';
+      callback(null, safe.replace(/\r\n/g, '\n'));
+    },
+    flush(callback) {
+      callback(null, this._leftover ?? '');
+    },
+  });
   try {
-    const content = await fs.readFile(filePath, "utf8");
-    const updatedContent = content.replace(/\r\n/g, "\n");
-
-    if (content !== updatedContent) {
-      /**
-       * @todo V8 javascript engine with 32-bit system cannot handle more than 2GB file,
-       * so I should use createReadStream and createWriteStream to handle large files
-       */
-      await fs.writeFile(filePath, updatedContent, "utf8");
-      logger.info(`converted: ${filePath}`);
-    } else {
-      logger.info(`no need to convert: ${filePath}`, filePath);
-    }
+    await pipeline(
+      createReadStream(filePath, { encoding: 'utf8' }),
+      crlf2lf,
+      createWriteStream(tmpPath, { encoding: 'utf8' }),
+    );
+    logger.info(`converted ${filePath}`);
   } catch (err) {
     logger.error(`error processing file: ${filePath}`, filePath, err);
     throw err;
   }
+  try {
+    await rename(tmpPath, filePath);
+  } catch (err) {
+    logger.error(`error rename file: ${tmpPath} to ${filePath}`);
+    unlink(tmpPath);
+    throw err;
+  }
 }
 
 async function main() {
   const options = parseArgs();
   const config = await resolveConfig(options);
 
+  logger.setLogLevel(config.logLevel);
+
   logger.info(`converting CRLF to LF in: ${config.entry}`, config.entry);
 
   await convertCRLFtoLF(config.entry, config);
 
-  logger.info("conversion completed.", config.entry);
+  logger.info('conversion completed.', config.entry);
 }
 
 if (require.main === module) {

package/index.e2e.test.js

@@ -0,0 +1,140 @@
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const { resolveConfig, convertCRLFtoLF } = require('./index.cjs');
+
+const FIXTURES_DIR = path.join(__dirname, '__fixtures__');
+const CRLF = Buffer.from([0x0d, 0x0a]);
+
+/**
+ * Recursively copy a directory from src to dest.
+ * @param {string} src - source directory
+ * @param {string} dest - destination directory
+ */
+async function copyDir(src, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+describe('E2E: CRLF to LF with real filesystem', () => {
+  let tempDir;
+  let originalCwd;
+
+  beforeEach(async () => {
+    originalCwd = process.cwd();
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'lfify-e2e-'));
+  });
+
+  afterEach(async () => {
+    try {
+      process.chdir(originalCwd);
+      if (tempDir) {
+        await fs.rm(tempDir, { recursive: true, force: true });
+      }
+    } catch {
+      // best-effort cleanup
+    }
+  });
+
+  describe('US1: default run (no config)', () => {
+    it('converts files under entry and excludes node_modules and .git', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'default-sensible'), tempDir);
+      await fs.rename(path.join(tempDir, '_git'), path.join(tempDir, '.git'));
+      await fs.rename(
+        path.join(tempDir, '_node_modules'),
+        path.join(tempDir, 'node_modules'),
+      );
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({});
+      await convertCRLFtoLF(config.entry, config);
+
+      const appJs = await fs.readFile(path.join(tempDir, 'src', 'app.js'));
+      expect(appJs.includes(CRLF)).toBe(false);
+      expect(appJs.equals(Buffer.from('console.log("app");\n', 'utf8'))).toBe(
+        true,
+      );
+
+      const readmeTxt = await fs.readFile(
+        path.join(tempDir, 'src', 'readme.txt'),
+      );
+      expect(readmeTxt.includes(CRLF)).toBe(false);
+      expect(readmeTxt.equals(Buffer.from('hello\nworld\n', 'utf8'))).toBe(
+        true,
+      );
+
+      const nodeModulesPkg = await fs.readFile(
+        path.join(tempDir, 'node_modules', 'pkg', 'index.js'),
+      );
+      expect(nodeModulesPkg.includes(CRLF)).toBe(true);
+
+      const gitConfig = await fs.readFile(path.join(tempDir, '.git', 'config'));
+      expect(gitConfig.includes(CRLF)).toBe(true);
+    });
+  });
+
+  describe('US2: .lfifyrc.json', () => {
+    it('applies config include/exclude so only matching files are converted', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'with-config'), tempDir);
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({ configPath: '.lfifyrc.json' });
+      await convertCRLFtoLF(config.entry, config);
+
+      const mainJs = await fs.readFile(path.join(tempDir, 'lib', 'main.js'));
+      expect(mainJs.includes(CRLF)).toBe(false);
+      expect(mainJs.equals(Buffer.from('const x = 1;\n', 'utf8'))).toBe(true);
+
+      const skipOtherJs = await fs.readFile(
+        path.join(tempDir, 'skip', 'other.js'),
+      );
+      expect(skipOtherJs.includes(CRLF)).toBe(true);
+
+      const docTxt = await fs.readFile(path.join(tempDir, 'doc.txt'));
+      expect(docTxt.includes(CRLF)).toBe(true);
+    });
+  });
+
+  describe('US3: CLI overrides config', () => {
+    it('CLI include overrides config so only .js files are converted', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'cli-override'), tempDir);
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({
+        configPath: '.lfifyrc.json',
+        include: ['**/*.js'],
+      });
+      await convertCRLFtoLF(config.entry, config);
+
+      const aJs = await fs.readFile(path.join(tempDir, 'src', 'a.js'));
+      expect(aJs.includes(CRLF)).toBe(false);
+      expect(aJs.equals(Buffer.from('const a = 1;\n', 'utf8'))).toBe(true);
+
+      const bTxt = await fs.readFile(path.join(tempDir, 'src', 'b.txt'));
+      expect(bTxt.includes(CRLF)).toBe(true);
+    });
+  });
+
+  describe('US4: already LF', () => {
+    it('does not modify files that already use LF', async () => {
+      await copyDir(path.join(FIXTURES_DIR, 'already-lf'), tempDir);
+      process.chdir(tempDir);
+
+      const config = await resolveConfig({});
+      await convertCRLFtoLF(config.entry, config);
+
+      const fileJs = await fs.readFile(path.join(tempDir, 'src', 'file.js'));
+      expect(fileJs.includes(CRLF)).toBe(false);
+      expect(fileJs.equals(Buffer.from('const x = 1;\n', 'utf8'))).toBe(true);
+    });
+  });
+});