import command feature (#57)

Author: kazupon

src/commands/import.ts

@@ -0,0 +1,100 @@
+import { Arguments, Argv } from 'yargs'
+
+import {
+  resolveProviderConf,
+  loadProvider,
+  loadProviderConf,
+  DEFUALT_CONF,
+  getRawLocaleMessages,
+  PushableOptions
+} from '../utils'
+
+type ImportOptions = {
+  provider: string
+  conf?: string
+  dryRun: boolean
+} & PushableOptions
+
+export const command = 'import'
+export const aliases = 'imp'
+export const describe = 'import locale messages to localization service'
+
+export const builder = (args: Argv): Argv<ImportOptions> => {
+  return args
+    .option('provider', {
+      type: 'string',
+      alias: 'p',
+      describe: 'the target localization service provider',
+      demandOption: true
+    })
+    .option('conf', {
+      type: 'string',
+      alias: 'c',
+      describe: 'the json file configration of localization service provider. If omitted, use the suffix file name with `-conf` for provider name of --provider (e.g. <provider>-conf.json).'
+    })
+    .option('target', {
+      type: 'string',
+      alias: 't',
+      describe: 'target path that locale messages file is stored, default import with the filename of target path as locale'
+    })
+    .option('locale', {
+      type: 'string',
+      alias: 'l',
+      describe: `option for the locale of locale messages file specified with --target, if it's specified single-file`
+    })
+    .option('targetPaths', {
+      type: 'string',
+      alias: 'T',
+      describe: 'target directory paths that locale messages files is stored, Can also be specified multi paths with comma delimiter'
+    })
+    .option('filenameMatch', {
+      type: 'string',
+      alias: 'm',
+      describe: `option should be accepted a regex filenames, must be specified together --targets if it's directory path of locale messages`
+    })
+    .option('dryRun', {
+      type: 'boolean',
+      alias: 'd',
+      default: false,
+      describe: `run the import command, but do not apply to locale messages of localization service`
+    })
+}
+
+export const handler = async (args: Arguments<ImportOptions>): Promise<unknown> => {
+  const { dryRun } = args
+  const ProviderFactory = loadProvider(args.provider)
+
+  if (ProviderFactory === null) {
+    // TODO: should refactor console message
+    console.log(`Not found ${args.provider} provider`)
+    return
+  }
+
+  if (!args.target && !args.targetPaths) {
+    // TODO: should refactor console message
+    console.log('You need to specify either --target or --target-paths')
+    return
+  }
+
+  const confPath = resolveProviderConf(args.provider, args.conf)
+  const conf = loadProviderConf(confPath) || DEFUALT_CONF
+
+  try {
+    const messages = getRawLocaleMessages(args)
+    const provider = ProviderFactory(conf)
+    await provider.import({ messages, dryRun })
+    // TODO: should refactor console message
+    console.log('import success')
+  } catch (e) {
+    // TODO: should refactor console message
+    console.error('import fail:', e.message)
+  }
+}
+
+export default {
+  command,
+  aliases,
+  describe,
+  builder,
+  handler
+}

src/commands/push.ts

@@ -85,22 +85,15 @@ export const handler = async (args: Arguments<PushOptions>): Promise<unknown> =>
   const confPath = resolveProviderConf(args.provider, args.conf)
   const conf = loadProviderConf(confPath) || DEFUALT_CONF
 
-  let messages
-  try {
-    messages = getLocaleMessages(args)
-  } catch (e) {
-    console.log(e.message)
-    return
-  }
-
   try {
+    const messages = getLocaleMessages(args)
     const provider = ProviderFactory(conf)
     await provider.push({ messages, dryRun, normalize })
     // TODO: should refactor console message
     console.log('push success')
   } catch (e) {
     // TODO: should refactor console message
-    console.error('push fail', e)
+    console.error('push fail:', e.message)
   }
 }
 

src/utils.ts

