schemas.forEach(schema => {
const file = path.basename(schema);
if (file === 'package.json') {
throw new Error('Cannot use name "package.json" for schema file');
}
fs.copySync(schema, path.join(destination, file));
});
function assertDirsEqual(actual: string, expected: string, basedir = actual) {
if (process.env['UPDATE_POLYMER_CLI_GOLDENS']) {
fsExtra.emptyDirSync(expected);
fsExtra.copySync(actual, expected);
throw new Error('Goldens updated, test failing for your safety.');
}
const actualNames = fs.readdirSync(actual).sort();
const expectedNames = fs.readdirSync(expected).sort();
assert.deepEqual(
actualNames,
expectedNames,
`expected files in directory ${path.relative(basedir, actual)}`);
for (const fn of actualNames) {
const subActual = path.join(actual, fn);
const subExpected = path.join(expected, fn);
const stat = fs.statSync(subActual);
if (stat.isDirectory()) {
assertDirsEqual(subActual, subExpected, basedir);
} else {
const actualContents = fs.readFileSync(subActual, 'utf-8').trim();
const expectedContents = fs.readFileSync(subExpected, 'utf-8').trim();
assert.deepEqual(
actualContents,
expectedContents,
`expected contents of ${path.relative(basedir, subActual)}`);
}
}
}
static async updateGhPagesAsync(
repoUrl: string,
siteFolder: string,
docfxExe: string,
docfxJson: string,
gitUserName: string,
gitUserEmail: string,
gitCommitMessage: string) {
Guard.argumentNotNullOrEmpty(repoUrl, "repoUrl");
Guard.argumentNotNullOrEmpty(siteFolder, "siteFolder");
Guard.argumentNotNullOrEmpty(docfxExe, "docfxExe");
Guard.argumentNotNullOrEmpty(docfxJson, "docfxJson");
Guard.argumentNotNullOrEmpty(gitUserName, "gitUserName");
Guard.argumentNotNullOrEmpty(gitUserEmail, "gitUserEmail");
Guard.argumentNotNullOrEmpty(gitCommitMessage, "gitCommitMessage");
await Common.execAsync(docfxExe, [docfxJson]);
let branch = "gh-pages";
let targetDir = "docfxsite";
this.cleanGitInfo(siteFolder);
await Common.execAsync("git", ["clone", repoUrl, "-b", branch, targetDir]);
fs.mkdirsSync(path.join(siteFolder, ".git"));
fs.copySync(path.join(targetDir, ".git"), path.join(siteFolder, ".git"));
await Common.execAsync("git", ["config", "user.name", gitUserName], siteFolder);
await Common.execAsync("git", ["config", "user.email", gitUserEmail], siteFolder);
await Common.execAsync("git", ["add", "."], siteFolder);
await Common.execAsync("git", ["commit", "-m", gitCommitMessage], siteFolder);
return Common.execAsync("git", ["push", "origin", branch], siteFolder);
}
files.forEach((fileName) => {
const sourcePath = isAbsolute(fileName) ? fileName : resolve(path, fileName);
const destFileName = isAbsolute(fileName) ? basename(fileName) : fileName;
const destPath = resolve(cwd, copiedFilesDir, commandName, destFileName);
console.log(` ${yellow('creating')} ${destPath.replace(cwd, '.')}`);
copySync(sourcePath, destPath);
});
const copyPublicFolder = async (dest: string): Promise<void> => {
if (await fs.pathExists(paths.appPublic)) {
await fs.copySync(paths.appPublic, paths.distPublic(dest), {
dereference: true,
filter: file => file !== paths.indexHtml,
})
}
}
export function generateMission(terrainId: string): Mission.GeneratedMission {
var mission = defaultMission(terrainId);
var generatedMission = Mission.generateMission(mission);
updateMissionSqm(`${generatedMission.missionDir}/mission.sqm`);
updateDescriptionExt(`${generatedMission.missionDir}/description.ext`);
fs.copySync(`${TS_HOME}/blufor_briefing.sqf`, `${generatedMission.missionDir}/hull3/briefing/blufor.sqf`);
return generatedMission;
}
return new Promise((resolve, reject) => {
try {
fse.copySync(srcDir, destDir, options);
resolve();
} catch (e) {
reject(e);
}
});
.then(() => {
FS.copySync(tmpPackagePath, packagePath);
let metadataJSON = JSON.stringify(metadata, undefined, 4);
FS.writeFileSync(metadataFilePath, metadataJSON);
return packagePath;
});
export function copy(src: string, dest: string) {
// Log.info(`./> cp ${src} ${dest}`);
try {
fse.copySync(src, dest);
} catch (e) {
Log.error(`copy: ${e.message}`);
}
}
export function generateMission(terrainId: string): Mission.GeneratedMission {
var mission = defaultMission(terrainId);
var generatedMission = Mission.generateMission(mission);
var missionSqmPath = `${generatedMission.missionDir}/mission.sqm`;
var missionAst = updateMissionSqm(missionSqmPath);
var maxPlayers = Mission.getPlayableUnitCount(missionAst);
var fullMissionName = `ark_${Mission.missionTypeToMissionNamePrefix(Mission.stringToMissionType(mission.missionTypeName))}${maxPlayers}_${mission.briefingName.toLowerCase()}`;
updateDescriptionExt(`${generatedMission.missionDir}/description.ext`, maxPlayers);
generatedMission.downloadMissionName = `${fullMissionName}.${mission.terrainId}`;
Ast.select(missionAst, 'ScenarioData.Header.maxPlayers')[0].value = maxPlayers;
Ast.select(missionAst, 'Mission.Intel.briefingName')[0].value = fullMissionName;
fs.writeFileSync(missionSqmPath, PrettyPrinter.create('\t').print(missionAst), 'UTF-8');
fs.copySync(`${RE_HOME}/blufor_briefing.sqf`, `${generatedMission.missionDir}/hull3/briefing/blufor.sqf`);
fs.copySync(`${RE_HOME}/opfor_briefing.sqf`, `${generatedMission.missionDir}/hull3/briefing/opfor.sqf`);
return generatedMission;
}
