nadesiko3 3.7.21 → 3.7.23

package/core/test/nako_plugin_manager_test.mjs

@@ -0,0 +1,185 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { NakoPluginManager, PLUGIN_MIN_VERSION_INT } from '../src/nako_plugin_manager.mjs'
+import { NakoLogger } from '../src/nako_logger.mjs'
+
+/**
+ * プラグイン管理を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_plugin_manager_test', () => {
+  /** テスト用にホストを差し替えた NakoPluginManager を作る */
+  const createManager = () => {
+    const funclist = new Map()
+    const sysVars = new Map()
+    const logger = new NakoLogger()
+    const manager = new NakoPluginManager({
+      getFuncList: () => funclist,
+      getSysVars: () => sysVars,
+      getLogger: () => logger
+    })
+    return { manager, funclist, sysVars, logger }
+  }
+
+  /** 現在のバージョン要求を満たすメタ情報を作る */
+  const newMeta = (pluginName, nakoVersion = '3.6.0') => {
+    return { type: 'const', value: { pluginName, nakoVersion } }
+  }
+
+  it('プラグイン名が重複した場合は登録されない', () => {
+    const nako = new NakoCompiler()
+    nako.addPlugin({
+      meta: newMeta('DuplicatedPlugin'),
+      重複テスト値: { type: 'const', value: 1 }
+    })
+    nako.addPlugin({
+      meta: newMeta('DuplicatedPlugin'),
+      重複テスト値: { type: 'const', value: 2 }
+    })
+    // 2回目の登録は無視されるので、最初に登録した値のままになる
+    assert.strictEqual(nako.getFunc('重複テスト値').value, 1)
+  })
+
+  it('metaが無い場合はプラグイン名をキー名から自動生成する', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({ hoge: { type: 'const', value: 1 } })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.ok(pluginInfo.hoge !== undefined, 'キー名からプラグイン名が作られること')
+    assert.ok(manager.pluginfiles.hoge !== undefined)
+  })
+
+  it('古い形式のプラグインは nakoVersionResult が false になる', () => {
+    const { manager, sysVars } = createManager()
+    // PLUGIN_MIN_VERSION_INT(600) より小さいバージョンを指定する
+    manager.addPlugin({
+      meta: newMeta('OldPlugin', '3.5.99'),
+      古い値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.strictEqual(pluginInfo.OldPlugin.nakoVersionResult, false)
+    assert.strictEqual(PLUGIN_MIN_VERSION_INT, 600)
+  })
+
+  it('新しい形式のプラグインは nakoVersionResult が true のまま', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({
+      meta: newMeta('NewPlugin', '3.6.0'),
+      新しい値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.notStrictEqual(pluginInfo.NewPlugin.nakoVersionResult, false)
+  })
+
+  it('「初期化」は「!プラグイン名:初期化」へ変換される', () => {
+    const { manager } = createManager()
+    const po = {
+      meta: newMeta('InitPlugin'),
+      初期化: { type: 'func', josi: [], fn: () => {} }
+    }
+    manager.addPlugin(po)
+    assert.strictEqual(po['初期化'], undefined)
+    assert.strictEqual(typeof po['!InitPlugin:初期化'], 'object')
+  })
+
+  it('ファイル名に使えない文字はアンダースコアに置換される', () => {
+    assert.strictEqual(NakoPluginManager.removeInvalidFilenameChars('my plugin/name'), 'my_plugin_name')
+    // 日本語(ひらがな・カタカナ・漢字)はそのまま残る
+    assert.strictEqual(NakoPluginManager.removeInvalidFilenameChars('プラグイン漢字かな'), 'プラグイン漢字かな')
+  })
+
+  it('プラグイン名の不正文字を置換した名前で登録される', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({
+      meta: newMeta('my plugin/name'),
+      置換テスト値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.ok(pluginInfo.my_plugin_name !== undefined)
+    assert.ok(manager.modules.my_plugin_name !== undefined)
+  })
+
+  it('「初期化」と「!」で始まるキーはコマンド一覧に登録されない', () => {
+    const { manager } = createManager()
+    manager.addPlugin({
+      meta: newMeta('CommandListPlugin'),
+      普通の値: { type: 'const', value: 1 },
+      '!クリア': { type: 'func', josi: [], fn: () => {} },
+      初期化: { type: 'func', josi: [], fn: () => {} }
+    })
+    assert.strictEqual(manager.hasCommand('普通の値'), true)
+    assert.strictEqual(manager.hasCommand('!クリア'), false)
+    assert.strictEqual(manager.hasCommand('初期化'), false)
+    assert.strictEqual(manager.hasCommand('!CommandListPlugin:初期化'), false)
+  })
+
+  it('addFuncで登録した関数をgetFuncで参照できる', () => {
+    const { manager, sysVars } = createManager()
+    const fn = (a) => a
+    manager.addFunc('テスト関数', [['を']], fn, false)
+    const f = manager.getFunc('テスト関数')
+    assert.strictEqual(f.type, 'func')
+    assert.strictEqual(f.return_none, false)
+    assert.strictEqual(sysVars.get('テスト関数'), fn)
+  })
+
+  it('createFuncListFromPluginsはプラグイン由来の関数だけを返す', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPlugin({
+      meta: newMeta('ResetPlugin'),
+      プラグイン値: { type: 'const', value: 1 }
+    })
+    // ユーザー定義関数を模したものはシステム領域には登録されない
+    const funclist = manager.createFuncListFromPlugins(sysVars)
+    assert.strictEqual(funclist.has('プラグイン値'), true)
+    assert.strictEqual(funclist.has('ユーザー関数'), false)
+  })
+
+  it('reset()するとユーザー定義関数は消えプラグイン関数は残る', async () => {
+    const nako = new NakoCompiler()
+    await nako.runAsync('●(Aを)ユーザー関数とは\nAを戻す\nここまで', 'main.nako3')
+    // ユーザー定義関数は名前空間付きで登録される
+    assert.ok(nako.getFunc('main__ユーザー関数') !== undefined)
+    nako.reset()
+    assert.strictEqual(nako.getFunc('main__ユーザー関数'), undefined)
+    assert.ok(nako.getFunc('表示') !== undefined, 'プラグインの命令は残ること')
+  })
+
+  it('NakoCompiler.__module と NakoPluginManager.modules は同じ内容を指す', () => {
+    const nako = new NakoCompiler()
+    nako.addPlugin({
+      meta: newMeta('ModuleSharePlugin'),
+      共有テスト値: { type: 'const', value: 1 }
+    })
+    assert.ok(nako.__module.ModuleSharePlugin !== undefined)
+    assert.ok(nako.getPluginfiles().ModuleSharePlugin !== undefined)
+  })
+
+  it('addPluginObjectはmetaが無いプラグインに名前を付ける', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPluginObject('ObjectPlugin', { オブジェクト値: { type: 'const', value: 1 } })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.ok(pluginInfo.ObjectPlugin !== undefined)
+  })
+
+  it('addPluginFromFileはメタ情報にファイルパスを記録する', () => {
+    const { manager, sysVars } = createManager()
+    manager.addPluginFromFile('/path/to/plugin.mjs', {
+      meta: newMeta('FilePlugin'),
+      ファイル値: { type: 'const', value: 1 }
+    })
+    const pluginInfo = sysVars.get('__pluginInfo')
+    assert.strictEqual(pluginInfo.FilePlugin.path, '/path/to/plugin.mjs')
+  })
+
+  it('未知のtypeを持つプラグインはエラーになる', () => {
+    const { manager } = createManager()
+    assert.throws(() => {
+      manager.addPlugin({
+        meta: newMeta('BrokenPlugin'),
+        壊れた値: { type: 'unknown', value: 1 }
+      })
+    }, /プラグインの追加でエラー/)
+  })
+})

