lfify 1.1.0 → 1.1.1

package/.github/workflows/cd.yml

@@ -4,13 +4,11 @@ on:
     branches:
       - main
 
-permissions:
-  contents: read # for checkout
-
 jobs:
   release:
     name: Release
     runs-on: ubuntu-latest
+    environment: npm
     permissions:
       contents: write # to be able to publish a GitHub release
       issues: write # to be able to comment on released issues
@@ -22,7 +20,7 @@ jobs:
         with:
           fetch-depth: 0
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: "lts/*"
       - name: Install dependencies
@@ -32,5 +30,4 @@ jobs:
       - name: Release
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npx semantic-release
+        run: NODE_AUTH_TOKEN="" npx semantic-release

package/.releaserc.json

@@ -0,0 +1,21 @@
+{
+  "branches": ["main"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    [
+      "@semantic-release/changelog",
+      {
+        "changelogFile": "CHANGELOG.md"
+      }
+    ],
+    "@semantic-release/npm",
+    [
+      "@semantic-release/git",
+      {
+        "assets": ["package.json", "package-lock.json", "CHANGELOG.md"],
+        "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+      }
+    ]
+  ]
+}

package/README.md

@@ -1,13 +1,19 @@
 # LFify
 
-> ⚠️ **Warning**: All files must be encoded in UTF-8. The library is being developed to automatically convert UTF-8 with BOM to UTF-8 without BOM. Using different encodings may cause unexpected issues.
-
-A lightweight Node.js library to convert CRLF to LF line endings.  
-It is useful when your development environment is Windows.  
+A lightweight Node.js program to convert CRLF to LF line endings.  
+It is useful when your development environment is Windows.
 
 ## Getting started
 
-create .lfifyrc.json
+### Using CLI options (no config file needed)
+
+```bash
+npx lfify --include "**/*.js" --exclude "node_modules/**"
+```
+
+### Using config file
+
+Create `.lfifyrc.json`:
 
 ```json
 {
@@ -25,22 +31,52 @@ create .lfifyrc.json
     "build/**",
     "coverage/**"
   ]
-} 
+}
 ```
 
-and then
+Then run:
 
 ```bash
-npx lifify
+npx lfify
 ```
 
-you can add options below.
-
 ## Options
 
-| Option | Description |
-|--------|-------------|
-| `--config <path>` | Specify a custom path for the configuration file. Default is `.lfifyrc.json` in the current directory. |
+| Option               | Description                                                                 |
+| -------------------- | --------------------------------------------------------------------------- |
+| `--config <path>`    | Specify a custom path for the configuration file. Default is `.lfifyrc.json`. |
+| `--entry <path>`     | Specify the entry directory to process. Default is `./`.                    |
+| `--include <pattern>`| Glob pattern(s) to include. Can be used multiple times.                     |
+| `--exclude <pattern>`| Glob pattern(s) to exclude. Can be used multiple times.                     |
+
+## Examples
+
+```bash
+# Process all JavaScript files, exclude node_modules
+npx lfify --include "**/*.js" --exclude "node_modules/**"
+
+# Process multiple file types
+npx lfify --include "**/*.js" --include "**/*.ts" --exclude "node_modules/**" --exclude ".git/**"
+
+# Process files in a specific directory
+npx lfify --entry ./src --include "**/*.js"
+
+# Use a custom config file
+npx lfify --config ./custom-config.json
+```
+
+## Default behavior
+
+When no config file is found and no CLI options are provided, lfify uses sensible defaults:
+- **include**: `**/*` (all files)
+- **exclude**: `node_modules/**`, `.git/**`, `dist/**`, `build/**`, `coverage/**`
+
+## Priority
+
+CLI options take precedence over config file values:
+1. CLI arguments (highest)
+2. Config file
+3. Default values (lowest)
 
 # Development
 

package/__mocks__/fs.js

@@ -19,7 +19,9 @@ const promises = {
     if (mockFiles.has(path)) {
       return Promise.resolve(mockFiles.get(path));
     }
-    return Promise.reject(new Error(`ENOENT: no such file or directory, open '${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) => {

package/__mocks__/micromatch.js

@@ -10,12 +10,28 @@ micromatch.isMatch = jest.fn().mockImplementation((filePath, patterns) => {
     // 정확한 매칭
     if (pattern === filePath) return true;
 
-    // 와일드카드 매칭
-    const regexPattern = pattern
-      .replace(/\./g, '\\.')
-      .replace(/\*/g, '.*')
-      .replace(/\?/g, '.');
-    
+    // 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);
   });
 });

package/index.cjs

@@ -20,7 +20,10 @@ const micromatch = require("micromatch");
 
 /**
  * @typedef {Object} CommandOptions
- * @property {string} configPath - 설정 파일 경로
+ * @property {string} [configPath] - 설정 파일 경로
+ * @property {string} [entry] - CLI로 지정한 entry 경로
+ * @property {string[]} [include] - CLI로 지정한 include 패턴
+ * @property {string[]} [exclude] - CLI로 지정한 exclude 패턴
  */
 
 /**
@@ -33,6 +36,22 @@ const DEFAULT_CONFIG = {
   exclude: []
 };
 
+/**
+ * Sensible defaults when no config file is provided
+ * @type {Config}
+ */
+const SENSIBLE_DEFAULTS = {
+  entry: './',
+  include: ['**/*'],
+  exclude: [
+    'node_modules/**',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    'coverage/**'
+  ]
+};
+
 /**
  * Configuration validation schema
  * @type {Object.<string, function(*): boolean>}
@@ -90,6 +109,83 @@ async function readConfig(configPath) {
   }
 }
 
+/**
+ * Resolve final configuration from CLI options, config file, and defaults
+ * @param {CommandOptions} cliOptions - parsed CLI options
+ * @returns {Promise<Config>} - resolved configuration
+ */
+async function resolveConfig(cliOptions) {
+  let fileConfig = null;
+
+  // Try to load config file if it exists
+  if (cliOptions.configPath) {
+    try {
+      const configContent = await fs.readFile(cliOptions.configPath, 'utf8');
+      fileConfig = JSON.parse(configContent);
+
+      // Validate config file fields
+      for (const [key, validator] of Object.entries(CONFIG_SCHEMA)) {
+        if (fileConfig[key] && !validator(fileConfig[key])) {
+          throw new Error(`Invalid "${key}" in configuration file`);
+        }
+      }
+    } catch (err) {
+      if (err.code !== 'ENOENT') {
+        // Re-throw parsing/validation errors
+        logger.error(`Error reading configuration file: ${err.message}`, cliOptions.configPath);
+        throw err;
+      }
+      // ENOENT is okay - config file is optional now
+    }
+  }
+
+  // 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 hasCLIEntry = typeof cliOptions.entry === 'string';
+
+  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 hasFileEntry = hasFileConfig && typeof fileConfig.entry === 'string';
+
+  // Resolve each config property
+  let include, exclude, entry;
+
+  // Include: CLI > file > default
+  if (hasCLIInclude) {
+    include = cliOptions.include;
+  } else if (hasFileInclude) {
+    include = fileConfig.include;
+  } else {
+    include = SENSIBLE_DEFAULTS.include;
+  }
+
+  // Exclude: CLI > file > default
+  if (hasCLIExclude) {
+    exclude = cliOptions.exclude;
+  } else if (hasFileExclude) {
+    exclude = fileConfig.exclude;
+  } else {
+    exclude = SENSIBLE_DEFAULTS.exclude;
+  }
+
+  // Entry: CLI > file > default
+  if (hasCLIEntry) {
+    entry = cliOptions.entry;
+  } else if (hasFileEntry) {
+    entry = fileConfig.entry;
+  } else {
+    entry = SENSIBLE_DEFAULTS.entry;
+  }
+
+  return {
+    entry: path.resolve(process.cwd(), entry),
+    include,
+    exclude
+  };
+}
+
 /**
  * Parse command line arguments
  * @returns {CommandOptions} - parsed arguments
@@ -101,9 +197,39 @@ function parseArgs() {
   };
 
   for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--config' && args[i + 1]) {
-      options.configPath = args[i + 1];
-      i++;
+    const arg = args[i];
+    const nextArg = args[i + 1];
+
+    switch (arg) {
+      case '--config':
+        if (nextArg) {
+          options.configPath = nextArg;
+          i++;
+        }
+        break;
+
+      case '--entry':
+        if (nextArg) {
+          options.entry = nextArg;
+          i++;
+        }
+        break;
+
+      case '--include':
+        if (nextArg) {
+          options.include = options.include || [];
+          options.include.push(nextArg);
+          i++;
+        }
+        break;
+
+      case '--exclude':
+        if (nextArg) {
+          options.exclude = options.exclude || [];
+          options.exclude.push(nextArg);
+          i++;
+        }
+        break;
     }
   }
 
@@ -184,7 +310,7 @@ async function processFile(filePath) {
 
 async function main() {
   const options = parseArgs();
-  const config = await readConfig(options.configPath);
+  const config = await resolveConfig(options);
 
   logger.info(`converting CRLF to LF in: ${config.entry}`, config.entry);
 
@@ -202,4 +328,7 @@ module.exports = {
   processFile,
   readConfig,
   parseArgs,
+  resolveConfig,
+  shouldProcessFile,
+  SENSIBLE_DEFAULTS,
 };

package/index.test.js

@@ -1,4 +1,4 @@
-const { readConfig, parseArgs, processFile } = require('./index.cjs');
+const { readConfig, parseArgs, processFile, resolveConfig, shouldProcessFile, SENSIBLE_DEFAULTS } = require('./index.cjs');
 
 jest.mock('fs');
 jest.mock('path');
@@ -16,10 +16,17 @@ describe('CRLF to LF Converter', () => {
     './node_modules/subdir/file4.txt': 'test\r\n',
     'index.js': 'console.log("test");\r\n'
   };
-  
+
+  let originalArgv;
+
   beforeEach(() => {
     jest.clearAllMocks();
     require('fs').__setMockFiles(MOCK_FILE_INFO);
+    originalArgv = process.argv;
+  });
+
+  afterEach(() => {
+    process.argv = originalArgv;
   });
 
   describe('readConfig', () => {
@@ -79,15 +86,108 @@ describe('CRLF to LF Converter', () => {
       // assert
       expect(options.configPath).toBe('.lfifyrc.json');
     });
+
+    it('should return include patterns when single --include option is provided', () => {
+      process.argv = ['node', 'lfify', '--include', '**/*.js'];
+      const options = parseArgs();
+      expect(options.include).toEqual(['**/*.js']);
+    });
+
+    it('should return multiple include patterns when multiple --include options are provided', () => {
+      process.argv = ['node', 'lfify', '--include', '**/*.js', '--include', '**/*.ts'];
+      const options = parseArgs();
+      expect(options.include).toEqual(['**/*.js', '**/*.ts']);
+    });
+
+    it('should return exclude patterns when --exclude option is provided', () => {
+      process.argv = ['node', 'lfify', '--exclude', 'node_modules/**'];
+      const options = parseArgs();
+      expect(options.exclude).toEqual(['node_modules/**']);
+    });
+
+    it('should return multiple exclude patterns when multiple --exclude options are provided', () => {
+      process.argv = ['node', 'lfify', '--exclude', 'node_modules/**', '--exclude', '.git/**'];
+      const options = parseArgs();
+      expect(options.exclude).toEqual(['node_modules/**', '.git/**']);
+    });
+
+    it('should return entry path when --entry option is provided', () => {
+      process.argv = ['node', 'lfify', '--entry', './src'];
+      const options = parseArgs();
+      expect(options.entry).toBe('./src');
+    });
+
+    it('should handle all options together', () => {
+      process.argv = [
+        'node', 'lfify',
+        '--entry', './src',
+        '--include', '**/*.js',
+        '--include', '**/*.ts',
+        '--exclude', 'node_modules/**',
+        '--config', 'custom.json'
+      ];
+      const options = parseArgs();
+      expect(options).toEqual({
+        configPath: 'custom.json',
+        entry: './src',
+        include: ['**/*.js', '**/*.ts'],
+        exclude: ['node_modules/**']
+      });
+    });
+
+    it('should return undefined for include/exclude/entry when not provided', () => {
+      process.argv = ['node', 'lfify'];
+      const options = parseArgs();
+      expect(options.include).toBeUndefined();
+      expect(options.exclude).toBeUndefined();
+      expect(options.entry).toBeUndefined();
+    });
   });
 
   describe('shouldProcessFile', () => {
     it('should return true when file matches include pattern and does not match exclude pattern', () => {
-      /**
-       * This function uses micromatch to check config.include and config.exclude
-       * so this test case is already tested in micromatch's test file
-       * so I'm not going to test this function
-       */
+      const config = {
+        include: ['**/*.js'],
+        exclude: ['node_modules/**']
+      };
+      expect(shouldProcessFile('src/file.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);
+    });
+
+    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);
+    });
+
+    it('should handle multiple include patterns', () => {
+      const config = {
+        include: ['**/*.js', '**/*.ts'],
+        exclude: []
+      };
+      expect(shouldProcessFile('src/file.js', config)).toBe(true);
+      expect(shouldProcessFile('src/file.ts', config)).toBe(true);
+      expect(shouldProcessFile('src/file.txt', config)).toBe(false);
+    });
+
+    it('should handle multiple exclude patterns', () => {
+      const config = {
+        include: ['**/*.js'],
+        exclude: ['node_modules/**', 'dist/**', 'test/**']
+      };
+      expect(shouldProcessFile('src/file.js', config)).toBe(true);
+      expect(shouldProcessFile('node_modules/pkg/index.js', config)).toBe(false);
+      expect(shouldProcessFile('dist/bundle.js', config)).toBe(false);
+      expect(shouldProcessFile('test/unit.js', config)).toBe(false);
     });
   });
 
@@ -102,6 +202,96 @@ describe('CRLF to LF Converter', () => {
 
       // 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' });
+
+      // act
+      await processFile('./src/clean.txt');
+      const content = await require('fs').promises.readFile('./src/clean.txt', 'utf8');
+
+      // assert
+      expect(content).toBe('hello\nworld\n');
+    });
+  });
+
+  describe('resolveConfig', () => {
+    it('should use CLI options when provided without config file', async () => {
+      const options = {
+        include: ['**/*.js'],
+        exclude: ['node_modules/**'],
+        entry: './src'
+      };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(['node_modules/**']);
+      expect(config.entry).toContain('src');
+    });
+
+    it('should use sensible defaults when no config file and no CLI options', async () => {
+      const config = await resolveConfig({});
+
+      expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
+      expect(config.exclude).toEqual(SENSIBLE_DEFAULTS.exclude);
+    });
+
+    it('should override config file values with CLI options', async () => {
+      require('fs').__setConfig(JSON.stringify({
+        entry: './',
+        include: ['**/*.md'],
+        exclude: ['dist/**']
+      }));
+
+      const options = {
+        configPath: '.lfifyrc.json',
+        include: ['**/*.js'] // CLI should override config
+      };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.js']); // CLI override
+      expect(config.exclude).toEqual(['dist/**']); // from config file
+    });
+
+    it('should load config file when configPath is provided and file exists', async () => {
+      require('fs').__setConfig(JSON.stringify({
+        entry: './lib',
+        include: ['**/*.ts'],
+        exclude: ['test/**']
+      }));
+
+      const options = { configPath: '.lfifyrc.json' };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.ts']);
+      expect(config.exclude).toEqual(['test/**']);
+    });
+
+    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);
+
+      expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
+      expect(config.exclude).toEqual(SENSIBLE_DEFAULTS.exclude);
+    });
+
+    it('should use CLI include with default exclude when only include provided', async () => {
+      const options = { include: ['**/*.js'] };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(['**/*.js']);
+      expect(config.exclude).toEqual(SENSIBLE_DEFAULTS.exclude);
+    });
+
+    it('should use CLI exclude with default include when only exclude provided', async () => {
+      const options = { exclude: ['custom/**'] };
+      const config = await resolveConfig(options);
+
+      expect(config.include).toEqual(SENSIBLE_DEFAULTS.include);
+      expect(config.exclude).toEqual(['custom/**']);
+    });
   });
 }); 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lfify",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "private": false,
   "description": "make your crlf to lf",
   "main": "index.cjs",
@@ -14,10 +14,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/GyeongHoKim/lfify"
+    "url": "https://github.com/GyeongHoKim/lfify.git"
   },
   "publishConfig": {
-    "registry": "https://registry.npmjs.org"
+    "registry": "https://registry.npmjs.org",
+    "tag": "latest"
   },
   "keywords": [
     "eol",
@@ -35,8 +36,14 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.15.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "eslint": "^9.15.0",
     "globals": "^15.12.0",
-    "jest": "^29.7.0"
+    "jest": "^29.7.0",
+    "semantic-release": "^25.0.2"
   }
 }