There are no dedicated showcase example pages for the Uize.Build.Util module.

SEARCH FOR EXAMPLES

Use the link below to search for example pages on the UIZE Web site that reference the Uize.Build.Util module...

SEARCH

The Uize.Build.Util module defines the Uize.Build.Util package under the Uize.Build namespace.

1.2.1. Features Introduced in This Module

1.2.2. Features Overridden in This Module

1.2.3. Features Inherited From Other Modules

1.2.4. Modules Directly Under This Namespace

1.2.5. Unit Tests

A regular expression that is used in determining source files for JavaScript modules.

This regular expression matches files with any of the file extensions contained in the Uize.Build.Util.jsModuleExtensions array.

NOTES

IMPLEMENTATION INFO

An array, containing a list of the file extensions for the source files from which JavaScript modules are built.

This list includes the string elements...

NOTES

IMPLEMENTATION INFO

IMPLEMENTATION INFO

IMPLEMENTATION INFO

Facilitates iterating through a folder hierarchy, processing specific files, and writing the results of processing to a specified log file.

SYNTAX

Uize.Build.Util.buildFiles ({
  targetFolderPathCreator:targetFolderPathCreatorFUNC,  // REQUIRED
  targetFilenameCreator:targetFilenameCreatorFUNC,      // REQUIRED
  fileBuilder:fileBuilderFUNC,                          // REQUIRED

  rootFolderPath:rootFolderPathSTR,                     // optional
  alwaysBuild:alwaysBuildBOOL,                          // optional
  doNotEnter:doNotEnterARRAYorREGEXP,                   // optional
  logFilePath:logFilePathSTR                            // optional
});

This method starts iterating through files in the folder that contains the build script being executed and then recursively iterates through subfolders.

3.1.1. targetFolderPathCreator

3.1.2. targetFilenameCreator

3.1.3. fileBuilder

3.1.4. rootFolderPath

3.1.5. alwaysBuild

3.1.6. doNotEnter

3.1.7. logFilePath

IMPLEMENTATION INFO

Returns a template function, compiled from the specified JST (.jst) template file.

SYNTAX

templateFUNC = Uize.Build.Util.compileJstFile (jstTemplatePathSTR);

This method caches the compiled template function so that, if multiple requests are made to compile the same template file, the file is only read and the template compiled once. Any modules that are required by the template, using the @required template directive, are required so that the template function returned by this method is safe to call. If the specified JST template file does not exist, then the method returns the value undefined.

IMPLEMENTATION INFO

Returns a string, being the text for a data module wrapper for the specified data.

SYNTAX

moduleTextSTR = Uize.Build.Util.dataAsModule (moduleNameSTR,moduleDataANYTYPE);

This method first serializes the data specified by the moduleDataANYTYPE parameter, after which it wraps this serialized data in the form of a data module and then returns the text serialization of this module. If this text were then to be written to a file under the modules folder of a project, then it could be required by the name specified in the moduleNameSTR parameter.

NOTES

IMPLEMENTATION INFO

Returns an object, providing information about the specified HTML file.

SYNTAX

htmlFileInfoOBJ = Uize.Build.Util.getHtmlFileInfo (filePathSTR,titleExtractorFUNC);

This method returns an object containing the following properties...

NOTES

IMPLEMENTATION INFO

Returns an array of objects, representing the file info for all the HTML files in the specified folder.

SYNTAX

htmlFilesInfoARRAY = Uize.Build.Util.getHtmlFilesInfo (folderToIndexPathSTR,titleExtractorFUNC);

The returned array is sorted by the titles of the files, as represented by the title property of the file info objects and lowercased so that the sort is case-insensitive. This method uses the related Uize.Build.Util.getHtmlFileInfo method in its implementation to generate the info object for each file, so you can refer to the documentation for that method for more info on the contents of the file info objects.

Files are only considered to be HTML files if their filenames have a .html file extension. Files whose filenames begin with a "~" (tilde) character are excluded from the list, as this prefix is used to indicate files that are not yet ready for prime time and that should be ignored by certain build processes.

NOTES

IMPLEMENTATION INFO

Returns a string array, containing the module names of all the TODO files (files with a .todo file extension) under the modules folder of the project.

SYNTAX

jsModuleTodosARRAY = Uize.Build.Util.getJsModuleTodos (paramsOBJ);