@@ -1,16 +1,20 @@
+// import types
 import { Arguments } from 'yargs'
 import { SFCDescriptor } from 'vue-template-compiler'
-import { SFCFileInfo, FormatOptions } from '../types'
 import { VueTemplateCompiler } from '@vue/component-compiler-utils/dist/types'
 import {
+  SFCFileInfo,
   Locale,
   LocaleMessages,
+  FormatOptions,
   ProviderFactory,
   ProviderConfiguration,
   TranslationStatusOptions,
-  TranslationStatus
+  TranslationStatus,
+  RawLocaleMessage
 } from '../types'
 
+// import modules
 import { parse } from '@vue/component-compiler-utils'
 import * as compiler from 'vue-template-compiler'
 import fs from 'fs'
@@ -22,6 +26,7 @@ import yaml from 'js-yaml'
 import { debug as Debug } from 'debug'
 const debug = Debug('vue-i18n-locale-message:utils')
 
+// define types
 export type PushableOptions = {
   target?: string
   locale?: string
@@ -36,14 +41,14 @@ const ESC: { [key in string]: string } = {
   '&': '&'
 }
 
-export function escape (s: string): string {
-  return s.replace(/[<>"&]/g, escapeChar)
-}
-
 function escapeChar (a: string): string {
   return ESC[a] || a
 }
 
+export function escape (s: string): string {
+  return s.replace(/[<>"&]/g, escapeChar)
+}
+
 export function resolve (...paths: string[]): string {
   return path.resolve(...paths)
 }
@@ -211,6 +216,46 @@ export function getLocaleMessages (args: Arguments<PushableOptions>): LocaleMess
   return messages
 }
 
+export function getRawLocaleMessages (args: Arguments<PushableOptions>): RawLocaleMessage[] {
+  const messages = [] as RawLocaleMessage[]
+
+  if (args.target) {
+    const targetPath = resolve(args.target)
+    const parsed = path.parse(targetPath)
+    messages.push({
+      locale: args.locale ? args.locale : parsed.name,
+      data: fs.readFileSync(targetPath)
+    })
+  } else if (args.targetPaths) {
+    const filenameMatch = args.filenameMatch
+    if (!filenameMatch) {
+      // TODO: should refactor console message
+      throw new Error('You need to specify together --filename-match')
+    }
+    const targetPaths = args.targetPaths.split(',').filter(p => p)
+    targetPaths.forEach(targetPath => {
+      const globedPaths = glob.sync(targetPath).map(p => resolve(p))
+      globedPaths.forEach(fullPath => {
+        const parsed = path.parse(fullPath)
+        const re = new RegExp(filenameMatch, 'ig')
+        const match = re.exec(parsed.base)
+        debug('regex match', match, fullPath)
+        if (match && match[1]) {
+          messages.push({
+            locale: match[1],
+            data: fs.readFileSync(fullPath)
+          })
+        } else {
+          // TODO: should refactor console message
+          console.log(`${fullPath} is not matched with ${filenameMatch}`)
+        }
+      })
+    })
+  }
+
+  return messages
+}
+
 export async function getTranslationStatus (options: TranslationStatusOptions): Promise<TranslationStatus[]> {
   const ProviderFactory = loadProvider(options.provider)
   if (ProviderFactory === null) {

test/commands/__mocks__/l10n-service-provider.js

@@ -17,6 +17,21 @@ class L10nServiceProvider {
       percentable: 100.0
     }])
   }
+
+  async import (messsages, dryRun) {
+    return
+  }
+
+  async export (locales, format, dryRun) {
+    const data = [{
+      locale: 'ja',
+      data: Buffer.from(JSON.stringify({}))
+    }, {
+      locale: 'en',
+      data: Buffer.from(JSON.stringify({}))
+    }]
+    return Promise.resolve(data)
+  }
 }
 
 module.exports = L10nServiceProvider