package/core/test/nako_require_test.mjs

@@ -0,0 +1,153 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { listRequireStatements, NakoRequireLoader } from '../src/nako_require.mjs'
+import { NakoImportError } from '../src/nako_errors.mjs'
+
+/**
+ * 取り込み文(require)の処理を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_require_test', () => {
+  /** テスト用のローダーを作る。addPluginFromFile の呼び出し履歴も返す */
+  const createLoader = () => {
+    const nako = new NakoCompiler()
+    const addedPlugins = []
+    const loader = new NakoRequireLoader({
+      rawtokenize: (code, line, filename, preCode) => nako.rawtokenize(code, line, filename, preCode),
+      addPluginFromFile: (fpath, po) => { addedPlugins.push({ fpath, po }) },
+      getLogger: () => nako.getLogger(),
+      createScanner: () => new NakoCompiler(),
+      countFailure: () => {}
+    })
+    return { nako, loader, addedPlugins }
+  }
+
+  /** 依存ファイルの情報を作る */
+  const newDependency = (nako, filePath, code) => {
+    return {
+      tokens: nako.rawtokenize(code, 0, filePath),
+      alias: new Set([filePath]),
+      addPluginFile: () => {},
+      funclist: new Map(),
+      moduleExport: new Map()
+    }
+  }
+
+  it('export関数とNakoCompilerのstaticメソッドは同じ結果を返す', () => {
+    const nako = new NakoCompiler()
+    const tokens = nako.rawtokenize('!「hoge.nako3」を取り込む\n「テスト」を表示\n', 0, 'main.nako3')
+    const a = listRequireStatements(tokens).map((t) => t.value)
+    const b = NakoCompiler.listRequireStatements(tokens).map((t) => t.value)
+    assert.deepStrictEqual(a, ['hoge.nako3'])
+    assert.deepStrictEqual(a, b)
+  })
+
+  it('複数の取り込み文をstartの昇順で列挙する', () => {
+    const nako = new NakoCompiler()
+    const code = '!「a.nako3」を取り込む\n!「b.nako3」を取り込む\n!「c.nako3」を取り込む\n'
+    const tokens = nako.rawtokenize(code, 0, 'main.nako3')
+    const list = listRequireStatements(tokens)
+    assert.deepStrictEqual(list.map((t) => t.value), ['a.nako3', 'b.nako3', 'c.nako3'])
+    for (let i = 0; i < list.length; i++) {
+      assert.strictEqual(list[i].end, list[i].start + 3, '取り込み文は3トークンで構成される')
+      if (i > 0) {
+        assert.ok(list[i - 1].start < list[i].start, 'startの昇順に並んでいること')
+      }
+    }
+  })
+
+  it('相互に取り込み合うファイルでも無限ループしない', () => {
+    const { nako, loader } = createLoader()
+    // a.nako3 は b.nako3 を、b.nako3 は a.nako3 を取り込む
+    loader.dependencies = {
+      'a.nako3': newDependency(nako, 'a.nako3', '!「b.nako3」を取り込む\n「A」を表示\n'),
+      'b.nako3': newDependency(nako, 'b.nako3', '!「a.nako3」を取り込む\n「B」を表示\n')
+    }
+    const tokens = nako.rawtokenize('!「a.nako3」を取り込む\n「M」を表示\n', 0, 'main.nako3')
+    const deleted = loader.replaceRequireStatements(tokens)
+    assert.ok(deleted.length > 0, '取り込み文が削除されること')
+    assert.strictEqual(listRequireStatements(tokens).length, 0, '取り込み文がすべて置換されること')
+  })
+
+  it('removeRequireStatementsは取り込み文を削除する', () => {
+    const { nako, loader } = createLoader()
+    let called = 0
+    loader.dependencies = {
+      'a.nako3': { ...newDependency(nako, 'a.nako3', '「A」を表示\n'), addPluginFile: () => { called++ } }
+    }
+    const tokens = nako.rawtokenize('!「a.nako3」を取り込む\n「M」を表示\n', 0, 'main.nako3')
+    const deleted = loader.removeRequireStatements(tokens)
+    assert.strictEqual(deleted.length, 3)
+    assert.strictEqual(listRequireStatements(tokens).length, 0)
+    assert.strictEqual(called, 1, 'シンタックスハイライトのためにaddPluginFileが呼ばれること')
+  })
+
+  it('読み込まれていないファイルを取り込むとエラーになる', () => {
+    const { nako, loader } = createLoader()
+    const tokens = nako.rawtokenize('!「notfound.nako3」を取り込む\n', 0, 'main.nako3')
+    assert.throws(() => loader.replaceRequireStatements(tokens), /読み込まれていません/)
+  })
+
+  it('未対応の拡張子ではNakoImportErrorになる', () => {
+    const { loader } = createLoader()
+    const tools = {
+      resolvePath: (name) => ({ filePath: name, type: 'txt' }),
+      readNako3: () => ({ task: Promise.resolve('') }),
+      readJs: () => ({ task: Promise.resolve(() => ({})) })
+    }
+    assert.throws(
+      () => loader.load('!「foo.txt」を取り込む\n', 'main.nako3', '', tools),
+      (err) => {
+        assert.ok(err instanceof NakoImportError)
+        assert.ok(/読み込めません/.test(err.msg))
+        return true
+      }
+    )
+  })
+
+  it('なでしこファイルを読み込んでdependenciesに保存する', async () => {
+    const { loader } = createLoader()
+    const tools = {
+      resolvePath: (name) => ({ filePath: name, type: 'nako3' }),
+      readNako3: () => ({ task: Promise.resolve('●(Aを)ライブラリ関数とは\nAを戻す\nここまで\n') }),
+      readJs: () => ({ task: Promise.resolve(() => ({})) })
+    }
+    await loader.load('!「lib.nako3」を取り込む\n', 'main.nako3', '', tools)
+    const dep = loader.dependencies['lib.nako3']
+    assert.ok(dep !== undefined, 'dependenciesに登録されること')
+    assert.ok(dep.tokens.length > 0, 'トークン列が保存されること')
+    const names = [...dep.funclist.keys()].filter((k) => String(k).includes('ライブラリ関数'))
+    assert.ok(names.length > 0, '関数名の一覧が事前に取り出されること')
+  })
+
+  it('JSプラグインを読み込んでaddPluginFromFileを呼ぶ', async () => {
+    const { loader, addedPlugins } = createLoader()
+    const pluginObject = {
+      meta: { type: 'const', value: { pluginName: 'RequireTestPlugin', nakoVersion: '3.6.0' } },
+      取込テスト値: { type: 'const', value: 123 }
+    }
+    const tools = {
+      resolvePath: (name) => ({ filePath: name, type: 'mjs' }),
+      readNako3: () => ({ task: Promise.resolve('') }),
+      readJs: () => ({ task: Promise.resolve(() => pluginObject) })
+    }
+    await loader.load('!「plugin.mjs」を取り込む\n', 'main.nako3', '', tools)
+    assert.strictEqual(addedPlugins.length, 1)
+    assert.strictEqual(addedPlugins[0].fpath, 'plugin.mjs')
+    assert.strictEqual(loader.dependencies['plugin.mjs'].funclist, pluginObject)
+  })
+
+  it('同じファイルを2回取り込んでもエイリアスにまとめられる', async () => {
+    const { loader } = createLoader()
+    const tools = {
+      resolvePath: (name) => ({ filePath: 'lib.nako3', type: 'nako3' }),
+      readNako3: () => ({ task: Promise.resolve('「LIB」を表示\n') }),
+      readJs: () => ({ task: Promise.resolve(() => ({})) })
+    }
+    await loader.load('!「lib.nako3」を取り込む\n!「./lib.nako3」を取り込む\n', 'main.nako3', '', tools)
+    assert.strictEqual(Object.keys(loader.dependencies).length, 1)
+    assert.deepStrictEqual([...loader.dependencies['lib.nako3'].alias].sort(), ['./lib.nako3', 'lib.nako3'])
+  })
+})

