lfify 1.1.1 → 1.2.1

package/index.test.js

@@ -1,89 +1,92 @@
-const { readConfig, parseArgs, processFile, resolveConfig, shouldProcessFile, SENSIBLE_DEFAULTS } = require('./index.cjs');
-
-jest.mock('fs');
-jest.mock('path');
-jest.mock('micromatch');
-
-describe('CRLF to LF Converter', () => {
-  const MOCK_FILE_INFO = {
-    './src/file1.txt': 'hello\r\nworld\r\n',
-    './src/file2.js': 'console.log("test");\r\n',
-    './src/subdir/file3.txt': 'test\r\n',
-    './test/file1.txt': 'hello\r\nworld\r\n',
-    './test/file2.js': 'console.log("test");\r\n',
-    './test/subdir/file3.txt': 'test\r\n',
-    './node_modules/file.js': 'console.log("test");\r\n',
-    './node_modules/subdir/file4.txt': 'test\r\n',
-    'index.js': 'console.log("test");\r\n'
+const mock = require('mock-fs');
+const {
+  readConfig,
+  parseArgs,
+  processFile,
+  resolveConfig,
+  shouldProcessFile,
+  SENSIBLE_DEFAULTS,
+} = require('./index.cjs');
+const fs = require('fs');
+
+function baseMock(overrides = {}) {
+  return {
+    'src/file1.txt': 'hello\r\nworld\r\n',
+    'src/file2.js': 'console.log("test");\r\n',
+    'src/subdir/file3.txt': 'test\r\n',
+    'test/file1.txt': 'hello\r\nworld\r\n',
+    'test/file2.js': 'console.log("test");\r\n',
+    'test/subdir/file3.txt': 'test\r\n',
+    'node_modules/file.js': 'console.log("test");\r\n',
+    'node_modules/subdir/file4.txt': 'test\r\n',
+    'index.js': 'console.log("test");\r\n',
+    ...overrides,
   };
+}
 
+describe('CRLF to LF Converter', () => {
   let originalArgv;
 
   beforeEach(() => {
-    jest.clearAllMocks();
-    require('fs').__setMockFiles(MOCK_FILE_INFO);
+    mock(baseMock());
     originalArgv = process.argv;
   });
 
   afterEach(() => {
+    mock.restore();
     process.argv = originalArgv;
   });
 
   describe('readConfig', () => {
     it('should return config when valid config file is provided', async () => {
-      // arrange
       const validConfig = {
         entry: './',
         include: ['*.js'],
-        exclude: ['node_modules/**']
+        exclude: ['node_modules/**'],
       };
-      require('fs').__setConfig(JSON.stringify(validConfig));
+      mock(baseMock({ '.lfifyrc.json': JSON.stringify(validConfig) }));
 
-      // act
       const config = await readConfig('.lfifyrc.json');
 
-      // assert
-      expect(config).toEqual(expect.objectContaining({
-        entry: expect.any(String),
-        include: expect.any(Array),
-        exclude: expect.any(Array)
-      }));
+      expect(config).toEqual(
+        expect.objectContaining({
+          entry: expect.any(String),
+          include: expect.any(Array),
+          exclude: expect.any(Array),
+        }),
+      );
     });
 
     it('should throw error when config file is not found', async () => {
-      // act & assert
       await expect(readConfig('.lfifyrc.json')).rejects.toThrow();
     });
 
     it('should throw error when config file is invalid json', async () => {
-      // arrange
-      require('fs').__setConfig('invalid json');
+      mock(baseMock({ '.lfifyrc.json': 'invalid json' }));
 
-      // act & assert
       await expect(readConfig('.lfifyrc.json')).rejects.toThrow();
     });
   });
 
   describe('parseArgs', () => {
     it('should return config path when --config option is provided', () => {
-      // arrange
-      process.argv = ['node', 'lfify', '--config', './path/for/test/.lfifyrc.json'];
+      process.argv = [
+        'node',
+        'lfify',
+        '--config',
+        './path/for/test/.lfifyrc.json',
+      ];
 
-      // act
       const options = parseArgs();
 
-      // assert
       expect(options.configPath).toBe('./path/for/test/.lfifyrc.json');
     });
 
     it('should return default config path when --config option is not provided', () => {
-      // arrange
       process.argv = ['node', 'lfify'];
 
-      // act
       const options = parseArgs();
 
-      // assert
       expect(options.configPath).toBe('.lfifyrc.json');
     });
 
@@ -94,7 +97,14 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should return multiple include patterns when multiple --include options are provided', () => {
-      process.argv = ['node', 'lfify', '--include', '**/*.js', '--include', '**/*.ts'];
+      process.argv = [
+        'node',
+        'lfify',
+        '--include',
+        '**/*.js',
+        '--include',
+        '**/*.ts',
+      ];
       const options = parseArgs();
       expect(options.include).toEqual(['**/*.js', '**/*.ts']);
     });
@@ -106,33 +116,45 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should return multiple exclude patterns when multiple --exclude options are provided', () => {
-      process.argv = ['node', 'lfify', '--exclude', 'node_modules/**', '--exclude', '.git/**'];
+      process.argv = [
+        'node',
+        'lfify',
+        '--exclude',
+        'dist/**',
+        '--exclude',
+        'coverage/**',
+      ];
       const options = parseArgs();
-      expect(options.exclude).toEqual(['node_modules/**', '.git/**']);
+      expect(options.exclude).toEqual(['dist/**', 'coverage/**']);
     });
 
     it('should return entry path when --entry option is provided', () => {
       process.argv = ['node', 'lfify', '--entry', './src'];
       const options = parseArgs();
-      expect(options.entry).toBe('./src');
+      expect(options.entry).toContain('src');
     });
 
     it('should handle all options together', () => {
       process.argv = [
-        'node', 'lfify',
-        '--entry', './src',
-        '--include', '**/*.js',
-        '--include', '**/*.ts',
-        '--exclude', 'node_modules/**',
-        '--config', 'custom.json'
+        'node',
+        'lfify',
+        '--config',
+        'custom.json',
+        '--include',
+        '*.js',
+        '--exclude',
+        'dist/**',
+        '--entry',
+        './lib',
+        '--log-level',
+        'info',
       ];
       const options = parseArgs();
-      expect(options).toEqual({
-        configPath: 'custom.json',
-        entry: './src',
-        include: ['**/*.js', '**/*.ts'],
-        exclude: ['node_modules/**']
-      });
+      expect(options.configPath).toBe('custom.json');
+      expect(options.include).toEqual(['*.js']);
+      expect(options.exclude).toEqual(['dist/**']);
+      expect(options.entry).toContain('lib');
+      expect(options.logLevel).toBe('info');
     });
 
     it('should return undefined for include/exclude/entry when not provided', () => {
@@ -142,77 +164,76 @@ describe('CRLF to LF Converter', () => {
       expect(options.exclude).toBeUndefined();
       expect(options.entry).toBeUndefined();
     });
+
+    it('should return logLevel when --log-level option is provided', () => {
+      process.argv = ['node', 'lfify', '--log-level', 'warn'];
+      const options = parseArgs();
+      expect(options.logLevel).toBe('warn');
+    });
+
+    it('should accept error, warn, info for --log-level', () => {
+      for (const level of ['error', 'warn', 'info']) {
+        process.argv = ['node', 'lfify', '--log-level', level];
+        expect(parseArgs().logLevel).toBe(level);
+      }
+    });
   });
 
   describe('shouldProcessFile', () => {
     it('should return true when file matches include pattern and does not match exclude pattern', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**']
-      };
-      expect(shouldProcessFile('src/file.js', config)).toBe(true);
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('src/app.js', config)).toBe(true);
     });
 
     it('should return false when file matches exclude pattern', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**']
-      };
-      expect(shouldProcessFile('node_modules/package/index.js', config)).toBe(false);
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('node_modules/pkg/index.js', config)).toBe(
+        false,
+      );
     });
 
     it('should return false when file does not match include pattern', () => {
-      const config = {
-        include: ['**/*.js'],
-        exclude: ['node_modules/**']
-      };
-      expect(shouldProcessFile('src/file.txt', config)).toBe(false);
+      const config = { include: ['**/*.js'], exclude: ['node_modules/**'] };
+      expect(shouldProcessFile('src/readme.txt', config)).toBe(false);
     });
 
     it('should handle multiple include patterns', () => {
       const config = {
         include: ['**/*.js', '**/*.ts'],
-        exclude: []
+        exclude: ['node_modules/**'],
       };
-      expect(shouldProcessFile('src/file.js', config)).toBe(true);
-      expect(shouldProcessFile('src/file.ts', config)).toBe(true);
-      expect(shouldProcessFile('src/file.txt', config)).toBe(false);
+      expect(shouldProcessFile('src/app.js', config)).toBe(true);
+      expect(shouldProcessFile('src/app.ts', config)).toBe(true);
     });
 
     it('should handle multiple exclude patterns', () => {
       const config = {
         include: ['**/*.js'],
-        exclude: ['node_modules/**', 'dist/**', 'test/**']
+        exclude: ['node_modules/**', 'dist/**', 'build/**', 'coverage/**'],
       };
       expect(shouldProcessFile('src/file.js', config)).toBe(true);
-      expect(shouldProcessFile('node_modules/pkg/index.js', config)).toBe(false);
+      expect(shouldProcessFile('node_modules/pkg/file.js', config)).toBe(false);
       expect(shouldProcessFile('dist/bundle.js', config)).toBe(false);
-      expect(shouldProcessFile('test/unit.js', config)).toBe(false);
+      expect(shouldProcessFile('test/unit.js', config)).toBe(true);
     });
   });
 
   describe('processFile', () => {
     it('should convert CRLF to LF when file is processed', async () => {
-      // arrange
       const shouldbe = 'hello\nworld\n';
 
-      // act
       await processFile('./src/file1.txt');
-      const content = await require('fs').promises.readFile('./src/file1.txt', 'utf8');
+      const content = await fs.promises.readFile('./src/file1.txt', 'utf8');
 
-      // assert
       expect(content).toBe(shouldbe);
     });
 
     it('should not modify file when no CRLF exists', async () => {
-      // arrange
-      require('fs').__setMockFiles({ './src/clean.txt': 'hello\nworld\n' });
+      mock(baseMock({ 'src/clean.txt': 'hello\nworld\n' }));
 
-      // act
       await processFile('./src/clean.txt');
-      const content = await require('fs').promises.readFile('./src/clean.txt', 'utf8');
+      const content = await fs.promises.readFile('./src/clean.txt', 'utf8');
 
-      // assert
       expect(content).toBe('hello\nworld\n');
     });
   });
