@nojaja/greputil 1.0.0

package/src/RegExpArray.ts

@@ -0,0 +1,209 @@
+/**
+ * 処理名: 正規表現配列クラス
+ * 
+ * 処理概要:
+ * 複数の正規表現パターンを配列として管理し、文字列に対して順次適用するためのクラス。
+ * 文字列、RegExpオブジェクト、[パターン, フラグ]配列の混在をサポートする。
+ * 
+ * 実装理由:
+ * 標準のJavaScript正規表現APIでは単一パターンのみ扱えるため、
+ * 複数パターンの一括処理を簡潔に記述できるユーティリティクラスが必要。
+ * grepのような複数パターンマッチングを効率的に実装するため。
+ */
+export class RegExpArray {
+    /**
+     * 正規表現インスタンスのリスト
+     */
+    private regExpInstanceList: RegExp[];
+
+    /**
+     * ソースパターンとフラグのリスト
+     */
+    private sourceLiat: Array<[string, string]>;
+
+    /**
+     * 最後に実行された正規表現
+     */
+    public last: RegExp | null;
+
+    /**
+     * 処理名: RegExpArrayコンストラクタ
+     *
+     * 処理概要:
+     * 複数の正規表現パターンからインスタンスを作成する。
+     * 文字列、RegExpオブジェクト、[パターン, フラグ]配列の混在可能。
+     *
+     * 実装理由:
+     * 柔軟なパターン指定を可能にし、様々な入力形式に対応するため。
+     * 配列でない単一パターンも自動的に配列化して統一的に処理する。
+     * @param patternList - 正規表現パターンのリスト（文字列、RegExp、[パターン, フラグ]の配列）
+     * @returns RegExpArrayインスタンス
+     */
+    constructor(patternList?: RegExp | string | Array<string> | Array<RegExp | string | Array<string>>) {
+        const _patternList = (!patternList) 
+            ? [] 
+            : (!Array.isArray(patternList)) 
+                ? [patternList] 
+                : patternList;
+        
+        this.regExpInstanceList = _patternList.map((pattern) => {
+            if (pattern instanceof RegExp) {
+                return pattern;
+            } else if (Array.isArray(pattern)) {
+                return new RegExp(pattern[0], pattern[1]);
+            } else {
+                return new RegExp(pattern);
+            }
+        });
+
+        this.sourceLiat = this.regExpInstanceList.map((regExp) => 
+            [regExp.source, regExp.flags]
+        );
+        this.last = null;
+    }
+
+    /**
+     * 処理名: 順次マッチング実行
+     *
+     * 処理概要:
+     * 各正規表現を順次実行し、すべてのマッチ結果を配列で返す。
+     * グローバルフラグ使用時はステートフルに動作する。
+     *
+     * 実装理由:
+     * 複数パターンのマッチ結果を一度に取得するため。
+     * reduceを使用して効率的に結果を集約する。
+     * @param string - マッチング対象の文字列
+     * @returns マッチした文字列の配列
+     */
+    exec(string: string): string[] {
+        return this.regExpInstanceList.reduce((previousValue, regexp) => {
+            this.last = regexp;
+            const result = regexp.exec(string);
+            return (result) ? previousValue.concat([...result]) : previousValue;
+        }, [] as string[]);
+    }
+
+    /**
+     * 処理名: 最初のマッチ取得
+     *
+     * 処理概要:
+     * 最初にマッチした正規表現の結果を返す。
+     * マッチしない場合はnullを返す。
+     *
+     * 実装理由:
+     * 全パターンをテストする必要がなく、最初のマッチで処理を終了できるため効率的。
+     * testメソッドの内部実装としても使用される。
+     * @param string - マッチング対象の文字列
+     * @returns マッチ結果の配列、またはnull
+     */
+    firstMatch(string: string): RegExpExecArray | null {
+        for (const regexp of this.regExpInstanceList) {
+            this.last = regexp;
+            const result = regexp.exec(string);
+            if (result) return result;
+        }
+        return null;
+    }
+
+    /**
+     * 処理名: マッチテスト
+     *
+     * 処理概要:
+     * いずれかの正規表現がマッチすればtrueを返す。
+     * グローバルフラグ使用時はステートフルに動作する。
+     *
+     * 実装理由:
+     * 真偽値のみが必要な場合に、マッチ結果の詳細を取得するオーバーヘッドを避けるため。
+     * firstMatchの結果を利用して効率的に判定する。
+     * @param string - テスト対象の文字列
+     * @returns マッチする場合true、しない場合false
+     */
+    test(string: string): boolean {
+        return this.firstMatch(string) !== null;
+    }
+
+    /**
+     * 処理名: RegExp配列取得
+     *
+     * 処理概要:
+     * 内部で保持している正規表現オブジェクトの配列を返す。
+     *
+     * 実装理由:
+     * インスタンス内部の正規表現を外部から参照・検査できるようにするため。
+     * デバッグやテスト時に有用。
+     * @returns 正規表現オブジェクトの配列
+     */
+    toArray(): RegExp[] {
+        return this.regExpInstanceList;
+    }
+
+    /**
+     * 処理名: 全マッチ結果取得（静的メソッド）
+     *
+     * 処理概要:
+     * 複数の正規表現パターンに対するすべてのマッチ結果を二次元配列で返す。
+     * regexpsがnullの場合はnullを返す。
+     *
+     * 実装理由:
+     * インスタンスを作成せずに一時的なマッチング処理を実行できるようにするため。
+     * String.prototype.matchAllを活用して効率的にマッチングを行う。
+     * @param string - マッチング対象の文字列
+     * @param regexps - 正規表現パターン（単一または配列）、nullの場合はnullを返す
+     * @returns マッチ結果の二次元配列、またはnull
+     * @throws エラーが発生した場合は例外を投げる
+     */
+    static matchAll(string: string, regexps: RegExp | string | Array<RegExp | string> | null): Array<Array<string>> | null {
+        if (regexps === null) return null;
+        const _regexps = (!Array.isArray(regexps)) ? [regexps] : regexps;
+        return _regexps.reduce((previousValue, regexp) => {
+            const matches = Array.from(string.matchAll(regexp instanceof RegExp ? regexp : new RegExp(regexp, 'g')));
+            return previousValue.concat(matches.map(m => Array.from(m)));
+        }, [] as Array<Array<string>>);
+    }
+
+    /**
+     * 処理名: 最初のマッチ取得（静的メソッド）
+     *
+     * 処理概要:
+     * 複数の正規表現パターンから最初にマッチした結果を返す。
+     * regexpsがnullの場合はnullを返す。
+     *
+     * 実装理由:
+     * インスタンスを作成せずに一時的なマッチング処理を実行できるようにするため。
+     * 最初のマッチで処理を終了するため効率的。
+     * @param string - マッチング対象の文字列
+     * @param regexps - 正規表現パターン（単一または配列）、nullの場合はnullを返す
+     * @returns マッチ結果の配列、またはnull
+     * @throws エラーが発生した場合は例外を投げる
+     */
+    static firstMatch(string: string, regexps: RegExp | string | Array<RegExp | string> | null): RegExpExecArray | null {
+        if (regexps === null) return null;
+        const _regexps = (!Array.isArray(regexps)) ? [regexps] : regexps;
+        for (const regexp of _regexps) {
+            const _regexp = regexp instanceof RegExp ? regexp : new RegExp(regexp);
+            const result = _regexp.exec(string);
+            if (result) return result;
+        }
+        return null;
+    }
+
+    /**
+     * 処理名: マッチテスト（静的メソッド）
+     *
+     * 処理概要:
+     * 複数の正規表現パターンのいずれかがマッチするか判定する。
+     * 内部でfirstMatchを使用して効率的に判定。
+     *
+     * 実装理由:
+     * インスタンスを作成せずに真偽値判定を行えるようにするため。
+     * firstMatchの結果を利用して簡潔に実装。
+     * @param string - テスト対象の文字列
+     * @param regexps - 正規表現パターン（単一または配列）
+     * @returns マッチする場合true、しない場合false
+     */
+    static test(string: string, regexps: RegExp | string | Array<RegExp | string> | null): boolean {
+        return RegExpArray.firstMatch(string, regexps) !== null;
+    }
+}
+
+export default RegExpArray;