package/core/test/nako_runner_test.mjs

@@ -0,0 +1,174 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler, newCompilerOptions } from '../src/nako3.mjs'
+import { newCompilerOptions as newCompilerOptionsFromRunner } from '../src/nako_runner.mjs'
+
+/**
+ * 実行部を NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_runner_test', () => {
+  it('newCompilerOptionsは既定値を埋める', () => {
+    const opt = newCompilerOptions()
+    assert.strictEqual(opt.testOnly, false)
+    assert.strictEqual(opt.resetEnv, false)
+    assert.strictEqual(opt.resetAll, false)
+    assert.strictEqual(opt.preCode, '')
+    assert.strictEqual(opt.nakoGlobal, null)
+  })
+
+  it('newCompilerOptionsは指定した値を残す', () => {
+    const opt = newCompilerOptions({ testOnly: true, preCode: 'A=1;' })
+    assert.strictEqual(opt.testOnly, true)
+    assert.strictEqual(opt.preCode, 'A=1;')
+    assert.strictEqual(opt.resetEnv, false)
+  })
+
+  it('nako3.mjsとnako_runner.mjsのnewCompilerOptionsは同じ関数', () => {
+    assert.strictEqual(newCompilerOptions, newCompilerOptionsFromRunner)
+  })
+
+  it('runAsyncが実行環境を返し__globalObjに記録される', async () => {
+    const nako = new NakoCompiler()
+    const g = await nako.runAsync('「テスト」を表示', 'main.nako3')
+    assert.strictEqual(g.log, 'テスト')
+    assert.strictEqual(nako.__globalObj, g, '現在の実行環境が記録されること')
+    assert.strictEqual(nako.__globals.length, 1)
+    assert.strictEqual(nako.__globals[0], g)
+  })
+
+  it('runAsyncは非同期プログラムの実行完了を待つ (#2381)', async () => {
+    const nako = new NakoCompiler()
+    const g = await nako.runAsync('0.02秒待つ\n「完了」を表示', 'main.nako3')
+    assert.strictEqual(g.log, '完了')
+  })
+
+  it('非同期処理中のエラーがrunAsync完了時に反映される (#2381)', async () => {
+    const nako = new NakoCompiler()
+    const g = await nako.runAsync('0.01秒待つ\n「ぐぬ」のエラー発生', 'main.nako3')
+    assert.strictEqual(g.numFailures, 1)
+  })
+
+  it('__globalObjは代入もできる(後方互換)', () => {
+    const nako = new NakoCompiler()
+    assert.strictEqual(nako.__globalObj, null)
+    const dummy = { dummy: true }
+    nako.__globalObj = dummy
+    assert.strictEqual(nako.__globalObj, dummy)
+  })
+
+  it('__globalsは代入もできる(後方互換)', () => {
+    const nako = new NakoCompiler()
+    nako.__globals = []
+    assert.deepStrictEqual(nako.__globals, [])
+  })
+
+  it('連続して実行すると同じ実行環境を再利用する', async () => {
+    const nako = new NakoCompiler()
+    const g1 = await nako.runAsync('A=10', 'main.nako3')
+    const g2 = await nako.runAsync('Aを表示', 'main.nako3')
+    assert.strictEqual(g1, g2, '実行環境が共有されること')
+    assert.strictEqual(g2.log, '10')
+    assert.strictEqual(nako.__globals.length, 1)
+  })
+
+  it('clearPluginsで実行環境の一覧が空になる', async () => {
+    const nako = new NakoCompiler()
+    await nako.runAsync('「テスト」を表示', 'main.nako3')
+    assert.strictEqual(nako.__globals.length, 1)
+    nako.clearPlugins()
+    assert.strictEqual(nako.__globals.length, 0)
+  })
+
+  it('resetAllを指定すると新しい実行環境が作られる', async () => {
+    const nako = new NakoCompiler()
+    const g1 = await nako.runAsync('A=10', 'main.nako3')
+    const g2 = await nako.runAsync('「テスト」を表示', 'main.nako3', newCompilerOptions({ resetAll: true, resetEnv: true }))
+    assert.notStrictEqual(g1, g2, '実行環境が作り直されること')
+  })
+
+  it('nakoGlobalを指定すると、その実行環境を使う', async () => {
+    const nako = new NakoCompiler()
+    const g1 = await nako.runAsync('A=10', 'main.nako3')
+    const g2 = await nako.runAsync('Aを表示', 'main.nako3', newCompilerOptions({ nakoGlobal: g1 }))
+    assert.strictEqual(g1, g2)
+    assert.strictEqual(g2.log, '10')
+  })
+
+  it('runSyncも同じように動作する', () => {
+    const nako = new NakoCompiler()
+    const g = nako.runSync('「同期」を表示', 'main.nako3')
+    assert.strictEqual(g.log, '同期')
+  })
+
+  it('testメソッドはpreCodeを反映する', () => {
+    const nako = new NakoCompiler()
+    // preCode は code の先頭に含めて渡す仕様
+    const g = nako.test('A=5;Aを表示', 'main.nako3', 'A=5;')
+    assert.strictEqual(g.log, '5')
+  })
+
+  it('runReset は他の実行インスタンスもリセットする', async () => {
+    const nako = new NakoCompiler()
+    await nako.runAsync('A=10', 'main.nako3')
+    const g = await nako.runReset('「リセット」を表示', 'main.nako3')
+    assert.strictEqual(g.log, 'リセット')
+    assert.strictEqual(nako.__globals.length, 1, '古い実行環境が破棄されること')
+  })
+
+  it('実行時エラーはログに記録された上で例外になる', async () => {
+    const nako = new NakoCompiler()
+    await assert.rejects(async () => {
+      await nako.runAsync('『存在しない関数』のエラー発生', 'main.nako3')
+    })
+  })
+
+  it('初期化に失敗したプラグインのクリア関数は呼ばれない #2064', async () => {
+    // プラグインの初期化は生成されたJavaScriptの中で実行されるため、
+    // 実行に失敗すると初期化されないまま実行環境が残ってしまう。
+    // その状態で次の実行を行うと「!クリア」でエラーが出ていた。
+    let failInit = true
+    let clearCount = 0
+    const plugin = {
+      meta: { type: 'const', value: { pluginName: 'plugin_dummy2064', nakoVersion: '3.6.0' } },
+      初期化: {
+        type: 'func',
+        josi: [],
+        pure: true,
+        fn: (sys) => {
+          if (failInit) { throw new Error('初期化に失敗') }
+          sys.__dummyClear2064 = () => { clearCount++ }
+        }
+      },
+      '!クリア': {
+        type: 'func',
+        josi: [],
+        pure: true,
+        // 初期化されていなければ、ここで TypeError になる
+        fn: (sys) => { sys.__dummyClear2064() }
+      }
+    }
+    const errors = []
+    const nako = new NakoCompiler()
+    nako.getLogger().addListener('error', (data) => { errors.push(data.noColor) })
+    nako.addPluginObject('plugin_dummy2064', plugin)
+
+    // 1回目 … 初期化に失敗して実行環境だけが残る
+    await assert.rejects(async () => { await nako.runReset('「NG」を表示', 'main.nako3') })
+
+    // 2回目 … 初期化されていないのでクリア関数は呼ばれない
+    failInit = false
+    const g2 = await nako.runReset('「OK」を表示', 'main.nako3')
+    assert.strictEqual(g2.log, 'OK')
+    assert.strictEqual(clearCount, 0, 'クリア関数が呼ばれないこと')
+    assert.strictEqual(
+      errors.filter((e) => e.includes('クリア関数でエラーが発生しました')).length, 0,
+      'クリア関数のエラーが出ないこと')
+
+    // 3回目 … 2回目で初期化が成功しているのでクリア関数が呼ばれる
+    const g3 = await nako.runReset('「OK2」を表示', 'main.nako3')
+    assert.strictEqual(g3.log, 'OK2')
+    assert.strictEqual(clearCount, 1, '初期化済みならクリア関数が呼ばれること')
+  })
+})

package/core/test/nako_tokenizer_test.mjs

@@ -0,0 +1,115 @@
+/* eslint-disable no-undef */
+import { describe, it } from 'node:test'
+import assert from 'assert'
+
+import { NakoCompiler } from '../src/nako3.mjs'
+import { NakoTokenizer } from '../src/nako_tokenizer.mjs'
+import { NakoLogger } from '../src/nako_logger.mjs'
+
+/**
+ * 字句解析パイプラインを NakoCompiler から分離したモジュールのテスト (#2360)
+ */
+describe('nako_tokenizer_test', () => {
+  /** 取り込み文を扱わない、単体テスト用のトークナイザを作る */
+  const createTokenizer = () => {
+    const logger = new NakoLogger()
+    return new NakoTokenizer({
+      getLogger: () => logger,
+      // 取り込み文は扱わないので、何もせず空配列を返す
+      replaceRequireStatements: () => [],
+      removeRequireStatements: () => []
+    })
+  }
+
+  it('rawtokenizeがトークン列を返す', () => {
+    const tokenizer = createTokenizer()
+    // 単体のトークナイザは関数一覧を持たないため、命令は word になる
+    const tokens = tokenizer.rawtokenize('1と2を足す', 0, 'main.nako3')
+    const types = tokens.map((t) => t.type)
+    assert.ok(types.includes('number'), '数値トークンが含まれること')
+    assert.ok(types.includes('word'), '単語トークンが含まれること')
+    assert.deepStrictEqual(tokens.filter((t) => t.type === 'number').map((t) => t.value), [1, 2])
+  })
+
+  it('rawtokenizeはpreCodeがcodeの先頭にないとエラーになる', () => {
+    const tokenizer = createTokenizer()
+    assert.throws(
+      () => tokenizer.rawtokenize('「A」を表示', 0, 'main.nako3', '「B」を表示'),
+      /preCodeを含める必要があります/
+    )
+  })
+
+  it('rawtokenizeがモジュールリストへ自身を追加する', () => {
+    const tokenizer = createTokenizer()
+    tokenizer.rawtokenize('「A」を表示', 0, 'sample.nako3')
+    assert.ok(tokenizer.getModList().includes('sample'))
+  })
+
+  it('全角の記号が半角へ正規化される', () => {
+    const tokenizer = createTokenizer()
+    // 全角の「＝」が半角の「=」として解釈される
+    const tokens = tokenizer.rawtokenize('Ａ＝１', 0, 'main.nako3')
+    const types = tokens.map((t) => t.type)
+    assert.ok(types.includes('eq'), '代入のトークンになること')
+  })
+
+  it('トークンに行番号と桁位置が設定される', () => {
+    const tokenizer = createTokenizer()
+    const tokens = tokenizer.rawtokenize('「A」を表示\n「B」を表示\n', 0, 'main.nako3')
+    const second = tokens.filter((t) => t.type === 'string' && t.value === 'B')[0]
+    assert.ok(second !== undefined)
+    assert.strictEqual(second.line, 1, '2行目のトークンの行番号は1になること')
+  })
+
+  it('コメントのトークンが残る', () => {
+    const tokenizer = createTokenizer()
+    const tokens = tokenizer.rawtokenize('# これはコメント\n「A」を表示\n', 0, 'main.nako3')
+    const comments = tokens.filter((t) => t.type === 'line_comment')
+    assert.strictEqual(comments.length, 1)
+  })
+
+  it('lexCodeTokenがstartOffsetを加算する', () => {
+    const tokenizer = createTokenizer()
+    const res = tokenizer.lexCodeToken('1に2を足す', 0, 'main.nako3', 100)
+    const withOffset = res.tokens.filter((t) => t.startOffset !== undefined)
+    assert.ok(withOffset.length > 0)
+    assert.ok(withOffset.every((t) => t.startOffset >= 100), 'startOffsetが加算されること')
+  })
+
+  it('lexCodeTokenにstartOffsetがnullならオフセットを消す', () => {
+    const tokenizer = createTokenizer()
+    const res = tokenizer.lexCodeToken('1に2を足す', 0, 'main.nako3', null)
+    assert.ok(res.tokens.every((t) => t.startOffset === undefined))
+    assert.ok(res.tokens.every((t) => t.endOffset === undefined))
+  })
+
+  it('lexが字句解析の結果を返す', () => {
+    const tokenizer = createTokenizer()
+    const res = tokenizer.lex('# コメント\n「A」を表示\n', 'main.nako3')
+    assert.ok(res.tokens.length > 0)
+    assert.strictEqual(res.commentTokens.length, 1)
+    assert.deepStrictEqual(res.requireTokens, [])
+  })
+
+  it('NakoCompilerの各メソッドはトークナイザへ委譲される', () => {
+    const nako = new NakoCompiler()
+    const viaCompiler = nako.rawtokenize('1と2を足す', 0, 'main.nako3')
+    const viaTokenizer = nako.tokenizer.rawtokenize('1と2を足す', 0, 'main.nako3')
+    assert.deepStrictEqual(viaCompiler.map((t) => t.type), viaTokenizer.map((t) => t.type))
+    // getModList もトークナイザが持つモジュールリストを返す
+    assert.strictEqual(nako.getModList(), nako.tokenizer.getModList())
+  })
+
+  it('replaceLoggerを呼ぶとトークナイザのロガーも差し替わる', () => {
+    const nako = new NakoCompiler()
+    const logger = nako.replaceLogger()
+    assert.strictEqual(nako.tokenizer.lexer.logger, logger)
+    assert.strictEqual(nako.getLogger(), logger)
+  })
+
+  it('文字列展開の中のコードも字句解析される', async () => {
+    const nako = new NakoCompiler()
+    const g = await nako.runAsync('A=3;「値は{A}です」を表示', 'main.nako3')
+    assert.strictEqual(g.log, '値は3です')
+  })
+})