fs/lib/resourceFactory.js

  1. const log = require("@ui5/logger").getLogger("resources:resourceFactory");
  2. const path = require("path");
  3. const FsAdapter = require("./adapters/FileSystem");
  4. const MemAdapter = require("./adapters/Memory");
  5. const ReaderCollection = require("./ReaderCollection");
  6. const ReaderCollectionPrioritized = require("./ReaderCollectionPrioritized");
  7. const DuplexCollection = require("./DuplexCollection");
  8. const Resource = require("./Resource");
  9. const hasOwnProperty = Object.prototype.hasOwnProperty;
  11. /**
  12.  * Resource Factory
  13.  *
  14.  * @public
  15.  * @namespace
  16.  * @alias module:@ui5/fs.resourceFactory
  17.  */
  18. const resourceFactory = {
  19. 	/**
  20. 	* Callback to retrieve excludes for a given project
  21. 	*
  22. 	* @public
  23. 	* @callback module:@ui5/fs.resourceFactory~getProjectExcludes
  24. 	* @param {object} Project
  25. 	* @returns {string[]} List of glob patterns to exclude
  26. 	*/
  28. 	/**
  29. 	* Callback to retrieve a prefix to use for a given virtual base path of a project
  30. 	*
  31. 	* @public
  32. 	* @callback module:@ui5/fs.resourceFactory~getVirtualBasePathPrefix
  33. 	* @param {object} parameters Parameters
  34. 	* @param {object} parameters.project Project
  35. 	* @param {object} parameters.virBasePath virtual base path to prefix
  36. 	* @returns {string} Prefix for the virtual base path
  37. 	*/
  39. 	/**
  40. 	 * Creates resource reader collections for a (sub-)tree. Returns an object of resource readers:
  41. 	 * <pre>
  42. 	 * {
  43. 	 *  source: Resource reader for source resources
  44. 	 *  dependencies: Resource readers for dependency resources
  45. 	 * }
  46. 	 * </pre>
  47. 	 *
  48. 	 * @public
  49. 	 * @param {object} tree A (sub-)tree
  50. 	 * @param {object} [parameters] Parameters
  51. 	 * @param {module:@ui5/fs.resourceFactory~getProjectExcludes} [parameters.getProjectExcludes]
  52. 	 *						Callback to retrieve the exclude globs of a project
  53. 	 * @param {module:@ui5/fs.resourceFactory~getVirtualBasePathPrefix} [parameters.getVirtualBasePathPrefix]
  54. 	 *						Callback to retrieve a prefix for a given virtual base path of a project if required
  55. 	 * @param {object} [parameters.virtualReaders] Experimental, internal parameter. Do not use
  56. 	 * @returns {object} Object containing <code>source</code> and <code>dependencies</code> resource readers
  57. 	 */
  58. 	createCollectionsForTree(tree, {
  59. 		getProjectExcludes, getVirtualBasePathPrefix, virtualReaders={}
  60. 	} = {}) {
  61. 		// TODO 3.0: virtualReaders is private API. The virtual reader of a project should be stored on the
  62. 		//	project itself. This requires projects to become objects independent from the dependency tree.
  63. 		//	Also see: https://github.com/SAP/ui5-project/issues/122
  65. 		const dependencyCollection = [];
  66. 		const dependencyPathIndex = {};
  67. 		const virtualReaderIndex = {};
  68. 		const sourceResourceLocators = [];
  70. 		function processDependencies(project) {
  71. 			if (project.resources && project.resources.pathMappings) {
  72. 				const fsAdapters = [];
  73. 				for (const virBasePath in project.resources.pathMappings) {
  74. 					if (hasOwnProperty.call(project.resources.pathMappings, virBasePath)) {
  75. 						// Prevent duplicate dependency resource locators
  76. 						const fsPath = project.resources.pathMappings[virBasePath];
  77. 						const fsBasePath = path.join(project.path, fsPath);
  78. 						const key = virBasePath + fsBasePath;
  79. 						if (dependencyPathIndex[key]) {
  80. 							continue;
  81. 						}
  82. 						dependencyPathIndex[key] = true;
  84. 						// Create an fs adapter for every path mapping
  85. 						const fsAdapter = resourceFactory._createFsAdapterForVirtualBasePath({
  86. 							project,
  87. 							virBasePath,
  88. 							getProjectExcludes,
  89. 							getVirtualBasePathPrefix
  90. 						});
  91. 						fsAdapters.push(fsAdapter);
  92. 					}
  93. 				}
  95. 				if (!virtualReaderIndex[project.metadata.name] && virtualReaders[project.metadata.name]) {
  96. 					// Mix-in virtual reader of dependency if available and not already added
  97. 					virtualReaderIndex[project.metadata.name] = true;
  98. 					const virtualReader = virtualReaders[project.metadata.name];
  99. 					const readerCollection = new ReaderCollectionPrioritized({
  100. 						name: `fs & vir reader collection for project ${project.metadata.name}`,
  101. 						readers: [virtualReader, ...fsAdapters]
  102. 					});
  103. 					dependencyCollection.push(readerCollection);
  104. 				} else {
  105. 					dependencyCollection.push(...fsAdapters);
  106. 				}
  107. 			}
  109. 			project.dependencies.forEach(function(depProject) {
  110. 				processDependencies(depProject);
  111. 			});
  112. 		}
  114. 		if (tree.resources && tree.resources.pathMappings) {
  115. 			for (const virBasePath in tree.resources.pathMappings) {
  116. 				if (hasOwnProperty.call(tree.resources.pathMappings, virBasePath)) {
  117. 					// Create an fs adapter for every path mapping
  118. 					const fsAdapter = resourceFactory._createFsAdapterForVirtualBasePath({
  119. 						project: tree,
  120. 						virBasePath,
  121. 						getProjectExcludes,
  122. 						getVirtualBasePathPrefix
  123. 					});
  124. 					sourceResourceLocators.push(fsAdapter);
  125. 				}
  126. 			}
  127. 		}
  129. 		tree.dependencies.forEach(function(project) {
  130. 			processDependencies(project);
  131. 		});
  133. 		const source = new ReaderCollection({
  134. 			name: "source of " + tree.metadata.name,
  135. 			readers: sourceResourceLocators
  136. 		});
  137. 		const dependencies = new ReaderCollection({
  138. 			name: "dependencies of " + tree.metadata.name,
  139. 			readers: dependencyCollection
  140. 		});
  141. 		return {
  142. 			source,
  143. 			dependencies
  144. 		};
  145. 	},
  147. 	/**
  148. 	 * Creates a FileSystem adapter mapping to the given virtual base path based on the given projects
  149. 	 * configuration.
  150. 	 *
  151. 	 * @param {object} parameters Parameters
  152. 	 * @param {Project} parameters.project A project
  153. 	 * @param {string} parameters.virBasePath Virtual base path to create the adapter for
  154. 	 * @param {module:@ui5/fs.resourceFactory~getProjectExcludes} [parameters.getProjectExcludes]
  155. 	 *												Callback to retrieve the exclude glob of a project
  156. 	 * @param {module:@ui5/fs.resourceFactory~getVirtualBasePathPrefix} [parameters.getVirtualBasePathPrefix]
  157. 	 *												Callback to retrieve the exclude glob of a project
  158. 	 * @returns {Promise<string[]>} Promise resolving to list of normalized glob patterns
  159. 	 */
  160. 	_createFsAdapterForVirtualBasePath({
  161. 		project, virBasePath, getProjectExcludes, getVirtualBasePathPrefix
  162. 	}) {
  163. 		const fsPath = project.resources.pathMappings[virBasePath];
  164. 		const fsBasePath = path.join(project.path, fsPath);
  166. 		let pathExcludes;
  167. 		if (getProjectExcludes) {
  168. 			pathExcludes = getProjectExcludes(project);
  169. 		}
  171. 		if (getVirtualBasePathPrefix) {
  172. 			const virBasePathPrefix = getVirtualBasePathPrefix({project, virBasePath});
  173. 			if (virBasePathPrefix) {
  174. 				log.verbose(`Prefixing virtual base path ${virBasePath} of project ${project.metadata.name} ` +
  175. 					`${virBasePathPrefix}...`);
  176. 				virBasePath = virBasePathPrefix + virBasePath;
  177. 				log.verbose(`New virtual base path: ${virBasePath}`);
  179. 				if (pathExcludes) {
  180. 					const normalizedPatterns = pathExcludes.map((pattern) => {
  181. 						return resourceFactory._prefixGlobPattern(pattern, virBasePathPrefix);
  182. 					});
  183. 					pathExcludes = Array.prototype.concat.apply([], normalizedPatterns);
  184. 				}
  185. 			}
  186. 		}
  188. 		return resourceFactory.createAdapter({
  189. 			fsBasePath,
  190. 			virBasePath,
  191. 			excludes: pathExcludes,
  192. 			project
  193. 		});
  194. 	},
  196. 	/**
  197. 	 * Normalizes virtual glob patterns by prefixing them with
  198. 	 * a given virtual base directory path
  199. 	 *
  200. 	 * @param {string} virPattern glob pattern for virtual directory structure
  201. 	 * @param {string} virBaseDir virtual base directory path to prefix the given patterns with
  202. 	 * @returns {Promise<string[]>} Promise resolving to list of normalized glob patterns
  203. 	 */
  204. 	_prefixGlobPattern(virPattern, virBaseDir) {
  205. 		const minimatch = require("minimatch");
  206. 		const mm = new minimatch.Minimatch(virPattern);
  208. 		const resultGlobs = [];
  209. 		for (let i = 0; i < mm.globSet.length; i++) {
  210. 			let resultPattern = path.posix.join(virBaseDir, mm.globSet[i]);
  212. 			if (mm.negate) {
  213. 				resultPattern = "!" + resultPattern;
  214. 			}
  215. 			resultGlobs.push(resultPattern);
  216. 		}
  217. 		return resultGlobs;
  218. 	},
  220. 	/**
  221. 	 * Creates a resource <code>ReaderWriter</code>.
  222. 	 *
  223. 	 * If a file system base path is given, file system resource <code>ReaderWriter</code> is returned.
  224. 	 * In any other case a virtual one.
  225. 	 *
  226. 	 * @public
  227. 	 * @param {object} parameters Parameters
  228. 	 * @param {string} parameters.virBasePath Virtual base path
  229. 	 * @param {string} [parameters.fsBasePath] File system base path
  230. 	 * @param {string[]} [parameters.excludes] List of glob patterns to exclude
  231. 	 * @param {object} [parameters.project] Experimental, internal parameter. Do not use
  232. 	 * @returns {module:@ui5/fs.adapters.FileSystem|module:@ui5/fs.adapters.Memory} File System- or Virtual Adapter
  233. 	 */
  234. 	createAdapter({fsBasePath, virBasePath, project, excludes}) {
  235. 		if (fsBasePath) {
  236. 			return new FsAdapter({fsBasePath, virBasePath, project, excludes});
  237. 		} else {
  238. 			return new MemAdapter({virBasePath, project, excludes});
  239. 		}
  240. 	},
  243. 	/**
  244. 	 * Creates a <code>Resource</code>. Accepts the same parameters as the Resource constructor.
  245. 	 *
  246. 	 * @public
  247. 	 * @param {object} parameters Parameters to be passed to the resource constructor
  248. 	 * @returns {module:@ui5/fs.Resource} Resource
  249. 	 */
  250. 	createResource(parameters) {
  251. 		return new Resource(parameters);
  252. 	},
  254. 	/**
  255. 	 * Creates a Workspace
  256. 	 *
  257. 	 * A workspace is a DuplexCollection which reads from the project sources. It is used during the build process
  258. 	 * to write modified files into a separate writer, this is usually a Memory adapter. If a file already exists it is
  259. 	 * fetched from the memory to work on it in further build steps.
  260. 	 *
  261. 	 * @public
  262. 	 * @param {object} parameters
  263. 	 * @param {module:@ui5/fs.AbstractReader} parameters.reader Single reader or collection of readers
  264. 	 * @param {module:@ui5/fs.AbstractReaderWriter} [parameters.writer] A ReaderWriter instance which is
  265. 	 *							only used for writing files. If not supplied, a Memory adapter will be created.
  266. 	 * @param {string} [parameters.name="vir & fs source"] Name of the collection
  267. 	 * @param {string} [parameters.virBasePath="/"] Virtual base path
  268. 	 * @returns {module:@ui5/fs.DuplexCollection} DuplexCollection which wraps the provided resource locators
  269. 	 */
  270. 	createWorkspace({reader, writer, virBasePath = "/", name = "vir & fs source"}) {
  271. 		if (!writer) {
  272. 			writer = new MemAdapter({
  273. 				virBasePath
  274. 			});
  275. 		}
  277. 		return new DuplexCollection({
  278. 			reader,
  279. 			writer,
  280. 			name
  281. 		});
  282. 	}
  283. };
  285. module.exports = resourceFactory;