@@ -222,7 +243,7 @@ describe('CRLF to LF Converter', () => {
       const options = {
         include: ['**/*.js'],
         exclude: ['node_modules/**'],
-        entry: './src'
+        entry: './src',
       };
       const config = await resolveConfig(options);
 
@@ -239,28 +260,36 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should override config file values with CLI options', async () => {
-      require('fs').__setConfig(JSON.stringify({
-        entry: './',
-        include: ['**/*.md'],
-        exclude: ['dist/**']
-      }));
+      mock(
+        baseMock({
+          '.lfifyrc.json': JSON.stringify({
+            entry: './',
+            include: ['**/*.md'],
+            exclude: ['dist/**'],
+          }),
+        }),
+      );
 
       const options = {
         configPath: '.lfifyrc.json',
-        include: ['**/*.js'] // CLI should override config
+        include: ['**/*.js'],
       };
       const config = await resolveConfig(options);
 
-      expect(config.include).toEqual(['**/*.js']); // CLI override
-      expect(config.exclude).toEqual(['dist/**']); // from config file
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(['dist/**']);
     });
 
     it('should load config file when configPath is provided and file exists', async () => {
-      require('fs').__setConfig(JSON.stringify({
-        entry: './lib',
-        include: ['**/*.ts'],
-        exclude: ['test/**']
-      }));
+      mock(
+        baseMock({
+          '.lfifyrc.json': JSON.stringify({
+            entry: './lib',
+            include: ['**/*.ts'],
+            exclude: ['test/**'],
+          }),
+        }),
+      );
 
       const options = { configPath: '.lfifyrc.json' };
       const config = await resolveConfig(options);
@@ -270,7 +299,6 @@ describe('CRLF to LF Converter', () => {
     });
 
     it('should use defaults when config file not found and no CLI options', async () => {
-      // No config file set up - mock will throw ENOENT
       const options = { configPath: 'nonexistent.json' };
       const config = await resolveConfig(options);
 
@@ -293,5 +321,43 @@ describe('CRLF to LF Converter', () => {
       expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
       expect(config.exclude).toEqual(['custom/**']);
     });
+
+    it('should include logLevel in config, defaulting to error', async () => {
+      const config = await resolveConfig({});
+      expect(config.logLevel).toBe('error');
+    });
+
+    it('should use logLevel from config file when provided', async () => {
+      mock(
+        baseMock({
+          '.lfifyrc.json': JSON.stringify({
+            entry: './',
+            include: ['**/*.js'],
+            exclude: ['node_modules/**'],
+            logLevel: 'info',
+          }),
+        }),
+      );
+      const config = await resolveConfig({ configPath: '.lfifyrc.json' });
+      expect(config.logLevel).toBe('info');
+    });
+
+    it('should override config file logLevel with CLI --log-level', async () => {
+      mock(
+        baseMock({
+          '.lfifyrc.json': JSON.stringify({
+            entry: './',
+            include: ['**/*.js'],
+            exclude: ['node_modules/**'],
+            logLevel: 'warn',
+          }),
+        }),
+      );
+      const config = await resolveConfig({
+        configPath: '.lfifyrc.json',
+        logLevel: 'info',
+      });
+      expect(config.logLevel).toBe('info');
+    });
   });
-}); 
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lfify",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "private": false,
   "description": "make your crlf to lf",
   "main": "index.cjs",