package/src/index.ts

@@ -0,0 +1,15 @@
+/**
+ * 処理名: ライブラリエントリポイント
+ * 
+ * 処理概要:
+ * NodeGrepUtilライブラリの公開APIをエクスポートする。
+ * RegExpArrayとBufferPatternMatcherクラスを提供。
+ * 
+ * 実装理由:
+ * ライブラリ利用者が必要なクラスを簡単にインポートできるようにするため。
+ * 単一のエントリポイントから全機能にアクセス可能にする。
+ */
+import { RegExpArray } from './RegExpArray';
+import { BufferPatternMatcher } from './BufferPatternMatcher';
+
+export { RegExpArray, BufferPatternMatcher };

package/tests/unit/RegExpArray.spec.ts

@@ -0,0 +1,205 @@
+import { RegExpArray } from '../../src/RegExpArray';
+import { BufferPatternMatcher } from '../../src/BufferPatternMatcher';
+
+describe('RegExpArray', () => {
+  describe('constructor', () => {
+    it('文字列配列から正規表現を生成できること', () => {
+      const regExpArray = new RegExpArray(['test.']);
+      expect(regExpArray.toArray()[0].source).toBe('test.');
+      expect(regExpArray.toArray()[0].flags).toBe('');
+    });
+
+    it('RegExpオブジェクト配列から正規表現を生成できること', () => {
+      const regExpArray = new RegExpArray([/t(e)(st(\d?))/g]);
+      expect(regExpArray.toArray()[0].source).toBe('t(e)(st(\\d?))');
+      expect(regExpArray.toArray()[0].flags).toBe('g');
+    });
+
+    it('文字列から正規表現を生成できること', () => {
+      const regExpArray = new RegExpArray(['t(e)(st(\\d?))']);
+      expect(regExpArray.toArray()[0].source).toBe('t(e)(st(\\d?))');
+      expect(regExpArray.toArray()[0].flags).toBe('');
+    });
+
+    it('[パターン, フラグ]配列から正規表現を生成できること', () => {
+      const regExpArray = new RegExpArray([['t(e)(st(\\d?))', 'g']]);
+      expect(regExpArray.toArray()[0].source).toBe('t(e)(st(\\d?))');
+      expect(regExpArray.toArray()[0].flags).toBe('g');
+    });
+
+    it('空の配列でインスタンス化できること', () => {
+      const regExpArray = new RegExpArray([]);
+      expect(regExpArray.toArray()).toEqual([]);
+    });
+
+    it('パターンなしでインスタンス化できること', () => {
+      const regExpArray = new RegExpArray();
+      expect(regExpArray.toArray()).toEqual([]);
+    });
+  });
+
+  describe('exec', () => {
+    it('グローバルフラグ付き正規表現で順次マッチできること', () => {
+      const regExpArray = new RegExpArray([/t(e)(st(\d?))/g]);
+      expect(regExpArray.exec('test1test2')).toEqual(['test1', 'e', 'st1', '1']);
+      expect(regExpArray.exec('test1test2')).toEqual(['test2', 'e', 'st2', '2']);
+      expect(regExpArray.exec('test1test2')).toEqual([]);
+    });
+
+    it('複数パターンのマッチ結果を返すこと', () => {
+      const regExpArray = new RegExpArray([/hello/, /world/]);
+      const result = regExpArray.exec('hello world');
+      expect(result).toContain('hello');
+      expect(result).toContain('world');
+    });
+
+    it('マッチしない場合は空配列を返すこと', () => {
+      const regExpArray = new RegExpArray([/xyz/]);
+      expect(regExpArray.exec('abc')).toEqual([]);
+    });
+  });
+
+  describe('firstMatch', () => {
+    it('最初のマッチ結果を返すこと', () => {
+      const regExpArray = new RegExpArray([/test\d/, /hello/]);
+      const result = regExpArray.firstMatch('test1 hello');
+      expect(result).not.toBeNull();
+      expect(result![0]).toBe('test1');
+    });
+
+    it('マッチしない場合はnullを返すこと', () => {
+      const regExpArray = new RegExpArray([/xyz/]);
+      expect(regExpArray.firstMatch('abc')).toBeNull();
+    });
+  });
+
+  describe('test', () => {
+    it('グローバルフラグ付き正規表現でマッチ判定できること', () => {
+      const regExpArray = new RegExpArray([/t(e)(st(\d?))/g]);
+      expect(regExpArray.test('test1test2')).toBe(true);
+      expect(regExpArray.test('test1test2')).toBe(true);
+      expect(regExpArray.test('test1test2')).toBe(false);
+    });
+
+    it('マッチする場合trueを返すこと', () => {
+      const regExpArray = new RegExpArray([/hello/]);
+      expect(regExpArray.test('hello world')).toBe(true);
+    });
+
+    it('マッチしない場合falseを返すこと', () => {
+      const regExpArray = new RegExpArray([/xyz/]);
+      expect(regExpArray.test('abc')).toBe(false);
+    });
+  });
+
+  describe('toArray', () => {
+    it('RegExpオブジェクトの配列を返すこと', () => {
+      const regExpArray = new RegExpArray([/test/, /hello/]);
+      const result = regExpArray.toArray();
+      expect(result).toHaveLength(2);
+      expect(result[0]).toBeInstanceOf(RegExp);
+      expect(result[1]).toBeInstanceOf(RegExp);
+    });
+  });
+
+  describe('matchAll (static)', () => {
+    it('すべてのマッチ結果を二次元配列で返すこと', () => {
+      const result = RegExpArray.matchAll('test1test2', [/t(e)(st(\d?))/g]);
+      expect(result).toEqual([['test1', 'e', 'st1', '1'], ['test2', 'e', 'st2', '2']]);
+    });
+
+    it('文字列パターンでマッチできること', () => {
+      const result = RegExpArray.matchAll('test1test2', 'test.');
+      expect(result).toHaveLength(2);
+      expect(result![0][0]).toMatch(/test\d/);
+    });
+
+    it('マッチしない場合は空配列を返すこと', () => {
+      const result = RegExpArray.matchAll('test1test2', 'string');
+      expect(result).toEqual([]);
+    });
+
+    it('nullを渡した場合はnullを返すこと', () => {
+      const result = RegExpArray.matchAll('test', null);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('firstMatch (static)', () => {
+    it('最初のマッチ結果を返すこと', () => {
+      const result = RegExpArray.firstMatch('test1 hello', [/test\d/, /hello/]);
+      expect(result).not.toBeNull();
+      expect(result![0]).toBe('test1');
+    });
+
+    it('マッチしない場合はnullを返すこと', () => {
+      const result = RegExpArray.firstMatch('abc', [/xyz/]);
+      expect(result).toBeNull();
+    });
+
+    it('nullを渡した場合はnullを返すこと', () => {
+      const result = RegExpArray.firstMatch('test', null);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('test (static)', () => {
+    it('マッチする場合trueを返すこと', () => {
+      expect(RegExpArray.test('hello world', [/hello/])).toBe(true);
+    });
+
+    it('マッチしない場合falseを返すこと', () => {
+      expect(RegExpArray.test('abc', [/xyz/])).toBe(false);
+    });
+
+    it('nullを渡した場合falseを返すこと', () => {
+      expect(RegExpArray.test('test', null)).toBe(false);
+    });
+  });
+});
+
+describe('BufferPatternMatcher', () => {
+  describe('compareBuf', () => {
+    it('パターンにマッチする場合trueを返すこと', () => {
+      const matcher = new BufferPatternMatcher();
+      const buffer = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A]);
+      const patterns = [Buffer.from([0x89, 0x50, 0x4E, 0x47])]; // PNGシグネチャ
+      
+      expect(matcher.compareBuf(buffer, patterns)).toBe(true);
+    });
+
+    it('パターンにマッチしない場合falseを返すこと', () => {
+      const matcher = new BufferPatternMatcher();
+      const buffer = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]);
+      const patterns = [Buffer.from([0x89, 0x50, 0x4E, 0x47])]; // PNGシグネチャ
+      
+      expect(matcher.compareBuf(buffer, patterns)).toBe(false);
+    });
+
+    it('複数パターンの1つにマッチする場合trueを返すこと', () => {
+      const matcher = new BufferPatternMatcher();
+      const buffer = Buffer.from([0xFF, 0xD8, 0xFF, 0xE0]);
+      const patterns = [
+        Buffer.from([0x89, 0x50, 0x4E, 0x47]), // PNGシグネチャ
+        Buffer.from([0xFF, 0xD8, 0xFF])        // JPEGシグネチャ
+      ];
+      
+      expect(matcher.compareBuf(buffer, patterns)).toBe(true);
+    });
+
+    it('patternsがnullの場合nullを返すこと', () => {
+      const matcher = new BufferPatternMatcher();
+      const buffer = Buffer.from([0x89, 0x50, 0x4E, 0x47]);
+      
+      expect(matcher.compareBuf(buffer, null)).toBeNull();
+    });
+
+    it('バッファがパターンより短い場合falseを返すこと', () => {
+      const matcher = new BufferPatternMatcher();
+      const buffer = Buffer.from([0x89, 0x50]);
+      const patterns = [Buffer.from([0x89, 0x50, 0x4E, 0x47])];
+      
+      expect(matcher.compareBuf(buffer, patterns)).toBe(false);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "types": ["node", "jest"],
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/typedoc.js

@@ -0,0 +1,16 @@
+module.exports = {
+  entryPoints: ['./src/index.ts'],
+  entryPointStrategy: 'expand',
+  out: './docs/typedoc-md',
+  plugin: ['typedoc-plugin-markdown'],
+  tsconfig: './tsconfig.json',
+  exclude: ['**/node_modules/**', '**/tests/**', '**/dist/**'],
+  excludePrivate: false,
+  excludeProtected: false,
+  includeVersion: true,
+  readme: 'none',
+  disableSources: false,
+  categorizeByGroup: true,
+  categoryOrder: ['Classes', 'Functions', 'Variables', '*'],
+  sort: ['source-order']
+};

package/webpack.config.js

@@ -0,0 +1,32 @@
+const path = require('path');
+
+module.exports = {
+  mode: 'production',
+  devtool: 'source-map',
+  target: 'node',
+  entry: './src/index.ts',
+  output: {
+    filename: 'GrepUtil.bundle.js',
+    path: path.resolve(__dirname, 'dist'),
+    publicPath: '',
+    library: {
+      name: 'GrepUtil',
+      type: 'umd',
+      export: 'default'
+    },
+    globalObject: 'this'
+  },
+  module: {
+    rules: [
+      {
+        test: /\.ts$/,
+        use: 'ts-loader',
+        exclude: /node_modules/
+      }
+    ]
+  },
+  resolve: {
+    extensions: ['.ts', '.js'],
+    modules: ['node_modules']
+  }
+};