IMPLEMENTATION INFO

Returns an array, containing the names of all the UIZE modules.

SYNTAX

jsModulesARRAY = Uize.Build.Util.getJsModules (paramsOBJ);

The array of module names returned by this method will include modules that are built from various non-JavaScript source files (such as CSS template files with the .csst file extension). For a comprehensive list of such source file types, consult the reference for the Uize.Build.Util.jsModuleExtensions static property.

3.7.1. Params

IMPLEMENTATION INFO

Returns a string, containing zero or more "../" (back folder) path segments, representing a relative path from the specified relative path back to the root.

SYNTAX

pathToRootSTR = Uize.Build.Util.getPathToRoot (relativePathSTR);

This method is used by build scripts that build pages for nested sections of a site that may have links that are root-absolute and need to be converted to paths that are relative to the document being built. The implementation is very basic (i.e. non-robust) and simply counts all the slashes in the specified path and builds a prefix with that many "../" (back folder) segments.

EXAMPLES

Uize.Build.Util.getPathToRoot ('foo.html');              // returns ''
Uize.Build.Util.getPathToRoot ('foo/bar.html');          // returns '../'
Uize.Build.Util.getPathToRoot ('foo/bar/baz.html');      // returns '../../'
Uize.Build.Util.getPathToRoot ('foo/bar/baz/qux.html');  // returns '../../../'

IMPLEMENTATION INFO

Returns a string, being a title that is generated from the specified filename.

SYNTAX

titleSTR = Uize.Build.Util.getTitleFromFilename (filenameSTR);

This method is used by build scripts that build HTML pages from a source format, where a title is needed for the HTML page but no pretty title is provided in the source file (such as in metadata, if the source format supports this). In such cases, a title can be derived from the filename using this method.

The method performs the following transformation on the specified filename...

EXAMPLE

Uize.Build.Util.getTitleFromFilename ('javascript-animation-and-effects.simple');

In the above example, the value 'Javascript Animation And Effects' would be returned.

IMPLEMENTATION INFO

Returns a string, being the module specified by a module definition object serialized to its string form.

SYNTAX

moduleTextSTR = Uize.Build.Util.moduleAsText (moduleDefinitionOBJ);

If a string value is specified for the builder property of the module definition (rather than a builder function, in other words), then this value will be substituted as is for the builder in the serialized module. This allows us to provide the exact code for a module's builder, complete with comments and formatting that you wish to preserve in the serialized text version of the module. This can be useful in some build processes that generate modules.

IMPLEMENTATION INFO

Returns a string, representing the module name of the module located at the specified path.

SYNTAX

moduleNameSTR = Uize.Build.Util.moduleNameFromModulePath (modulePathSTR);

This method removes the file extension and replaces slashes and underscores with periods to address the way that module paths are constructed for folder organizated modules.

EXAMPLE

Uize.Build.Util.moduleNameFromModulePath ('Uize/Widgets/Button/Html.js.jst');

In the above example, the value 'Uize.Widgets.Button.Html' would be returned.

IMPLEMENTATION INFO

Compiles the specified JST template file, uses the compiled template function to process the specified input, and writes the result as a new file.

SYNTAX

Uize.Build.Util.processJstFile (jstTemplatePathSTR,templateInputOBJ);

This method writes the result as a file alongside the JST template file, where the name of the written file is the same as the template file but with the .jst suffix stripped off. So, for example, if the JST template file being processed were named "homepage.html.jst", then the written file would be named "homepage.html".

NOTES

IMPLEMENTATION INFO

Returns an object that is parsed from the specified simple data file, with the children collapsed using the collapseChildren option of the SimpleData parser.

SYNTAX

simpleDataOBJ = Uize.Build.Util.readSimpleDataFile (simpleDataFilePathSTR);

IMPLEMENTATION INFO

Wraps the specified data in a data module wrapper of the specified module name and writes the module under the specified modules folder path.

SYNTAX

Uize.Build.Util.writeDataModule (modulesFolderPathSTR,moduleNameSTR,moduleDataANYTYPE);

This method uses the Uize.Build.Util.dataAsModule static method to wrap the data specified by the moduleDataANYTYPE parameter as a data module of the name specified by the moduleNameSTR parameter and then writes the module under the modules folder path specified by the modulesFolderPathSTR parameter.

NOTES

IMPLEMENTATION INFO