开源软件名称（OpenSource Name）：

开源软件地址(OpenSource Url)：

开源编程语言(OpenSource Language)：

开源软件介绍(OpenSource Introduction)：

Sublime Gulp

A plugin to run your Gulp tasks from within Sublime plus some handy snippets too.

Quickstart

1. Install Via Package Control Gulp
2. Open your repo containing either a gulpfile.js file or directory
3. If you don't already have a default gulp task make one
4. Menu to Tools>Gulp>Run Default Task
5. Enjoy!

Installation

via PackageControl

If you have PackageControl installed, you can use it to install the package.

Just type cmd-shift-p/ctrl-shift-p to bring up the command pallete and pick Package Control: Install Package from the dropdown, search and select the package there and you're all set.

Manually

You can clone the repo in your /Packages (Preferences -> Browse Packages...) folder and start using/hacking it.

cd ~/path/to/Packages
git clone git://github.com/nicosantangelo/sublime-gulp.git Gulp

Troubleshooting

For older gulp versions, the plugin makes use of node which should already be installed if you are using Gulp. It creates a cache using node, so in some systems you might need to add your node_modules path to the NODE_PATH, for example (for Unix):

export NODE_PATH=/usr/local/lib/node_modules

Sublime Gulp might not work without var gulp = require('gulp'); defined in each task file. More info (thanks @smeijer for the help)

If you are having trouble running the plugin in Mac OSX it's possible that your path isn't being reported by your shell. In which case give the plugin SublimeFixMacPath a try. It may resolve our issue.

If you still can't get it to run properly, first make sure your Gulp tasks run from a terminal (i.e. outside of sublime) and if so then submit an issue.

CoffeeScript Support

If you want to use a gulpfile.coffee you need to do two things:

1. Add module.exports = gulp to your gulpfile.coffee so node can use it
2. Create a gulpfile.js if it doesn't exist and add this to it:

require('coffee-script/register');
var gulp = require('./gulpfile.coffee');

Gulpfile.js

The Sublime Gulp plugin was made for those using the Gulp Streaming Build - Task Runner System within Node.js for their workflow.

Sublime Gulp now supports not only a basic gulpfile.js file in the root of your project but also recognizes your tasks within a directory set by the RequireDir module or within a gulpfile.js directory. So no matter how your gulp tasks are organized Sublime Gulp will find them.

Usage

Available Commands

Sublime Gulp supports the following commands accessible from Tools -> Command Palette by typing in "Gulp". They are also accesible from menus as indicated below the table. Default.sublime-commands also lists them.

• The first five commands are available via Tools -> Gulp in the main menu and in Gulp in the sidebar context menu.
• The the 6th and 7th are available via View -> Gulp in the main menu.
• The last command is available via File at the bottom in the main menu.

Running a Gulp Task

To run a task, first choose Gulp from the command pallete or List Tasks to Run from the menu, the package will search for your tasks in the open folder/project and create a cache (.sublime-gulp.cache) in the root. The first run will be slow as the cache builds but then the cache will speed up future access. You can use the gulp_delete_cache command to rebuild the cache if you are not seeing your newly added Gulp Tasks or some have gone missing.

The plugin will then display all the Gulp tasks in a list. Selecting one will run that task. To show the task's standard output the plugin uses a panel or a new tab (depends on your settings). After a first task has been run you can use the hide and show panel commands as desired. (see table above)

If you want to run the normal Gulp command without standard output to the panel use instead Gulp (silent).

Arbitrary task

If you want to run an arbitrary task you need to choose Gulp: Run arbitrary task from the command pallete or Run arbitrary task from the menu. The package will then prompt an input panel where you can write what you want to add as a sufix to gulp.

Run last task

