pull command feature (#33)

Author: kazupon

src/commands/pull.ts

@@ -0,0 +1,125 @@
+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:pull')
+
+const mkdirPromisify = promisify(fs.mkdir)
+const writeFilePromisify = promisify(fs.writeFile)
+
+import { resolve, loadProvider, loadProviderConf, DEFUALT_CONF } from '../utils'
+import { ProviderPullResource, Locale, LocaleMessage } from '../../types'
+
+type PullOptions = {
+  provider: string
+  conf?: string
+  output: string
+  locales?: string
+  dryRun?: boolean
+}
+
+export const command = 'pull'
+export const aliases = 'pl'
+export const describe = 'pull locale messages from localization service'
+
+export const builder = (args: Argv): Argv<PullOptions> => {
+  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'
+    })
+    .option('output', {
+      type: 'string',
+      alias: 'o',
+      describe: 'the path to output that pulled 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 pull all locale messages`
+    })
+    .option('dryRun', {
+      type: 'boolean',
+      alias: 'd',
+      default: false,
+      describe: 'run the pull command, but do not pull to locale messages of localization service'
+    })
+}
+
+export const handler = async (args: Arguments<PullOptions>): Promise<unknown> => {
+  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
+  }
+
+  let conf = DEFUALT_CONF
+  if (args.conf) {
+    conf = loadProviderConf(resolve(args.conf))
+  }
+
+  try {
+    const locales = args.locales?.split(',').filter(p => p) as Locale[] || []
+    const provider = ProviderFactory(conf)
+    const resource = await provider.pull(locales, args.dryRun)
+    await applyPullResource(args.output, resource, args.dryRun)
+    // TODO: should refactor console message
+    console.log('pull success')
+  } catch (e) {
+    console.error('pull fail', e)
+    return
+  }
+}
+
+async function applyPullResource (output: string, resource: ProviderPullResource, dryRun: boolean) {
+  const locales = Object.keys(resource) as Locale[]
+  debug('applyPullResource', resource, locales, 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, locale: Locale, message: LocaleMessage) => {
+    const localePath = path.resolve(output, `${locale}.json`)
+    console.log(`write '${locale}' messages to ${localePath}`)
+    return !dryRun
+      ? writeFilePromisify(localePath, JSON.stringify(message, null, 2))
+      : Promise.resolve()
+  }
+
+  // run!
+  await mkdir(output)
+  for (const locale of locales) {
+    await writeFile(output, locale, resource[locale])
+  }
+}
+
+export default {
+  command,
+  aliases,
+  describe,
+  builder,
+  handler
+}

src/commands/push.ts

@@ -1,15 +1,13 @@
 import { Arguments, Argv } from 'yargs'
 
-import { resolve } from '../utils'
+import { resolve, loadProvider, loadProviderConf, DEFUALT_CONF } from '../utils'
 import path from 'path'
 import glob from 'glob'
 
 import { debug as Debug } from 'debug'
 const debug = Debug('vue-i18n-locale-message:commands:push')
 
 import {
-  ProviderFactory,
-  ProviderConfiguration,
   ProviderPushResource,
   ProviderPushMode
 } from '../../types'
@@ -24,8 +22,6 @@ type PushOptions = {
   dryRun: boolean
 }
 
-const DEFUALT_CONF = { provider: {}, pushMode: 'locale-message' } as ProviderConfiguration
-
 export const command = 'push'
 export const aliases = 'ph'
 export const describe = 'push locale messages to localization service'
@@ -110,30 +106,6 @@ export const handler = async (args: Arguments<PushOptions>): Promise<unknown> =>
   }
 }
 
