appium 2.0.0-beta.20 → 2.0.0-beta.24

package/README.md

@@ -1,8 +1,7 @@
 ## Appium
 
 [![NPM version](https://badge.fury.io/js/appium.svg)](https://npmjs.org/package/appium)
-[![Dependency Status](https://david-dm.org/appium/appium.svg)](https://david-dm.org/appium/appium)
-[![devDependency Status](https://david-dm.org/appium/appium/dev-status.svg)](https://david-dm.org/appium/appium#info=devDependencies)
+[![Node.js CI](https://github.com/appium/appium/actions/workflows/node.js.yml/badge.svg?branch=2.0)](https://github.com/appium/appium/actions/workflows/node.js.yml)
 
 [![Monthly Downloads](https://img.shields.io/npm/dm/appium.svg)](https://npmjs.org/package/appium)
 

package/build/check-npm-pack-files.js

@@ -0,0 +1,23 @@
+"use strict";
+
+require("source-map-support/register");
+
+const childProcess = require('child_process');
+
+const _ = require('lodash');
+
+const res = JSON.parse(childProcess.execSync('npm pack --dry-run --json --ignore-scripts', {
+  encoding: 'utf8'
+}))[0];
+const testFiles = ['LICENSE', 'build/lib/appium.js'];
+
+const missingFiles = _.without(testFiles, ..._.map(res.files, 'path'));
+
+if (!_.isEmpty(missingFiles)) {
+  throw new Error(`Files [${missingFiles.join(', ')}] are not included in package.json "files". ` + `Please make sure these files are included before publishing.`);
+}
+
+process.exit(0);require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImNoZWNrLW5wbS1wYWNrLWZpbGVzLmpzIl0sIm5hbWVzIjpbImNoaWxkUHJvY2VzcyIsInJlcXVpcmUiLCJfIiwicmVzIiwiSlNPTiIsInBhcnNlIiwiZXhlY1N5bmMiLCJlbmNvZGluZyIsInRlc3RGaWxlcyIsIm1pc3NpbmdGaWxlcyIsIndpdGhvdXQiLCJtYXAiLCJmaWxlcyIsImlzRW1wdHkiLCJFcnJvciIsImpvaW4iLCJwcm9jZXNzIiwiZXhpdCJdLCJtYXBwaW5ncyI6Ijs7OztBQUFBLE1BQU1BLFlBQVksR0FBR0MsT0FBTyxDQUFDLGVBQUQsQ0FBNUI7O0FBQ0EsTUFBTUMsQ0FBQyxHQUFHRCxPQUFPLENBQUMsUUFBRCxDQUFqQjs7QUFFQSxNQUFNRSxHQUFHLEdBQUdDLElBQUksQ0FBQ0MsS0FBTCxDQUFXTCxZQUFZLENBQUNNLFFBQWIsQ0FBc0IsNENBQXRCLEVBQW9FO0FBQUNDLEVBQUFBLFFBQVEsRUFBRTtBQUFYLENBQXBFLENBQVgsRUFBb0csQ0FBcEcsQ0FBWjtBQUdBLE1BQU1DLFNBQVMsR0FBRyxDQUNoQixTQURnQixFQUVoQixxQkFGZ0IsQ0FBbEI7O0FBTUEsTUFBTUMsWUFBWSxHQUFHUCxDQUFDLENBQUNRLE9BQUYsQ0FBVUYsU0FBVixFQUFxQixHQUFHTixDQUFDLENBQUNTLEdBQUYsQ0FBTVIsR0FBRyxDQUFDUyxLQUFWLEVBQWlCLE1BQWpCLENBQXhCLENBQXJCOztBQUVBLElBQUksQ0FBQ1YsQ0FBQyxDQUFDVyxPQUFGLENBQVVKLFlBQVYsQ0FBTCxFQUE4QjtBQUM1QixRQUFNLElBQUlLLEtBQUosQ0FBVyxVQUFTTCxZQUFZLENBQUNNLElBQWIsQ0FBa0IsSUFBbEIsQ0FBd0IsOENBQWxDLEdBQ2IsOERBREcsQ0FBTjtBQUVEOztBQUVEQyxPQUFPLENBQUNDLElBQVIsQ0FBYSxDQUFiIiwic291cmNlc0NvbnRlbnQiOlsiY29uc3QgY2hpbGRQcm9jZXNzID0gcmVxdWlyZSgnY2hpbGRfcHJvY2VzcycpO1xuY29uc3QgXyA9IHJlcXVpcmUoJ2xvZGFzaCcpO1xuXG5jb25zdCByZXMgPSBKU09OLnBhcnNlKGNoaWxkUHJvY2Vzcy5leGVjU3luYygnbnBtIHBhY2sgLS1kcnktcnVuIC0tanNvbiAtLWlnbm9yZS1zY3JpcHRzJywge2VuY29kaW5nOiAndXRmOCd9KSlbMF07XG5cbi8vIExpc3Qgb2YgZmlsZXMgd2UgYXJlIHRlc3RpbmcgdG8gbWFrZSBzdXJlIHRoZXkgYXJlIGluY2x1ZGVkIGluIHBhY2thZ2VcbmNvbnN0IHRlc3RGaWxlcyA9IFtcbiAgJ0xJQ0VOU0UnLCAvLyBDaGVjayB0aGF0IGxpY2Vuc2UgaXMgaW5jbHVkZWRcbiAgJ2J1aWxkL2xpYi9hcHBpdW0uanMnLCAvLyBTYW5pdHkgY2hlY2sgdGhhdCBidWlsZCBmaWxlcyBhcmUgYmVpbmcgaW5jbHVkZWQgYnkgdGVzdGluZyBqdXN0IG9uZSBmaWxlXG5dO1xuXG4vLyBHZXQgbGlzdCBvZiBmaWxlcyBpbiBgdGVzdEZpbGVzYCB0aGF0IGFyZW4ndCBpbiB0aGUgbGlzdCBvZiBwYWNrYWdlZCBmaWxlTmFtZXNcbmNvbnN0IG1pc3NpbmdGaWxlcyA9IF8ud2l0aG91dCh0ZXN0RmlsZXMsIC4uLl8ubWFwKHJlcy5maWxlcywgJ3BhdGgnKSk7XG5cbmlmICghXy5pc0VtcHR5KG1pc3NpbmdGaWxlcykpIHtcbiAgdGhyb3cgbmV3IEVycm9yKGBGaWxlcyBbJHttaXNzaW5nRmlsZXMuam9pbignLCAnKX1dIGFyZSBub3QgaW5jbHVkZWQgaW4gcGFja2FnZS5qc29uIFwiZmlsZXNcIi4gYCArXG4gICAgYFBsZWFzZSBtYWtlIHN1cmUgdGhlc2UgZmlsZXMgYXJlIGluY2x1ZGVkIGJlZm9yZSBwdWJsaXNoaW5nLmApO1xufVxuXG5wcm9jZXNzLmV4aXQoMCk7XG4iXSwiZmlsZSI6ImNoZWNrLW5wbS1wYWNrLWZpbGVzLmpzIiwic291cmNlUm9vdCI6Ii4uIn0=

package/build/commands-yml/parse.js

@@ -0,0 +1,319 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _yamlJs = _interopRequireDefault(require("yaml-js"));
+
+var _appiumSupport = require("appium-support");
+
+var _validate = _interopRequireDefault(require("validate.js"));
+
+var _handlebars = _interopRequireDefault(require("handlebars"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _asyncbox = require("asyncbox");
+
+var _validator = require("./validator");
+
+var _url = _interopRequireDefault(require("url"));
+
+var _fancyLog = _interopRequireDefault(require("fancy-log"));
+
+var _findRoot = _interopRequireDefault(require("find-root"));
+
+const platformRanges = {
+  xcuitest: ['9.3'],
+  uiautomation: ['8.0', '9.3'],
+  espresso: ['?'],
+  uiautomator2: ['?'],
+  uiautomator: ['4.3'],
+  windows: ['10'],
+  mac: ['?']
+};
+const appiumRanges = {
+  xcuitest: ['1.6.0'],
+  uiautomator2: ['1.6.0'],
+  espresso: ['1.9.0'],
+  windows: ['1.6.0'],
+  mac: ['1.6.4']
+};
+const rootFolder = (0, _findRoot.default)(__dirname);
+
+_handlebars.default.registerHelper('versions', function versionHelper(object, name, driverName) {
+  if (!object) {
+    return 'None';
+  }
+
+  if (!_lodash.default.isObject(object)) {
+    object = {};
+  }
+
+  let min = object[name ? `${name}_min` : 'min'];
+  let max = object[name ? `${name}_max` : 'max'];
+
+  if (!min) {
+    if (name === 'appium' && _lodash.default.isArray(appiumRanges[driverName])) {
+      min = appiumRanges[driverName][0];
+    } else if (name === 'platform' && _lodash.default.isArray(platformRanges[driverName])) {
+      min = platformRanges[driverName][0];
+    }
+  }
+
+  if (!max) {
+    if (name === 'appium' && appiumRanges[driverName]) {
+      max = appiumRanges[driverName][1];
+    } else if (name === 'platform' && platformRanges[driverName]) {
+      max = platformRanges[driverName][1];
+    }
+  }
+
+  if (!min && !max) {
+    return 'All';
+  } else if (!max) {
+    return `${min}+`;
+  } else if (!min) {
+    return `<= ${max}`;
+  }
+
+  return `${min} to ${max}`;
+});
+
+_handlebars.default.registerHelper('hyphenate', str => str.replace('_', '-'));
+
+_handlebars.default.registerHelper('uppercase', str => str.toUpperCase());
+
+_handlebars.default.registerHelper('capitalize', function capitalizeDriver(driverName) {
+  switch (driverName.toLowerCase()) {
+    case 'xcuitest':
+      return 'XCUITest';
+
+    case 'uiautomation':
+      return 'UIAutomation';
+
+    case 'uiautomator2':
+      return 'UiAutomator2';
+
+    case 'uiautomator':
+      return 'UiAutomator';
+
+    case 'espresso':
+      return 'Espresso';
+
+    default:
+      return driverName.length === 0 ? driverName : driverName[0].toUpperCase() + driverName.substr(1);
+  }
+});
+
+_handlebars.default.registerHelper('if_eq', function ifEq(a, b, opts) {
+  if (a === b) {
+    return opts.fn(this);
+  } else {
+    return opts.inverse(this);
+  }
+});
+
+function getBaseHostname(fullUrl) {
+  const baseUrl = _url.default.parse(fullUrl);
+
+  return baseUrl.hostname;
+}
+
+_handlebars.default.registerHelper('base_url', function baseUrl(fullUrl) {
+  return getBaseHostname(fullUrl);
+});
+
+_handlebars.default.registerHelper('client_url', function clientUrl(clientUrl) {
+  if (!clientUrl) {
+    return;
+  }
+
+  const createUrlString = function createUrlString(clientUrl, name = getBaseHostname(clientUrl)) {
+    return `[${name}](${clientUrl})`;
+  };
+
+  if (!_lodash.default.isArray(clientUrl)) {
+    return createUrlString(clientUrl);
+  }
+
+  let urlStrings = [];
+
+  for (const item of clientUrl) {
+    for (let [key, value] of _lodash.default.toPairs(item)) {
+      key = key.toLowerCase();
+      const urlStr = _validator.CLIENT_URL_TYPES[key] === 'hostname' ? createUrlString(value) : createUrlString(value, _validator.CLIENT_URL_TYPES[key]);
+      urlStrings.push(urlStr);
+    }
+  }
+
+  return urlStrings.join(' ');
+});
+
+async function registerSpecUrlHelper() {
+  const routesFile = await _appiumSupport.fs.readFile(_path.default.resolve(rootFolder, '..', 'base-driver', 'lib', 'protocol', 'routes.js'), 'utf8');
+  const routesFileLines = routesFile.split('\n');
+
+  _handlebars.default.registerHelper('spec_url', function specUrl(specUrl, endpoint) {
+    if (!specUrl.includes('routes.js')) {
+      return specUrl;
+    }
+
+    if (specUrl.startsWith('routes.js')) {
+      specUrl = `https://github.com/appium/appium-base-driver/blob/master/lib/protocol/${specUrl}`;
+    }
+
+    specUrl = specUrl.split('#L')[0];
+    endpoint = endpoint.replace('session_id', 'sessionId');
+    endpoint = endpoint.replace('element_id', 'elementId');
+    let index;
+
+    for (const i in routesFileLines) {
+      if (routesFileLines[i].includes(endpoint)) {
+        index = parseInt(i, 10) + 1;
+        break;
+      }
+    }
+
+    if (_lodash.default.isUndefined(index)) {
+      throw new Error(`Unable to find entry in 'appium-base-driver#routes' for endpoint '${endpoint}'`);
+    }
+
+    return `${specUrl}#L${index}`;
+  });
+}
+
+async function generateCommands() {
+  await registerSpecUrlHelper();
+
+  const commands = _path.default.resolve(rootFolder, 'commands-yml', 'commands/**/*.yml');
+
+  (0, _fancyLog.default)('Traversing YML files', commands);
+  await _appiumSupport.fs.rimraf(_path.default.resolve(rootFolder, 'docs', 'en', 'commands'));
+
+  const template = _handlebars.default.compile(await _appiumSupport.fs.readFile(_path.default.resolve(rootFolder, 'commands-yml', 'template.md'), 'utf8'), {
+    noEscape: true,
+    strict: true
+  });
+
+  let fileCount = 0;
+
+  for (const filename of await _appiumSupport.fs.glob(commands)) {
+    const relativeFilename = _path.default.relative(_path.default.resolve(rootFolder, 'commands-yml'), filename);
+
+    (0, _fancyLog.default)(`Rendering file: ${filename} ${relativeFilename}`);
+    const inputYML = await _appiumSupport.fs.readFile(filename, 'utf8');
+
+    const inputJSON = _yamlJs.default.load(inputYML);
+
+    inputJSON.ymlFileName = `/${_path.default.relative(rootFolder, filename)}`;
+    const validationErrors = (0, _validate.default)(inputJSON, _validator.validator);
+
+    if (validationErrors) {
+      throw new Error(`Data validation error for ${filename}: ${JSON.stringify(validationErrors)}`);
+    }
+
+    const markdown = template(inputJSON);
+
+    const ext = _path.default.extname(relativeFilename);
+
+    const markdownPath = `${relativeFilename.substring(0, relativeFilename.length - ext.length)}.md`;
+
+    const outfile = _path.default.resolve(rootFolder, 'docs', 'en', markdownPath);
+
+    (0, _fancyLog.default)(`    Writing to: ${outfile}`);
+    await (0, _appiumSupport.mkdirp)(_path.default.dirname(outfile));
+    await _appiumSupport.fs.writeFile(outfile, markdown, 'utf8');
+    fileCount++;
+  }
+
+  (0, _fancyLog.default)(`Done writing ${fileCount} command documents`);
+}
+
+async function generateCommandIndex() {
+  function getTree(element, path) {
+    let node = {
+      name: element[0]
+    };
+
+    if (!_lodash.default.isArray(element[1])) {
+      node.path = `${path}/${element[1]}`;
+    } else {
+      node.path = `${path}/${element[1][0]}`;
+      const name = element[1].shift();
+      node.commands = [];
+
+      for (let subElement of element[1]) {
+        node.commands.push(getTree(subElement, `${path}/${name}`));
+      }
+    }
+
+    return node;
+  }
+
+  const toc = require(_path.default.resolve(rootFolder, '../..', 'docs', 'toc.js'));
+
+  const commandToc = _lodash.default.find(toc.en, value => value.indexOf('Commands') === 0);
+
+  const commands = [];
+
+  for (let el of commandToc[1].slice(1)) {
+    commands.push(getTree(el, '/docs/en/commands'));
+  }
+
+  const commandTemplate = _handlebars.default.compile(await _appiumSupport.fs.readFile(_path.default.resolve(rootFolder, 'commands-yml', 'api-template.md'), 'utf8'), {
+    noEscape: true,
+    strict: true
+  });
+
+  async function writeIndex(index, commands, indexPath) {
+    (0, _fancyLog.default)(`Creating API index '${index}'`);
+    const commandMarkdown = commandTemplate({
+      commands,
+      path: indexPath
+    });
+    await _appiumSupport.fs.writeFile(index, commandMarkdown, 'utf8');
+  }
+
+  const apiIndex = _path.default.resolve(rootFolder, '../..', 'docs', 'en', 'about-appium', 'api.md');
+
+  await writeIndex(apiIndex, commands);
+  (0, _fancyLog.default)(`Done writing main API index`);
+
+  async function writeIndividualIndexes(command) {
+    if (!_appiumSupport.util.hasValue(command.commands)) {
+      return;
+    }
+
+    const relPath = command.path.startsWith(_path.default.sep) ? command.path.substring(1) : command.path;
+
+    const index = _path.default.resolve(rootFolder, relPath, 'README.md');
+
+    await writeIndex(index, command.commands, command.path);
+
+    for (const el of command.commands) {
+      await writeIndividualIndexes(el);
+    }
+  }
+
+  const index = _path.default.resolve(rootFolder, '../..', 'docs', 'en', 'commands', 'README.md');
+
+  await writeIndex(index, commands);
+
+  for (const el of commands) {
+    await writeIndividualIndexes(el);
+  }
+}
+
+async function main() {
+  await generateCommands();
+  await generateCommandIndex();
+}
+
+(0, _asyncbox.asyncify)(main);require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["commands-yml/parse.js"],"names":["platformRanges","xcuitest","uiautomation","espresso","uiautomator2","uiautomator","windows","mac","appiumRanges","rootFolder","__dirname","Handlebars","registerHelper","versionHelper","object","name","driverName","_","isObject","min","max","isArray","str","replace","toUpperCase","capitalizeDriver","toLowerCase","length","substr","ifEq","a","b","opts","fn","inverse","getBaseHostname","fullUrl","baseUrl","url","parse","hostname","clientUrl","createUrlString","urlStrings","item","key","value","toPairs","urlStr","CLIENT_URL_TYPES","push","join","registerSpecUrlHelper","routesFile","fs","readFile","path","resolve","routesFileLines","split","specUrl","endpoint","includes","startsWith","index","i","parseInt","isUndefined","Error","generateCommands","commands","rimraf","template","compile","noEscape","strict","fileCount","filename","glob","relativeFilename","relative","inputYML","inputJSON","yaml","load","ymlFileName","validationErrors","validator","JSON","stringify","markdown","ext","extname","markdownPath","substring","outfile","dirname","writeFile","generateCommandIndex","getTree","element","node","shift","subElement","toc","require","commandToc","find","en","indexOf","el","slice","commandTemplate","writeIndex","indexPath","commandMarkdown","apiIndex","writeIndividualIndexes","command","util","hasValue","relPath","sep","main"],"mappings":"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","sourcesContent":["import path from 'path';\nimport yaml from 'yaml-js';\nimport { fs, mkdirp, util } from 'appium-support';\nimport validate from 'validate.js';\nimport Handlebars from 'handlebars';\nimport _ from 'lodash';\nimport { asyncify } from 'asyncbox';\nimport { validator, CLIENT_URL_TYPES } from './validator';\nimport url from 'url';\nimport log from 'fancy-log';\nimport findRoot from 'find-root';\n\n\n// What range of platforms do the driver's support\nconst platformRanges = {\n  xcuitest: ['9.3'],\n  uiautomation: ['8.0', '9.3'],\n  espresso: ['?'],\n  uiautomator2: ['?'],\n  uiautomator: ['4.3'],\n  windows: ['10'],\n  mac: ['?'], // TODO\n};\n\n// When was the driver supported in Appium?\nconst appiumRanges = {\n  xcuitest: ['1.6.0'],\n  uiautomator2: ['1.6.0'],\n  espresso: ['1.9.0'],\n  windows: ['1.6.0'],\n  mac: ['1.6.4'],\n};\n\nconst rootFolder = findRoot(__dirname);\n\n// Create Handlebars helper that shows a version range\nHandlebars.registerHelper('versions', function versionHelper (object, name, driverName) {\n  if (!object) {\n    return 'None';\n  }\n\n  if (!_.isObject(object)) {\n    object = {};\n  }\n\n  let min = object[name ? `${name}_min` : 'min'];\n  let max = object[name ? `${name}_max` : 'max'];\n\n  if (!min) {\n    if (name === 'appium' && _.isArray(appiumRanges[driverName])) {\n      min = appiumRanges[driverName][0];\n    } else if (name === 'platform' && _.isArray(platformRanges[driverName])) {\n      min = platformRanges[driverName][0];\n    }\n  }\n\n  if (!max) {\n    if (name === 'appium' && appiumRanges[driverName]) {\n      max = appiumRanges[driverName][1];\n    } else if (name === 'platform' && platformRanges[driverName]) {\n      max = platformRanges[driverName][1];\n    }\n  }\n\n  if (!min && !max) {\n    return 'All';\n  } else if (!max) {\n    return `${min}+`;\n  } else if (!min) {\n    return `<= ${max}`;\n  }\n\n  return `${min} to ${max}`;\n});\n\nHandlebars.registerHelper('hyphenate', (str) => str.replace('_', '-'));\nHandlebars.registerHelper('uppercase', (str) => str.toUpperCase());\n\nHandlebars.registerHelper('capitalize', function capitalizeDriver (driverName) {\n  switch (driverName.toLowerCase()) {\n    case 'xcuitest':\n      return 'XCUITest';\n    case 'uiautomation':\n      return 'UIAutomation';\n    case 'uiautomator2':\n      return 'UiAutomator2';\n    case 'uiautomator':\n      return 'UiAutomator';\n    case 'espresso':\n      return 'Espresso';\n    default:\n      return driverName.length === 0 ? driverName : driverName[0].toUpperCase() + driverName.substr(1);\n  }\n});\n\nHandlebars.registerHelper('if_eq', function ifEq (a, b, opts) {\n  if (a === b) {\n    return opts.fn(this);\n  } else {\n    return opts.inverse(this);\n  }\n});\n\nfunction getBaseHostname (fullUrl) {\n  const baseUrl = url.parse(fullUrl);\n  return baseUrl.hostname;\n}\n\nHandlebars.registerHelper('base_url', function baseUrl (fullUrl) {\n  return getBaseHostname(fullUrl);\n});\n\nHandlebars.registerHelper('client_url', function clientUrl (clientUrl) {\n  if (!clientUrl) {\n    return;\n  }\n\n  const createUrlString = function createUrlString (clientUrl, name = getBaseHostname(clientUrl)) {\n    return `[${name}](${clientUrl})`;\n  };\n\n  if (!_.isArray(clientUrl)) {\n    return createUrlString(clientUrl);\n  }\n\n  let urlStrings = [];\n  for (const item of clientUrl) {\n    for (let [key, value] of _.toPairs(item)) {\n      key = key.toLowerCase();\n      const urlStr = CLIENT_URL_TYPES[key] === 'hostname'\n        ? createUrlString(value)\n        : createUrlString(value, CLIENT_URL_TYPES[key]);\n      urlStrings.push(urlStr);\n    }\n  }\n  return urlStrings.join(' ');\n});\n\nasync function registerSpecUrlHelper () {\n  const routesFile = await fs.readFile(path.resolve(rootFolder, '..', 'base-driver', 'lib', 'protocol', 'routes.js'), 'utf8');\n  const routesFileLines = routesFile.split('\\n');\n\n  Handlebars.registerHelper('spec_url', function specUrl (specUrl, endpoint) {\n    // return the url if it is not a link to our routes doc\n    if (!specUrl.includes('routes.js')) {\n      return specUrl;\n    }\n    // make sure it is a full url\n    if (specUrl.startsWith('routes.js')) {\n      specUrl = `https://github.com/appium/appium-base-driver/blob/master/lib/protocol/${specUrl}`;\n    }\n\n    // strip off any line numbers\n    specUrl = specUrl.split('#L')[0];\n\n    // the endpoint here is often `session_id` and we need `sessionId`\n    endpoint = endpoint.replace('session_id', 'sessionId');\n    // and `element_id` and we need `elementId`\n    endpoint = endpoint.replace('element_id', 'elementId');\n\n    // find the line number for this endpoint\n    let index;\n    for (const i in routesFileLines) {\n      if (routesFileLines[i].includes(endpoint)) {\n        // line numbers are 1-indexed\n        index = parseInt(i, 10) + 1;\n        break;\n      }\n    }\n    if (_.isUndefined(index)) {\n      throw new Error(`Unable to find entry in 'appium-base-driver#routes' for endpoint '${endpoint}'`);\n    }\n\n    return `${specUrl}#L${index}`;\n  });\n}\n\nasync function generateCommands () {\n  await registerSpecUrlHelper();\n\n  const commands = path.resolve(rootFolder, 'commands-yml', 'commands/**/*.yml');\n  log('Traversing YML files', commands);\n  await fs.rimraf(path.resolve(rootFolder, 'docs', 'en', 'commands'));\n\n  // get the template from which the md files will be created\n  const template = Handlebars.compile(await fs.readFile(path.resolve(rootFolder, 'commands-yml', 'template.md'), 'utf8'), {noEscape: true, strict: true});\n\n  let fileCount = 0;\n  for (const filename of await fs.glob(commands)) {\n    const relativeFilename = path.relative(path.resolve(rootFolder, 'commands-yml'), filename);\n    log(`Rendering file: ${filename} ${relativeFilename}`);\n\n    // Translate the YML specs to JSON\n    const inputYML = await fs.readFile(filename, 'utf8');\n    const inputJSON = yaml.load(inputYML);\n    inputJSON.ymlFileName = `/${path.relative(rootFolder, filename)}`;\n    const validationErrors = validate(inputJSON, validator);\n    if (validationErrors) {\n      throw new Error(`Data validation error for ${filename}: ${JSON.stringify(validationErrors)}`);\n    }\n\n    // Pass the inputJS into our Handlebars template\n    const markdown = template(inputJSON);\n\n    // Write the markdown to its right place\n    const ext = path.extname(relativeFilename);\n    const markdownPath = `${relativeFilename.substring(0, relativeFilename.length - ext.length)}.md`;\n    const outfile = path.resolve(rootFolder, 'docs', 'en', markdownPath);\n    log(`    Writing to: ${outfile}`);\n    await mkdirp(path.dirname(outfile));\n    await fs.writeFile(outfile, markdown, 'utf8');\n\n    fileCount++;\n  }\n  log(`Done writing ${fileCount} command documents`);\n}\n\nasync function generateCommandIndex () {\n  function getTree (element, path) {\n    let node = {\n      name: element[0],\n    };\n    if (!_.isArray(element[1])) {\n      node.path = `${path}/${element[1]}`;\n    } else {\n      node.path = `${path}/${element[1][0]}`;\n      const name = element[1].shift();\n      node.commands = [];\n      for (let subElement of element[1]) {\n        node.commands.push(getTree(subElement, `${path}/${name}`));\n      }\n    }\n    return node;\n  }\n\n  // parse the toc.js file and get the commands into the form of\n  //   {commands: [{name: '', path: ''}, {name: '', commands: [...]}]}\n  const toc = require(path.resolve(rootFolder, '../..', 'docs', 'toc.js'));\n  const commandToc = _.find(toc.en, (value) => value.indexOf('Commands') === 0);\n  const commands = [];\n  for (let el of commandToc[1].slice(1)) {\n    commands.push(getTree(el, '/docs/en/commands'));\n  }\n\n  const commandTemplate = Handlebars.compile(await fs.readFile(path.resolve(rootFolder, 'commands-yml', 'api-template.md'), 'utf8'), {noEscape: true, strict: true});\n\n  async function writeIndex (index, commands, indexPath) {\n    log(`Creating API index '${index}'`);\n    const commandMarkdown = commandTemplate({\n      commands,\n      path: indexPath,\n    });\n    await fs.writeFile(index, commandMarkdown, 'utf8');\n  }\n\n  const apiIndex = path.resolve(rootFolder, '../..', 'docs', 'en', 'about-appium', 'api.md');\n  await writeIndex(apiIndex, commands);\n  log(`Done writing main API index`);\n\n  async function writeIndividualIndexes (command) {\n    if (!util.hasValue(command.commands)) {\n      // this is a leaf, so end\n      return;\n    }\n\n    // write this node\n    const relPath = command.path.startsWith(path.sep) ? command.path.substring(1) : command.path;\n    const index = path.resolve(rootFolder, relPath, 'README.md');\n    await writeIndex(index, command.commands, command.path);\n\n    // go through all the sub-commands\n    for (const el of command.commands) {\n      await writeIndividualIndexes(el);\n    }\n  }\n\n  // go through the full tree and generate readme files\n  const index = path.resolve(rootFolder, '../..', 'docs', 'en', 'commands', 'README.md');\n  await writeIndex(index, commands);\n  for (const el of commands) {\n    await writeIndividualIndexes(el);\n  }\n}\n\nasync function main () {\n  await generateCommands();\n  await generateCommandIndex();\n}\n\nasyncify(main);\n"],"file":"commands-yml/parse.js","sourceRoot":"../.."}

package/build/commands-yml/validator.js

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validator = exports.default = exports.CLIENT_URL_TYPES = void 0;
+
+require("source-map-support/register");
+
+var _validate = _interopRequireDefault(require("validate.js"));
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+_validate.default.validators.array = function array(value, options, key, attributes) {
+  if (attributes[key] && !_validate.default.isArray(attributes[key])) {
+    return `must be an array`;
+  }
+};
+
+_validate.default.validators.hasAttributes = function hasAttributes(value, options) {
+  if (!value) {
+    return;
+  }
+
+  if (!_lodash.default.isArray(value)) {
+    value = [value];
+  }
+
+  for (const item of value) {
+    for (const option of options) {
+      if (_lodash.default.isUndefined(item[option])) {
+        return `must have attributes: ${options}`;
+      }
+    }
+  }
+};
+
+_validate.default.validators.hasPossibleAttributes = function hasPossibleAttributes(value, options) {
+  if (!value) {
+    return;
+  }
+
+  if (!_lodash.default.isArray(value)) {
+    return;
+  }
+
+  for (const item of value) {
+    for (const key of _lodash.default.keys(item)) {
+      if (!options.includes(key)) {
+        return `must not include '${key}'. Available options: ${options}`;
+      }
+    }
+  }
+};
+
+const CLIENT_URL_TYPES = {
+  url: 'hostname',
+  android: 'Android',
+  ios: 'iOS'
+};
+exports.CLIENT_URL_TYPES = CLIENT_URL_TYPES;
+const validator = {
+  'name': {
+    presence: true
+  },
+  'short_description': {
+    presence: true
+  },
+  'example_usage': {},
+  'example_usage.java': {},
+  'example_usage.javascript_wdio': {},
+  'example_usage.javascript_wd': {},
+  'example_usage.ruby': {},
+  'example_usage.ruby_core': {},
+  'example_usage.csharp': {},
+  'description': {},
+  'client_docs.java': {
+    hasPossibleAttributes: _lodash.default.keys(CLIENT_URL_TYPES)
+  },
+  'client_docs.javascript_wdio': {
+    hasPossibleAttributes: _lodash.default.keys(CLIENT_URL_TYPES)
+  },
+  'client_docs.javascript_wd': {
+    hasPossibleAttributes: _lodash.default.keys(CLIENT_URL_TYPES)
+  },
+  'client_docs.ruby': {
+    hasPossibleAttributes: _lodash.default.keys(CLIENT_URL_TYPES)
+  },
+  'client_docs.ruby_core': {
+    hasPossibleAttributes: _lodash.default.keys(CLIENT_URL_TYPES)
+  },
+  'client_docs.csharp': {
+    hasPossibleAttributes: _lodash.default.keys(CLIENT_URL_TYPES)
+  },
+  'endpoint': {
+    presence: true
+  },
+  'driver_support': {
+    presence: true
+  },
+  'endpoint.url': {
+    presence: true
+  },
+  'endpoint.url_parameters': {
+    array: true,
+    hasAttributes: ['name', 'description']
+  },
+  'endpoint.json_parameters': {
+    array: true,
+    hasAttributes: ['name', 'description']
+  },
+  'endpoint.response': {
+    hasAttributes: ['type', 'description']
+  },
+  'specifications': {
+    presence: true
+  },
+  'links': {
+    array: true,
+    hasAttributes: ['name', 'url']
+  }
+};
+exports.validator = validator;
+var _default = validator;
+exports.default = _default;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+"use strict";
+
+require("source-map-support/register");
+
+const {
+  asyncify
+} = require('asyncbox');
+
+const appium = require('./build/lib/main.js');
+
+if (require.main === module) {
+  asyncify(appium.main);
+}
+
+module.exports = appium;require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbImluZGV4LmpzIl0sIm5hbWVzIjpbImFzeW5jaWZ5IiwicmVxdWlyZSIsImFwcGl1bSIsIm1haW4iLCJtb2R1bGUiLCJleHBvcnRzIl0sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7QUFFQSxNQUFNO0FBQUNBLEVBQUFBO0FBQUQsSUFBYUMsT0FBTyxDQUFDLFVBQUQsQ0FBMUI7O0FBRUEsTUFBTUMsTUFBTSxHQUFHRCxPQUFPLENBQUMscUJBQUQsQ0FBdEI7O0FBRUEsSUFBSUEsT0FBTyxDQUFDRSxJQUFSLEtBQWlCQyxNQUFyQixFQUE2QjtBQUMzQkosRUFBQUEsUUFBUSxDQUFDRSxNQUFNLENBQUNDLElBQVIsQ0FBUjtBQUNEOztBQUVEQyxNQUFNLENBQUNDLE9BQVAsR0FBaUJILE1BQWpCIiwic291cmNlc0NvbnRlbnQiOlsiIyEvdXNyL2Jpbi9lbnYgbm9kZVxuXG5jb25zdCB7YXN5bmNpZnl9ID0gcmVxdWlyZSgnYXN5bmNib3gnKTtcblxuY29uc3QgYXBwaXVtID0gcmVxdWlyZSgnLi9idWlsZC9saWIvbWFpbi5qcycpO1xuXG5pZiAocmVxdWlyZS5tYWluID09PSBtb2R1bGUpIHtcbiAgYXN5bmNpZnkoYXBwaXVtLm1haW4pO1xufVxuXG5tb2R1bGUuZXhwb3J0cyA9IGFwcGl1bTtcbiJdLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiLi4ifQ==