7202

Committed 06 Oct 2023 02:44AM UTC coverage: 60.048% (-0.3%) from 60.393%

Build # 7202

Build Type

push

Azure Pipelines

Committed by

web-flow

Commit Message

Merge pull request #1902 from Karthiccc23/add-pod-update

Add optional podRepoUpdate flag in iosConfig

Run Details

3790 of 7668 branches covered (49.43%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

48 existing lines in 2 files now uncovered.

9910 of 15147 relevant lines covered (65.43%)

553.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/ern-local-cli/src/index.ts

import chalk from 'chalk';
import { execSync } from 'child_process';
import fs from 'fs-extra';
import { getActiveCauldron } from 'ern-cauldron-api';
import {
  config,
  ERN_RC_GLOBAL_FILE_PATH,
  ernRcFilePath,
  kax,
  log,
  LogLevel,
  Manifest,
  OverrideManifestConfig,
  Platform,
  shell,
} from 'ern-core';
import {
  KaxAdvancedRenderer,
  KaxRenderer,
  KaxSimpleRenderer,
  KaxTask,
} from 'kax';
import path from 'path';
import yargs from 'yargs';
import semver from 'semver';

// ==============================================================================
// Geeky eye candy
// ==============================================================================

function showBanner() {
  console.log(
    chalk.yellow(' ___ _        _               _      ') +
      chalk.green(' _  _      _   _         '),
  );
  console.log(
    chalk.yellow('| __| |___ __| |_ _ _ ___  __| |___  ') +
      chalk.green('| \\| |__ _| |_(_)_ _____ '),
  );
  console.log(
    chalk.yellow("| _|| / -_) _|  _| '_/ _ \\/ _` / -_) ") +
      chalk.green('| .` / _` |  _| \\ V / -_)'),
  );
  console.log(
    chalk.yellow('|___|_\\___\\__|\\__|_| \\___/\\__,_\\___| ') +
      chalk.green('|_|\\_\\__,_|\\__|_|\\_/\\___|'),
  );
}

async function showInfo() {
  const currentCauldronRepo = config.get('cauldronRepoInUse') || '-NONE-';
  const bundleStoreId = config.get('bundlestore-id');
  const l = bundleStoreId ? chalk.cyan(` [BundleStore: ${bundleStoreId}]`) : '';
  console.log(
    chalk.cyan(`[v${Platform.currentVersion}]`) +
      chalk.cyan(` [Cauldron: ${currentCauldronRepo}]`) +
      l,
  );
  if (ERN_RC_GLOBAL_FILE_PATH !== ernRcFilePath) {
    // Log .ernrc configuration file path only if it differs from default
    console.log(chalk.cyan(`${chalk.bold('Config:')} ${ernRcFilePath}`));
  }
  const overrideManifest = await Manifest.getOverrideManifestConfig();
  if (overrideManifest) {
    // Log override manifest only if set
    console.log(
      chalk.cyan(
        `${chalk.bold('Manifest [override]:')} ${
          overrideManifest.url
        } ${chalk.italic(`(from ${overrideManifest.source}`)})`,
      ),
    );
  }
  const manifestErnRcConf = config.get('manifest', undefined);
  if (manifestErnRcConf && manifestErnRcConf.master) {
    //  Log master manifest only if set
    console.log(
      chalk.cyan(
        `${chalk.bold('Manifest [master]:')} ${
          manifestErnRcConf.master.url
        } ${chalk.italic('(from .ernrc)')}`,
      ),
    );
  }
  console.log('');
}

function showVersion() {
  let packageInfo;
  try {
    const pkg = path.join(
      execSync('yarn global dir').toString().trim(),
      'node_modules',
      'electrode-native',
      'package.json',
    );
    packageInfo = fs.existsSync(pkg) ? require(pkg) : '';
  } catch (err) {
    log.trace(err);
  }

  if (!packageInfo) {
    try {
      packageInfo = JSON.parse(
        execSync('npm ls -g electrode-native --json').toString(),
      ).dependencies['electrode-native'];
    } catch (err) {
      log.trace(err);
    }
  }

  const globalVersion = packageInfo ? packageInfo.version : '';
  log.info(`electrode-native: ${globalVersion ? globalVersion : '-UNKNOWN-'}`);

  const localVersion = config.get('platformVersion');
  log.info(`ern platform: ${localVersion ? localVersion : '-UNKNOWN-'}`);
}

function getNodeEngineVersionRequirement() {
  const pjsonPath = path.resolve(__dirname, '..', 'package.json');
  const pjson = fs.readJSONSync(pjsonPath);
  return pjson.engines.node;
}

function isNodeVersionCompatible(version: string) {
  const requiredVersion = getNodeEngineVersionRequirement();
  return semver.satisfies(version, requiredVersion);
}

Manifest.getOverrideManifestConfig =
  async (): Promise<OverrideManifestConfig | void> => {
    // Try to find override manifest config in .ernrc config first
    let manifestConfig = config.get('manifest', undefined);
    if (
      manifestConfig &&
      manifestConfig.override &&
      manifestConfig.override.url
    ) {
      return {
        source: '.ernrc',
        type: manifestConfig.override.type || 'partial',
        url: manifestConfig.override.url,
      };
    }

    // If not found in .ernrc, look in cauldron config
    try {
      const cauldronInstance = await getActiveCauldron({
        silent: true,
        throwIfNoActiveCauldron: false,
      });
      manifestConfig = await cauldronInstance?.getManifestConfig();
      if (manifestConfig) {
        return {
          source: 'cauldron',
          type: manifestConfig.override.type || 'partial',
          url: manifestConfig.override.url,
        };
      }
    } catch (e) {
      log.warn('Cannot reach Cauldron');
    }
  };

const kaxRendererConfig = {
  colorScheme: {
    error: 'red',
    info: 'cyan',
    task: 'white',
    warning: 'yellow',
  },
  shouldLogTime: true,
  symbolScheme: {
    error: 'error',
    info: 'info',
    taskFailure: 'error',
    taskRunning: 'dots',
    taskSuccess: 'success',
    warning: 'warning',
  },
  symbolizeMultiLine: true,
};

class KaxNullRenderer implements KaxRenderer {
  public renderWarning(msg: string) {
    // noop
  }
  public renderInfo(msg: string) {
    // noop
  }
  public renderError(msg: string) {
    // noop
  }
  public renderRaw(msg: string) {
    // noop
  }
  public renderTask<T>(msg: string, task: KaxTask<T>) {
    // noop
  }
}

const logLevelStringToEnum = (level: string) => {
  switch (level) {
    case 'trace':
      return LogLevel.Trace;
    case 'debug':
      return LogLevel.Debug;
    case 'info':
      return LogLevel.Info;
    case 'warn':
      return LogLevel.Warn;
    case 'error':
      return LogLevel.Error;
    case 'off':
      return LogLevel.Off;
    default:
      throw new Error(`Invalid log level ${level}`);
  }
};

// ==============================================================================
// Entry point
// =============================================================================
(async function run() {
  const hasJsonOpt = process.argv.slice(1).includes('--json');
  const logLevel: LogLevel = hasJsonOpt
    ? LogLevel.Off
    : process.env.ERN_LOG_LEVEL
    ? logLevelStringToEnum(process.env.ERN_LOG_LEVEL)
    : logLevelStringToEnum(config.get('logLevel', 'info'));

  log.setLogLevel(logLevel);
  shell.config.fatal = true;
  shell.config.verbose = logLevel === LogLevel.Trace;
  shell.config.silent = !(
    logLevel === LogLevel.Trace || logLevel === LogLevel.Debug
  );

  kax.renderer =
    logLevel === LogLevel.Trace || logLevel === LogLevel.Debug
      ? new KaxSimpleRenderer(kaxRendererConfig)
      : logLevel === LogLevel.Off
      ? new KaxNullRenderer()
      : new KaxAdvancedRenderer(kaxRendererConfig);

  const nodeVersion = process.version;
  if (!isNodeVersionCompatible(nodeVersion)) {
    const requiredVersion = getNodeEngineVersionRequirement();
    log.error(`This version of ern requires Node.js ${requiredVersion}
Node.js version currently in use is ${nodeVersion}
Please switch to a version of Node satisfying the version requirement`);
    process.exit(1);
  }

  if (!hasJsonOpt) {
    if (config.get('showBanner', true)) {
      showBanner();
    }
    await showInfo();
  }

  if (process.argv[2] === '--version') {
    return showVersion();
  }

  return yargs
    .commandDir('commands', {
      extensions: process.env.ERN_ENV === 'development' ? ['js', 'ts'] : ['js'],
    })
    .demandCommand()
    .help()
    .strict()
    .version(false)
    .wrap(yargs.terminalWidth()).argv;
})();

1	import chalk from 'chalk';
2	import { execSync } from 'child_process';
3	import fs from 'fs-extra';
4	import { getActiveCauldron } from 'ern-cauldron-api';
5	import {
6	config,
7	ERN_RC_GLOBAL_FILE_PATH,
8	ernRcFilePath,
9	kax,
10	log,
11	LogLevel,
12	Manifest,
13	OverrideManifestConfig,
14	Platform,
15	shell,
16	} from 'ern-core';
17	import {
18	KaxAdvancedRenderer,
19	KaxRenderer,
20	KaxSimpleRenderer,
21	KaxTask,
22	} from 'kax';
23	import path from 'path';
24	import yargs from 'yargs';
25	import semver from 'semver';
26
27	// ==============================================================================
28	// Geeky eye candy
29	// ==============================================================================
30
31	function showBanner() {
UNCOV 32	console.log(	×
33	chalk.yellow(' ___ _ _ _ ') +
34	chalk.green(' _ _ _ _ '),
35	);
UNCOV 36	console.log(	×
37	chalk.yellow('\| __\| \|___ __\| \|_ _ _ ___ __\| \|___ ') +
38	chalk.green('\| \\\| \|__ _\| \|_(_)_ _____ '),
39	);
UNCOV 40	console.log(	×
41	chalk.yellow("\| _\|\| / -_) _\| _\| '_/ _ \\/ _` / -_) ") +
42	chalk.green('\| .` / _` \| _\| \\ V / -_)'),
43	);
UNCOV 44	console.log(	×
45	chalk.yellow('\|___\|_\\___\\__\|\\__\|_\| \\___/\\__,_\\___\| ') +
46	chalk.green('\|_\|\\_\\__,_\|\\__\|_\|\\_/\\___\|'),
47	);
48	}
49
50	async function showInfo() {
UNCOV 51	const currentCauldronRepo = config.get('cauldronRepoInUse') \|\| '-NONE-';	×
UNCOV 52	const bundleStoreId = config.get('bundlestore-id');	×
UNCOV 53	const l = bundleStoreId ? chalk.cyan(` [BundleStore: ${bundleStoreId}]`) : '';	×
UNCOV 54	console.log(	×
55	chalk.cyan(`[v${Platform.currentVersion}]`) +
56	chalk.cyan(` [Cauldron: ${currentCauldronRepo}]`) +
57	l,
58	);
UNCOV 59	if (ERN_RC_GLOBAL_FILE_PATH !== ernRcFilePath) {	×
60	// Log .ernrc configuration file path only if it differs from default
61	console.log(chalk.cyan(`${chalk.bold('Config:')} ${ernRcFilePath}`));	×
62	}
UNCOV 63	const overrideManifest = await Manifest.getOverrideManifestConfig();	×
UNCOV 64	if (overrideManifest) {	×
65	// Log override manifest only if set
66	console.log(	×
67	chalk.cyan(
68	`${chalk.bold('Manifest [override]:')} ${
69	overrideManifest.url
70	} ${chalk.italic(`(from ${overrideManifest.source}`)})`,
71	),
72	);
73	}
UNCOV 74	const manifestErnRcConf = config.get('manifest', undefined);	×
UNCOV 75	if (manifestErnRcConf && manifestErnRcConf.master) {	×
76	// Log master manifest only if set
77	console.log(	×
78	chalk.cyan(
79	`${chalk.bold('Manifest [master]:')} ${
80	manifestErnRcConf.master.url
81	} ${chalk.italic('(from .ernrc)')}`,
82	),
83	);
84	}
UNCOV 85	console.log('');	×
86	}
87
88	function showVersion() {
89	let packageInfo;
90	try {	×
91	const pkg = path.join(	×
92	execSync('yarn global dir').toString().trim(),
93	'node_modules',
94	'electrode-native',
95	'package.json',
96	);
97	packageInfo = fs.existsSync(pkg) ? require(pkg) : '';	×
98	} catch (err) {
99	log.trace(err);	×
100	}
101
102	if (!packageInfo) {	×
103	try {	×
104	packageInfo = JSON.parse(	×
105	execSync('npm ls -g electrode-native --json').toString(),
106	).dependencies['electrode-native'];
107	} catch (err) {
108	log.trace(err);	×
109	}
110	}
111
112	const globalVersion = packageInfo ? packageInfo.version : '';	×
113	log.info(`electrode-native: ${globalVersion ? globalVersion : '-UNKNOWN-'}`);	×
114
115	const localVersion = config.get('platformVersion');	×
116	log.info(`ern platform: ${localVersion ? localVersion : '-UNKNOWN-'}`);	×
117	}
118
119	function getNodeEngineVersionRequirement() {
UNCOV 120	const pjsonPath = path.resolve(__dirname, '..', 'package.json');	×
UNCOV 121	const pjson = fs.readJSONSync(pjsonPath);	×
UNCOV 122	return pjson.engines.node;	×
123	}
124
125	function isNodeVersionCompatible(version: string) {
UNCOV 126	const requiredVersion = getNodeEngineVersionRequirement();	×
UNCOV 127	return semver.satisfies(version, requiredVersion);	×
128	}
129
UNCOV 130	Manifest.getOverrideManifestConfig =	×
131	async (): Promise<OverrideManifestConfig \| void> => {
132	// Try to find override manifest config in .ernrc config first
UNCOV 133	let manifestConfig = config.get('manifest', undefined);	×
UNCOV 134	if (	×
135	manifestConfig &&	×
136	manifestConfig.override &&
137	manifestConfig.override.url
138	) {
139	return {	×
140	source: '.ernrc',
141	type: manifestConfig.override.type \|\| 'partial',	×
142	url: manifestConfig.override.url,
143	};
144	}
145
146	// If not found in .ernrc, look in cauldron config
UNCOV 147	try {	×
UNCOV 148	const cauldronInstance = await getActiveCauldron({	×
149	silent: true,
150	throwIfNoActiveCauldron: false,
151	});
UNCOV 152	manifestConfig = await cauldronInstance?.getManifestConfig();	×
UNCOV 153	if (manifestConfig) {	×
154	return {	×
155	source: 'cauldron',
156	type: manifestConfig.override.type \|\| 'partial',	×
157	url: manifestConfig.override.url,
158	};
159	}
160	} catch (e) {
161	log.warn('Cannot reach Cauldron');	×
162	}
163	};
164
UNCOV 165	const kaxRendererConfig = {	×
166	colorScheme: {
167	error: 'red',
168	info: 'cyan',
169	task: 'white',
170	warning: 'yellow',
171	},
172	shouldLogTime: true,
173	symbolScheme: {
174	error: 'error',
175	info: 'info',
176	taskFailure: 'error',
177	taskRunning: 'dots',
178	taskSuccess: 'success',
179	warning: 'warning',
180	},
181	symbolizeMultiLine: true,
182	};
183
184	class KaxNullRenderer implements KaxRenderer {
185	public renderWarning(msg: string) {
186	// noop
187	}
188	public renderInfo(msg: string) {
189	// noop
190	}
191	public renderError(msg: string) {
192	// noop
193	}
194	public renderRaw(msg: string) {
195	// noop
196	}
197	public renderTask<T>(msg: string, task: KaxTask<T>) {
198	// noop
199	}
200	}
201
UNCOV 202	const logLevelStringToEnum = (level: string) => {	×
UNCOV 203	switch (level) {	×
204	case 'trace':
UNCOV 205	return LogLevel.Trace;	×
206	case 'debug':
207	return LogLevel.Debug;	×
208	case 'info':
UNCOV 209	return LogLevel.Info;	×
210	case 'warn':
211	return LogLevel.Warn;	×
212	case 'error':
213	return LogLevel.Error;	×
214	case 'off':
215	return LogLevel.Off;	×
216	default:
217	throw new Error(`Invalid log level ${level}`);	×
218	}
219	};
220
221	// ==============================================================================
222	// Entry point
223	// =============================================================================
UNCOV 224	(async function run() {	×
UNCOV 225	const hasJsonOpt = process.argv.slice(1).includes('--json');	×
UNCOV 226	const logLevel: LogLevel = hasJsonOpt	×
227	? LogLevel.Off
228	: process.env.ERN_LOG_LEVEL	×
229	? logLevelStringToEnum(process.env.ERN_LOG_LEVEL)
230	: logLevelStringToEnum(config.get('logLevel', 'info'));
231
UNCOV 232	log.setLogLevel(logLevel);	×
UNCOV 233	shell.config.fatal = true;	×
UNCOV 234	shell.config.verbose = logLevel === LogLevel.Trace;	×
UNCOV 235	shell.config.silent = !(	×
236	logLevel === LogLevel.Trace \|\| logLevel === LogLevel.Debug	×
237	);
238
UNCOV 239	kax.renderer =	×
240	logLevel === LogLevel.Trace \|\| logLevel === LogLevel.Debug	×
241	? new KaxSimpleRenderer(kaxRendererConfig)
242	: logLevel === LogLevel.Off	×
243	? new KaxNullRenderer()
244	: new KaxAdvancedRenderer(kaxRendererConfig);
245
UNCOV 246	const nodeVersion = process.version;	×
UNCOV 247	if (!isNodeVersionCompatible(nodeVersion)) {	×
248	const requiredVersion = getNodeEngineVersionRequirement();	×
249	log.error(`This version of ern requires Node.js ${requiredVersion}	×
250	Node.js version currently in use is ${nodeVersion}
251	Please switch to a version of Node satisfying the version requirement`);
252	process.exit(1);	×
253	}
254
UNCOV 255	if (!hasJsonOpt) {	×
UNCOV 256	if (config.get('showBanner', true)) {	×
UNCOV 257	showBanner();	×
258	}
UNCOV 259	await showInfo();	×
260	}
261
UNCOV 262	if (process.argv[2] === '--version') {	×
263	return showVersion();	×
264	}
265
UNCOV 266	return yargs	×
267	.commandDir('commands', {
268	extensions: process.env.ERN_ENV === 'development' ? ['js', 'ts'] : ['js'],	×
269	})
270	.demandCommand()
271	.help()
272	.strict()
273	.version(false)
274	.wrap(yargs.terminalWidth()).argv;
275	})();

electrode-io / electrode-native / 7202

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous