docs: function proceedConcatTask(task, done) {
        var sources          = task.src;
        var dest             = task.dest;
        var options          = task.options;
        var lazy             = options.lazy;
        var transformsConcat = options.transformsConcat.slice(0);
        var separator        = options.separator;
        var banner           = options.banner;
        var footer           = options.footer;
        var mode             = options.mode;
        var statSources      = {};
        var statDest;
  
        grunt.verbose.writeln('Concat [%s] -> %s', sources.join(',').blue, dest.blue);
  
        async.series([
          // All sources stats
          function(next) {
            Q.all(sources.map(function(src) {
              return Q.nfcall(fs.stat, src)
              .then(function(stat) {
                statSources[src] = stat;
              });
            }))
            .then(function() { next(); })
            .fail(function(err) {next(err);});
          },
  
          // Destination stats
          function(next) {
            fs.stat(dest, function(err, stat) {
              // Ignore error
              statDest = stat;
              next();
            });
          },
  
          // Lazy mode
          function(next) {
            // If not lazy or if destination do not exist, continue
            if(!lazy || !statDest) {
              return next();
            }
  
            // If any of the sources is newer than dest, then continue,
            // else, done in lazy mode
            if(_.any(statSources, function(statSrc) { return statSrc.mtime.getTime() > statDest.mtime.getTime();})) {
              next();
            } else {
              grunt.verbose.writeln('  Ignore :'+' Destination file (%s) is allready transformed (See options.lazy).'.grey, dest.blue);
              return done(null, false);
            }
  
          },
  
          // Make parent directory
          function(next) {
            // Here destination is allways a file.
            // Only the parent folder is required
            var dir = dirname(dest);
            if(dirExists[dir]) {
              return next();
            }
  
            grunt.verbose.writeln('  Make directory %s', dir.blue);
            mkdirp(dir, function(err) {
              if(err) {
                return next(err);
              }
              tally.dirs++;
              dirExists[dir] = true;
              return next();
            });
  
          },
  
          // Concat
          function(next) {
            var wait = 0;
            function _exec() {
              if(writtingFiles[dest]) {
                // Try leater
                grunt.verbose.writeln('  ... wait for %s before writing (%s)', dest, wait++);
                return setImmediate(_exec);
              }
              writtingFiles[dest] = true;
  
              var trans = [], transStream = through2();
              tally.concats++;
  
              // Each transform builder is called and combined in
              // one readable/writable stream using stream-combiner
              if(transformsConcat && transformsConcat.length) {
                trans = _(transformsConcat)
                // Call each tranform stream builder
                .map(function(f) {
                  return f(sources, dest, _.extend({}, options));
                })
                // Keep only stream (ignore anything without a pipe() method)
                .filter(function(s) { return s && s.pipe; });
                transStream = bun(trans);
              }
  
              var mainStream    = new StreamStream({separator: ''});
              var bodyStream    = new StreamStream({separator: separator});
              var writeStream   = fs.createWriteStream(dest, {mode: mode});
  
              // Concat each sources
              sources.forEach(function(src) {
                if(!statSources[src].size) {
                  return;
                }
                bodyStream.write(fs.createReadStream(src));
              });
              bodyStream.end();
  
  
              grunt.verbose.writeln(
                '  read([%s]) -> transform(count:%s) -> write(%s)',
                sources.join(',').blue,
                trans.length.toString().blue,
                dest.blue
              );
  
              // Pipe all together
              if(banner) {
                mainStream.write(strToStream(banner));
              }
  
              mainStream.write(bun([bodyStream, transStream]));
  
              if(footer) {
                mainStream.write(strToStream(footer));
              }
  
              mainStream.end();
  
              // Write out
              mainStream.pipe(writeStream);
  
              mainStream.on('error', function(error) {
                grunt.fail.fatal(error);
              });
  
              writeStream.once('finish', function() {
                writtingFiles[dest] = false;
                next();
              });
            }
            _exec();
          }
        ], function(err, result) {
          if(err) {
            grunt.log.error(err);
            grunt.log.writeln("Consider using a 'clean' task before running this task again");
            done(err);
          } else {
            // Finished with changes
            done(null, true);
          }
        });
      }