use platform definitions for which platforms to generate resources

imhoffd · imhoffd · commit ab2d6754dc3f · 2019-09-18T10:45:11.000-05:00
diff --git a/README.md b/README.md
@@ -28,6 +28,16 @@ To generate resources with all the default options, just run:
 $ cordova-res
 ```
 
+`cordova-res` accepts a platform for the first argument. If specified, resources are generated only for that platform:
+
+```bash
+$ cordova-res ios
+```
+
+Otherwise, `cordova-res` looks for platforms in `config.xml` (e.g. `<platform name="ios">`) and generates resources only for them.
+
+#### Documentation
+
 See the help documentation on the command line with the `--help` flag.
 
 ```bash
diff --git a/src/__tests__/cli.ts b/src/__tests__/cli.ts
@@ -1,10 +1,50 @@
-import { generateRunOptions } from '../cli';
+import { Options } from '..';
+import { generateRunOptions, parseOptions } from '../cli';
 import { Platform } from '../platform';
 
 describe('cordova-res', () => {
 
   describe('cli', () => {
 
+    describe('parseOptions', () => {
+
+      const DEFAULT_OPTIONS: Options = {
+        logstream: process.stdout,
+        errstream: process.stderr,
+        resourcesDirectory: 'resources',
+      };
+
+      it('should parse default options with no arguments', () => {
+        const result = parseOptions([]);
+        expect(result).toEqual(DEFAULT_OPTIONS);
+      });
+
+      it('should parse options for android', () => {
+        const args = ['android'];
+        const result = parseOptions(args);
+        expect(result).toEqual({ ...DEFAULT_OPTIONS, platforms: { android: generateRunOptions(Platform.ANDROID, 'resources', args) } });
+      });
+
+      it('should parse default options when the first argument is not a platform', () => {
+        const args = ['--help', 'android'];
+        const result = parseOptions(args);
+        expect(result).toEqual(DEFAULT_OPTIONS);
+      });
+
+      it('should accept --resources flag', () => {
+        const args = ['--resources', 'res'];
+        const result = parseOptions(args);
+        expect(result).toEqual({ ...DEFAULT_OPTIONS, resourcesDirectory: 'res' });
+      });
+
+      it('should log to stderr with --json flag', () => {
+        const args = ['--json'];
+        const result = parseOptions(args);
+        expect(result).toEqual({ ...DEFAULT_OPTIONS, logstream: process.stderr });
+      });
+
+    });
+
     describe('generateRunOptions', () => {
 
       it('should provide defaults with no args', async () => {
diff --git a/src/__tests__/config.ts b/src/__tests__/config.ts
@@ -25,7 +25,7 @@ describe('cordova-res', () => {
         const src = 'resources/icon.png';
         const container = et.Element('platform');
 
-        runResource('/path/to/config.xml', resource, container);
+        runResource('/path/to/config.xml', container, resource);
 
         const children = container.findall('icon');
         expect(children.length).toEqual(1);
@@ -38,7 +38,7 @@ describe('cordova-res', () => {
         const container = et.Element('platform');
         et.SubElement(container, 'icon', { src });
 
-        runResource('/path/to/config.xml', resource, container);
+        runResource('/path/to/config.xml', container, resource);
 
         const children = container.findall('icon');
         expect(children.length).toEqual(1);
@@ -51,7 +51,7 @@ describe('cordova-res', () => {
         const container = et.Element('platform');
         et.SubElement(container, 'icon', { src: 'resources\\icon.png' });
 
-        runResource('/path/to/config.xml', resource, container);
+        runResource('/path/to/config.xml', container, resource);
 
         const children = container.findall('icon');
         expect(children.length).toEqual(1);
diff --git a/src/cli.ts b/src/cli.ts
@@ -1,28 +1,49 @@
+import et from 'elementtree';
+
 import { Options, PlatformOptions } from '.';
+import { getPlatforms } from './config';
 import { BadInputError } from './error';
-import { AdaptiveIconResourceOptions, PLATFORMS, Platform, RunPlatformOptions, SimpleResourceOptions, validatePlatforms } from './platform';
+import { AdaptiveIconResourceOptions, Platform, RunPlatformOptions, SimpleResourceOptions, validatePlatforms } from './platform';
 import { DEFAULT_RESOURCES_DIRECTORY, RESOURCE_TYPES, ResourceKey, ResourceType, Source, SourceType, validateResourceTypes } from './resources';
 import { getOptionValue } from './utils/cli';
 
+export function getDirectory(): string {
+  return process.cwd();
+}
+
+export async function resolveOptions(args: ReadonlyArray<string>, directory: string, config?: et.ElementTree): Promise<Options> {
+  const doc = config ? config.getroot() : undefined;
+  const platformList = validatePlatforms(doc ? getPlatforms(doc) : []);
+  const parsedOptions = parseOptions(args);
+  const { resourcesDirectory = DEFAULT_RESOURCES_DIRECTORY } = parsedOptions;
+
+  return {
+    ...{ directory, ...platformList.length > 0 ? { platforms: generatePlatformOptions(platformList, resourcesDirectory, args) } : {} },
+    ...parsedOptions,
+  };
+}
+
 export function parseOptions(args: ReadonlyArray<string>): Options {
-  const platformArg = args[0] ? args[0] : undefined;
-  const platformList = validatePlatforms(platformArg && !platformArg.startsWith('-') ? [platformArg] : PLATFORMS);
-  const platforms: PlatformOptions = {};
-  const resourcesDirectory = getOptionValue(args, '--resources', DEFAULT_RESOURCES_DIRECTORY);
   const json = args.includes('--json');
+  const resourcesDirectory = getOptionValue(args, '--resources', DEFAULT_RESOURCES_DIRECTORY);
+  const platformArg = args[0] ? args[0] : undefined;
+  const platformList = validatePlatforms(platformArg && !platformArg.startsWith('-') ? [platformArg] : []);
 
   return {
-    directory: process.cwd(),
     resourcesDirectory,
     logstream: json ? process.stderr : process.stdout,
     errstream: process.stderr,
-    platforms: platformList.reduce((acc, platform) => {
-      acc[platform] = generateRunOptions(platform, resourcesDirectory, args);
-      return acc;
-    }, platforms),
+    ...platformList.length > 0 ? { platforms: generatePlatformOptions(platformList, resourcesDirectory, args) } : {},
   };
 }
 
+export function generatePlatformOptions(platforms: ReadonlyArray<Platform>, resourcesDirectory: string, args: ReadonlyArray<string>): PlatformOptions {
+  return platforms.reduce((acc, platform) => {
+    acc[platform] = generateRunOptions(platform, resourcesDirectory, args);
+    return acc;
+  }, {} as PlatformOptions);
+}
+
 export function generateRunOptions(platform: Platform, resourcesDirectory: string, args: ReadonlyArray<string>): RunPlatformOptions {
   const typeOption = getOptionValue(args, '--type');
   const types = validateResourceTypes(typeOption ? [typeOption] : RESOURCE_TYPES);
diff --git a/src/config.ts b/src/config.ts
@@ -9,11 +9,14 @@ import { ResolvedColorSource, ResolvedSource, ResourceNodeAttribute, ResourceNod
 
 const debug = Debug('cordova-res:config');
 
-export async function run(configPath: string, resourcesDirectory: string, sources: ReadonlyArray<ResolvedSource>, resources: ReadonlyArray<GeneratedResource>, errstream?: NodeJS.WritableStream): Promise<void> {
+export function getConfigPath(directory: string): string {
+  return pathlib.resolve(directory, 'config.xml');
+}
+
+export async function run(configPath: string, resourcesDirectory: string, doc: et.ElementTree, sources: ReadonlyArray<ResolvedSource>, resources: ReadonlyArray<GeneratedResource>, errstream?: NodeJS.WritableStream): Promise<void> {
   const colors = sources.filter((source): source is ResolvedColorSource => source.type === SourceType.COLOR);
-  const config = await read(configPath);
 
-  const androidPlatformElement = resolvePlatformElement(config.getroot(), Platform.ANDROID);
+  const androidPlatformElement = resolvePlatformElement(doc.getroot(), Platform.ANDROID);
 
   if (colors.length > 0) {
     debug('Color sources found--generating colors document.');
@@ -31,9 +34,7 @@ export async function run(configPath: string, resourcesDirectory: string, source
     resourceFileElement.set('target', '/app/src/main/res/values/colors.xml');
   }
 
-  runConfig(configPath, resources, config, errstream);
-
-  await write(configPath, config);
+  runConfig(configPath, doc, resources, errstream);
 }
 
 export async function resolveColorsDocument(colorsPath: string): Promise<et.ElementTree> {
@@ -69,9 +70,9 @@ export async function runColorsConfig(colorsPath: string, colors: ReadonlyArray<
   await write(colorsPath, colorsDocument);
 }
 
-export function runConfig(configPath: string, resources: ReadonlyArray<GeneratedResource>, doc: et.ElementTree, errstream?: NodeJS.WritableStream): void {
+export function runConfig(configPath: string, doc: et.ElementTree, resources: ReadonlyArray<GeneratedResource>, errstream?: NodeJS.WritableStream): void {
   const root = doc.getroot();
-  const orientationPreference = getPreference(doc, 'Orientation');
+  const orientationPreference = getPreference(root, 'Orientation');
   debug('Orientation preference: %O', orientationPreference);
 
   const orientation = orientationPreference || 'default';
@@ -89,7 +90,7 @@ export function runConfig(configPath: string, resources: ReadonlyArray<Generated
       filteredResources = filteredResources.filter(img => typeof img.target === 'string');
     }
     for (const resource of filteredResources) {
-      runResource(configPath, resource, platformElement);
+      runResource(configPath, platformElement, resource);
     }
   }
 }
@@ -98,7 +99,7 @@ export function conformPath(configPath: string, value: string | number): string
   return pathlib.relative(pathlib.dirname(configPath), value.toString()).replace(/\\/g, '/');
 }
 
-export function runResource(configPath: string, resource: GeneratedResource, container: et.Element): void {
+export function runResource(configPath: string, container: et.Element, resource: GeneratedResource): void {
   const src = resource[resource.indexAttribute.key];
 
   if (typeof src !== 'string') {
@@ -181,9 +182,15 @@ export async function write(path: string, doc: et.ElementTree): Promise<void> {
   await writeFile(path, contents, 'utf8');
 }
 
-export function getPreference(doc: et.ElementTree, name: string): string | undefined {
-  const root = doc.getroot();
-  const preferenceElement = root.find(`preference[@name='${name}']`);
+export function getPlatforms(container: et.Element): string[] {
+  const platformElements = container.findall('platform');
+  const platforms = platformElements.map(el => el.get('name'));
+
+  return platforms.filter((p): p is string => typeof p === 'string');
+}
+
+export function getPreference(container: et.Element, name: string): string | undefined {
+  const preferenceElement = container.find(`preference[@name='${name}']`);
 
   if (!preferenceElement) {
     return undefined;
diff --git a/src/help.ts b/src/help.ts
@@ -1,7 +1,11 @@
 const help = `
   Usage: cordova-res [ios|android] [options]
 
-    Generate Cordova resources for one or all platforms.
+    Generate Cordova resources for native platforms.
+
+    This tool writes to 'config.xml' to register resources with Cordova. Valid
+    platform definitions are required. See the Cordova docs[1] for more
+    information.
 
     By default, this tool will look for 'icon.(png|jpg)' and 'splash.(png|jpg)'
     files inside 'resources/'. If an 'icon-foreground.(png|jpg)' file is found
@@ -18,6 +22,8 @@ const help = `
     'icon-background.(png|jpg)' file in 'resources/android/'. To use a color,
     specify a hex color, e.g. '--icon-background-source #FF0000'.
 
+    [1]: https://cordova.apache.org/docs/en/latest/config_ref/index.html#platform
+
   Options:
 
     --type <icon|splash|adaptive-icon> ... Only generate one type of resource
diff --git a/src/index.ts b/src/index.ts
@@ -1,12 +1,14 @@
 import { pathWritable } from '@ionic/utils-fs';
 import Debug from 'debug';
+import et from 'elementtree';
 import path from 'path';
 
-import { generateRunOptions, parseOptions } from './cli';
-import { run as runConfig } from './config';
+import { generateRunOptions, getDirectory, resolveOptions } from './cli';
+import { getConfigPath, read as readConfig, run as runConfig, write as writeConfig } from './config';
 import { BaseError } from './error';
 import { GeneratedResource, PLATFORMS, Platform, RunPlatformOptions, run as runPlatform } from './platform';
 import { DEFAULT_RESOURCES_DIRECTORY, Density, Orientation, ResolvedSource, SourceType } from './resources';
+import { tryFn } from './utils/fn';
 
 const debug = Debug('cordova-res');
 
@@ -32,7 +34,7 @@ interface ResultSource {
 }
 
 async function CordovaRes({
-  directory = process.cwd(),
+  directory = getDirectory(),
   resourcesDirectory = DEFAULT_RESOURCES_DIRECTORY,
   logstream = process.stdout,
   errstream = process.stderr,
@@ -42,13 +44,24 @@ async function CordovaRes({
     [Platform.WINDOWS]: generateRunOptions(Platform.WINDOWS, resourcesDirectory, []),
   },
 }: CordovaRes.Options = {}): Promise<Result> {
-  const configPath = path.resolve(directory, 'config.xml');
+  const configPath = getConfigPath(directory);
 
   debug('Paths: (config: %O) (resources dir: %O)', configPath, resourcesDirectory);
 
+  let config: et.ElementTree | undefined;
   const resources: GeneratedResource[] = [];
   const sources: ResolvedSource[] = [];
 
+  if (await pathWritable(configPath)) {
+    config = await readConfig(configPath);
+  } else {
+    debug('File missing/not writable: %O', configPath);
+
+    if (errstream) {
+      errstream.write(`WARN: No config.xml file in directory. Skipping config.\n`);
+    }
+  }
+
   for (const platform of PLATFORMS) {
     const platformOptions = platforms[platform];
 
@@ -60,15 +73,11 @@ async function CordovaRes({
     }
   }
 
-  if (await pathWritable(configPath)) {
-    await runConfig(configPath, resourcesDirectory, sources, resources, errstream);
-    logstream.write(`Wrote to config.xml\n`);
-  } else {
-    debug('File missing/not writable: %O', configPath);
+  if (config) {
+    await runConfig(configPath, resourcesDirectory, config, sources, resources, errstream);
+    await writeConfig(configPath, config);
 
-    if (errstream) {
-      errstream.write(`WARN: No config.xml file in directory. Skipping config.\n`);
-    }
+    logstream.write(`Wrote to config.xml\n`);
   }
 
   return {
@@ -162,7 +171,10 @@ namespace CordovaRes {
     }
 
     try {
-      const options = parseOptions(args);
+      const directory = getDirectory();
+      const configPath = getConfigPath(directory);
+      const config = await tryFn(() => readConfig(configPath));
+      const options = await resolveOptions(args, directory, config);
       const result = await run(options);
 
       if (args.includes('--json')) {
diff --git a/src/utils/fn.ts b/src/utils/fn.ts
@@ -0,0 +1,11 @@
+import Debug from 'debug';
+
+const debug = Debug('cordova-res:utils:fn');
+
+export async function tryFn<T>(fn: (() => Promise<T>)): Promise<T | undefined> {
+  try {
+    return await fn();
+  } catch (e) {
+    debug('Encountered error when trying function: %O', fn);
+  }
+}
