lfify 1.1.0

package/.github/workflows/cd.yml

@@ -0,0 +1,36 @@
+name: Release
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: read # for checkout
+
+jobs:
+  release:
+    name: Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # to be able to publish a GitHub release
+      issues: write # to be able to comment on released issues
+      pull-requests: write # to be able to comment on released pull requests
+      id-token: write # to enable use of OIDC for npm provenance
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+      - name: Install dependencies
+        run: npm clean-install
+      - name: Verify the integrity of provenance attestations and registry signatures for installed dependencies
+        run: npm audit signatures
+      - name: Release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: npx semantic-release

package/.github/workflows/ci.yml

@@ -0,0 +1,42 @@
+name: Lint and Test
+
+on:
+  pull_request:
+    branches: [ main ]
+  push:
+    branches: [ main ]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: '18'
+        
+    - name: Install dependencies
+      run: npm ci
+      
+    - name: Run linting
+      run: npm run lint || true
+
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    
+    - name: Setup Node.js
+      uses: actions/setup-node@v3
+      with:
+        node-version: '18'
+        
+    - name: Install dependencies
+      run: npm ci
+      
+    - name: Run tests
+      run: npm test

package/.lfifyrc-sample.json

@@ -0,0 +1,16 @@
+{
+  "entry": "./",
+  "include": [
+    "**/*.{js,ts,jsx,tsx}",
+    "**/*.{json,md}",
+    "**/*.{css,scss}",
+    "**/*.{html,vue}"
+  ],
+  "exclude": [
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    "coverage/**"
+  ]
+} 

package/.vscode/launch.json

@@ -0,0 +1,31 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Jest Tests Debug",
+      "program": "${workspaceFolder}/node_modules/jest/bin/jest",
+      "args": [
+        "--runInBand",
+        "--watchAll=false",
+        "--testTimeout=100000",
+        "--detectOpenHandles"
+      ],
+      "console": "integratedTerminal",
+      "internalConsoleOptions": "neverOpen"
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Program",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "program": "${workspaceFolder}/index.cjs"
+    }
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 GyeongHo Kim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# 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.  
+
+## Getting started
+
+create .lfifyrc.json
+
+```json
+{
+  "entry": "./",
+  "include": [
+    "**/*.{js,ts,jsx,tsx}",
+    "**/*.{json,md}",
+    "**/*.{css,scss}",
+    "**/*.{html,vue}"
+  ],
+  "exclude": [
+    "node_modules/**",
+    ".git/**",
+    "dist/**",
+    "build/**",
+    "coverage/**"
+  ]
+} 
+```
+
+and then
+
+```bash
+npx lifify
+```
+
+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. |
+
+# Development
+
+## Prerequisites
+
+- Node.js 18 or higher
+- npm
+
+## Setup
+
+Clone the repository:
+
+```bash
+git clone https://github.com/GyeongHoKim/lfify.git
+```
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+# Testing
+
+```bash
+npm test
+```
+
+# Linting
+
+```bash
+npm run lint
+```
+
+# Contributing
+
+1. Fork the repository
+2. Create a new branch
+3. Make your changes
+4. Run `npm run lint` to check your code
+5. Run `npm test` to check your code
+6. Submit a pull request
+
+# Issues and Support
+
+If you have any issues or feedback, please open an [issue](https://github.com/GyeongHoKim/lfify/issues) on the GitHub repository.

package/__mocks__/fs.js

@@ -0,0 +1,54 @@
+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));
+    }
+    return Promise.reject(new Error(`ENOENT: no such file or directory, open '${path}'`));
+  }),
+
+  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

@@ -0,0 +1,23 @@
+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;
+
+    // 와일드카드 매칭
+    const regexPattern = pattern
+      .replace(/\./g, '\\.')
+      .replace(/\*/g, '.*')
+      .replace(/\?/g, '.');
+    
+    return new RegExp(`^${regexPattern}$`).test(filePath);
+  });
+});
+
+module.exports = micromatch; 

package/__mocks__/path.js

@@ -0,0 +1,17 @@
+const path = jest.createMockFromModule('path');
+
+const actualPath = jest.requireActual('path');
+
+path.join = jest.fn().mockImplementation((...paths) => {
+  return actualPath.join(...paths);
+});
+
+path.resolve = jest.fn().mockImplementation((...paths) => {
+  return actualPath.resolve(...paths);
+});
+
+path.relative = jest.fn().mockImplementation((from, to) => {
+  return actualPath.relative(from, to);
+});
+
+module.exports = path; 

package/eslint.config.mjs

@@ -0,0 +1,17 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  {files: ["**/*.js"], languageOptions: {sourceType: "commonjs"}},
+  {
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.jest,
+      },
+    },
+  },
+  pluginJs.configs.recommended,
+];