@@ -9,15 +9,20 @@
     "lfify": "./index.cjs"
   },
   "scripts": {
-    "test": "jest",
-    "lint": "eslint ."
+    "test": "npm run test:unit && npm run test:e2e",
+    "test:unit": "jest --testPathPattern=\"index\\.test\\.js\"",
+    "test:e2e": "jest --testPathPattern=\"index\\.e2e\\.test\\.js\"",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/GyeongHoKim/lfify.git"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org",
+    "registry": "https://registry.npmjs.org/",
+    "provenance": true,
     "tag": "latest"
   },
   "keywords": [
@@ -42,8 +47,12 @@
     "@semantic-release/npm": "^13.1.3",
     "@semantic-release/release-notes-generator": "^14.1.0",
     "eslint": "^9.15.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.5",
     "globals": "^15.12.0",
     "jest": "^29.7.0",
+    "mock-fs": "^5.5.0",
+    "prettier": "^3.8.1",
     "semantic-release": "^25.0.2"
   }
 }

package/__mocks__/fs.js

@@ -1,56 +0,0 @@
-const fs = jest.createMockFromModule('fs');
-
-const mockFiles = new Map();
-
-function __setMockFiles(newMockFiles) {
-  mockFiles.clear();
-  for (const [path, content] of Object.entries(newMockFiles)) {
-    mockFiles.set(path, content);
-  }
-}
-
-function __setConfig(stringifiedConfig, path = '.lfifyrc.json') {
-  mockFiles.set(path, stringifiedConfig);
-}
-
-const promises = {
-  /* eslint-disable-next-line no-unused-vars */
-  readFile: jest.fn().mockImplementation((path, ...rest) => {
-    if (mockFiles.has(path)) {
-      return Promise.resolve(mockFiles.get(path));
-    }
-    const error = new Error(`ENOENT: no such file or directory, open '${path}'`);
-    error.code = 'ENOENT';
-    return Promise.reject(error);
-  }),
-
-  writeFile: jest.fn().mockImplementation((path, content) => {
-    mockFiles.set(path, content);
-    return Promise.resolve();
-  }),
-
-  /* eslint-disable-next-line no-unused-vars */
-  readdir: jest.fn().mockImplementation((path, ...rest) => {
-    const entries = [];
-    for (const filePath of mockFiles.keys()) {
-      if (filePath.startsWith(path)) {
-        const relativePath = filePath.slice(path.length + 1);
-        const name = relativePath.split('/')[0];
-        if (name && !entries.some(e => e.name === name)) {
-          entries.push({
-            name,
-            isFile: () => !name.includes('/'),
-            isDirectory: () => name.includes('/')
-          });
-        }
-      }
-    }
-    return Promise.resolve(entries);
-  })
-};
-
-fs.promises = promises;
-fs.__setMockFiles = __setMockFiles;
-fs.__setConfig = __setConfig;
-
-module.exports = fs;

