6107141959

Committed 07 Sep 2023 08:11AM UTC coverage: 82.853% (+0.2%) from 82.683%

Build # 6107141959

Build Type

push

github

Committed by

web-flow

Commit Message

Use Asynchronous Code for Loading Modules (#1471)

* Add async loading code

* Made infinite loop checking async

* Update stepper to be async

* Add assert and misc utils

* Update transpiler to be async

* Update runners

* Add new import options

* Ignore tests during typechecking

* Relocate typeguards

* Update with assertions and typeguards

* Update repl transpiler to be async

* Abstract out module context initialization and tab loading

* Renamed promise timeout error and added tests

* Remove old code

* Update options

* Add files to avoid line ending issues

* Use POSIX paths on Windows systems

* Ran format

* Update eslint rules to follow exclusion of tests

* Incorporate changes for posix path handling

* Minor change to resolve certain webpack issues with the frontend

* Use a different posix path import

* Allow loading of export default tabs

* Refactor collation of import declarations

---------

Co-authored-by: Ian Yong <ianyongyc@gmail.com>

Run Details

3629 of 4814 branches covered (0.0%)

Branch coverage included in aggregate %.

266 of 266 new or added lines in 25 files covered. (100.0%)

10886 of 12705 relevant lines covered (85.68%)

96881.51 hits per line

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

71.25

/src/modules/moduleLoader.ts

import es from 'estree'
import { memoize } from 'lodash'
import { XMLHttpRequest as NodeXMLHttpRequest } from 'xmlhttprequest-ts'

import {
  ModuleConnectionError,
  ModuleInternalError,
  ModuleNotFoundError
} from '../errors/moduleErrors'
import { Context } from '../types'
import { wrapSourceModule } from '../utils/operators'
import { ModuleBundle, ModuleDocumentation, ModuleFunctions, ModuleManifest } from './moduleTypes'
import { getRequireProvider } from './requireProvider'
import { evalRawTab } from './utils'

// Supports both JSDom (Web Browser) environment and Node environment
export const newHttpRequest = () =>
  typeof window === 'undefined' ? new NodeXMLHttpRequest() : new XMLHttpRequest()

// Default modules static url. Exported for testing.
export let MODULES_STATIC_URL = 'https://source-academy.github.io/modules'

export function setModulesStaticURL(url: string) {
  MODULES_STATIC_URL = url
}

/**
 * Send a HTTP Get request to the specified endpoint.
 * @return NodeXMLHttpRequest | XMLHttpRequest
 */
export function httpGet(url: string): string {
  const request = newHttpRequest()
  try {
    // If running function in node environment, set request timeout
    if (typeof window === 'undefined') request.timeout = 10000
    request.open('GET', url, false)
    request.send(null)
  } catch (error) {
    if (!(error instanceof DOMException)) throw error
  }
  if (request.status !== 200 && request.status !== 304) throw new ModuleConnectionError()
  return request.responseText
}

/**
 * Send a HTTP GET request to the modules endpoint to retrieve the manifest
 * @return Modules
 */
export const memoizedGetModuleManifest = memoize(getModuleManifest)
function getModuleManifest(): ModuleManifest {
  const rawManifest = httpGet(`${MODULES_STATIC_URL}/modules.json`)
  return JSON.parse(rawManifest)
}

/**
 * Send a HTTP GET request to the modules endpoint to retrieve the specified file
 * @return String of module file contents
 */

const memoizedGetModuleFileInternal = memoize(getModuleFile)
export const memoizedGetModuleFile = (name: string, type: 'tab' | 'bundle' | 'json') =>
  memoizedGetModuleFileInternal({ name, type })
function getModuleFile({ name, type }: { name: string; type: 'tab' | 'bundle' | 'json' }): string {
  return httpGet(`${MODULES_STATIC_URL}/${type}s/${name}.js${type === 'json' ? 'on' : ''}`)
}

/**
 * Loads the respective module package (functions from the module)
 * @param path imported module name
 * @param context
 * @param node import declaration node
 * @returns the module's functions object
 */
export function loadModuleBundle(path: string, context: Context, node?: es.Node): ModuleFunctions {
  const modules = memoizedGetModuleManifest()

  // Check if the module exists
  const moduleList = Object.keys(modules)
  if (moduleList.includes(path) === false) throw new ModuleNotFoundError(path, node)

  // Get module file
  const moduleText = memoizedGetModuleFile(path, 'bundle')
  try {
    const moduleBundle: ModuleBundle = eval(moduleText)
    return wrapSourceModule(path, moduleBundle, getRequireProvider(context))
  } catch (error) {
    // console.error("bundle error: ", error)
    throw new ModuleInternalError(path, error, node)
  }
}

/**
 * Loads the module contents of a package
 *
 * @param path imported module name
 * @param node import declaration node
 * @returns an array of functions
 */
export function loadModuleTabs(path: string, node?: es.Node) {
  const modules = memoizedGetModuleManifest()
  // Check if the module exists
  const moduleList = Object.keys(modules)
  if (moduleList.includes(path) === false) throw new ModuleNotFoundError(path, node)

  // Retrieves the tabs the module has from modules.json
  const sideContentTabPaths: string[] = modules[path].tabs
  // Load the tabs for the current module
  return sideContentTabPaths.map(path => {
    const rawTabFile = memoizedGetModuleFile(path, 'tab')
    try {
      return evalRawTab(rawTabFile)
    } catch (error) {
      // console.error('tab error:', error);
      throw new ModuleInternalError(path, error, node)
    }
  })
}

export const memoizedloadModuleDocs = memoize(loadModuleDocs)
export function loadModuleDocs(path: string, node?: es.Node) {
  try {
    const modules = memoizedGetModuleManifest()
    // Check if the module exists
    const moduleList = Object.keys(modules)
    if (!moduleList.includes(path)) throw new ModuleNotFoundError(path, node)
    const result = getModuleFile({ name: path, type: 'json' })
    return JSON.parse(result) as ModuleDocumentation
  } catch (error) {
    console.warn('Failed to load module documentation')
    return null
  }
}

export function initModuleContext(
  moduleName: string,
  context: Context,
  loadTabs: boolean,
  node?: es.Node
) {
  if (!(moduleName in context.moduleContexts)) {
    context.moduleContexts[moduleName] = {
      state: null,
      tabs: loadTabs ? loadModuleTabs(moduleName, node) : null
    }
  } else if (context.moduleContexts[moduleName].tabs === null && loadTabs) {
    context.moduleContexts[moduleName].tabs = loadModuleTabs(moduleName, node)
  }
}

1	import es from 'estree'
2	import { memoize } from 'lodash'	66✔
3	import { XMLHttpRequest as NodeXMLHttpRequest } from 'xmlhttprequest-ts'	66✔
4
5	import {	66✔
6	ModuleConnectionError,
7	ModuleInternalError,
8	ModuleNotFoundError
9	} from '../errors/moduleErrors'
10	import { Context } from '../types'
11	import { wrapSourceModule } from '../utils/operators'	66✔
12	import { ModuleBundle, ModuleDocumentation, ModuleFunctions, ModuleManifest } from './moduleTypes'
13	import { getRequireProvider } from './requireProvider'	66✔
14	import { evalRawTab } from './utils'	66✔
15
16	// Supports both JSDom (Web Browser) environment and Node environment
17	export const newHttpRequest = () =>	66✔
18	typeof window === 'undefined' ? new NodeXMLHttpRequest() : new XMLHttpRequest()	24!
19
20	// Default modules static url. Exported for testing.
21	export let MODULES_STATIC_URL = 'https://source-academy.github.io/modules'	66✔
22
23	export function setModulesStaticURL(url: string) {	66✔
24	MODULES_STATIC_URL = url	1✔
25	}
26
27	/**
28	* Send a HTTP Get request to the specified endpoint.
29	* @return NodeXMLHttpRequest \| XMLHttpRequest
30	*/
31	export function httpGet(url: string): string {	66✔
32	const request = newHttpRequest()	23✔
33	try {	23✔
34	// If running function in node environment, set request timeout
35	if (typeof window === 'undefined') request.timeout = 10000	23!
36	request.open('GET', url, false)	23✔
37	request.send(null)	23✔
38	} catch (error) {
39	if (!(error instanceof DOMException)) throw error	×
40	}
41	if (request.status !== 200 && request.status !== 304) throw new ModuleConnectionError()	23✔
42	return request.responseText	22✔
43	}
44
45	/**
46	* Send a HTTP GET request to the modules endpoint to retrieve the manifest
47	* @return Modules
48	*/
49	export const memoizedGetModuleManifest = memoize(getModuleManifest)	66✔
50	function getModuleManifest(): ModuleManifest {
51	const rawManifest = httpGet(`${MODULES_STATIC_URL}/modules.json`)	9✔
52	return JSON.parse(rawManifest)	9✔
53	}
54
55	/**
56	* Send a HTTP GET request to the modules endpoint to retrieve the specified file
57	* @return String of module file contents
58	*/
59
60	const memoizedGetModuleFileInternal = memoize(getModuleFile)	66✔
61	export const memoizedGetModuleFile = (name: string, type: 'tab' \| 'bundle' \| 'json') =>	66✔
62	memoizedGetModuleFileInternal({ name, type })	12✔
63	function getModuleFile({ name, type }: { name: string; type: 'tab' \| 'bundle' \| 'json' }): string {
64	return httpGet(`${MODULES_STATIC_URL}/${type}s/${name}.js${type === 'json' ? 'on' : ''}`)	12!
65	}
66
67	/**
68	* Loads the respective module package (functions from the module)
69	* @param path imported module name
70	* @param context
71	* @param node import declaration node
72	* @returns the module's functions object
73	*/
74	export function loadModuleBundle(path: string, context: Context, node?: es.Node): ModuleFunctions {	66✔
75	const modules = memoizedGetModuleManifest()	4✔
76
77	// Check if the module exists
78	const moduleList = Object.keys(modules)	4✔
79	if (moduleList.includes(path) === false) throw new ModuleNotFoundError(path, node)	4!
80
81	// Get module file
82	const moduleText = memoizedGetModuleFile(path, 'bundle')	4✔
83	try {	4✔
84	const moduleBundle: ModuleBundle = eval(moduleText)	4✔
85	return wrapSourceModule(path, moduleBundle, getRequireProvider(context))	3✔
86	} catch (error) {
87	// console.error("bundle error: ", error)
88	throw new ModuleInternalError(path, error, node)	1✔
89	}
90	}
91
92	/**
93	* Loads the module contents of a package
94	*
95	* @param path imported module name
96	* @param node import declaration node
97	* @returns an array of functions
98	*/
99	export function loadModuleTabs(path: string, node?: es.Node) {	66✔
100	const modules = memoizedGetModuleManifest()	5✔
101	// Check if the module exists
102	const moduleList = Object.keys(modules)	5✔
103	if (moduleList.includes(path) === false) throw new ModuleNotFoundError(path, node)	5!
104
105	// Retrieves the tabs the module has from modules.json
106	const sideContentTabPaths: string[] = modules[path].tabs	5✔
107	// Load the tabs for the current module
108	return sideContentTabPaths.map(path => {	5✔
109	const rawTabFile = memoizedGetModuleFile(path, 'tab')	6✔
110	try {	6✔
111	return evalRawTab(rawTabFile)	6✔
112	} catch (error) {
113	// console.error('tab error:', error);
114	throw new ModuleInternalError(path, error, node)	1✔
115	}
116	})
117	}
118
119	export const memoizedloadModuleDocs = memoize(loadModuleDocs)	66✔
120	export function loadModuleDocs(path: string, node?: es.Node) {	66✔
121	try {	×
122	const modules = memoizedGetModuleManifest()	×
123	// Check if the module exists
124	const moduleList = Object.keys(modules)	×
125	if (!moduleList.includes(path)) throw new ModuleNotFoundError(path, node)	×
126	const result = getModuleFile({ name: path, type: 'json' })	×
127	return JSON.parse(result) as ModuleDocumentation	×
128	} catch (error) {
129	console.warn('Failed to load module documentation')	×
130	return null	×
131	}
132	}
133
134	export function initModuleContext(	66✔
135	moduleName: string,
136	context: Context,
137	loadTabs: boolean,
138	node?: es.Node
139	) {
140	if (!(moduleName in context.moduleContexts)) {	2!
141	context.moduleContexts[moduleName] = {	2✔
142	state: null,
143	tabs: loadTabs ? loadModuleTabs(moduleName, node) : null	2!
144	}
145	} else if (context.moduleContexts[moduleName].tabs === null && loadTabs) {	×
146	context.moduleContexts[moduleName].tabs = loadModuleTabs(moduleName, node)	×
147	}
148	}

source-academy / js-slang / 6107141959

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