google / clasp / 897

pending completion

Build # 897

Build Type

Pull #556

travis-ci

Committed by

web-flow

Commit Message

Refactor isValidFileName and make test for it

Signed-off-by: campionfellin <campionfellin@gmail.com>

Pull Request Pull Request #556: Refactor isValidFileName and make test for it

Run Details

254 of 610 branches covered (41.64%)

Branch coverage included in aggregate %.

39 of 39 new or added lines in 2 files covered. (100.0%)

1249 of 1806 relevant lines covered (69.16%)

436.96 hits per line

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

77.21

/src/files.ts

import * as fs from 'fs';
import * as path from 'path';
import * as mkdirp from 'mkdirp';
import * as multimatch from 'multimatch';
import * as recursive from 'recursive-readdir';
import * as ts from 'typescript';
import { loadAPICredentials, script } from './auth';
import { DOT, DOTFILE } from './dotfile';
import { ERROR, LOG, checkIfOnline, getAPIFileType, getProjectSettings, logError, spinner } from './utils';

const ts2gas = require('ts2gas');
const readMultipleFiles = require('read-multiple-files');
const findParentDir = require('find-parent-dir');

// An Apps Script API File
interface AppsScriptFile {
  name: string;
  type: string;
  source: string;
}

// Used to receive files tracked by current project
interface FilesCallback {
  (error: Error | boolean, result: string[][] | null, files: Array<AppsScriptFile | undefined> | null): void;
}

/**
 * Gets the local file type from the API FileType.
 * @param  {string} type The file type returned by Apps Script
 * @return {string}      The file type
 * @see https://developers.google.com/apps-script/api/reference/rest/v1/File#FileType
 */
export function getFileType(type: string, fileExtension?: string): string {
  return type === 'SERVER_JS' ? fileExtension || 'js' : type.toLowerCase();
}

/**
 * Returns true if the user has a clasp project.
 * @returns {boolean} If .clasp.json exists.
 */
export function hasProject(): boolean {
  return fs.existsSync(DOT.PROJECT.PATH);
}

/**
 * Returns in tsconfig.json.
 * @returns {ts.TranspileOptions} if tsconfig.json not exists, return undefined.
 */
export function getTranspileOptions(): ts.TranspileOptions{
  const projectDirectory: string = findParentDir.sync(process.cwd(), DOT.PROJECT.PATH) || DOT.PROJECT.DIR;
  const tsconfigPath = path.join(projectDirectory, 'tsconfig.json');
  const userConf: ts.TranspileOptions = {};
  if(fs.existsSync(tsconfigPath)){
    const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
    const parsedConfigResult = ts.parseConfigFileTextToJson(tsconfigPath, tsconfigContent);
    return {
      compilerOptions: parsedConfigResult.config.compilerOptions,
    };
  }
  return {};
}

/**
 * Recursively finds all files that are part of the current project, and those that are ignored
 * by .claspignore and calls the passed callback function with the file lists.
 * @param {string} rootDir The project's root directory
 * @param {FilesCallBack} callback The callback will be called with the following paramters
 *   error: Error if there's an error, otherwise null
 *   result: string[][], List of two lists of strings, ie. [nonIgnoredFilePaths,ignoredFilePaths]
 *   files?: Array<AppsScriptFile|undefined> Array of AppsScriptFile objects used by clasp push
 * @todo Make this function actually return a Promise that can be awaited.
 */
