Fare file sorso di scrittura in modo sincrono prima di passare al prossimo compito

Question

gulpfile.js

gulp.task('browser-bundle', ['react'], function() { 
... 

}); 


gulp.task('react', function(){ 
    gulp.src(options.JSX_SOURCE) 
     .pipe(react()) 
     .pipe(gulp.dest(options.JSX_DEST)) 
}); 

Come potete vedere ho il compito browser fascio a seconda del compito reagire. Credo che questo funziona come previsto perché in uscita vedo questo:

[gulp] Running 'react'... 
[gulp] Finished 'react' in 3.43 ms 
[gulp] Running 'browser-bundle'... 

Tuttavia, anche se il compito di reagire è terminato, i file sua presunta di scrivere il sistema operativo non sono ancora lontani. Ho notato che se inserisco un'istruzione sleep nel comando bundle del browser, funziona come previsto, tuttavia questo mi sembra un po 'fastidioso.

Se si desidera che l'attività di risposta non venga considerata terminata finché i file (da gulp.dest) non sono stati scritti in modo sincrono su disco, come dovrei farlo?

Answer 1

Hai bisogno di un istruzione return:

gulp.task('react', function(){ 
    return gulp.src(options.JSX_SOURCE) 
     .pipe(react()) 
     .pipe(gulp.dest(options.JSX_DEST)) 
}); 

Con questo tutte le mie operazioni di scrittura sono fatte prima che l'attività successiva elaborazione.

Answer 2

La risposta accettata è a posto, ma come per https://github.com/gulpjs/gulp/issues/899, nel ramo 3.x di gulp, non si può fare questo con le dipendenze senza un po 'di salsa speciale:

var run = require('run-sequence'); 
var nodeunit = require('gulp-nodeunit'); 
var babel = require('gulp-babel'); 
var gulp = require('gulp'); 

/// Explicitly run items in order 
gulp.task('default', function(callback) { 
    run('scripts', 'tests', callback); 
}); 

/// Run tests 
gulp.task('tests', function() { 
    return gulp.src('./build/**/*.tests.js').pipe(nodeunit()); 
}); 

// Compile ES6 scripts using bable 
gulp.task('scripts', function() { 
    return gulp.src('./src/**/*.js') 
    .pipe(babel()) 
    .pipe(gulp.dest('./build')); 
}); 

Avviso specificamente l'uso del modulo "sequenza di esecuzione" per forzare l'esecuzione delle attività una dopo l'altra.

(Senza run, rm -rf build && gulp si tradurrà in OK: 0 assertions (0ms) perché il compito tests non troverà i file creati con il compito scripts perché comincia prima che l'attività scripts è completamente risolto)

Answer 3

Met stesso problema qui. Diciamo che ci sono 2 compiti, primo e secondo. La seconda rincorsa dopo la prima. La prima attività genera alcuni file, che devono essere letti dalla seconda attività. L'utilizzo della dipendenza non garantisce che la seconda attività possa trovare i file generati.

Devo usare esplicitamente il callback done sulla pipeline per consentire che Second solo inizi dopo il primo veramente eseguito.

//This approach works! 
gulp.task('First', function(done)) { 
    var subFolders = fs.readdirSync(somefolder)... 
    var tasksForFolders = subFolders.map(function(folder) { 
     return gulp.src('folder/**/*').sthtogeneratefiles(); 
    }); 
    tasksForFolders[tasksForFolders.length-1].on('end',done); 
    return tasksForFolders; 
} 

gulp.task('Second', ['First'],function() { 
    return gulp.src('generatedfolders/**/*').doth(); 
} 

Senza la done trucco, la seconda non trova mai i file generati da First. Di seguito viene mostrato ciò che ho provato, la seconda attività può trovare i file generati chiamando a mano gulp First e quindi chiamando gulp Second successivamente.

//This is the WRONG approach, just for demonstration!! 
gulp.task('First', function()) { 
    var subFolders = fs.readdirSync(somefolder)... 
    var tasksForFolders = subFolders.map(function(folder) { 
     return gulp.src('folder/**/*').sthtogeneratefiles(); 
    }); 
    return tasksForFolders; 
} 

gulp.task('Second', function() { 
    return gulp.src('generatedfolders/**/*').doth(); 
}