node-gulp-4.0.2+~cs38.20.35/000077500000000000000000000000001415667007300150405ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/LICENSE000066400000000000000000000021421415667007300160440ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Blaine Bublitz, Eric Schoffstall and other contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. node-gulp-4.0.2+~cs38.20.35/README.md000066400000000000000000000176341415667007300163320ustar00rootroot00000000000000

# gulp-cli [![NPM version][npm-image]][npm-url] [![Downloads][downloads-image]][npm-url] [![Build Status][travis-image]][travis-url] [![AppVeyor Build Status][appveyor-image]][appveyor-url] [![Coveralls Status][coveralls-image]][coveralls-url] [![Gitter chat][gitter-image]][gitter-url] Command Line Utility for Gulp ## Usage ```bash > gulp [flags] ... ``` ## Custom Metadata When listing tasks with the `gulp -T` command, gulp-cli displays some custom metadata as defined upon task functions. Currently supported properties: * `task.description` - String of the description to display. ```js function clean() { ... } clean.description = 'Cleans up generated files.'; ``` * `task.flags` - Object with key/value pairs being flag/description to display. ```js function build() { ... } build.flags = { '--prod': 'Builds in production mode.' }; ``` Example Usage: ```js function build() { ... } build.description = 'Build entire project.'; build.flags = { '--prod': 'Builds in production mode (minification, etc).' }; // gulp 3.x gulp.task('build', build); // gulp 4.x gulp.task(build); ``` ## Tasks The task(s) listed on the command line will be executed. If more than one task is listed, Gulp will execute all of them concurrently, that is, as if they had all been listed as dependencies of a single task. By default, Gulp does not serialize tasks listed on the command line. If you would like to execute tasks serially, you must specify the `--series` flag. e.g. `gulp clean build --series` Just running `gulp` will execute the task `default`. If there is no `default` task, gulp will error. ## Completion > Thanks to the grunt team, specifically Tyler Kellen To enable tasks auto-completion in shell you should add `eval "$(gulp --completion=shell)"` in your `.shellrc` file. ###### Bash: Add `eval "$(gulp --completion=bash)"` to `~/.bashrc`. ###### Zsh: Add `eval "$(gulp --completion=zsh)"` to `~/.zshrc`. ###### Powershell: Add `Invoke-Expression ((gulp --completion=powershell) -join [System.Environment]::NewLine)` to `$PROFILE`. ###### Fish: Add `gulp --completion=fish | source` to `~/.config/fish/config.fish`. ## Compilers You can find a list of supported languages at https://github.com/js-cli/js-interpret. If you would like to add support for a new language, send pull requests/open issues on that project. ## Environment The CLI adds process.env.INIT_CWD which is the original cwd it was launched from. ## Configuration Configuration is supported through the use of a `.gulp.*` file (e.g. `.gulp.json`, `.gulp.yml`). You can find a list of supported languages at https://github.com/js-cli/js-interpret. Configuration from the home directory (`~`) and current working directory (`cwd`) are merged with `cwd` taking precedence. Supported configurations properties: | Property | Description | |--------------------|-------------| | description | Top-level description of the project/gulpfile (Replaces "Tasks for ~/path/of/gulpfile.js") | | flags.continue | Continue execution of tasks upon failure by default. | | flags.compactTasks | Reduce the output of task dependency tree by default. | | flags.tasksDepth | Set default depth of task dependency tree. | | flags.gulpfile | Set a default gulpfile | | flags.silent | Silence logging by default | | flags.series | Run tasks given on the CLI in series (the default is parallel) | | flags.require | An array of modules to require before running the gulpfile. Any relative paths will be resolved against the `--cwd` directory (if you don't want that behavior, use absolute paths) | | flags.nodeFlags | An array of flags used to forcibly respawn the process upon startup. For example, if you always want your gulpfiles to run in node's harmony mode, you can set `--harmony` here | ## Flags gulp has very few flags to know about. All other flags are for tasks to use if needed. __Some flags only work with gulp 4 and will be ignored when invoked against gulp 3.__
Flag Short Flag Description
--help -h Show this help.
--version -v Print the global and local gulp versions.
--require [path] Will require a module before running the gulpfile. This is useful for transpilers but also has other applications.
--gulpfile [path] -f Manually set path of gulpfile. Useful if you have multiple gulpfiles. This will set the CWD to the gulpfile directory as well.
--cwd [path] Manually set the CWD. The search for the gulpfile, as well as the relativity of all requires (including the `--require` flag) will be from here.
--verify [path (optional)] Will verify plugins referenced in project's package.json against the plugins blacklist.
--tasks -T Print the task dependency tree for the loaded gulpfile.
--tasks-simple Print a plaintext list of tasks for the loaded gulpfile.
--tasks-json [path] Print the task dependency tree, in JSON format, for the loaded gulpfile. The [path] argument is optional, and if given writes the JSON to the path.
--tasks-depth [number] Specify the depth of the task dependency tree to print. This flag can be used with --tasks or --tasks-json. (This flag was named --depth before but is deprecated.)
--compact-tasks Reduce the output of task dependency tree by printing only top tasks and their child tasks. This flag can be used with --tasks or --tasks-json.
--sort-tasks Will sort top tasks of task dependency tree. This flag can be used with --tasks.
--color Will force gulp and gulp plugins to display colors, even when no color support is detected.
--no-color Will force gulp and gulp plugins to not display colors, even when color support is detected.
--silent -S Suppress all gulp logging.
--continue Continue execution of tasks upon failure.
--series Run tasks given on the CLI in series (the default is parallel).
--log-level -L Set the loglevel. -L for least verbose and -LLLL for most verbose. -LLL is default.
## License MIT [downloads-image]: http://img.shields.io/npm/dm/gulp-cli.svg [npm-url]: https://www.npmjs.com/package/gulp-cli [npm-image]: http://img.shields.io/npm/v/gulp-cli.svg [travis-url]: https://travis-ci.org/gulpjs/gulp-cli [travis-image]: http://img.shields.io/travis/gulpjs/gulp-cli.svg?label=travis-ci [appveyor-url]: https://ci.appveyor.com/project/gulpjs/gulp-cli [appveyor-image]: https://img.shields.io/appveyor/ci/gulpjs/gulp-cli.svg?label=appveyor [coveralls-url]: https://coveralls.io/r/gulpjs/gulp-cli [coveralls-image]: http://img.shields.io/coveralls/gulpjs/gulp-cli/master.svg [gitter-url]: https://gitter.im/gulpjs/gulp [gitter-image]: https://badges.gitter.im/gulpjs/gulp.svg node-gulp-4.0.2+~cs38.20.35/bin/000077500000000000000000000000001415667007300156105ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/bin/gulp.js000077500000000000000000000000661415667007300171220ustar00rootroot00000000000000#!/usr/bin/env node 'use strict'; require('../')(); node-gulp-4.0.2+~cs38.20.35/completion/000077500000000000000000000000001415667007300172115ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/completion/README.md000066400000000000000000000010161415667007300204660ustar00rootroot00000000000000# Completion for gulp > Thanks to the grunt team, specifically Tyler Kellen To enable tasks auto-completion in shell you should add `eval "$(gulp --completion=shell)"` in your `.shellrc` file. ## Bash Add `eval "$(gulp --completion=bash)"` to `~/.bashrc`. ## Zsh Add `eval "$(gulp --completion=zsh)"` to `~/.zshrc`. ## Powershell Add `Invoke-Expression ((gulp --completion=powershell) -join [System.Environment]::NewLine)` to `$PROFILE`. ## Fish Add `gulp --completion=fish | source` to `~/.config/fish/config.fish`. node-gulp-4.0.2+~cs38.20.35/completion/bash000066400000000000000000000013361415667007300200540ustar00rootroot00000000000000#!/bin/bash # Borrowed from grunt-cli # http://gruntjs.com/ # # Copyright (c) 2012 Tyler Kellen, contributors # Licensed under the MIT license. # https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT # Usage: # # To enable bash completion for gulp, add the following line (minus the # leading #, which is the bash comment character) to your ~/.bashrc file: # # eval "$(gulp --completion=bash)" # Enable bash autocompletion. function _gulp_completions() { # The currently-being-completed word. local cur="${COMP_WORDS[COMP_CWORD]}" #Grab tasks local compls=$(gulp --tasks-simple) # Tell complete what stuff to show. COMPREPLY=($(compgen -W "$compls" -- "$cur")) } complete -o default -F _gulp_completions gulp node-gulp-4.0.2+~cs38.20.35/completion/fish000066400000000000000000000003421415667007300200640ustar00rootroot00000000000000#!/usr/bin/env fish # Usage: # # To enable fish completion for gulp, add the following line to # your ~/.config/fish/config.fish file: # # gulp --completion=fish | source complete -c gulp -a "(gulp --tasks-simple)" -f node-gulp-4.0.2+~cs38.20.35/completion/powershell000066400000000000000000000036001415667007300213170ustar00rootroot00000000000000# Copyright (c) 2014 Jason Jarrett # # Tab completion for the `gulp` # # Usage: # # To enable powershell completion for gulp you need to be running # at least PowerShell v3 or greater and add the below to your $PROFILE # # Invoke-Expression ((gulp --completion=powershell) -join [System.Environment]::NewLine) # # $gulp_completion_Process = { param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameter) # Load up an assembly to read the gulpfile's sha1 if(-not $global:GulpSHA1Managed) { [Reflection.Assembly]::LoadWithPartialName("System.Security") | out-null $global:GulpSHA1Managed = new-Object System.Security.Cryptography.SHA1Managed } # setup a global (in-memory) cache if(-not $global:GulpfileShaCache) { $global:GulpfileShaCache = @{}; } $cache = $global:GulpfileShaCache; # Get the gulpfile's sha1 $sha1gulpFile = (resolve-path gulpfile.js -ErrorAction Ignore | %{ $file = [System.IO.File]::Open($_.Path, "open", "read") [string]::join('', ($global:GulpSHA1Managed.ComputeHash($file) | %{ $_.ToString("x2") })) $file.Dispose() }) # lookup the sha1 for previously cached task lists. if($cache.ContainsKey($sha1gulpFile)){ $tasks = $cache[$sha1gulpFile]; } else { $tasks = (gulp --tasks-simple).split("`n"); $cache[$sha1gulpFile] = $tasks; } $tasks | where { $_.startswith($commandName) } Sort-Object | foreach { New-Object System.Management.Automation.CompletionResult $_, $_, 'ParameterValue', ('{0}' -f $_) } } if (-not $global:options) { $global:options = @{ CustomArgumentCompleters = @{}; NativeArgumentCompleters = @{} } } $global:options['NativeArgumentCompleters']['gulp'] = $gulp_completion_Process $function:tabexpansion2 = $function:tabexpansion2 -replace 'End\r\n{','End { if ($null -ne $options) { $options += $global:options} else {$options = $global:options}' node-gulp-4.0.2+~cs38.20.35/completion/zsh000066400000000000000000000011211415667007300177330ustar00rootroot00000000000000#!/bin/zsh # Borrowed from grunt-cli # http://gruntjs.com/ # # Copyright (c) 2012 Tyler Kellen, contributors # Licensed under the MIT license. # https://github.com/gruntjs/grunt/blob/master/LICENSE-MIT # Usage: # # To enable zsh completion for gulp, add the following line (minus the # leading #, which is the zsh comment character) to your ~/.zshrc file: # # eval "$(gulp --completion=zsh)" # Enable zsh autocompletion. function _gulp_completion() { # Grab tasks compls=$(gulp --tasks-simple) completions=(${=compls}) compadd -- $completions } compdef _gulp_completion gulp node-gulp-4.0.2+~cs38.20.35/gulp.1000066400000000000000000000063461415667007300161020ustar00rootroot00000000000000.TH "GULP" "" "June 2020" "" "" .SH "NAME" \fBgulp\fR .SS Usage .P \fBgulp [flags] \.\.\.\fP .SS Tasks .P The task(s) listed will be executed\. If more than one task is listed, Gulp will execute all of them concurrently, that is, as if they had all been listed as dependencies of a single task\. .P By default, Gulp does not serialize tasks listed on the command line\. If you would like to execute tasks serially, you must specify the \fB\-\-series\fP flag\. e\.g\. \fBgulp clean build \-\-series\fP .P Just running \fBgulp\fP will execute the task \fBdefault\fP\|\. If there is no \fBdefault\fP task, gulp will error\. .SS Compilers .P You can find a list of supported languages at https:// If you would like to add support for a new language, send pull requests/open issues on that project\. .SS Environment .P The CLI adds process\.env\.INIT_CWD which is the original cwd it was launched from\. .SS Flags .P gulp has very few flags to know about\. All other flags are for tasks to use if needed\. .P \fBSome flags only work with gulp 4 and will be ignored when invoked against gulp 3\.\fR .P \fB\-\-help\fR, \fB\-h\fR Show the help\. .P \fB\-\-version\fR, \fB\-v\fR Print the global and local gulp versions\. .P \fB\-\-require\fR [path] Will require a module before running the gulpfile\. This is useful for transpilers but also has other applications\. .P \fB\-\-gulpfile\fR [path], \fB\-f\fR [path] Manually set path of gulpfile\. Useful if you have multiple gulpfiles\. This will set the CWD to the gulpfile directory as well\. .P \fB\-\-cwd\fR [path] Manually set the CWD\. The search for the gulpfile, as well as the relativity of all requires will be from here\. .P \fB\-\-verify\fR [path (optional)] Will verify plugins referenced in project's package\.json against the plugins blacklist\. .P \fB\-\-tasks\fR, \fB\-T\fR Print the task dependency tree for the loaded gulpfile\. .P \fB\-\-tasks\-simple\fR Print a plaintext list of tasks for the loaded gulpfile\. .P \fB\-\-tasks\-json\fR [path] Print the task dependency tree, in JSON format, for the loaded gulpfile\. The [path] argument is optional, and if given writes the JSON to the path\. .P \fB\-\-tasks\-depth\fR [number] Specify the depth of the task dependency tree to print\. This flag can be used with \-\-tasks or \-\-tasks\-json\. (This flag was named \-\-depth before but is deprecated\.) .P \fB\-\-compact\-tasks\fR Reduce the output of task dependency tree by printing only top tasks and their child tasks\. This flag can be used with \-\-tasks or \-\-tasks\-json\. .P \fB\-\-sort\-tasks\fR Will sort top tasks of task dependency tree\. This flag can be used with \-\-tasks\. .P \fB\-\-color\fR Will force gulp and gulp plugins to display colors, even when no color support is detected\. .P \fB\-\-no\-color\fR Will force gulp and gulp plugins to not display colors, even when color support is detected\. .P \fB\-\-silent\fR, \fB\-S\fR Suppress all gulp logging\. .P \fB\-\-continue\fR Continue execution of tasks upon failure\. .P \fB\-\-series\fR Run tasks given on the CLI in series (the default is parallel)\. .P \fB\-\-log\-level\fR, \fB\-L\fR Set the loglevel\. \-L for least verbose and \-LLLL for most verbose\. \-LLL is default\. node-gulp-4.0.2+~cs38.20.35/index.js000066400000000000000000000136031415667007300165100ustar00rootroot00000000000000'use strict'; var fs = require('fs'); var path = require('path'); var log = require('gulplog'); var yargs = require('yargs'); var Liftoff = require('liftoff'); var interpret = require('interpret'); var v8flags = require('v8flags'); var findRange = require('semver-greatest-satisfied-range'); var ansi = require('./lib/shared/ansi'); var exit = require('./lib/shared/exit'); var tildify = require('./lib/shared/tildify'); var makeTitle = require('./lib/shared/make-title'); var cliOptions = require('./lib/shared/cli-options'); var completion = require('./lib/shared/completion'); var verifyDeps = require('./lib/shared/verify-dependencies'); var cliVersion = require('./package.json').version; var getBlacklist = require('./lib/shared/get-blacklist'); var toConsole = require('./lib/shared/log/to-console'); var loadConfigFiles = require('./lib/shared/config/load-files'); var mergeConfigToCliFlags = require('./lib/shared/config/cli-flags'); var mergeConfigToEnvFlags = require('./lib/shared/config/env-flags'); // Logging functions var logVerify = require('./lib/shared/log/verify'); var logBlacklistError = require('./lib/shared/log/blacklist-error'); // Get supported ranges var ranges = fs.readdirSync(path.join(__dirname, '/lib/versioned/')); // Set env var for ORIGINAL cwd // before anything touches it process.env.INIT_CWD = process.cwd(); var cli = new Liftoff({ name: 'gulp', processTitle: makeTitle('gulp', process.argv.slice(2)), completions: completion, extensions: interpret.jsVariants, v8flags: v8flags, configFiles: { '.gulp': { home: { path: '~', extensions: interpret.extensions, }, cwd: { path: '.', extensions: interpret.extensions, }, }, }, }); var usage = '\n' + ansi.bold('Usage:') + ' gulp ' + ansi.blue('[options]') + ' tasks'; var parser = yargs.usage(usage, cliOptions); var opts = parser.argv; cli.on('require', function(name) { // This is needed because interpret needs to stub the .mjs extension // Without the .mjs require hook, rechoir blows up // However, we don't want to show the mjs-stub loader in the logs if (path.basename(name, '.js') !== 'mjs-stub') { log.info('Requiring external module', ansi.magenta(name)); } }); cli.on('requireFail', function(name, error) { log.warn( ansi.yellow('Failed to load external module'), ansi.magenta(name) ); /* istanbul ignore else */ if (error) { log.warn(ansi.yellow(error.toString())); } }); cli.on('respawn', function(flags, child) { var nodeFlags = ansi.magenta(flags.join(', ')); var pid = ansi.magenta(child.pid); log.info('Node flags detected:', nodeFlags); log.info('Respawned to PID:', pid); }); function run() { cli.prepare({ cwd: opts.cwd, configPath: opts.gulpfile, require: opts.require, completion: opts.completion, }, function(env) { var cfgLoadOrder = ['home', 'cwd']; var cfg = loadConfigFiles(env.configFiles['.gulp'], cfgLoadOrder); opts = mergeConfigToCliFlags(opts, cfg); env = mergeConfigToEnvFlags(env, cfg, opts); env.configProps = cfg; // Set up event listeners for logging again after configuring. toConsole(log, opts); cli.execute(env, env.nodeFlags, handleArguments); }); } module.exports = run; // The actual logic function handleArguments(env) { // This translates the --continue flag in gulp // To the settle env variable for undertaker // We use the process.env so the user's gulpfile // Can know about the flag if (opts.continue) { process.env.UNDERTAKER_SETTLE = 'true'; } if (opts.help) { parser.showHelp(console.log); exit(0); } // Anything that needs to print outside of the logging mechanism should use console.log if (opts.version) { console.log('CLI version:', cliVersion); console.log('Local version:', env.modulePackage.version || 'Unknown'); exit(0); } if (opts.verify) { var pkgPath = opts.verify !== true ? opts.verify : 'package.json'; /* istanbul ignore else */ if (path.resolve(pkgPath) !== path.normalize(pkgPath)) { pkgPath = path.join(env.cwd, pkgPath); } log.info('Verifying plugins in ' + pkgPath); return getBlacklist(function(err, blacklist) { /* istanbul ignore if */ if (err) { return logBlacklistError(err); } var blacklisted = verifyDeps(require(pkgPath), blacklist); logVerify(blacklisted); }); } if (!env.modulePath) { /* istanbul ignore next */ var missingNodeModules = fs.existsSync(path.join(env.cwd, 'package.json')) && !fs.existsSync(path.join(env.cwd, 'node_modules')); /* istanbul ignore next */ var missingGulpMessage = missingNodeModules ? 'Local modules not found in' : 'Local gulp not found in'; log.error( ansi.red(missingGulpMessage), ansi.magenta(tildify(env.cwd)) ); var hasYarn = fs.existsSync(path.join(env.cwd, 'yarn.lock')); /* istanbul ignore next */ var installCommand = missingNodeModules ? hasYarn ? 'yarn install' : 'npm install' : hasYarn ? 'yarn add gulp' : 'npm install gulp'; log.error(ansi.red('Try running: ' + installCommand)); exit(1); } if (!env.configPath) { log.error(ansi.red('No gulpfile found')); exit(1); } // Chdir before requiring gulpfile to make sure // we let them chdir as needed if (process.cwd() !== env.cwd) { process.chdir(env.cwd); log.info( 'Working directory changed to', ansi.magenta(tildify(env.cwd)) ); } // Find the correct CLI version to run var range = findRange(env.modulePackage.version, ranges); if (!range) { log.error( ansi.red('Unsupported gulp version', env.modulePackage.version) ); exit(1); } // Load and execute the CLI version var versionedDir = path.join(__dirname, '/lib/versioned/', range, '/'); require(versionedDir)(opts, env, env.configProps); } node-gulp-4.0.2+~cs38.20.35/lib/000077500000000000000000000000001415667007300156065ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/shared/000077500000000000000000000000001415667007300170545ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/shared/ansi.js000066400000000000000000000016411415667007300203460ustar00rootroot00000000000000'use strict'; var colors = require('ansi-colors'); var supportsColor = require('color-support'); var hasColors = colorize(); /* istanbul ignore next */ module.exports = { red: hasColors ? colors.red : noColor, green: hasColors ? colors.green : noColor, blue: hasColors ? colors.blue : noColor, magenta: hasColors ? colors.magenta : noColor, cyan: hasColors ? colors.cyan : noColor, white: hasColors ? colors.white : noColor, gray: hasColors ? colors.gray : noColor, bgred: hasColors ? colors.bgred : noColor, bold: hasColors ? colors.bold : noColor, yellow: hasColors ? colors.yellow : noColor, }; function noColor(message) { return message; } function hasFlag(flag) { return (process.argv.indexOf('--' + flag) !== -1); } function colorize() { if (hasFlag('no-color')) { return false; } /* istanbul ignore if */ if (hasFlag('color')) { return true; } return supportsColor(); } node-gulp-4.0.2+~cs38.20.35/lib/shared/cli-options.js000066400000000000000000000065561415667007300216660ustar00rootroot00000000000000'use strict'; var ansi = require('./ansi'); module.exports = { help: { alias: 'h', type: 'boolean', desc: ansi.gray( 'Show this help.'), }, version: { alias: 'v', type: 'boolean', desc: ansi.gray( 'Print the global and local gulp versions.'), }, require: { type: 'string', requiresArg: true, desc: ansi.gray( 'Will require a module before running the gulpfile. ' + 'This is useful for transpilers but also has other applications.'), }, gulpfile: { alias: 'f', type: 'string', requiresArg: true, desc: ansi.gray( 'Manually set path of gulpfile. Useful if you have multiple gulpfiles. ' + 'This will set the CWD to the gulpfile directory as well.'), }, cwd: { type: 'string', requiresArg: true, desc: ansi.gray( 'Manually set the CWD. The search for the gulpfile, ' + 'as well as the relativity of all requires will be from here.'), }, verify: { desc: ansi.gray( 'Will verify plugins referenced in project\'s package.json against ' + 'the plugins blacklist.'), }, tasks: { alias: 'T', type: 'boolean', desc: ansi.gray( 'Print the task dependency tree for the loaded gulpfile.'), }, 'tasks-simple': { type: 'boolean', desc: ansi.gray( 'Print a plaintext list of tasks for the loaded gulpfile.'), }, 'tasks-json': { desc: ansi.gray( 'Print the task dependency tree, ' + 'in JSON format, for the loaded gulpfile.'), }, 'tasks-depth': { alias: 'depth', type: 'number', requiresArg: true, default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Specify the depth of the task dependency tree.'), }, 'compact-tasks': { type: 'boolean', default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Reduce the output of task dependency tree by printing ' + 'only top tasks and their child tasks.'), }, 'sort-tasks': { type: 'boolean', default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Will sort top tasks of task dependency tree.'), }, color: { type: 'boolean', desc: ansi.gray( 'Will force gulp and gulp plugins to display colors, ' + 'even when no color support is detected.'), }, 'no-color': { type: 'boolean', desc: ansi.gray( 'Will force gulp and gulp plugins to not display colors, ' + 'even when color support is detected.'), }, silent: { alias: 'S', type: 'boolean', default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Suppress all gulp logging.'), }, continue: { type: 'boolean', default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Continue execution of tasks upon failure.'), }, series: { type: 'boolean', default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Run tasks given on the CLI in series (the default is parallel).'), }, 'log-level': { alias: 'L', // Type isn't needed because count acts as a boolean count: true, default: undefined, // To detect if this cli option is specified. desc: ansi.gray( 'Set the loglevel. -L for least verbose and -LLLL for most verbose. ' + '-LLL is default.'), }, }; node-gulp-4.0.2+~cs38.20.35/lib/shared/completion.js000066400000000000000000000007461415667007300215720ustar00rootroot00000000000000'use strict'; var fs = require('fs'); var path = require('path'); module.exports = function(name) { if (typeof name !== 'string') { throw new Error('Missing completion type'); } var file = path.join(__dirname, '../../completion', name); try { console.log(fs.readFileSync(file, 'utf8')); process.exit(0); } catch (err) { console.log( 'echo "gulp autocompletion rules for', '\'' + name + '\'', 'not found"' ); process.exit(5); } }; node-gulp-4.0.2+~cs38.20.35/lib/shared/config/000077500000000000000000000000001415667007300203215ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/shared/config/cli-flags.js000066400000000000000000000010501415667007300225140ustar00rootroot00000000000000'use strict'; var copyProps = require('copy-props'); var fromTo = { 'flags.silent': 'silent', 'flags.continue': 'continue', 'flags.series': 'series', 'flags.logLevel': 'logLevel', 'flags.compactTasks': 'compactTasks', 'flags.tasksDepth': 'tasksDepth', 'flags.sortTasks': 'sortTasks', }; function mergeConfigToCliFlags(opt, config) { return copyProps(config, opt, fromTo, defaults); } function defaults(cfgInfo, optInfo) { if (optInfo.value === undefined) { return cfgInfo.value; } } module.exports = mergeConfigToCliFlags; node-gulp-4.0.2+~cs38.20.35/lib/shared/config/env-flags.js000066400000000000000000000020751415667007300225450ustar00rootroot00000000000000'use strict'; var path = require('path'); var copyProps = require('copy-props'); var toFrom = { configPath: 'flags.gulpfile', configBase: 'flags.gulpfile', require: 'flags.require', nodeFlags: 'flags.nodeFlags', }; function mergeConfigToEnvFlags(env, config, cliOpts) { // This must reverse because `flags.gulpfile` determines 2 different properties var reverse = true; return copyProps(env, config, toFrom, convert, reverse); function convert(configInfo, envInfo) { if (envInfo.keyChain === 'configBase') { if (cliOpts.gulpfile === undefined) { return path.dirname(configInfo.value); } return; } if (envInfo.keyChain === 'configPath') { if (cliOpts.gulpfile === undefined) { return configInfo.value; } return; } if (envInfo.keyChain === 'require') { return [].concat(envInfo.value, configInfo.value); } /* istanbul ignore else */ if (envInfo.keyChain === 'nodeFlags') { return [].concat(configInfo.value || []); } } } module.exports = mergeConfigToEnvFlags; node-gulp-4.0.2+~cs38.20.35/lib/shared/config/load-files.js000066400000000000000000000011541415667007300226770ustar00rootroot00000000000000'use strict'; var copyProps = require('copy-props'); var path = require('path'); function loadConfigFiles(configFiles, configFileOrder) { var config = {}; configFileOrder.forEach(loadFile); function loadFile(key) { var filePath = configFiles[key]; if (!filePath) { return; } copyProps(require(filePath), config, convert); function convert(loadedInfo) { if (loadedInfo.keyChain === 'flags.gulpfile') { return path.resolve(path.dirname(filePath), loadedInfo.value); } return loadedInfo.value; } } return config; } module.exports = loadConfigFiles; node-gulp-4.0.2+~cs38.20.35/lib/shared/exit.js000066400000000000000000000004711415667007300203650ustar00rootroot00000000000000'use strict'; // Fix stdout truncation on windows function exit(code) { /* istanbul ignore next */ if (process.platform === 'win32' && process.stdout.bufferSize) { process.stdout.once('drain', function() { process.exit(code); }); return; } process.exit(code); } module.exports = exit; node-gulp-4.0.2+~cs38.20.35/lib/shared/get-blacklist.js000066400000000000000000000022261415667007300221410ustar00rootroot00000000000000'use strict'; var https = require('https'); var concat = require('concat-stream'); var url = 'https://raw.githubusercontent.com/gulpjs/plugins/master/src/blackList.json'; function collect(stream, cb) { stream.on('error', cb); stream.pipe(concat(onSuccess)); function onSuccess(result) { cb(null, result); } } function parse(str, cb) { try { cb(null, JSON.parse(str)); } catch (err) { /* istanbul ignore next */ cb(new Error('Invalid Blacklist JSON.')); } } // TODO: Test this impl function getBlacklist(cb) { https.get(url, onRequest); function onRequest(res) { /* istanbul ignore if */ if (res.statusCode !== 200) { // TODO: Test different status codes return cb(new Error('Request failed. Status Code: ' + res.statusCode)); } res.setEncoding('utf8'); collect(res, onCollect); } function onCollect(err, result) { /* istanbul ignore if */ if (err) { return cb(err); } parse(result, onParse); } function onParse(err, blacklist) { /* istanbul ignore if */ if (err) { return cb(err); } cb(null, blacklist); } } module.exports = getBlacklist; node-gulp-4.0.2+~cs38.20.35/lib/shared/log/000077500000000000000000000000001415667007300176355ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/shared/log/blacklist-error.js000066400000000000000000000005431415667007300232740ustar00rootroot00000000000000'use strict'; var log = require('gulplog'); var ansi = require('../ansi'); var exit = require('../exit'); /* istanbul ignore next */ function logBlacklistError(err) { log.error(ansi.red('Error: failed to retrieve plugins black-list')); log.error(err.message); // Avoid duplicating for each version exit(1); } module.exports = logBlacklistError; node-gulp-4.0.2+~cs38.20.35/lib/shared/log/copy-tree.js000066400000000000000000000034111415667007300221010ustar00rootroot00000000000000'use strict'; function copyNode(node) { var newNode = {}; Object.keys(node).forEach(function(key) { newNode[key] = node[key]; }); return newNode; } var defaultNodeFactory = { topNode: copyNode, taskNode: copyNode, childNode: copyNode, }; function copyTree(tree, opts, nodeFactory) { opts = opts || {}; var depth = opts.tasksDepth; depth = typeof depth === 'number' ? ((depth < 1) ? 1 : depth) : null; nodeFactory = nodeFactory || defaultNodeFactory; var newTree = nodeFactory.topNode(tree); newTree.nodes = []; if (Array.isArray(tree.nodes)) { tree.nodes.forEach(visit); } function visit(node) { var newNode = nodeFactory.taskNode(node); newNode.nodes = []; newTree.nodes.push(newNode); if (opts.compactTasks) { forEach(node.nodes, copyNotRecursively, newNode); } else if (!depth || depth > 1) { forEach(node.nodes, copyRecursively, depth, 2, newNode); } } function copyNotRecursively(child, newParent) { var newChild = nodeFactory.childNode(child); newChild.nodes = []; newParent.nodes.push(newChild); if (child.branch) { forEach(child.nodes, copyNotRecursively, newChild); } } function copyRecursively(child, maxDepth, nowDepth, newParent) { var newChild = nodeFactory.childNode(child); newChild.nodes = []; newParent.nodes.push(newChild); if (!maxDepth || maxDepth > nowDepth) { forEach(child.nodes, copyRecursively, maxDepth, nowDepth + 1, newChild); } } return newTree; } function forEach(nodes, fn) { if (!Array.isArray(nodes)) { return; } var args = Array.prototype.slice.call(arguments, 2); for (var i = 0, n = nodes.length; i < n; i++) { fn.apply(nodes[i], [nodes[i]].concat(args)); } } module.exports = copyTree; node-gulp-4.0.2+~cs38.20.35/lib/shared/log/tasks.js000066400000000000000000000073511415667007300213260ustar00rootroot00000000000000'use strict'; var archy = require('archy'); var log = require('gulplog'); var sortBy = require('array-sort'); var isObject = require('isobject'); var ansi = require('../ansi'); var copyTree = require('./copy-tree'); function logTasks(tree, opts, getTask) { if (opts.sortTasks) { tree.nodes = sortBy(tree.nodes, 'label'); } var lineInfos = []; var entryObserver = getLineInfoCollector(lineInfos); var nodeFactory = getNodeFactory(getTask, entryObserver); tree = copyTree(tree, opts, nodeFactory); var spacer = getSpacerForLineIndents(tree, lineInfos); var lines = getLinesContainingOnlyBranches(tree); log.info(tree.label); printTreeList(lines, spacer, lineInfos); } function getLineInfoCollector(lineInfos) { return { topTask: function(node) { lineInfos.push({ name: node.label, desc: node.desc, type: 'top', }); }, option: function(opt) { lineInfos.push({ name: opt.label, desc: opt.desc, type: 'option', }); }, childTask: function(node) { lineInfos.push({ name: node.label, type: 'child', }); }, }; } function getNodeFactory(getTask, entryObserver) { return { topNode: function(node) { return { label: node.label, }; }, taskNode: function(node) { /* istanbul ignore next */ var task = getTask(node.label) || {}; var newNode = { label: node.label, desc: typeof task.description === 'string' ? task.description : '', opts: [], }; entryObserver.topTask(newNode); if (isObject(task.flags)) { Object.keys(task.flags).sort().forEach(function(flag) { if (flag.length === 0) { return; } /* istanbul ignore next */ var opt = { label: flag, desc: typeof task.flags[flag] === 'string' ? task.flags[flag] : '', }; entryObserver.option(opt); newNode.opts.push(opt); newNode.label += '\n' + opt.label; // The way of archy for options. }); } return newNode; }, childNode: function(node) { var newChild = { label: node.label, }; entryObserver.childTask(newChild); newChild.label = ''; // Because don't use child tasks to calc indents. return newChild; }, }; } function getSpacerForLineIndents(tree, lineInfos) { var maxSize = 0; var sizes = []; archy(tree) .split('\n') .slice(1, -1) .forEach(function(line, index) { var info = lineInfos[index]; if (info.type === 'top' || info.type === 'option') { maxSize = Math.max(maxSize, line.length); sizes.push(line.length); } else { sizes.push(0); } }); maxSize += 3; return function(index) { return Array(maxSize - sizes[index]).join(' '); }; } function getLinesContainingOnlyBranches(tree) { tree.nodes.forEach(function(node) { node.label = ''; node.opts.forEach(function() { node.label += '\n'; }); }); return archy(tree) .split('\n') .slice(1, -1); } function printTreeList(lines, spacer, lineInfos) { lines.forEach(function(branch, index) { var info = lineInfos[index]; var line = ansi.white(branch); if (info.type === 'top') { line += ansi.cyan(info.name); if (info.desc.length > 0) { line += spacer(index) + ansi.white(info.desc); } } else if (info.type === 'option') { line += ansi.magenta(info.name); if (info.desc.length > 0) { line += spacer(index) + ansi.white('…' + info.desc); } } else { // If (info.type === 'child') { line += ansi.white(info.name); } log.info(line); }); } module.exports = logTasks; node-gulp-4.0.2+~cs38.20.35/lib/shared/log/to-console.js000066400000000000000000000024541415667007300222620ustar00rootroot00000000000000'use strict'; var fancyLog = require('fancy-log'); /* istanbul ignore next */ function noop() {} // The sorting of the levels is // significant. var levels = [ 'error', // -L: Logs error events. 'warn', // -LL: Logs warn and error events. 'info', // -LLL: Logs info, warn and error events. 'debug', // -LLLL: Logs all log levels. ]; function cleanup(log) { levels.forEach(removeListeners); function removeListeners(level) { if (level === 'error') { log.removeListener(level, noop); log.removeListener(level, fancyLog.error); } else { log.removeListener(level, fancyLog); } } } function toConsole(log, opts) { // Remove previous listeners to enable to call this twice. cleanup(log); // Return immediately if logging is // not desired. if (opts.tasksSimple || opts.tasksJson || opts.help || opts.version || opts.silent) { // Keep from crashing process when silent. log.on('error', noop); return; } // Default loglevel to info level (3). var loglevel = opts.logLevel || 3; levels .filter(function(item, i) { return i < loglevel; }) .forEach(function(level) { if (level === 'error') { log.on(level, fancyLog.error); } else { log.on(level, fancyLog); } }); } module.exports = toConsole; node-gulp-4.0.2+~cs38.20.35/lib/shared/log/verify.js000066400000000000000000000011061415667007300214750ustar00rootroot00000000000000'use strict'; var log = require('gulplog'); var ansi = require('../ansi'); var exit = require('../exit'); function logVerify(blacklisted) { var pluginNames = Object.keys(blacklisted); if (!pluginNames.length) { log.info( ansi.green('There are no blacklisted plugins in this project') ); exit(0); } log.warn(ansi.red('Blacklisted plugins found in this project:')); pluginNames.map(function(pluginName) { var reason = blacklisted[pluginName]; log.warn(ansi.bgred(pluginName) + ': ' + reason); }); exit(1); } module.exports = logVerify; node-gulp-4.0.2+~cs38.20.35/lib/shared/make-title.js000066400000000000000000000002561415667007300214510ustar00rootroot00000000000000'use strict'; function makeTitle(cmd, argv) { if (!argv || argv.length === 0) { return cmd; } return [cmd].concat(argv).join(' '); } module.exports = makeTitle; node-gulp-4.0.2+~cs38.20.35/lib/shared/register-exports.js000066400000000000000000000005761415667007300227500ustar00rootroot00000000000000'use strict'; function registerExports(gulpInst, tasks) { var taskNames = Object.keys(tasks); if (taskNames.length) { taskNames.forEach(register); } function register(taskName) { var task = tasks[taskName]; if (typeof task !== 'function') { return; } gulpInst.task(task.displayName || taskName, task); } } module.exports = registerExports; node-gulp-4.0.2+~cs38.20.35/lib/shared/require-or-import.js000066400000000000000000000017251415667007300230210ustar00rootroot00000000000000'use strict'; var pathToFileURL = require('url').pathToFileURL; var importESM; try { // Node.js <10 errors out with a SyntaxError when loading a script that uses import(). // So a function is dynamically created to catch the SyntaxError at runtime instead of parsetime. // That way we can keep supporting all Node.js versions all the way back to 0.10. importESM = new Function('id', 'return import(id);'); } catch (e) { importESM = null; } function requireOrImport(path, callback) { var err = null; var cjs; try { cjs = require(path); } catch (e) { if (pathToFileURL && importESM && e.code === 'ERR_REQUIRE_ESM') { // This is needed on Windows, because import() fails if providing a Windows file path. var url = pathToFileURL(path); importESM(url).then(function(esm) { callback(null, esm); }, callback); return; } err = e; } process.nextTick(function() { callback(err, cjs); }); } module.exports = requireOrImport; node-gulp-4.0.2+~cs38.20.35/lib/shared/tildify.js000066400000000000000000000002431415667007300210550ustar00rootroot00000000000000'use strict'; var replaceHomedir = require('replace-homedir'); function tildify(filepath) { return replaceHomedir(filepath, '~'); } module.exports = tildify; node-gulp-4.0.2+~cs38.20.35/lib/shared/verify-dependencies.js000066400000000000000000000013141415667007300233410ustar00rootroot00000000000000'use strict'; var matchdep = require('matchdep'); /** * Given a collection of plugin names verifies this collection against * the blacklist. Returns an object with: * [plugin name]=>[blacklisting reason] * or an empty object if none of the dependencies to check are blacklisted. * * @param pkg - package.json contents * @param blacklist - contents of the blacklist in JSON format */ function verifyDependencies(pkg, blacklist) { var blacklisted = matchdep .filterAll(Object.keys(blacklist), pkg) .reduce(function(blacklisted, pluginName) { blacklisted[pluginName] = blacklist[pluginName]; return blacklisted; }, {}); return blacklisted; } module.exports = verifyDependencies; node-gulp-4.0.2+~cs38.20.35/lib/versioned/000077500000000000000000000000001415667007300176045ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/000077500000000000000000000000001415667007300204075ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/format-error.js000066400000000000000000000006051415667007300233650ustar00rootroot00000000000000'use strict'; // Format orchestrator errors function formatError(e) { if (!e.err) { return e.message; } // PluginError if (typeof e.err.showStack === 'boolean') { return e.err.toString(); } // Normal error if (e.err.stack) { return e.err.stack; } // Unknown (string, number, etc.) return new Error(String(e.err)).stack; } module.exports = formatError; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/index.js000066400000000000000000000047111415667007300220570ustar00rootroot00000000000000'use strict'; var fs = require('fs'); var log = require('gulplog'); var stdout = require('mute-stdout'); var taskTree = require('./task-tree'); var copyTree = require('../../shared/log/copy-tree'); var tildify = require('../../shared/tildify'); var logTasks = require('../../shared/log/tasks'); var ansi = require('../../shared/ansi'); var exit = require('../../shared/exit'); var logEvents = require('./log/events'); var logTasksSimple = require('./log/tasks-simple'); var registerExports = require('../../shared/register-exports'); var requireOrImport = require('../../shared/require-or-import'); function execute(opts, env, config) { var tasks = opts._; var toRun = tasks.length ? tasks : ['default']; if (opts.tasksSimple || opts.tasks || opts.tasksJson) { // Mute stdout if we are listing tasks stdout.mute(); } // This is what actually loads up the gulpfile requireOrImport(env.configPath, function(err, exported) { // Before import(), if require() failed we got an unhandled exception on the module level. // So console.error() & exit() were added here to mimic the old behavior as close as possible. if (err) { console.error(err); exit(1); } log.info('Using gulpfile', ansi.magenta(tildify(env.configPath))); var gulpInst = require(env.modulePath); logEvents(gulpInst); registerExports(gulpInst, exported); // Always unmute stdout after gulpfile is required stdout.unmute(); var tree; if (opts.tasksSimple) { return logTasksSimple(env, gulpInst); } if (opts.tasks) { tree = taskTree(gulpInst.tasks); if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath)); } return logTasks(tree, opts, function(task) { return gulpInst.tasks[task].fn; }); } if (opts.tasksJson) { tree = taskTree(gulpInst.tasks); if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + tildify(env.configPath); } var output = JSON.stringify(copyTree(tree, opts)); if (typeof opts.tasksJson === 'boolean') { return console.log(output); } return fs.writeFileSync(opts.tasksJson, output, 'utf-8'); } gulpInst.start.apply(gulpInst, toRun); }); } module.exports = execute; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/log/000077500000000000000000000000001415667007300211705ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/log/events.js000066400000000000000000000027011415667007300230320ustar00rootroot00000000000000'use strict'; var log = require('gulplog'); var prettyTime = require('pretty-hrtime'); var ansi = require('../../../shared/ansi'); var exit = require('../../../shared/exit'); var formatError = require('../format-error'); // Wire up logging events function logEvents(gulpInst) { // Exit with 0 or 1 var failed = false; process.once('exit', function(code) { if (code === 0 && failed) { exit(1); } }); // Total hack due to poor error management in orchestrator gulpInst.on('err', function() { failed = true; }); gulpInst.on('task_start', function(e) { // TODO: batch these // so when 5 tasks start at once it only logs one time with all 5 log.info('Starting', '\'' + ansi.cyan(e.task) + '\'...'); }); gulpInst.on('task_stop', function(e) { var time = prettyTime(e.hrDuration); log.info( 'Finished', '\'' + ansi.cyan(e.task) + '\'', 'after', ansi.magenta(time) ); }); gulpInst.on('task_err', function(e) { var msg = formatError(e); var time = prettyTime(e.hrDuration); log.error( '\'' + ansi.cyan(e.task) + '\'', ansi.red('errored after'), ansi.magenta(time) ); log.error(msg); }); gulpInst.on('task_not_found', function(err) { log.error( ansi.red('Task \'' + err.task + '\' is not in your gulpfile') ); log.error('Please check the documentation for proper gulpfile formatting'); exit(1); }); } module.exports = logEvents; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/log/tasks-simple.js000066400000000000000000000002461415667007300241440ustar00rootroot00000000000000'use strict'; function logTasksSimple(env, localGulp) { console.log(Object.keys(localGulp.tasks) .join('\n') .trim()); } module.exports = logTasksSimple; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^3.7.0/task-tree.js000066400000000000000000000011341415667007300226430ustar00rootroot00000000000000'use strict'; module.exports = function(tasks) { var map = {}; var arr = []; Object.keys(tasks).forEach(function(taskname) { var task = { label: taskname, type: 'task', nodes: [], }; map[taskname] = task; arr.push(task); }); Object.keys(tasks).forEach(function(taskname) { var task = map[taskname]; tasks[taskname].dep.forEach(function(childname) { var child = map[childname] || { label: childname, type: 'task', nodes: [], }; task.nodes.push(child); }); }); return { label: 'Tasks', nodes: arr }; }; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0-alpha.1/000077500000000000000000000000001415667007300216235ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0-alpha.1/index.js000066400000000000000000000055611415667007300232770ustar00rootroot00000000000000'use strict'; var fs = require('fs'); var log = require('gulplog'); var stdout = require('mute-stdout'); var ansi = require('../../shared/ansi'); var exit = require('../../shared/exit'); var tildify = require('../../shared/tildify'); var logTasks = require('../../shared/log/tasks'); var logEvents = require('../^4.0.0/log/events'); var logSyncTask = require('../^4.0.0/log/sync-task'); var logTasksSimple = require('../^4.0.0/log/tasks-simple'); var registerExports = require('../../shared/register-exports'); var copyTree = require('../../shared/log/copy-tree'); var requireOrImport = require('../../shared/require-or-import'); function execute(opts, env, config) { var tasks = opts._; var toRun = tasks.length ? tasks : ['default']; if (opts.tasksSimple || opts.tasks || opts.tasksJson) { // Mute stdout if we are listing tasks stdout.mute(); } var gulpInst = require(env.modulePath); logEvents(gulpInst); logSyncTask(gulpInst, opts); // This is what actually loads up the gulpfile requireOrImport(env.configPath, function(err, exported) { // Before import(), if require() failed we got an unhandled exception on the module level. // So console.error() & exit() were added here to mimic the old behavior as close as possible. if (err) { console.error(err); exit(1); } registerExports(gulpInst, exported); // Always unmute stdout after gulpfile is required stdout.unmute(); var tree; if (opts.tasksSimple) { return logTasksSimple(gulpInst.tree()); } if (opts.tasks) { tree = {}; if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath)); } tree.nodes = gulpInst.tree({ deep: true }); return logTasks(tree, opts, function(taskname) { return gulpInst.task(taskname); }); } if (opts.tasksJson) { tree = {}; if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + tildify(env.configPath); } tree.nodes = gulpInst.tree({ deep: true }); var output = JSON.stringify(copyTree(tree, opts)); if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) { return console.log(output); } return fs.writeFileSync(opts.tasksJson, output, 'utf-8'); } try { log.info('Using gulpfile', ansi.magenta(tildify(env.configPath))); var runMethod = opts.series ? 'series' : 'parallel'; gulpInst[runMethod](toRun)(function(err) { if (err) { exit(1); } }); } catch (err) { log.error(ansi.red(err.message)); log.error('To list available tasks, try running: gulp --tasks'); exit(1); } }); } module.exports = execute; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0-alpha.2/000077500000000000000000000000001415667007300216245ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0-alpha.2/index.js000066400000000000000000000055341415667007300233000ustar00rootroot00000000000000'use strict'; var fs = require('fs'); var log = require('gulplog'); var stdout = require('mute-stdout'); var ansi = require('../../shared/ansi'); var exit = require('../../shared/exit'); var tildify = require('../../shared/tildify'); var logTasks = require('../../shared/log/tasks'); var logEvents = require('../^4.0.0/log/events'); var logSyncTask = require('../^4.0.0/log/sync-task'); var logTasksSimple = require('../^4.0.0/log/tasks-simple'); var registerExports = require('../../shared/register-exports'); var copyTree = require('../../shared/log/copy-tree'); var getTask = require('../^4.0.0/log/get-task'); var requireOrImport = require('../../shared/require-or-import'); function execute(opts, env, config) { var tasks = opts._; var toRun = tasks.length ? tasks : ['default']; if (opts.tasksSimple || opts.tasks || opts.tasksJson) { // Mute stdout if we are listing tasks stdout.mute(); } var gulpInst = require(env.modulePath); logEvents(gulpInst); logSyncTask(gulpInst, opts); // This is what actually loads up the gulpfile requireOrImport(env.configPath, function(err, exported) { // Before import(), if require() failed we got an unhandled exception on the module level. // So console.error() & exit() were added here to mimic the old behavior as close as possible. if (err) { console.error(err); exit(1); } registerExports(gulpInst, exported); // Always unmute stdout after gulpfile is required stdout.unmute(); var tree; if (opts.tasksSimple) { tree = gulpInst.tree(); return logTasksSimple(tree.nodes); } if (opts.tasks) { tree = gulpInst.tree({ deep: true }); if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath)); } return logTasks(tree, opts, getTask(gulpInst)); } if (opts.tasksJson) { tree = gulpInst.tree({ deep: true }); if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + tildify(env.configPath); } var output = JSON.stringify(copyTree(tree, opts)); if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) { return console.log(output); } return fs.writeFileSync(opts.tasksJson, output, 'utf-8'); } try { log.info('Using gulpfile', ansi.magenta(tildify(env.configPath))); var runMethod = opts.series ? 'series' : 'parallel'; gulpInst[runMethod](toRun)(function(err) { if (err) { exit(1); } }); } catch (err) { log.error(ansi.red(err.message)); log.error('To list available tasks, try running: gulp --tasks'); exit(1); } }); } module.exports = execute; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/000077500000000000000000000000001415667007300204015ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/format-error.js000066400000000000000000000006541415667007300233630ustar00rootroot00000000000000'use strict'; // Format orchestrator errors /* istanbul ignore next */ function formatError(e) { if (!e.error) { return e.message; } // PluginError if (typeof e.error.showStack === 'boolean') { return e.error.toString(); } // Normal error if (e.error.stack) { return e.error.stack; } // Unknown (string, number, etc.) return new Error(String(e.error)).stack; } module.exports = formatError; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/index.js000066400000000000000000000054741415667007300220600ustar00rootroot00000000000000'use strict'; var fs = require('fs'); var log = require('gulplog'); var stdout = require('mute-stdout'); var ansi = require('../../shared/ansi'); var exit = require('../../shared/exit'); var tildify = require('../../shared/tildify'); var logTasks = require('../../shared/log/tasks'); var logEvents = require('./log/events'); var logSyncTask = require('./log/sync-task'); var logTasksSimple = require('./log/tasks-simple'); var registerExports = require('../../shared/register-exports'); var copyTree = require('../../shared/log/copy-tree'); var getTask = require('./log/get-task'); var requireOrImport = require('../../shared/require-or-import'); function execute(opts, env, config) { var tasks = opts._; var toRun = tasks.length ? tasks : ['default']; if (opts.tasksSimple || opts.tasks || opts.tasksJson) { // Mute stdout if we are listing tasks stdout.mute(); } var gulpInst = require(env.modulePath); logEvents(gulpInst); logSyncTask(gulpInst, opts); // This is what actually loads up the gulpfile requireOrImport(env.configPath, function(err, exported) { // Before import(), if require() failed we got an unhandled exception on the module level. // So console.error() & exit() were added here to mimic the old behavior as close as possible. if (err) { console.error(err); exit(1); } registerExports(gulpInst, exported); // Always unmute stdout after gulpfile is required stdout.unmute(); var tree; if (opts.tasksSimple) { tree = gulpInst.tree(); return logTasksSimple(tree.nodes); } if (opts.tasks) { tree = gulpInst.tree({ deep: true }); if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + ansi.magenta(tildify(env.configPath)); } return logTasks(tree, opts, getTask(gulpInst)); } if (opts.tasksJson) { tree = gulpInst.tree({ deep: true }); if (config.description && typeof config.description === 'string') { tree.label = config.description; } else { tree.label = 'Tasks for ' + tildify(env.configPath); } var output = JSON.stringify(copyTree(tree, opts)); if (typeof opts.tasksJson === 'boolean' && opts.tasksJson) { return console.log(output); } return fs.writeFileSync(opts.tasksJson, output, 'utf-8'); } try { log.info('Using gulpfile', ansi.magenta(tildify(env.configPath))); var runMethod = opts.series ? 'series' : 'parallel'; gulpInst[runMethod](toRun)(function(err) { if (err) { exit(1); } }); } catch (err) { log.error(ansi.red(err.message)); log.error('To list available tasks, try running: gulp --tasks'); exit(1); } }); } module.exports = execute; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/log/000077500000000000000000000000001415667007300211625ustar00rootroot00000000000000node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/log/events.js000066400000000000000000000024511415667007300230260ustar00rootroot00000000000000'use strict'; var log = require('gulplog'); var prettyTime = require('pretty-hrtime'); var ansi = require('../../../shared/ansi'); var formatError = require('../format-error'); // Wire up logging events function logEvents(gulpInst) { var loggedErrors = []; gulpInst.on('start', function(evt) { /* istanbul ignore next */ // TODO: batch these // so when 5 tasks start at once it only logs one time with all 5 var level = evt.branch ? 'debug' : 'info'; log[level]('Starting', '\'' + ansi.cyan(evt.name) + '\'...'); }); gulpInst.on('stop', function(evt) { var time = prettyTime(evt.duration); /* istanbul ignore next */ var level = evt.branch ? 'debug' : 'info'; log[level]( 'Finished', '\'' + ansi.cyan(evt.name) + '\'', 'after', ansi.magenta(time) ); }); gulpInst.on('error', function(evt) { var msg = formatError(evt); var time = prettyTime(evt.duration); var level = evt.branch ? 'debug' : 'error'; log[level]( '\'' + ansi.cyan(evt.name) + '\'', ansi.red('errored after'), ansi.magenta(time) ); // If we haven't logged this before, log it and add to list if (loggedErrors.indexOf(evt.error) === -1) { log.error(msg); loggedErrors.push(evt.error); } }); } module.exports = logEvents; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/log/get-task.js000066400000000000000000000015571415667007300232470ustar00rootroot00000000000000'use strict'; var isObject = require('isobject'); function getTask(gulpInst) { return function(name) { var task = gulpInst.task(name); return { description: getDescription(task), flags: getFlags(task), }; }; } function getDescription(task) { if (typeof task.description === 'string') { return task.description; } /* istanbul ignore else */ if (typeof task.unwrap === 'function') { var origFn = task.unwrap(); if (typeof origFn.description === 'string') { return origFn.description; } } return undefined; } function getFlags(task) { if (isObject(task.flags)) { return task.flags; } /* istanbul ignore else */ if (typeof task.unwrap === 'function') { var origFn = task.unwrap(); if (isObject(origFn.flags)) { return origFn.flags; } } return undefined; } module.exports = getTask; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/log/sync-task.js000066400000000000000000000017001415667007300234320ustar00rootroot00000000000000'use strict'; var log = require('gulplog'); var ansi = require('../../../shared/ansi'); var tasks = {}; function warn() { var taskKeys = Object.keys(tasks); if (!taskKeys.length) { return; } var taskNames = taskKeys.map(function(key) { return tasks[key]; }).join(', '); process.exitCode = 1; log.warn( ansi.red('The following tasks did not complete:'), ansi.cyan(taskNames) ); log.warn( ansi.red('Did you forget to signal async completion?') ); } function start(e) { tasks[e.uid] = e.name; } function clear(e) { delete tasks[e.uid]; } function clearAll() { tasks = {}; } function logSyncTask(gulpInst, opts) { process.once('exit', warn); gulpInst.on('start', start); gulpInst.on('stop', clear); // When not running in --continue mode, we need to clear everything on error to avoid // false positives. gulpInst.on('error', opts.continue ? clear : clearAll); } module.exports = logSyncTask; node-gulp-4.0.2+~cs38.20.35/lib/versioned/^4.0.0/log/tasks-simple.js000066400000000000000000000001741415667007300241360ustar00rootroot00000000000000'use strict'; function logTasksSimple(nodes) { console.log(nodes.join('\n').trim()); } module.exports = logTasksSimple; node-gulp-4.0.2+~cs38.20.35/package.json000066400000000000000000000035111415667007300173260ustar00rootroot00000000000000{ "name": "gulp-cli", "version": "2.3.0", "description": "Command line interface for gulp", "author": "Gulp Team (https://gulpjs.com/)", "contributors": [], "homepage": "https://gulpjs.com", "repository": "gulpjs/gulp-cli", "license": "MIT", "man": "gulp.1", "engines": { "node": ">= 0.10" }, "main": "index.js", "bin": { "gulp": "bin/gulp.js" }, "files": [ "index.js", "lib", "bin", "completion", "gulp.1" ], "scripts": { "lint": "eslint .", "prepublish": "marked-man --name gulp docs/CLI.md > gulp.1", "pretest": "npm run lint", "test": "mocha --async-only --timeout 5000 test/lib test", "cover": "nyc --reporter=lcov --reporter=text-summary npm test", "coveralls": "nyc --reporter=text-lcov npm test | coveralls" }, "dependencies": { "ansi-colors": "^1.0.1", "archy": "^1.0.0", "array-sort": "^1.0.0", "concat-stream": "^1.6.0", "color-support": "^1.1.3", "copy-props": "^2.0.1", "fancy-log": "^1.3.2", "gulplog": "^1.0.0", "interpret": "^1.4.0", "isobject": "^3.0.1", "liftoff": "^3.1.0", "matchdep": "^2.0.0", "mute-stdout": "^1.0.0", "pretty-hrtime": "^1.0.0", "replace-homedir": "^1.0.0", "semver-greatest-satisfied-range": "^1.1.0", "v8flags": "^3.2.0", "yargs": "^7.1.0" }, "devDependencies": { "babel-preset-es2015": "^6.5.0", "babel-register": "^6.5.1", "coveralls": "^3.0.3", "eslint": "^2.13.1", "eslint-config-gulp": "^3.0.1", "expect": "^1.20.2", "gulp": "^4.0.0", "gulp-test-tools": "^0.6.1", "marked-man": "^0.2.1", "mocha": "^3.2.0", "nyc": "^13.3.0", "rimraf": "^2.6.1", "semver": "^5.7.1" }, "keywords": [ "build", "stream", "system", "make", "tool", "asset", "pipeline" ] }