export async function getProjectFiles(rootDir: string = path.join('.', '/'), callback: FilesCallback) {
  const { filePushOrder } = await getProjectSettings();

  // Load tsconfig
  const userConf = getTranspileOptions();

  // Read all filenames as a flattened tree
  // Note: filePaths contain relative paths such as "test/bar.ts", "../../src/foo.js"
  recursive(rootDir, (err, filePaths) => {
    if (err) return callback(err, null, null);
    // Filter files that aren't allowed.
    DOTFILE.IGNORE().then((ignorePatterns: string[]) => {
      filePaths = filePaths.sort(); // Sort files alphanumerically
      let abortPush = false;
      let nonIgnoredFilePaths: string[] = [];
      let ignoredFilePaths: string[] = [];
      ignoredFilePaths = ignoredFilePaths.concat(ignorePatterns);
      // Match the files with ignored glob pattern
      readMultipleFiles(filePaths, 'utf8', (err: string, contents: string[]) => {
        if (err) return callback(new Error(err), null, null);
        // Check if there are files that will conflict if renamed .gs to .js.
        // When pushing to Apps Script, these files will overwrite each other.
        filePaths.map((name: string) => {
          const fileNameWithoutExt = name.slice(0, -path.extname(name).length);
          if (
            filePaths.indexOf(fileNameWithoutExt + '.js') !== -1 &&
            filePaths.indexOf(fileNameWithoutExt + '.gs') !== -1
          ) {
            // Can't rename, conflicting files
            abortPush = true;
            if (path.extname(name) === '.gs') {
              // only print error once (for .gs)
              logError(null, ERROR.CONFLICTING_FILE_EXTENSION(fileNameWithoutExt));
            }
          }
        });
        if (abortPush) return callback(new Error(), null, null);

        // Replace OS specific path separator to common '/' char for console output
        filePaths = filePaths.map((name) => name.replace(/\\/g, '/'));

        // check ignore files
        const ignoreMatches = multimatch(filePaths, ignorePatterns, { dot: true });
        const intersection: string[] = filePaths.filter(file => !ignoreMatches.includes(file));

        // Loop through files that are not ignored
        const files = intersection
          .map((name, i) => {
            const normalizedName = path.normalize(name);

            let type = getAPIFileType(name);

            // File source
            let source = fs.readFileSync(name).toString();
            if (type === 'TS') {
              // Transpile TypeScript to Google Apps Script
              // @see github.com/grant/ts2gas
              source = ts2gas(source, userConf);
              type = 'SERVER_JS';
            }

            // Formats rootDir/appsscript.json to appsscript.json.
            // Preserves subdirectory names in rootDir
            // (rootDir/foo/Code.js becomes foo/Code.js)
            const formattedName = getAppsScriptFileName(rootDir, name);

            // If the file is valid, return the file in a format suited for the Apps Script API.
            if (isValidFileName(name, type, rootDir, normalizedName, ignoreMatches)) {
              nonIgnoredFilePaths.push(name);
              const file: AppsScriptFile = {
                name: formattedName, // the file base name
                type, // the file extension
                source, //the file contents
              };
              return file;
            } else {
              ignoredFilePaths.push(name);
              return; // Skip ignored files
            }
          })
          .filter(Boolean); // remove null values

        // This statement customizes the order in which the files are pushed.
        // It puts the files in the setting's filePushOrder first.
        // This is needed because Apps Script blindly executes files in order of creation time.
        // The Apps Script API updates the creation time of files.
        if (filePushOrder) {
          spinner.stop(true);
          console.log('Detected filePushOrder setting. Pushing these files first:');
          filePushOrder.map(file => {
            console.log(`└─ ${file}`);
          });
          console.log('');
          nonIgnoredFilePaths = nonIgnoredFilePaths.sort((path1: string, path2: string) => {
            // Get the file order index
            let path1Index = filePushOrder.indexOf(path1);
            let path2Index = filePushOrder.indexOf(path2);
            // If a file path isn't in the filePushOrder array, set the order to -∞.
            path1Index = path1Index === -1 ? Number.NEGATIVE_INFINITY : path1Index;
            path2Index = path2Index === -1 ? Number.NEGATIVE_INFINITY : path2Index;
            return path2Index - path1Index;
          });
        }

        callback(false, [nonIgnoredFilePaths, ignoredFilePaths], files);
      });
    });
  });
}

/**
 * If the file is valid, add it to our file list.
 * We generally want to allow for all file types, including files in node_modules/.
 * However, node_modules/@types/ files should be ignored.
 */