The command will re-run the last task ran by any of the package commands (if there's one).

Customized Task Access

Out of the box Sublime Gulp has a menu item Run Default Task under Tools -> Gulp that will run your default Gulp task. Most Gulp users have a default task defined (like running their development tasks).

If you want to run other of your tasks from a menu item or keyboard shortcut you can customize both.

For example to add a menu item in the tools menu for a sass task do this. In your sublime user directory add following json in the Main.sublime-menu file (create one if you don't have one).

[
    {
        "id": "tools",
        "children": [
             { "caption": "Run Sass Task", "command": "gulp", "args": { "task_name": "sass" } }
         ]
    }
]

Note: You can run any command silently by adding "silent": true to the args.

or you also can use a keyboard shortcut to do the same. Edit Preferences -> Key Bindings - User to access the user key bindings file to which add this line:

{ "keys": ["KEYS"], "command": "gulp", "args": { "task_name": "sass" } }

For more detailed information on shortcut keys and binding specific tasks below.

Killing Tasks

To kill running tasks like watch you have two options, you can pick the command Gulp: Kill running tasks to kill all currently running tasks or Gulp: Kill specific running task to choose from the command pallete which task to kill.

If you want to supress the command output, you can map it to a keyboard shortcut and pass true to the silent argument like this:

{ "keys": ["KEYS"], "command": "gulp_kill", "args": { "silent": true } }

{ "keys": ["KEYS"], "command": "gulp_kill_task", "args": { "silent": true } }

For more detailed information on shortcut keys and binding specific tasks below.

Windows

If you're running Windows, the package will use taskkill so every child process is correctly terminated. If the executable isn't on your system, you'll need to add it for this command to work correctly.

Show or Hide the Panel

Gulp: Show Panel shows the closed output panel (just the panel, it won't re-open the tab if you're using the results_in_new_tab setting). Alternatively typing <esc> will also close/hide an open panel.

Listing Gulp Plugins

Running Gulp: List plugins from the command palette will display all gulp plugins available on a searcheable list. Picking one will open its github repo on your default browser.

Deleting The Cache

Running Gulp: Delete cache will delete the .sublime-gulp.cache file for you, forcing a re-parse of the gulpfile.js.

Quitting Sublime Killing Running Gulp Tasks

This command will close Sublime Text, but first it'll kill any running tasks. It's the same as running Gulp: Kill running tasks and immediately exiting the editor. If error occurs killing the tasks or no running tasks are found, the editor will close anyways.

You can select Gulp: Exit editor killing running tasks from the command palette or create a keybinding like this:

{ "keys": ["KEYS"], "command": "gulp_exit" }

You can bind it to alt+f4 or super+q so you don't have to remember it. Sadly it won't run if you close the editor using the close button (x).

Snippets

vargulp

var gulp = require('gulp-name');

pipe

pipe(name('file'))

gulps - Docs

gulp.src('scriptFiles')
  .pipe(name('file'))

gulpt - Docs

gulp.task('name',['tasks'], function() {
    // content
});

gulpd - Docs

.pipe(gulp.dest('folder'));

gulpw - Docs

gulp.watch('file', ['tasks']);

gulpwcb - Docs

gulp.watch('file', function(event) {
  console.log(' File '+event.path+' was '+event.type+', running tasks...');
});

Settings

The file Gulp.sublime-settings is used for configuration, you can change your user settings in Preferences -> Package Settings -> Gulp -> Settings - User.

The defaults are:

{
    "exec_args": {},
    "recursive_gulpfile_search": false,
    "ignored_gulpfile_folders": [".git", "node_modules", "vendor", "tmp", "dist"],
    "gulpfile_paths": [],
    "results_in_new_tab": false,
    "results_autoclose_timeout_in_milliseconds": 0,
    "show_silent_errors": true,
    "log_errors": true,
    "syntax": "Packages/Gulp/syntax/GulpResults.tmLanguage",
    "nonblocking": true,
    "track_processes": true,
    "flags": {},
    "check_for_gulpfile": false,
    "tasks_on_save": {},
    "silent_tasks_on_save": {},
    "kill_before_save_tasks": false,
    "status_bar_tasks": false,
    "status_bar_format": "Gulp: {task_name}"
}

exec_args

You may override your PATH environment variable as follows (from sublime-grunt):

{
    "exec_args": {
        "path": "/bin:/usr/bin:/usr/local/bin"
    }
}

gulp installed locally

If gulp is installed locally in the project, you have to specify the path to the gulp executable. Threfore, adjust the path to /bin:/usr/bin:/usr/local/bin:node_modules/.bin

recursive_gulpfile_search

If set to true, the package will search for a gulpfile.js file recursively through each top level folder ignoring the folders defined in ignored_gulpfile_folders.

If false, only top level folders and the ones found on gulpfile_paths are used.

ignored_gulpfile_folders

Ignored folder names for the recursive search of gulpfile.js files, used to drastically improve performance. Example: [".git", "node_modules", "vendor", "tmp", "dist"]

gulpfile_paths

This setting is active only if recursive_gulpfile_search is false.

Each item in the array constitutes an additional paths to search the gulpfile in, by default only the root of each project folder is used. Example: ["src", "nested/folder"]

results_in_new_tab

If set to true, a new tab will be used instead of a panel to output the results.

results_autoclose_timeout_in_milliseconds

Defines the delay used to autoclose the panel or tab that holds the gulp results. If false (or 0) it will remain open, so if what you want is to keep it closed check the silent command.

show_silent_errors

If true it will open the output panel when running Gulp (silent) only if the task failed

log_errors

Toggles the creation of sublime-gulp.log if any error occurs.

syntax

Syntax file for highlighting the gulp results. You can pick it from from the command panel as Set Syntax: Gulp results.

Set the setting to false if you don't want any colors (you may need to restart Sublime if you're removing the syntax).

nonblocking

When enabled, the package will read the streams from the task process using two threads, one for stdout and another for stderr. This allows all the output to be piped to Sublime live without having to wait for the task to finish.

If set to false, it will read first from stdout and then from stderr.

track_processes

Persist the long running task pids to a local file to keep track even if the editor is closed.

If set to false package will keep track of tasks in memory, meaning that if you run a long running task like gulp watch and restart Sublime Text, the process wont't necessarily die and you won't be able to kill it from the editor anymore.

If set to true the package will keep track of long running tasks using an internal .sublime-gulp.cache. So even if you close your editor and re-open it, you should still be able to list and kill running tasks.

Depending on the OS you're on, the process might die anyways without the package interverting. Sublime Gulp tries to remedy this by checking if the process is still alive before listing it, which works most of the time but it's not a reliable check. Worst case scenario, you'll see a dead task, killing it won't do anything. Worst and really not likely case scenario, you'll kill another process if the pid was reused by the OS