export command feature (#56)

* export command feature

* remove normalize option

Author: kazupon

src/commands/export.ts

@@ -0,0 +1,136 @@
+import * as fs from 'fs'
+import * as path from 'path'
+import { promisify } from 'util'
+import { Arguments, Argv } from 'yargs'
+
+import { debug as Debug } from 'debug'
+const debug = Debug('vue-i18n-locale-message:commands:export')
+
+const mkdirPromisify = promisify(fs.mkdir)
+const writeFilePromisify = promisify(fs.writeFile)
+
+import {
+  resolveProviderConf,
+  loadProvider,
+  loadProviderConf,
+  DEFUALT_CONF
+} from '../utils'
+import { Locale, RawLocaleMessage } from '../../types'
+
+type ExportOptions = {
+  provider: string
+  conf?: string
+  output: string
+  locales?: string
+  format: string
+  dryRun: boolean
+}
+
+export const command = 'export'
+export const aliases = 'ex'
+export const describe = 'export locale messages from localization service'
+
+export const builder = (args: Argv): Argv<ExportOptions> => {
+  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('output', {
+      type: 'string',
+      alias: 'o',
+      describe: 'the path to output that exported locale messages',
+      demandOption: true
+    })
+    .option('locales', {
+      type: 'string',
+      alias: 'l',
+      default: '',
+      describe: `option for some locales of locale messages, you can also be specified multi locale with comma delimiter. if it's not specified export all locale messages`
+    })
+    .option('format', {
+      type: 'string',
+      alias: 'f',
+      default: 'json',
+      describe: 'option for the locale messages format, default `json`'
+    })
+    .option('dryRun', {
+      type: 'boolean',
+      alias: 'd',
+      default: false,
+      describe: 'run the export command, but do not export to locale messages of localization service'
+    })
+}
+
+export const handler = async (args: Arguments<ExportOptions>): Promise<unknown> => {
+  const { dryRun, format } = args
+  const ProviderFactory = loadProvider(args.provider)
+
+  if (ProviderFactory === null) {
+    // TODO: should refactor console message
+    console.log(`Not found ${args.provider} provider`)
+    return
+  }
+
+  if (!args.output) {
+    // TODO: should refactor console message
+    console.log('You need to specify --output')
+    return
+  }
+
+  const confPath = resolveProviderConf(args.provider, args.conf)
+  const conf = loadProviderConf(confPath) || DEFUALT_CONF
+
+  try {
+    const locales = args.locales?.split(',').filter(p => p) as Locale[] || []
+    const provider = ProviderFactory(conf)
+    const messages = await provider.export({ locales, dryRun, format })
+    await writeRawLocaleMessages(args.output, format, messages, args.dryRun)
+    // TODO: should refactor console message
+    console.log('export success')
+  } catch (e) {
+    // TODO: should refactor console message
+    console.error('export fail', e)
+  }
+}
+
+async function writeRawLocaleMessages (output: string, format: string, messages: RawLocaleMessage[], dryRun: boolean) {
+  debug('writeRawLocaleMessages', messages, dryRun)
+
+  // wrap mkdir with dryRun
+  const mkdir = async (output: string) => {
+    return !dryRun
+      ? mkdirPromisify(path.resolve(output), { recursive: true })
+      : Promise.resolve()
+  }
+
+  // wrap writeFile with dryRun
+  const writeFile = async (output: string, format: string, message: RawLocaleMessage) => {
+    const localePath = path.resolve(output, `${message.locale}.${format}`)
+    console.log(`write '${message.locale}' messages to ${localePath}`)
+    return !dryRun
+      ? writeFilePromisify(localePath, message.data)
+      : Promise.resolve()
+  }
+
+  // run!
+  await mkdir(output)
+  for (const message of messages) {
+    await writeFile(output, format, message)
+  }
+}
+
+export default {
+  command,
+  aliases,
+  describe,
+  builder,
+  handler
+}

test/commands/export.test.ts

@@ -0,0 +1,241 @@
+import * as yargs from 'yargs'
+import * as path from 'path'
+
+// ------
+// mocks
+
+// l10n service provider module
+const mockExport = jest.fn()
+jest.mock('@scope/l10n-service-provider', () => {
+  return jest.fn().mockImplementation(() => {
+    return { export: mockExport }
+  })
+})
+import L10nServiceProvider from '@scope/l10n-service-provider'
+
+jest.mock('@scope/l10n-omit-service-provider', () => {
+  return jest.fn().mockImplementation(() => {
+    return {
+      export: jest.fn().mockImplementation((locales, format) => {
+        const data = [{
+          locale: 'en',
+          data: Buffer.from(JSON.stringify({ hello: 'hello' }))
+        }, {
+          locale: 'ja',
+          data: Buffer.from(JSON.stringify({ hello: 'こんにちわわわ！' }))
+        }]
+        return Promise.resolve(data)
+      })
+    }
+  })
+})
+import L10nOmitServiceProvider from '@scope/l10n-omit-service-provider'
+
+// fs module
+jest.mock('fs', () => ({
+  ...jest.requireActual('fs'),
+  mkdir: jest.fn(),
+  writeFile: jest.fn()
+}))
+import fs from 'fs'
+
+// --------------------
+// setup/teadown hooks
+
+const PROCESS_CWD_TARGET_PATH = path.resolve(__dirname)
+
+let orgCwd // for process.cwd mock
+let spyLog
+let spyError
+beforeEach(() => {
+  spyLog = jest.spyOn(global.console, 'log')
+  spyError = jest.spyOn(global.console, 'error')
+  orgCwd = process.cwd
+  process.cwd = jest.fn(() => PROCESS_CWD_TARGET_PATH) // mock: process.cwd
+})
+
+afterEach(() => {
+  spyError.mockRestore()
+  spyLog.mockRestore()
+  jest.clearAllMocks()
+  process.cwd = orgCwd
+})
+
+// -----------
+// test cases
+
+test('require options', async () => {
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  try {
+    await new Promise((resolve, reject) => {
+      cmd.parse(`export`, (err, argv, output) => {
+        err ? reject(err) : resolve(output)
+      })
+    })
+  } catch (e) {
+    expect(e).toMatchObject({ name: 'YError' })
+  }
+})
+
+test('--provider: not found', async () => {
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=./404-provider.js \
+      --output=./foo`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+  expect(spyLog).toHaveBeenCalledWith('Not found ./404-provider.js provider')
+})
+
+test('--conf option', async () => {
+  // setup mocks
+  const data = [
+    { locale: 'ja', data: Buffer.from(JSON.stringify({})) },
+    { locale: 'en', data: Buffer.from(JSON.stringify({})) }
+  ]
+  mockExport.mockImplementation(({ locales, format }) => Promise.resolve(data))
+
+  // run
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=@scope/l10n-service-provider \
+      --conf=./test/fixtures/conf/l10n-service-provider-conf.json \
+      --output=./test/fixtures/locales \
+      --dry-run`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(L10nServiceProvider).toHaveBeenCalledWith({
+    provider: { token: 'xxx' }
+  })
+})
+
+test('--conf option omit', async () => {
+  // run
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=@scope/l10n-omit-service-provider \
+      --output=./test/fixtures/locales \
+      --dry-run`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(L10nOmitServiceProvider).toHaveBeenCalledWith({
+    provider: { token: 'yyy' }
+  })
+})
+
+test('--locales option', async () => {
+  // setup mocks
+  const data = [
+    { locale: 'ja', data: Buffer.from(JSON.stringify({})) },
+    { locale: 'en', data: Buffer.from(JSON.stringify({})) }
+  ]
+  mockExport.mockImplementation(({ locales, format }) => Promise.resolve(data))
+
+  // run
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=@scope/l10n-service-provider \
+      --output=./test/fixtures/locales \
+      --locales=en,ja,fr \
+      --dry-run`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(mockExport).toHaveBeenCalledWith({
+    locales: ['en', 'ja', 'fr'],
+    format: 'json',
+    dryRun: true,
+    normalize: undefined
+  })
+})
+
+test('--output option', async () => {
+  // setup mocks
+  const data = [
+    { locale: 'ja', data: Buffer.from(JSON.stringify({ hello: 'hello' })) },
+    { locale: 'en', data: Buffer.from(JSON.stringify({ hello: 'こんにちわわわ！' })) }
+  ]
+  mockExport.mockImplementation(({ locales, format }) => Promise.resolve(data))
+  const mockFS = fs as jest.Mocked<typeof fs>
+  mockFS.mkdir.mockImplementation((p, option, cb) => cb(null))
+  mockFS.writeFile.mockImplementation((p, data, cb) => cb(null))
+
+  // run
+  const OUTPUT_FULL_PATH = path.resolve('./test/fixtures/locales')
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=@scope/l10n-service-provider \
+      --conf=./test/fixtures/conf/l10n-service-provider-conf.json \
+      --output=./test/fixtures/locales`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(mockFS.mkdir.mock.calls[0][0]).toEqual(OUTPUT_FULL_PATH)
+  expect(mockFS.mkdir.mock.calls[0][1]).toEqual({ recursive: true })
+})
+
+test('--normalize option', async () => {
+  // setup mocks
+  const data = [
+    { locale: 'ja', data: Buffer.from(JSON.stringify({})) },
+    { locale: 'en', data: Buffer.from(JSON.stringify({})) }
+  ]
+  mockExport.mockImplementation(({ locales, format }) => Promise.resolve(data))
+
+  // run
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=@scope/l10n-service-provider \
+      --output=./test/fixtures/locales \
+      --normalize=hierarchy`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(mockExport).toHaveBeenCalledWith({
+    locales: [],
+    format: 'json',
+    dryRun: false
+  })
+})
+
+test('--format option', async () => {
+  // setup mocks
+  const data = [
+    { locale: 'ja', data: Buffer.from(JSON.stringify({})) },
+    { locale: 'en', data: Buffer.from(JSON.stringify({})) }
+  ]
+  mockExport.mockImplementation(({ locales, format }) => Promise.resolve(data))
+
+  // run
+  const exp = await import('../../src/commands/export')
+  const cmd = yargs.command(exp)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`export --provider=@scope/l10n-service-provider \
+      --output=./test/fixtures/locales \
+      --format=xliff`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(mockExport).toHaveBeenCalledWith({
+    locales: [],
+    format: 'xliff',
+    dryRun: false,
+    normalize: undefined
+  })
+})