export function isValidFileName(name: string,
                                type: string,
                                rootDir: string,
                                normalizedName: string,
                                ignoreMatches: string[]): boolean {
  let valid = true; // Valid by default, until proven otherwise.
  // Has a type or is appsscript.json
  let isValidJSONIfJSON = true;
  if (type === 'JSON') {
    if (rootDir) {
      isValidJSONIfJSON = normalizedName === path.join(rootDir, 'appsscript.json');
    } else {
      isValidJSONIfJSON = name === 'appsscript.json';
    }
  } else {
    // Must be SERVER_JS or HTML.
    // https://developers.google.com/apps-script/api/reference/rest/v1/File
    valid = type === 'SERVER_JS' || type === 'HTML';
  }
  // Prevent node_modules/@types/
  if (name.includes('node_modules/@types')) {
    return false;
  }
  const validType = type && isValidJSONIfJSON;
  const notIgnored = !ignoreMatches.includes(name);
  valid = !!(valid && validType && notIgnored);
  return valid;
}

/**
 * Gets the name of the file for Apps Script.
 * Formats rootDir/appsscript.json to appsscript.json.
 * Preserves subdirectory names in rootDir
 * (rootDir/foo/Code.js becomes foo/Code.js)
 * @param {string} rootDir The directory to save the project files to.
 * @param {string} filePath Path of file that is part of the current project
 */
export function getAppsScriptFileName(rootDir: string, filePath: string) {
  const nameWithoutExt = filePath.slice(0, -path.extname(filePath).length);
  let fullFilePathNoExt = rootDir ? path.relative(rootDir, nameWithoutExt) : nameWithoutExt;
  // Replace OS specific path separator to common '/' char
  fullFilePathNoExt = fullFilePathNoExt.replace(/\\/g, '/');
  return fullFilePathNoExt;
}

/**
 * Fetches the files for a project from the server
 * @param {string} scriptId The project script id
 * @param {number?} versionNumber The version of files to fetch.
 * @returns {AppsScriptFile[]} Fetched files
 */
export async function fetchProject(
  scriptId: string,
  versionNumber?: number,
  silent = false,
): Promise<AppsScriptFile[]> {
  await checkIfOnline();
  await loadAPICredentials();
  spinner.start();
  let res;
  try {
    res = await script.projects.getContent({
      scriptId,
      versionNumber,
    });
  } catch (error) {
    if (error.statusCode === 404) {
      throw Error(ERROR.SCRIPT_ID_INCORRECT(scriptId));
    }
    throw Error(ERROR.SCRIPT_ID);
  }
  spinner.stop(true);
  const data = res.data;
  if (!data.files) throw Error(ERROR.SCRIPT_ID_INCORRECT(scriptId));
  if (!silent) console.log(LOG.CLONE_SUCCESS(data.files.length));
  return data.files as AppsScriptFile[];
}

/**
 * Writes files locally to `pwd` with dots converted to subdirectories.
 * @param {AppsScriptFile[]} Files to wirte
 * @param {string?} rootDir The directory to save the project files to. Defaults to `pwd`
 */
export async function writeProjectFiles(files: AppsScriptFile[], rootDir = '') {
  const { fileExtension } = await getProjectSettings();
  const sortedFiles = files.sort((file1, file2) => file1.name.localeCompare(file2.name));
  sortedFiles.map((file: AppsScriptFile) => {
    const filePath = `${file.name}.${getFileType(file.type, fileExtension)}`;
    const truePath = `${rootDir || '.'}/${filePath}`;
    mkdirp(path.dirname(truePath), err => {
      if (err) return logError(err, ERROR.FS_DIR_WRITE);
      if (!file.source) return; // disallow empty files
      fs.writeFile(truePath, file.source, err => {
        if (err) return logError(err, ERROR.FS_FILE_WRITE);
      });
      // Log only filename if pulling to root (Code.gs vs ./Code.gs)
      console.log(`└─ ${rootDir ? truePath : filePath}`);
    });
  });
}

/**
 * Pushes project files to script.google.com.
 * @param {boolean} silent If true, doesn't console.log any success message.
 */