package/__mocks__/micromatch.js

@@ -1,39 +0,0 @@
-const micromatch = jest.createMockFromModule('micromatch');
-
-micromatch.isMatch = jest.fn().mockImplementation((filePath, patterns) => {
-  if (!Array.isArray(patterns)) {
-    patterns = [patterns];
-  }
-
-  // 간단한 glob 패턴 매칭 구현
-  return patterns.some(pattern => {
-    // 정확한 매칭
-    if (pattern === filePath) return true;
-
-    // glob 패턴을 정규식으로 변환
-    // 플레이스홀더를 사용해서 순서 문제 해결
-    const GLOBSTAR_SLASH = '___GLOBSTARSLASH___';
-    const GLOBSTAR = '___GLOBSTAR___';
-
-    let regexPattern = pattern
-      // **/ 패턴을 플레이스홀더로 임시 변환
-      .replace(/\*\*\//g, GLOBSTAR_SLASH)
-      // ** 패턴을 플레이스홀더로 임시 변환
-      .replace(/\*\*/g, GLOBSTAR)
-      // {a,b} 패턴
-      .replace(/\{([^}]+)\}/g, (_, group) => `(${group.split(',').join('|')})`)
-      // 특수문자 이스케이프 (*, ?, / 제외)
-      .replace(/[.+^$|()[\]\\]/g, '\\$&')
-      // * 패턴: 슬래시를 제외한 모든 것 매칭
-      .replace(/\*/g, '[^/]*')
-      // ? 패턴: 슬래시를 제외한 한 문자 매칭
-      .replace(/\?/g, '[^/]')
-      // 플레이스홀더를 실제 정규식으로 변환
-      .replace(new RegExp(GLOBSTAR_SLASH, 'g'), '(?:.*/)?')
-      .replace(new RegExp(GLOBSTAR, 'g'), '.*');
-
-    return new RegExp(`^${regexPattern}$`).test(filePath);
-  });
-});
-
-module.exports = micromatch;