-function loadProvider (provider: string): ProviderFactory | null {
-  let mod: ProviderFactory | null = null
-  try {
-    // TODO: should validate I/F checking & dynamic importing
-    const m = require(require.resolve(provider))
-    debug('loaderProvider', m)
-    if ('__esModule' in m) {
-      mod = m.default as ProviderFactory
-    } else {
-      mod = m as ProviderFactory
-    }
-  } catch (e) { }
-  return mod
-}
-
-function loadProviderConf (confPath: string): ProviderConfiguration {
-  let conf = DEFUALT_CONF
-  try {
-    // TODO: should validate I/F checking & dynamic importing
-    conf = require(confPath) as ProviderConfiguration
-  } catch (e) { }
-  return conf
-}
-
 function getProviderPushResource (args: Arguments<PushOptions>, mode: ProviderPushMode): ProviderPushResource {
   const resource = { mode } as ProviderPushResource
   debug(`getProviderPushResource: mode=${mode}`)

src/utils.ts

@@ -1,6 +1,7 @@
 import { SFCDescriptor } from 'vue-template-compiler'
 import { SFCFileInfo, FormatOptions } from '../types'
 import { VueTemplateCompiler } from '@vue/component-compiler-utils/dist/types'
+import { ProviderFactory, ProviderConfiguration } from '../types'
 
 import { parse } from '@vue/component-compiler-utils'
 import * as compiler from 'vue-template-compiler'
@@ -121,3 +122,29 @@ function resolveGlob (target: string) {
   // TODO: async implementation
   return glob.sync(`${target}/**/*.vue`)
 }
+
+export const DEFUALT_CONF = { provider: {}, pushMode: 'locale-message' } as ProviderConfiguration
+
+export function loadProvider (provider: string): ProviderFactory | null {
+  let mod: ProviderFactory | null = null
+  try {
+    // TODO: should validate I/F checking & dynamic importing
+    const m = require(require.resolve(provider))
+    debug('loaderProvider', m)
+    if ('__esModule' in m) {
+      mod = m.default as ProviderFactory
+    } else {
+      mod = m as ProviderFactory
+    }
+  } catch (e) { }
+  return mod
+}
+
+export function loadProviderConf (confPath: string): ProviderConfiguration {
+  let conf = DEFUALT_CONF
+  try {
+    // TODO: should validate I/F checking & dynamic importing
+    conf = require(confPath) as ProviderConfiguration
+  } catch (e) { }
+  return conf
+}

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

@@ -6,6 +6,10 @@ class L10nServiceProvider {
   async push (resource, dryRun) {
     return
   }
+
+  async pull (locales, dryRun) {
+    return Promise.resolve({ ja: {}, en: {}})
+  }
 }
 
 module.exports = L10nServiceProvider

test/commands/pull.test.ts

@@ -0,0 +1,131 @@
+import * as yargs from 'yargs'
+import * as path from 'path'
+
+// ------
+// mocks
+
+// l10n service provider module
+const mockPull = jest.fn()
+jest.mock('@scope/l10n-service-provider', () => {
+  return jest.fn().mockImplementation(() => {
+    return { pull: mockPull }
+  })
+})
+import L10nServiceProvider from '@scope/l10n-service-provider'
+
+// fs module
+jest.mock('fs', () => ({
+  ...jest.requireActual('fs'),
+  mkdir: jest.fn(),
+  writeFile: jest.fn()
+}))
+import fs from 'fs'
+
+// --------------------
+// setup/teadown hooks
+
+let spyLog
+let spyError
+beforeEach(() => {
+  spyLog = jest.spyOn(global.console, 'log')
+  spyError = jest.spyOn(global.console, 'error')
+})
+
+afterEach(() => {
+  spyError.mockRestore()
+  spyLog.mockRestore()
+  jest.clearAllMocks()
+})
+
+// -----------
+// test cases
+
+test('require options', async () => {
+  const pull = await import('../../src/commands/pull')
+  const cmd = yargs.command(pull)
+  try {
+    await new Promise((resolve, reject) => {
+      cmd.parse(`pull`, (err, argv, output) => {
+        err ? reject(err) : resolve(output)
+      })
+    })
+  } catch (e) {
+    expect(e).toMatchObject({ name: 'YError' })
+  }
+})
+
+test('--provider: not found', async () => {
+  const pull = await import('../../src/commands/pull')
+  const cmd = yargs.command(pull)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`pull --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
+  mockPull.mockImplementation(locales => Promise.resolve({ ja: {}, en: {}}))
+
+  // run
+  const pull = await import('../../src/commands/pull')
+  const cmd = yargs.command(pull)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`pull --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' },
+    pushMode: 'file-path'
+  })
+})
+
+test('--locales option', async () => {
+  // setup mocks
+  mockPull.mockImplementation(locales => Promise.resolve({ ja: {}, en: {}}))
+
+  // run
+  const pull = await import('../../src/commands/pull')
+  const cmd = yargs.command(pull)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`pull --provider=@scope/l10n-service-provider \
+      --output=./test/fixtures/locales \
+      --locales=en,ja,fr \
+      --dry-run`, (err, argv, output) => {
+      err ? reject(err) : resolve(output)
+    })
+  })
+
+  expect(mockPull).toHaveBeenCalledWith(['en', 'ja', 'fr'], true)
+})
+
+test('--output option', async () => {
+  // setup mocks
+  mockPull.mockImplementation(locales => Promise.resolve({ ja: { hello: 'hello' }, en: { hello: 'こんにちわわわ！' }}))
+  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 pull = await import('../../src/commands/pull')
+  const cmd = yargs.command(pull)
+  await new Promise((resolve, reject) => {
+    cmd.parse(`pull --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 })
+})

types/index.d.ts

@@ -170,8 +170,11 @@ export type ProviderPushResource = {
   messages?: LocaleMessages
 }
 
+export type ProviderPullResource = LocaleMessages
+
 export interface Provider {
   push (resource: ProviderPushResource, dryRun: boolean): Promise<void>
+  pull (locales: Locale[], dryRun: boolean): Promise<ProviderPullResource>
 }
 
 export type ProviderFactory<T = {}> = (configration: ProviderConfiguration<T>) => Provider