export async function pushFiles(silent = false) {
  const { scriptId, rootDir } = await getProjectSettings();
  if (!scriptId) return;
  // TODO Make getProjectFiles async
  getProjectFiles(rootDir, async (err, projectFiles, files = []) => {
    if (err) {
      logError(err, LOG.PUSH_FAILURE);
      spinner.stop(true);
    } else if (projectFiles) {
      const [nonIgnoredFilePaths] = projectFiles;
      // tslint:disable-next-line:no-any
      const filesForAPI: any = files;
      try {
        await script.projects.updateContent({
          scriptId,
          requestBody: {
            scriptId,
            files: filesForAPI,
          },
        });
      } catch (e) {
        console.error(LOG.PUSH_FAILURE);
        console.log(e);
      } finally {
        if (!silent) spinner.stop(true);
        // no error
        if (!silent) {
          nonIgnoredFilePaths.map((filePath: string) => {
            console.log(`└─ ${filePath}`);
          });
          console.log(LOG.PUSH_SUCCESS(nonIgnoredFilePaths.length));
        }
      }
    }
  });
}

1	import * as fs from 'fs';	592✔
2	import * as path from 'path';	592✔
3	import * as mkdirp from 'mkdirp';	592✔
4	import * as multimatch from 'multimatch';	592✔
5	import * as recursive from 'recursive-readdir';	592✔
6	import * as ts from 'typescript';	592✔
7	import { loadAPICredentials, script } from './auth';	592✔
8	import { DOT, DOTFILE } from './dotfile';	592✔
9	import { ERROR, LOG, checkIfOnline, getAPIFileType, getProjectSettings, logError, spinner } from './utils';	592✔
10
11	const ts2gas = require('ts2gas');	592✔
12	const readMultipleFiles = require('read-multiple-files');	592✔
13	const findParentDir = require('find-parent-dir');	592✔
14
15	// An Apps Script API File
16	interface AppsScriptFile {
17	name: string;
18	type: string;
19	source: string;
20	}
21
22	// Used to receive files tracked by current project
23	interface FilesCallback {
24	(error: Error \| boolean, result: string[][] \| null, files: Array<AppsScriptFile \| undefined> \| null): void;
25	}
26
27	/**
28	* Gets the local file type from the API FileType.
29	* @param {string} type The file type returned by Apps Script
30	* @return {string} The file type
31	* @see https://developers.google.com/apps-script/api/reference/rest/v1/File#FileType
32	*/
33	export function getFileType(type: string, fileExtension?: string): string {	592✔
34	return type === 'SERVER_JS' ? fileExtension \|\| 'js' : type.toLowerCase();	128✔
35	}
36
37	/**
38	* Returns true if the user has a clasp project.
39	* @returns {boolean} If .clasp.json exists.
40	*/
41	export function hasProject(): boolean {	592✔
42	return fs.existsSync(DOT.PROJECT.PATH);	96✔
43	}
44
45	/**
46	* Returns in tsconfig.json.
47	* @returns {ts.TranspileOptions} if tsconfig.json not exists, return undefined.
48	*/
49	export function getTranspileOptions(): ts.TranspileOptions{	592✔
50	const projectDirectory: string = findParentDir.sync(process.cwd(), DOT.PROJECT.PATH) \|\| DOT.PROJECT.DIR;	32!
51	const tsconfigPath = path.join(projectDirectory, 'tsconfig.json');	32✔
52	const userConf: ts.TranspileOptions = {};	32✔
53	if(fs.existsSync(tsconfigPath)){	32✔
54	const tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');	24✔
55	const parsedConfigResult = ts.parseConfigFileTextToJson(tsconfigPath, tsconfigContent);	24✔
56	return {	24✔
57	compilerOptions: parsedConfigResult.config.compilerOptions,
58	};
59	}
60	return {};	8✔
61	}
62
63	/**
64	* Recursively finds all files that are part of the current project, and those that are ignored
65	* by .claspignore and calls the passed callback function with the file lists.
66	* @param {string} rootDir The project's root directory
67	* @param {FilesCallBack} callback The callback will be called with the following paramters
68	* error: Error if there's an error, otherwise null
69	* result: string[][], List of two lists of strings, ie. [nonIgnoredFilePaths,ignoredFilePaths]
70	* files?: Array<AppsScriptFile\|undefined> Array of AppsScriptFile objects used by clasp push
71	* @todo Make this function actually return a Promise that can be awaited.
72	*/
73	export async function getProjectFiles(rootDir: string = path.join('.', '/'), callback: FilesCallback) {	592✔
74	const { filePushOrder } = await getProjectSettings();	32✔
75
76	// Load tsconfig
77	const userConf = getTranspileOptions();	32✔
78
79	// Read all filenames as a flattened tree
80	// Note: filePaths contain relative paths such as "test/bar.ts", "../../src/foo.js"
81	recursive(rootDir, (err, filePaths) => {	32✔
82	if (err) return callback(err, null, null);	32!
83	// Filter files that aren't allowed.
84	DOTFILE.IGNORE().then((ignorePatterns: string[]) => {	32✔
85	filePaths = filePaths.sort(); // Sort files alphanumerically	32✔
86	let abortPush = false;	32✔
87	let nonIgnoredFilePaths: string[] = [];	32✔
88	let ignoredFilePaths: string[] = [];	32✔
89	ignoredFilePaths = ignoredFilePaths.concat(ignorePatterns);	32✔
90	// Match the files with ignored glob pattern
91	readMultipleFiles(filePaths, 'utf8', (err: string, contents: string[]) => {	32✔
92	if (err) return callback(new Error(err), null, null);	32!
93	// Check if there are files that will conflict if renamed .gs to .js.
94	// When pushing to Apps Script, these files will overwrite each other.
95	filePaths.map((name: string) => {	32✔
96	const fileNameWithoutExt = name.slice(0, -path.extname(name).length);	132,228✔
97	if (	132,228!
98	filePaths.indexOf(fileNameWithoutExt + '.js') !== -1 &&	213,612✔
99	filePaths.indexOf(fileNameWithoutExt + '.gs') !== -1
100	) {
101	// Can't rename, conflicting files
102	abortPush = true;	×
103	if (path.extname(name) === '.gs') {	×
104	// only print error once (for .gs)
105	logError(null, ERROR.CONFLICTING_FILE_EXTENSION(fileNameWithoutExt));	×
106	}
107	}
108	});
109	if (abortPush) return callback(new Error(), null, null);	32!
110
111	// Replace OS specific path separator to common '/' char for console output
112	filePaths = filePaths.map((name) => name.replace(/\\/g, '/'));	132,228✔
113
114	// check ignore files
115	const ignoreMatches = multimatch(filePaths, ignorePatterns, { dot: true });	32✔
116	const intersection: string[] = filePaths.filter(file => !ignoreMatches.includes(file));	132,228✔
117
118	// Loop through files that are not ignored
119	const files = intersection	32✔
120	.map((name, i) => {
121	const normalizedName = path.normalize(name);	96✔
122
123	let type = getAPIFileType(name);	96✔
124
125	// File source
126	let source = fs.readFileSync(name).toString();	96✔
127	if (type === 'TS') {	96!
128	// Transpile TypeScript to Google Apps Script
129	// @see github.com/grant/ts2gas
130	source = ts2gas(source, userConf);	×
131	type = 'SERVER_JS';	×
132	}
133
134	// Formats rootDir/appsscript.json to appsscript.json.
135	// Preserves subdirectory names in rootDir
136	// (rootDir/foo/Code.js becomes foo/Code.js)
137	const formattedName = getAppsScriptFileName(rootDir, name);	96✔
138
139	// If the file is valid, return the file in a format suited for the Apps Script API.
140	if (isValidFileName(name, type, rootDir, normalizedName, ignoreMatches)) {	96✔
141	nonIgnoredFilePaths.push(name);	56✔
142	const file: AppsScriptFile = {	56✔
143	name: formattedName, // the file base name
144	type, // the file extension
145	source, //the file contents
146	};
147	return file;	56✔
148	} else {
149	ignoredFilePaths.push(name);	40✔
150	return; // Skip ignored files	40✔
151	}
152	})
153	.filter(Boolean); // remove null values
154
155	// This statement customizes the order in which the files are pushed.
156	// It puts the files in the setting's filePushOrder first.
157	// This is needed because Apps Script blindly executes files in order of creation time.
158	// The Apps Script API updates the creation time of files.
159	if (filePushOrder) {	32!
160	spinner.stop(true);	×
161	console.log('Detected filePushOrder setting. Pushing these files first:');	×
162	filePushOrder.map(file => {	×
163	console.log(`└─ ${file}`);	×
164	});
165	console.log('');	×
166	nonIgnoredFilePaths = nonIgnoredFilePaths.sort((path1: string, path2: string) => {	×
167	// Get the file order index
168	let path1Index = filePushOrder.indexOf(path1);	×
169	let path2Index = filePushOrder.indexOf(path2);	×
170	// If a file path isn't in the filePushOrder array, set the order to -∞.
171	path1Index = path1Index === -1 ? Number.NEGATIVE_INFINITY : path1Index;	×
172	path2Index = path2Index === -1 ? Number.NEGATIVE_INFINITY : path2Index;	×
173	return path2Index - path1Index;	×
174	});
175	}
176
177	callback(false, [nonIgnoredFilePaths, ignoredFilePaths], files);	32✔
178	});
179	});
180	});
181	}
182
183	/**
184	* If the file is valid, add it to our file list.
185	* We generally want to allow for all file types, including files in node_modules/.
186	* However, node_modules/@types/ files should be ignored.
187	*/
188	export function isValidFileName(name: string,	592✔
189	type: string,
190	rootDir: string,
191	normalizedName: string,
192	ignoreMatches: string[]): boolean {
193	let valid = true; // Valid by default, until proven otherwise.	144✔
194	// Has a type or is appsscript.json
195	let isValidJSONIfJSON = true;	144✔
196	if (type === 'JSON') {	144✔
197	if (rootDir) {	40!
198	isValidJSONIfJSON = normalizedName === path.join(rootDir, 'appsscript.json');	40✔
199	} else {
200	isValidJSONIfJSON = name === 'appsscript.json';	×
201	}
202	} else {
203	// Must be SERVER_JS or HTML.
204	// https://developers.google.com/apps-script/api/reference/rest/v1/File
205	valid = type === 'SERVER_JS' \|\| type === 'HTML';	104✔
206	}
207	// Prevent node_modules/@types/
208	if (name.includes('node_modules/@types')) {	144✔
209	return false;	8✔
210	}
211	const validType = type && isValidJSONIfJSON;	136✔
212	const notIgnored = !ignoreMatches.includes(name);	136✔
213	valid = !!(valid && validType && notIgnored);	136✔
214	return valid;	136✔
215	}
216
217	/**
218	* Gets the name of the file for Apps Script.
219	* Formats rootDir/appsscript.json to appsscript.json.
220	* Preserves subdirectory names in rootDir
221	* (rootDir/foo/Code.js becomes foo/Code.js)
222	* @param {string} rootDir The directory to save the project files to.
223	* @param {string} filePath Path of file that is part of the current project
224	*/
225	export function getAppsScriptFileName(rootDir: string, filePath: string) {	592✔
226	const nameWithoutExt = filePath.slice(0, -path.extname(filePath).length);	128✔
227	let fullFilePathNoExt = rootDir ? path.relative(rootDir, nameWithoutExt) : nameWithoutExt;	128✔
228	// Replace OS specific path separator to common '/' char
229	fullFilePathNoExt = fullFilePathNoExt.replace(/\\/g, '/');	128✔
230	return fullFilePathNoExt;	128✔
231	}
232
233	/**
234	* Fetches the files for a project from the server
235	* @param {string} scriptId The project script id
236	* @param {number?} versionNumber The version of files to fetch.
237	* @returns {AppsScriptFile[]} Fetched files
238	*/
239	export async function fetchProject(	592✔
240	scriptId: string,
241	versionNumber?: number,
242	silent = false,	88✔
243	): Promise<AppsScriptFile[]> {
244	await checkIfOnline();	48✔
245	await loadAPICredentials();	48✔
246	spinner.start();	48✔
247	let res;
248	try {
249	res = await script.projects.getContent({	48✔
250	scriptId,
251	versionNumber,
252	});
253	} catch (error) {
254	if (error.statusCode === 404) {	8!
255	throw Error(ERROR.SCRIPT_ID_INCORRECT(scriptId));	×
256	}
257	throw Error(ERROR.SCRIPT_ID);	8✔
258	}
259	spinner.stop(true);	40✔
260	const data = res.data;	40✔
261	if (!data.files) throw Error(ERROR.SCRIPT_ID_INCORRECT(scriptId));	40!
262	if (!silent) console.log(LOG.CLONE_SUCCESS(data.files.length));	40✔
263	return data.files as AppsScriptFile[];	40✔
264	}
265
266	/**
267	* Writes files locally to `pwd` with dots converted to subdirectories.
268	* @param {AppsScriptFile[]} Files to wirte
269	* @param {string?} rootDir The directory to save the project files to. Defaults to `pwd`
270	*/
271	export async function writeProjectFiles(files: AppsScriptFile[], rootDir = '') {	592!
272	const { fileExtension } = await getProjectSettings();	32✔
273	const sortedFiles = files.sort((file1, file2) => file1.name.localeCompare(file2.name));	32✔
274	sortedFiles.map((file: AppsScriptFile) => {	32✔
275	const filePath = `${file.name}.${getFileType(file.type, fileExtension)}`;	64✔
276	const truePath = `${rootDir \|\| '.'}/${filePath}`;	64✔
277	mkdirp(path.dirname(truePath), err => {	64✔
278	if (err) return logError(err, ERROR.FS_DIR_WRITE);	64!
279	if (!file.source) return; // disallow empty files	64!
280	fs.writeFile(truePath, file.source, err => {	64✔
281	if (err) return logError(err, ERROR.FS_FILE_WRITE);	64!
282	});
283	// Log only filename if pulling to root (Code.gs vs ./Code.gs)
284	console.log(`└─ ${rootDir ? truePath : filePath}`);	64!
285	});
286	});
287	}
288
289	/**
290	* Pushes project files to script.google.com.
291	* @param {boolean} silent If true, doesn't console.log any success message.
292	*/
293	export async function pushFiles(silent = false) {	592!
294	const { scriptId, rootDir } = await getProjectSettings();	8✔
295	if (!scriptId) return;	8!
296	// TODO Make getProjectFiles async
297	getProjectFiles(rootDir, async (err, projectFiles, files = []) => {	8!
298	if (err) {	8✔
299	logError(err, LOG.PUSH_FAILURE);	×
300	spinner.stop(true);	×
301	} else if (projectFiles) {	×
302	const [nonIgnoredFilePaths] = projectFiles;	8✔
303	// tslint:disable-next-line:no-any
304	const filesForAPI: any = files;	8✔
305	try {
306	await script.projects.updateContent({	8✔
307	scriptId,
308	requestBody: {
309	scriptId,
310	files: filesForAPI,
311	},
312	});
313	} catch (e) {
314	console.error(LOG.PUSH_FAILURE);	×
315	console.log(e);	×
316	} finally {
317	if (!silent) spinner.stop(true);	8!
318	// no error
319	if (!silent) {	8!
320	nonIgnoredFilePaths.map((filePath: string) => {	8✔
321	console.log(`└─ ${filePath}`);	16✔
322	});
323	console.log(LOG.PUSH_SUCCESS(nonIgnoredFilePaths.length));	8✔
324	}
325	}
326	}
327	});
328	}

google / clasp / 897

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