Change to apply update when resource file is updated. (#87)

Author: ota-meshi

lib/rules/no-unused-keys.js

@@ -4,7 +4,7 @@
 'use strict'
 
 const { extname } = require('path')
-const { collectKeysFromFiles, collectKeysFromAST } = require('../utils/collect-keys')
+const { collectKeysFromAST, usedKeysCache } = require('../utils/collect-keys')
 const collectLinkedKeys = require('../utils/collect-linked-keys')
 const { getLocaleMessages } = require('../utils/index')
 const { traverseNodes, getStaticJSONValue } = require('eslint-plugin-jsonc')
@@ -17,9 +17,6 @@ const debug = require('debug')('eslint-plugin-vue-i18n:no-unused-keys')
  * @typedef {import('../utils/locale-messages').LocaleMessage} LocaleMessage
  */
 
-/** @type {string[] | null} */
-let cacheUsedLocaleMessageKeys = null // used locale message keys
-
 /**
  * @param {LocaleMessage} targetLocaleMessage
  * @param {object} jsonValue
@@ -236,7 +233,7 @@ function create (context) {
     const src = options.src || process.cwd()
     const extensions = options.extensions || ['.js', '.vue']
 
-    const usedLocaleMessageKeys = cacheUsedLocaleMessageKeys || (cacheUsedLocaleMessageKeys = collectKeysFromFiles([src], extensions))
+    const usedLocaleMessageKeys = usedKeysCache.collectKeysFromFiles([src], extensions)
     const sourceCode = context.getSourceCode()
     const { enterNode, leaveNode, reports } = createVisitor(sourceCode, targetLocaleMessage, usedLocaleMessageKeys)
 

lib/utils.js

@@ -2,13 +2,17 @@
 'use strict'
 
 module.exports = {
+  'cache-function': require('./utils/cache-function'),
+  'cache-loader': require('./utils/cache-loader'),
   'collect-keys': require('./utils/collect-keys'),
   'collect-linked-keys': require('./utils/collect-linked-keys'),
+  'default-timeouts': require('./utils/default-timeouts'),
   'glob-sync': require('./utils/glob-sync'),
   'glob-utils': require('./utils/glob-utils'),
   'ignored-paths': require('./utils/ignored-paths'),
   'index': require('./utils/index'),
   'json-parsers': require('./utils/json-parsers'),
   'locale-messages': require('./utils/locale-messages'),
-  'path-utils': require('./utils/path-utils')
+  'path-utils': require('./utils/path-utils'),
+  'resource-loader': require('./utils/resource-loader')
 }

lib/utils/cache-function.js

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Cache function
+ * @author Yosuke Ota
+ */
+
+const CacheLoader = require('./cache-loader')
+
+/**
+ * This function returns a function that returns the result value that was called for the given function.
+ * But when called, it returns the cached value if it is the same as the previous argument.
+ */
+module.exports = function defineCacheFunction (fn) {
+  const loader = new CacheLoader(fn, Infinity)
+  return (...args) => {
+    return loader.get(...args)
+  }
+}
+

lib/utils/cache-loader.js

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Cache loader class
+ * @author Yosuke Ota
+ */
+
+/**
+ * The class that returns load value or cache value.
+ * This class returns the called result value of of the given loader.
+ * But when the loader is called, it does not get a new value and returns a cached value until it times out.
+ */
+module.exports = class CacheLoader {
+  constructor (loader, timeout = () => require('./default-timeouts').CACHE_LOADER) {
+    this.loader = loader
+    this.timeout = timeout
+    this._cacheTime = Number.MIN_SAFE_INTEGER
+  }
+
+  get (...args) {
+    const key = JSON.stringify(args)
+    const now = Date.now()
+    if (this._cacheKey === key) {
+      const timeout = typeof this.timeout === 'function' ? this.timeout() : this.timeout
+      if (this._cacheTime + timeout > now) {
+        return this._cache
+      }
+    }
+    this._cacheKey = key
+    this._cacheTime = now
+    return (this._cache = this.loader(...args))
+  }
+}
+

lib/utils/collect-keys.js

@@ -9,6 +9,9 @@ const vueESLintParser = require('vue-eslint-parser')
 const { readFileSync } = require('fs')
 const { resolve, extname } = require('path')
 const { listFilesToProcess } = require('./glob-utils')
+const ResourceLoader = require('./resource-loader')
+const CacheLoader = require('./cache-loader')
+const defineCacheFunction = require('./cache-function')
 const debug = require('debug')('eslint-plugin-vue-i18n:collect-keys')
 
 /**
@@ -94,30 +97,26 @@ function collectKeysFromText (text, filename, cliEngine) {
 
 /**
  * Collect the used keys from files.
- * @returns {string[]}
+ * @returns {ResourceLoader[]}
  */
-function collectKeysFromFiles (files, extensions) {
-  debug('collectKeysFromFiles', files, extensions)
+function collectKeyResourcesFromFiles (fileNames) {
+  debug('collectKeysFromFiles', fileNames)
 
   const cliEngine = new CLIEngine()
 
-  const results = new Set()
+  const results = []
 
   // detect used lodalization keys with linter
-  for (const { filename, ignored } of listFilesToProcess(files, { extensions })) {
+  for (const filename of fileNames) {
     debug(`Processing file ... ${filename}`)
 
-    if (ignored) { continue }
-    if (!extensions.includes(extname(filename))) { continue }
-
-    const text = readFileSync(resolve(filename), 'utf8')
-
-    for (const usedKey of collectKeysFromText(text, filename, cliEngine)) {
-      results.add(usedKey)
-    }
+    results.push(new ResourceLoader(resolve(filename), () => {
+      const text = readFileSync(resolve(filename), 'utf8')
+      return collectKeysFromText(text, filename, cliEngine)
+    }))
   }
 
-  return [...results]
+  return results
 }
 
 /**
@@ -164,7 +163,45 @@ function collectKeysFromAST (node, visitorKeys) {
   return [...results]
 }
 
+class UsedKeysCache {
+  constructor () {
+    this._targetFilesLoader = new CacheLoader((files, extensions) => {
+      return listFilesToProcess(files, { extensions })
+        .filter(f => !f.ignored && extensions.includes(extname(f.filename)))
+        .map(f => f.filename)
+    })
+    this._collectKeyResourcesFromFiles = defineCacheFunction((fileNames) => {
+      return collectKeyResourcesFromFiles(fileNames)
+    })
+  }
+  /**
+   * Collect the used keys from files.
+   * @param {string[]} files
+   * @param {string[]} extensions
+   * @returns {string[]}
+   */
+  collectKeysFromFiles (files, extensions) {
+    const result = new Set()
+    for (const resource of this._getKeyResources(files, extensions)) {
+      for (const key of resource.getResource()) {
+        result.add(key)
+      }
+    }
+    return [...result]
+  }
+
+  /**
+   * @returns {ResourceLoader[]}
+   */
+  _getKeyResources (files, extensions) {
+    const fileNames = this._targetFilesLoader.get(files, extensions)
+    return this._collectKeyResourcesFromFiles(fileNames)
+  }
+}
+
+const usedKeysCache = new UsedKeysCache() // used locale message keys
+
 module.exports = {
-  collectKeysFromFiles,
-  collectKeysFromAST
+  collectKeysFromAST,
+  usedKeysCache
 }

lib/utils/default-timeouts.js

@@ -0,0 +1,9 @@
+/**
+ * @fileoverview Default timeouts
+ * @author Yosuke Ota
+ */
+
+module.exports = {
+  CACHE_LOADER: 1000,
+  MTIME_MS_CHECK: 300
+}

lib/utils/index.js

@@ -7,6 +7,8 @@
 const glob = require('glob')
 const { resolve, dirname, extname } = require('path')
 const { FileLocaleMessage, BlockLocaleMessage, LocaleMessages } = require('./locale-messages')
+const CacheLoader = require('./cache-loader')
+const defineCacheFunction = require('./cache-function')
 
 /**
  * @typedef {import('vue-eslint-parser').AST.ESLintProgram} Program
@@ -57,19 +59,15 @@ function defineTemplateBodyVisitor (context, templateBodyVisitor, scriptVisitor)
 }
 
 /**
- * @param {SettingsVueI18nLocaleDir} localeDir
+ * @param {string[]} files
+ * @param {LocaleKeyType} localeKey
  * @returns {LocaleMessage[]}
  */
-function loadLocaleMessages (localeDir) {
-  if (typeof localeDir === 'string') {
-    return loadLocaleMessages({ pattern: localeDir, localeKey: 'file' })
-  } else {
-    const files = glob.sync(localeDir.pattern)
-    return files.map(file => {
-      const fullpath = resolve(process.cwd(), file)
-      return new FileLocaleMessage({ fullpath, localeKey: localeDir.localeKey || 'file' })
-    })
-  }
+function loadLocaleMessages (files, localeKey) {
+  return files.map(file => {
+    const fullpath = resolve(process.cwd(), file)
+    return new FileLocaleMessage({ fullpath, localeKey })
+  })
 }
 
 /** @type {Set<RuleContext>} */
@@ -99,30 +97,42 @@ function getLocaleMessages (context) {
 
   return new LocaleMessages([
     ...(getLocaleMessagesFromI18nBlocks(context, i18nBlocks) || []),
-    ...(localeDir && getLocaleMessagesFromLocaleDir(localeDir) || [])
+    ...(localeDir && localeDirLocaleMessagesCache.getLocaleMessagesFromLocaleDir(localeDir) || [])
   ])
 }
 
-/** @type {LocaleMessage[] | null} */
-let localeDirLocaleMessages = null // locale messages
-let localeDir = null // locale dir
-/** @type {Map<Program, LocaleMessage[]>} */
-const i18nBlockLocaleMessages = new WeakMap()
+class LocaleDirLocaleMessagesCache {
+  constructor () {
+    this._targetFilesLoader = new CacheLoader((pattern) => glob.sync(pattern))
 
-/**
- * @param {SettingsVueI18nLocaleDir} localeDirectory
- * @returns {LocaleMessage[]}
- */
-function getLocaleMessagesFromLocaleDir (localeDirectory) {
-  if (localeDir !== localeDirectory) {
-    localeDir = localeDirectory
-    localeDirLocaleMessages = loadLocaleMessages(localeDir)
-  } else {
-    localeDirLocaleMessages = localeDirLocaleMessages || loadLocaleMessages(localeDir)
+    this._loadLocaleMessages = defineCacheFunction((files, localeKey) => {
+      return loadLocaleMessages(files, localeKey)
+    })
+  }
+  /**
+   * @param {SettingsVueI18nLocaleDir} localeDir
+   * @returns {LocaleMessage[]}
+   */
+  getLocaleMessagesFromLocaleDir (localeDir) {
+    const targetFilesLoader = this._targetFilesLoader
+    let files
+    let localeKey
+    if (typeof localeDir === 'string') {
+      files = targetFilesLoader.get(localeDir)
+      localeKey = 'file'
+    } else {
+      files = targetFilesLoader.get(localeDir.pattern)
+      localeKey = `${localeDir.localeKey || 'file'}`
+    }
+    return this._loadLocaleMessages(files, localeKey)
   }
-  return localeDirLocaleMessages
 }
 
+const localeDirLocaleMessagesCache = new LocaleDirLocaleMessagesCache()
+
+/** @type {Map<Program, LocaleMessage[]>} */
+const i18nBlockLocaleMessages = new WeakMap()
+
 /**
  * @param {RuleContext} context
  * @param {VElement[]} i18nBlocks

lib/utils/locale-messages.js

@@ -5,6 +5,7 @@
 'use strict'
 
 const { parseJsonInI18nBlock } = require('./json-parsers')
+const ResourceLoader = require('./resource-loader')
 const { getStaticJSONValue } = require('eslint-plugin-jsonc')
 
 /**
@@ -37,11 +38,21 @@ class LocaleMessage {
     // abstract
   }
 
+  /**
+   * @protected
+   */
+  getMessagesInternal () {
+    if (this._messages) {
+      return this._messages
+    }
+    return (this._messages = this.loadMessages())
+  }
+
   /**
    * @returns {object} The localization messages object.
    */
   get messages () {
-    return this._messages || (this._messages = this.loadMessages())
+    return this.getMessagesInternal()
   }
   /**
    * @returns {string[]} Array of locales.
@@ -186,10 +197,15 @@ class FileLocaleMessage extends LocaleMessage {
       locales,
       localeKey
     })
+    this._resource = new ResourceLoader(fullpath, (p) => {
+      const key = require.resolve(p)
+      delete require.cache[key]
+      return require(p)
+    })
   }
 
-  loadMessages () {
-    return require(this.fullpath)
+  getMessagesInternal () {
+    return this._resource.getResource()
   }
 }
 

lib/utils/resource-loader.js

@@ -0,0 +1,39 @@
+/**
+ * @fileoverview Resource loader class
+ * @author Yosuke Ota
+ */
+
+const fs = require('fs')
+const CacheLoader = require('./cache-loader')
+
+/**
+ * The class of resource loader.
+ * This class gets and returns the resource for the given file.
+ * But when the loader is called, the loader will not check for new values until 300ms has elapsed.
+ * Also, if the result of the check is that the mtime of the file has not changed, the new value is not load and the cached value is returned.
+ */
+module.exports = class ResourceLoader {
+  constructor (filename, loader, mtimeCheckTimeout = () => require('./default-timeouts').MTIME_MS_CHECK) {
+    this.filename = filename
+    this.loader = loader
+    this._resource = null
+    this._mtimeLoader = new CacheLoader(() => {
+      try {
+        const stat = fs.statSync(this.filename)
+        return stat.mtimeMs
+      } catch (_e) {
+        // ignore
+      }
+      return this._mtimeMs || 0
+    }, mtimeCheckTimeout)
+  }
+
+  getResource () {
+    const mtimeMs = this._mtimeLoader.get()
+    if (this._resource && this._mtimeMs >= mtimeMs) {
+      return this._resource
+    }
+    this._mtimeMs = mtimeMs
+    return (this._resource = this.loader(this.filename))
+  }
+}