package/index.cjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+const fs = require("fs").promises;
+const path = require("path");
+const micromatch = require("micromatch");
+
+/**
+ * @typedef {Object} Config
+ * @property {string} entry - 처리할 시작 디렉토리 경로
+ * @property {string[]} include - 포함할 파일 패턴 목록
+ * @property {string[]} exclude - 제외할 파일 패턴 목록
+ */
+
+/**
+ * @typedef {Object} Logger
+ * @property {function(string, string): void} warn - 경고 메시지 출력
+ * @property {function(string, string, Error=): void} error - 에러 메시지 출력
+ * @property {function(string, string): void} info - 정보 메시지 출력
+ */
+
+/**
+ * @typedef {Object} CommandOptions
+ * @property {string} configPath - 설정 파일 경로
+ */
+
+/**
+ * Default configuration
+ * @type {Config}
+ */
+const DEFAULT_CONFIG = {
+  entry: './',
+  include: [],
+  exclude: []
+};
+
+/**
+ * Configuration validation schema
+ * @type {Object.<string, function(*): boolean>}
+ */
+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'),
+};
+
+/**
+ * Logging utility
+ * @type {Logger}
+ */
+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}`),
+};
+
+/**
+ * Read and validate configuration file
+ * @param {string} configPath - path to configuration file
+ * @returns {Promise<Config>} - validated configuration
+ * @throws {Error} - if configuration is invalid or file is not found
+ */
+async function readConfig(configPath) {
+  try {
+    const configContent = await fs.readFile(configPath, 'utf8');
+    const config = JSON.parse(configContent);
+
+    // Validate required fields
+    for (const [key, validator] of Object.entries(CONFIG_SCHEMA)) {
+      if (config[key] && !validator(config[key])) {
+        throw new Error(`Invalid "${key}" in configuration file`);
+      }
+    }
+
+    return {
+      ...DEFAULT_CONFIG,
+      ...config,
+      entry: path.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);
+    }
+    
+    if (require.main === module) {
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+
+/**
+ * Parse command line arguments
+ * @returns {CommandOptions} - parsed arguments
+ */
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const options = {
+    configPath: '.lfifyrc.json'
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--config' && args[i + 1]) {
+      options.configPath = args[i + 1];
+      i++;
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Check if file should be processed based on include/exclude patterns
+ * @param {string} filePath - relative file path
+ * @param {Config} config - configuration object
+ * @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);
+
+  return isIncluded && !isExcluded;
+}
+
+/**
+ * traverse a specific directory recursively and convert all files' CRLF to LF
+ * @param {string} dirPath - directory path to search
+ * @param {Config} config - configuration object
+ * @returns {Promise<void>}
+ * @throws {Error} - if there's an error reading directory or processing files
+ */
+async function convertCRLFtoLF(dirPath, config) {
+  try {
+    const entries = await fs.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);
+      }
+    }));
+  } catch (err) {
+    logger.error(`error reading directory: ${dirPath}`, dirPath, err);
+    throw err;
+  }
+}
+
+/**
+ * convert CRLF to LF
+ * @param {string} filePath - full path of the file to process
+ * @returns {Promise<void>}
+ * @throws {Error} - if there's an error reading or writing file
+ */
+async function processFile(filePath) {
+  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);
+    }
+  } catch (err) {
+    logger.error(`error processing file: ${filePath}`, filePath, err);
+    throw err;
+  }
+}
+
+async function main() {
+  const options = parseArgs();
+  const config = await readConfig(options.configPath);
+
+  logger.info(`converting CRLF to LF in: ${config.entry}`, config.entry);
+
+  await convertCRLFtoLF(config.entry, config);
+
+  logger.info("conversion completed.", config.entry);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  convertCRLFtoLF,
+  processFile,
+  readConfig,
+  parseArgs,
+};

package/index.test.js

@@ -0,0 +1,107 @@
+const { readConfig, parseArgs, processFile } = 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'
+  };
+  
+  beforeEach(() => {
+    jest.clearAllMocks();
+    require('fs').__setMockFiles(MOCK_FILE_INFO);
+  });
+
+  describe('readConfig', () => {
+    it('should return config when valid config file is provided', async () => {
+      // arrange
+      const validConfig = {
+        entry: './',
+        include: ['*.js'],
+        exclude: ['node_modules/**']
+      };
+      require('fs').__setConfig(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)
+      }));
+    });
+
+    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');
+
+      // 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'];
+
+      // 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');
+    });
+  });
+
+  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
+       */
+    });
+  });
+
+  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');
+
+      // assert
+      expect(content).toBe(shouldbe);
+    })
+  });
+}); 

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "lfify",
+  "version": "1.1.0",
+  "private": false,
+  "description": "make your crlf to lf",
+  "main": "index.cjs",
+  "type": "commonjs",
+  "bin": {
+    "lfify": "./index.cjs"
+  },
+  "scripts": {
+    "test": "jest",
+    "lint": "eslint ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GyeongHoKim/lfify"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [
+    "eol",
+    "lf",
+    "crlf"
+  ],
+  "author": "GyeongHoKim",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/GyeongHoKim/lfify/issues"
+  },
+  "homepage": "https://github.com/GyeongHoKim/lfify#readme",
+  "dependencies": {
+    "micromatch": "^4.0.8"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.15.0",
+    "eslint": "^9.15.0",
+    "globals": "^15.12.0",
+    "jest": "^29.7.0"
+  }
+}