diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 49502f00f7..9574c8aaf2 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -312,6 +312,8 @@ All definitions files include a header with the author and editors, so at some p
* [Valerie](https://github.com/davewatts/valerie) (by [Howard Richards](https://github.com/conficient))
* [Viewporter](https://github.com/zynga/viewporter) (by [Boris Yankov](https://github.com/borisyankov))
* [Vimeo](http://developer.vimeo.com/player/js-api) (by [Daz Wilkin](https://github.com/DazWilkin/))
+* [vinyl](https://github.com/wearefractal/vinyl) (by [vvakame](https://github.com/vvakame/))
+* [vinyl-fs](https://github.com/wearefractal/vinyl-fs) (by [vvakame](https://github.com/vvakame/))
* [WebRTC](http://dev.w3.org/2011/webrtc/editor/webrtc.html) (by [Ken Smith](https://github.com/smithkl42))
* [websocket](https://github.com/Worlize/WebSocket-Node) (by [Paul Loyd](https://github.com/loyd))
* [WinJS](http://msdn.microsoft.com/en-us/library/windows/apps/br229773.aspx) (from TypeScript samples)
diff --git a/vinyl-fs/vinyl-fs-tests.ts b/vinyl-fs/vinyl-fs-tests.ts
new file mode 100644
index 0000000000..016da5e8b3
--- /dev/null
+++ b/vinyl-fs/vinyl-fs-tests.ts
@@ -0,0 +1,531 @@
+///
+///
+
+///
+
+///
+
+
+// from src
+
+import vfs = require('vinyl-fs');
+
+import path = require('path');
+import fs = require('fs'); // require('graceful-fs');
+
+// import bufEqual = require('buffer-equal');
+declare var bufEqual: any;
+// import through = require('through2');
+declare var through: any;
+import File = require('vinyl');
+
+import should = require('should');
+require('mocha');
+
+declare var gulp: any;
+declare var bufferStream: any;
+
+var dataWrap = function(fn:any) {
+ return function(data:any, enc:any, cb:any) {
+ fn(data);
+ cb();
+ };
+};
+
+describe('source stream', function() {
+
+ it('should explode on invalid glob (empty)', function(done) {
+ var stream:any;
+ try {
+ stream = gulp.src();
+ } catch (err) {
+ should.exist(err);
+ should.not.exist(stream);
+ done();
+ }
+ });
+
+ it('should explode on invalid glob (number)', function(done) {
+ var stream:any;
+ try {
+ stream = gulp.src(123);
+ } catch (err) {
+ should.exist(err);
+ should.not.exist(stream);
+ done();
+ }
+ });
+
+ it('should explode on invalid glob (empty array)', function(done) {
+ var stream:any;
+ try {
+ stream = gulp.src([]);
+ } catch (err) {
+ should.exist(err);
+ should.not.exist(stream);
+ done();
+ }
+ });
+
+ it('should pass through writes', function(done) {
+ var expectedPath = path.join(__dirname, "./fixtures/test.coffee");
+ var expectedContent = fs.readFileSync(expectedPath);
+
+ var expectedFile = new File({
+ base: __dirname,
+ cwd: __dirname,
+ path: expectedPath,
+ contents: expectedContent
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ bufEqual(buffered[0].contents, expectedContent).should.equal(true);
+ done();
+ };
+
+ var stream = vfs.src("./fixtures/nothing.coffee");
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should glob a file with default settings', function(done) {
+ var expectedPath = path.join(__dirname, "./fixtures/test.coffee");
+ var expectedContent = fs.readFileSync(expectedPath);
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ should.exist(buffered[0].stat);
+ buffered[0].path.should.equal(expectedPath);
+ buffered[0].isBuffer().should.equal(true);
+ bufEqual(buffered[0].contents, expectedContent).should.equal(true);
+ done();
+ };
+
+ var stream = vfs.src("./fixtures/*.coffee", {cwd: __dirname});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ });
+
+ it('should glob a file with default settings and relative cwd', function(done) {
+ var expectedPath = path.join(__dirname, "./fixtures/test.coffee");
+ var expectedContent = fs.readFileSync(expectedPath);
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ should.exist(buffered[0].stat);
+ buffered[0].path.should.equal(expectedPath);
+ buffered[0].isBuffer().should.equal(true);
+ bufEqual(buffered[0].contents, expectedContent).should.equal(true);
+ done();
+ };
+
+ var stream = vfs.src("./fixtures/*.coffee", {cwd: path.relative(process.cwd(), __dirname)});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ });
+
+ it('should glob a directory with default settings', function(done) {
+ var expectedPath = path.join(__dirname, "./fixtures/wow");
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].path.should.equal(expectedPath);
+ buffered[0].isNull().should.equal(true);
+ buffered[0].isDirectory().should.equal(true);
+ done();
+ };
+
+ var stream = vfs.src("./fixtures/wow/", {cwd: __dirname});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ });
+
+ it('should glob a file with with no contents', function(done) {
+ var expectedPath = path.join(__dirname, "./fixtures/test.coffee");
+ var expectedContent = fs.readFileSync(expectedPath);
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].path.should.equal(expectedPath);
+ buffered[0].isNull().should.equal(true);
+ should.not.exist(buffered[0].contents);
+ done();
+ };
+
+ var stream = vfs.src("./fixtures/*.coffee", {cwd: __dirname, read: false});
+
+ var buffered:any = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ });
+
+ it('should glob a file with streaming contents', function(done) {
+ var expectedPath = path.join(__dirname, "./fixtures/test.coffee");
+ var expectedContent = fs.readFileSync(expectedPath);
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ should.exist(buffered[0].stat);
+ buffered[0].path.should.equal(expectedPath);
+ buffered[0].isStream().should.equal(true);
+
+ var contentBuffer = new Buffer([]);
+ var contentBufferStream = through(dataWrap(function(data:any){
+ contentBuffer = Buffer.concat([contentBuffer, data]);
+ }));
+ buffered[0].contents.pipe(contentBufferStream);
+ buffered[0].contents.once('end', function(){
+ bufEqual(contentBuffer, expectedContent);
+ done();
+ });
+ };
+
+ var stream = vfs.src("./fixtures/*.coffee", {cwd: __dirname, buffer: false});
+
+ var buffered:any = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ });
+
+});
+
+// from dest
+// var vfs = require('../');
+
+// var path = require('path');
+// var fs = require('graceful-fs');
+import rimraf = require('rimraf');
+
+// var bufEqual = require('buffer-equal');
+// var through = require('through2');
+// var File = require('vinyl');
+
+// var should = require('should');
+require('mocha');
+
+var wipeOut = function(cb:any) {
+ rimraf(path.join(__dirname, "./out-fixtures/"), cb);
+};
+
+var dataWrap = function(fn:any) {
+ return function(data:any, enc:any, cb:any) {
+ fn(data);
+ cb();
+ };
+};
+
+var realMode = function(n:any) {
+ return n & 07777;
+};
+
+describe('dest stream', function() {
+ beforeEach(wipeOut);
+ afterEach(wipeOut);
+
+ it('should explode on invalid folder', function(done) {
+ var stream:any;
+ try {
+ stream = gulp.dest();
+ } catch (err) {
+ should.exist(err);
+ should.not.exist(stream);
+ done();
+ }
+ });
+
+ it('should pass through writes with cwd', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test.coffee");
+
+ var expectedFile = new File({
+ base: __dirname,
+ cwd: __dirname,
+ path: inputPath,
+ contents: null
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ done();
+ };
+
+ var stream = vfs.dest("./out-fixtures/", {cwd: __dirname});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should pass through writes with default cwd', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test.coffee");
+
+ var expectedFile = new File({
+ base: __dirname,
+ cwd: __dirname,
+ path: inputPath,
+ contents: null
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ done();
+ };
+
+ var stream = vfs.dest(path.join(__dirname, "./out-fixtures/"));
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should not write null files', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test.coffee");
+ var inputBase = path.join(__dirname, "./fixtures/");
+ var expectedPath = path.join(__dirname, "./out-fixtures/test.coffee");
+ var expectedCwd = __dirname;
+ var expectedBase = path.join(__dirname, "./out-fixtures");
+
+ var expectedFile = new File({
+ base: inputBase,
+ cwd: __dirname,
+ path: inputPath,
+ contents: null
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ buffered[0].cwd.should.equal(expectedCwd, 'cwd should have changed');
+ buffered[0].base.should.equal(expectedBase, 'base should have changed');
+ buffered[0].path.should.equal(expectedPath, 'path should have changed');
+ fs.existsSync(expectedPath).should.equal(false);
+ done();
+ };
+
+ var stream = vfs.dest("./out-fixtures/", {cwd: __dirname});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should write buffer files to the right folder with relative cwd', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test.coffee");
+ var inputBase = path.join(__dirname, "./fixtures/");
+ var expectedPath = path.join(__dirname, "./out-fixtures/test.coffee");
+ var expectedCwd = __dirname;
+ var expectedBase = path.join(__dirname, "./out-fixtures");
+ var expectedContents = fs.readFileSync(inputPath);
+
+ var expectedFile = new File({
+ base: inputBase,
+ cwd: __dirname,
+ path: inputPath,
+ contents: expectedContents
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ buffered[0].cwd.should.equal(expectedCwd, 'cwd should have changed');
+ buffered[0].base.should.equal(expectedBase, 'base should have changed');
+ buffered[0].path.should.equal(expectedPath, 'path should have changed');
+ fs.existsSync(expectedPath).should.equal(true);
+ bufEqual(fs.readFileSync(expectedPath), expectedContents).should.equal(true);
+ done();
+ };
+
+ var stream = vfs.dest("./out-fixtures/", {cwd: path.relative(process.cwd(), __dirname)});
+
+ var buffered:any = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should write buffer files to the right folder', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test.coffee");
+ var inputBase = path.join(__dirname, "./fixtures/");
+ var expectedPath = path.join(__dirname, "./out-fixtures/test.coffee");
+ var expectedContents = fs.readFileSync(inputPath);
+ var expectedCwd = __dirname;
+ var expectedBase = path.join(__dirname, "./out-fixtures");
+ var expectedMode = 0655;
+
+ var expectedFile = new File({
+ base: inputBase,
+ cwd: __dirname,
+ path: inputPath,
+ contents: expectedContents,
+ stat: {
+ mode: expectedMode
+ }
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ buffered[0].cwd.should.equal(expectedCwd, 'cwd should have changed');
+ buffered[0].base.should.equal(expectedBase, 'base should have changed');
+ buffered[0].path.should.equal(expectedPath, 'path should have changed');
+ fs.existsSync(expectedPath).should.equal(true);
+ bufEqual(fs.readFileSync(expectedPath), expectedContents).should.equal(true);
+ realMode(fs.lstatSync(expectedPath).mode).should.equal(expectedMode);
+ done();
+ };
+
+ var stream = vfs.dest("./out-fixtures/", {cwd: __dirname});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should write streaming files to the right folder', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test.coffee");
+ var inputBase = path.join(__dirname, "./fixtures/");
+ var expectedPath = path.join(__dirname, "./out-fixtures/test.coffee");
+ var expectedContents = fs.readFileSync(inputPath);
+ var expectedCwd = __dirname;
+ var expectedBase = path.join(__dirname, "./out-fixtures");
+ var expectedMode = 0655;
+
+ var contentStream = through.obj();
+ var expectedFile = new File({
+ base: inputBase,
+ cwd: __dirname,
+ path: inputPath,
+ contents: contentStream,
+ stat: {
+ mode: expectedMode
+ }
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ buffered[0].cwd.should.equal(expectedCwd, 'cwd should have changed');
+ buffered[0].base.should.equal(expectedBase, 'base should have changed');
+ buffered[0].path.should.equal(expectedPath, 'path should have changed');
+ fs.existsSync(expectedPath).should.equal(true);
+ bufEqual(fs.readFileSync(expectedPath), expectedContents).should.equal(true);
+ realMode(fs.lstatSync(expectedPath).mode).should.equal(expectedMode);
+ done();
+ };
+
+ var stream = vfs.dest("./out-fixtures/", {cwd: __dirname});
+
+ var buffered:any = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ setTimeout(function(){
+ contentStream.write(expectedContents);
+ contentStream.end();
+ }, 100);
+ stream.end();
+ });
+
+ it('should write directories to the right folder', function(done) {
+ var inputPath = path.join(__dirname, "./fixtures/test");
+ var inputBase = path.join(__dirname, "./fixtures/");
+ var expectedPath = path.join(__dirname, "./out-fixtures/test");
+ var expectedCwd = __dirname;
+ var expectedBase = path.join(__dirname, "./out-fixtures");
+ var expectedMode = 0655;
+
+ var expectedFile = new File({
+ base: inputBase,
+ cwd: __dirname,
+ path: inputPath,
+ contents: null,
+ stat: {
+ isDirectory: function(){
+ return true;
+ },
+ mode: expectedMode
+ }
+ });
+
+ var onEnd = function(){
+ buffered.length.should.equal(1);
+ buffered[0].should.equal(expectedFile);
+ buffered[0].cwd.should.equal(expectedCwd, 'cwd should have changed');
+ buffered[0].base.should.equal(expectedBase, 'base should have changed');
+ buffered[0].path.should.equal(expectedPath, 'path should have changed');
+ fs.existsSync(expectedPath).should.equal(true);
+ fs.lstatSync(expectedPath).isDirectory().should.equal(true);
+ realMode(fs.lstatSync(expectedPath).mode).should.equal(expectedMode);
+ done();
+ };
+
+ var stream = vfs.dest("./out-fixtures/", {cwd: __dirname});
+
+ var buffered:any[] = [];
+ bufferStream = through.obj(dataWrap(buffered.push.bind(buffered)), onEnd);
+ stream.pipe(bufferStream);
+ stream.write(expectedFile);
+ stream.end();
+ });
+
+ it('should allow piping multiple dests in streaming mode', function(done) {
+ var inputPath1 = path.join(__dirname, "./out-fixtures/multiple-first");
+ var inputPath2 = path.join(__dirname, "./out-fixtures/multiple-second");
+ var inputBase = path.join(__dirname, "./out-fixtures/");
+ var srcPath = path.join(__dirname, "./fixtures/test.coffee");
+ var stream1 = vfs.dest('./out-fixtures/', {cwd: __dirname});
+ var stream2 = vfs.dest('./out-fixtures/', {cwd: __dirname});
+ var content = fs.readFileSync(srcPath);
+ var rename = through.obj(function(file:any, _:any, next:any) {
+ file.path = inputPath2;
+ this.push(file);
+ next();
+ });
+
+ stream1.on('data', function(file:any) {
+ file.path.should.equal(inputPath1);
+ })
+
+ stream1.pipe(rename).pipe(stream2);
+ stream2.on('data', function(file:any) {
+ file.path.should.equal(inputPath2);
+ }).once('end', function() {
+ fs.readFileSync(inputPath1, 'utf8').should.equal(content.toString());
+ fs.readFileSync(inputPath2, 'utf8').should.equal(content.toString());
+ done();
+ });
+
+ var file = new File({
+ base: inputBase,
+ path: inputPath1,
+ cwd: __dirname,
+ contents: content
+ })
+
+ stream1.write(file);
+ stream1.end();
+ })
+
+});
diff --git a/vinyl-fs/vinyl-fs.d.ts b/vinyl-fs/vinyl-fs.d.ts
new file mode 100644
index 0000000000..e9f5491610
--- /dev/null
+++ b/vinyl-fs/vinyl-fs.d.ts
@@ -0,0 +1,31 @@
+// Type definitions for vinyl-fs
+// Project: https://github.com/wearefractal/vinyl-fs
+// Definitions by: vvakame
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///
+///
+
+declare module NodeJS {
+ interface WritableStream {
+ write(buffer: any/* Vinyl.IFile */, cb?: Function): boolean;
+ }
+}
+
+declare module "vinyl-fs" {
+ import _events = require("events");
+
+ function src(globs:string, opt?:{read?:boolean;buffer?:boolean;}):NodeJS.ReadWriteStream;
+
+ function src(globs:string[], opt?:{read?:boolean;buffer?:boolean;}):NodeJS.ReadWriteStream;
+
+ function watch(globs:string, cb?:(outEvt:{type:any;path:any;old:any;})=>void):_events.EventEmitter;
+
+ function watch(globs:string[], cb?:(outEvt:{type:any;path:any;old:any;})=>void):_events.EventEmitter;
+
+ function watch(globs:string, opt?:{interval?:number;debounceDelay?:number;cwd?:string;maxListeners?:Function;}, cb?:(outEvt:{type:any;path:any;old:any;})=>void):_events.EventEmitter;
+
+ function watch(globs:string[], opt?:{interval?:number;debounceDelay?:number;cwd?:string;maxListeners?:Function;}, cb?:(outEvt:{type:any;path:any;old:any;})=>void):_events.EventEmitter;
+
+ function dest(folder:string, opt?:{cwd?:string; mode?:any/* number or string */;}):NodeJS.ReadWriteStream;
+}
diff --git a/vinyl/vinyl-tests.ts b/vinyl/vinyl-tests.ts
new file mode 100644
index 0000000000..e09539990b
--- /dev/null
+++ b/vinyl/vinyl-tests.ts
@@ -0,0 +1,544 @@
+///
+///
+
+///
+
+import File = require('vinyl');
+import Stream = require('stream');
+import fs = require('fs');
+
+import should = require('should');
+
+describe('File', function() {
+
+ describe('constructor()', function() {
+ it('should default cwd to process.cwd', function(done) {
+ var file = new File();
+ file.cwd.should.equal(process.cwd());
+ done();
+ });
+
+ it('should default base to cwd', function(done) {
+ var cwd = "/";
+ var file = new File({cwd: cwd});
+ file.base.should.equal(cwd);
+ done();
+ });
+
+ it('should default base to cwd even when none is given', function(done) {
+ var file = new File();
+ file.base.should.equal(process.cwd());
+ done();
+ });
+
+ it('should default path to null', function(done) {
+ var file = new File();
+ should.not.exist(file.path);
+ done();
+ });
+
+ it('should default stat to null', function(done) {
+ var file = new File();
+ should.not.exist(file.stat);
+ done();
+ });
+
+ it('should default contents to null', function(done) {
+ var file = new File();
+ should.not.exist(file.contents);
+ done();
+ });
+
+ it('should set base to given value', function(done) {
+ var val = "/";
+ var file = new File({base: val});
+ file.base.should.equal(val);
+ done();
+ });
+
+ it('should set cwd to given value', function(done) {
+ var val = "/";
+ var file = new File({cwd: val});
+ file.cwd.should.equal(val);
+ done();
+ });
+
+ it('should set path to given value', function(done) {
+ var val = "/test.coffee";
+ var file = new File({path: val});
+ file.path.should.equal(val);
+ done();
+ });
+
+ it('should set stat to given value', function(done) {
+ var val = {};
+ var file = new File({stat: val});
+ file.stat.should.equal(val);
+ done();
+ });
+
+ it('should set contents to given value', function(done) {
+ var val = new Buffer("test");
+ var file = new File({contents: val});
+ file.contents.should.equal(val);
+ done();
+ });
+ });
+
+ describe('isBuffer()', function() {
+ it('should return true when the contents are a Buffer', function(done) {
+ var val = new Buffer("test");
+ var file = new File({contents: val});
+ file.isBuffer().should.equal(true);
+ done();
+ });
+
+ it('should return false when the contents are a Stream', function(done) {
+ var val: NodeJS.ReadWriteStream; // = new Stream();
+ var file = new File({contents: val});
+ file.isBuffer().should.equal(false);
+ done();
+ });
+
+ it('should return false when the contents are a null', function(done) {
+ var file = new File({contents: null});
+ file.isBuffer().should.equal(false);
+ done();
+ });
+ });
+
+ describe('isStream()', function() {
+ it('should return false when the contents are a Buffer', function(done) {
+ var val = new Buffer("test");
+ var file = new File({contents: val});
+ file.isStream().should.equal(false);
+ done();
+ });
+
+ it('should return true when the contents are a Stream', function(done) {
+ var val: NodeJS.ReadWriteStream; // = new Stream();
+ var file = new File({contents: val});
+ file.isStream().should.equal(true);
+ done();
+ });
+
+ it('should return false when the contents are a null', function(done) {
+ var file = new File({contents: null});
+ file.isStream().should.equal(false);
+ done();
+ });
+ });
+
+ describe('isNull()', function() {
+ it('should return false when the contents are a Buffer', function(done) {
+ var val = new Buffer("test");
+ var file = new File({contents: val});
+ file.isNull().should.equal(false);
+ done();
+ });
+
+ it('should return false when the contents are a Stream', function(done) {
+ var val: NodeJS.ReadWriteStream; // = new Stream();
+ var file = new File({contents: val});
+ file.isNull().should.equal(false);
+ done();
+ });
+
+ it('should return true when the contents are a null', function(done) {
+ var file = new File({contents: null});
+ file.isNull().should.equal(true);
+ done();
+ });
+ });
+
+ describe('isDirectory()', function() {
+ var fakeStat = {
+ isDirectory: function() {
+ return true;
+ }
+ };
+
+ it('should return false when the contents are a Buffer', function(done) {
+ var val = new Buffer("test");
+ var file = new File({contents: val, stat: fakeStat});
+ file.isDirectory().should.equal(false);
+ done();
+ });
+
+ it('should return false when the contents are a Stream', function(done) {
+ var val: NodeJS.ReadWriteStream; // = new Stream();
+ var file = new File({contents: val, stat: fakeStat});
+ file.isDirectory().should.equal(false);
+ done();
+ });
+
+ it('should return true when the contents are a null', function(done) {
+ var file = new File({contents: null, stat: fakeStat});
+ file.isDirectory().should.equal(true);
+ done();
+ });
+ });
+
+ describe('clone()', function() {
+ it('should copy all attributes over with Buffer', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: new Buffer("test")
+ };
+ var file = new File(options);
+ var file2 = file.clone();
+
+ file2.should.not.equal(file, 'refs should be different');
+ file2.cwd.should.equal(file.cwd);
+ file2.base.should.equal(file.base);
+ file2.path.should.equal(file.path);
+ file2.contents.should.not.equal(file.contents, 'buffer ref should be different');
+ file2.contents.toString('utf8').should.equal(file.contents.toString('utf8'));
+ done();
+ });
+
+ it('should copy all attributes over with Stream', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: null // new Stream()
+ };
+ var file = new File(options);
+ var file2 = file.clone();
+
+ file2.should.not.equal(file, 'refs should be different');
+ file2.cwd.should.equal(file.cwd);
+ file2.base.should.equal(file.base);
+ file2.path.should.equal(file.path);
+ file2.contents.should.equal(file.contents, 'stream ref should be the same');
+ done();
+ });
+
+ it('should copy all attributes over with null', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: null
+ };
+ var file = new File(options);
+ var file2 = file.clone();
+
+ file2.should.not.equal(file, 'refs should be different');
+ file2.cwd.should.equal(file.cwd);
+ file2.base.should.equal(file.base);
+ file2.path.should.equal(file.path);
+ should.not.exist(file2.contents);
+ done();
+ });
+
+ it('should properly clone the `stat` property', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.js",
+ contents: new Buffer("test"),
+ stat: fs.statSync(__filename)
+ };
+
+ var file = new File(options);
+ var copy = file.clone();
+
+ copy.stat.isFile().should.be.true;
+ copy.stat.isDirectory().should.be.false;
+ // should(file.stat instanceof fs.Stats).be.true;
+ // should(copy.stat instanceof fs.Stats).be.true;
+
+ done();
+ });
+ });
+
+ describe('pipe()', function() {
+ it('should write to stream with Buffer', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: new Buffer("test")
+ };
+ var file = new File(options);
+ var stream = new Stream.PassThrough();
+ stream.on('data', function(chunk:any) {
+ should.exist(chunk);
+ (chunk instanceof Buffer).should.equal(true, 'should write as a buffer');
+ chunk.toString('utf8').should.equal(options.contents.toString('utf8'));
+ });
+ stream.on('end', function(chunk:any) {
+ done();
+ });
+ var ret = file.pipe(stream);
+ ret.should.equal(stream, 'should return the stream');
+ });
+
+ it('should pipe to stream with Stream', function(done) {
+ var testChunk = new Buffer("test");
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: new Stream.PassThrough()
+ };
+ var file = new File(options);
+ var stream = new Stream.PassThrough();
+ stream.on('data', function(chunk:any) {
+ should.exist(chunk);
+ (chunk instanceof Buffer).should.equal(true, 'should write as a buffer');
+ chunk.toString('utf8').should.equal(testChunk.toString('utf8'));
+ done();
+ });
+ var ret = file.pipe(stream);
+ ret.should.equal(stream, 'should return the stream');
+
+ file.contents.write(testChunk);
+ });
+
+ it('should do nothing with null', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: null
+ };
+ var file = new File(options);
+ var stream = new Stream.PassThrough();
+ stream.on('data', function(chunk:any) {
+ throw new Error("should not write");
+ });
+ stream.on('end', function() {
+ done();
+ });
+ var ret = file.pipe(stream);
+ ret.should.equal(stream, 'should return the stream');
+ });
+
+ it('should write to stream with Buffer', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: new Buffer("test")
+ };
+ var file = new File(options);
+ var stream = new Stream.PassThrough();
+ stream.on('data', function(chunk:any) {
+ should.exist(chunk);
+ (chunk instanceof Buffer).should.equal(true, 'should write as a buffer');
+ chunk.toString('utf8').should.equal(options.contents.toString('utf8'));
+ done();
+ });
+ stream.on('end', function(chunk:any) {
+ throw new Error("should not end");
+ });
+ var ret = file.pipe(stream, {end: false});
+ ret.should.equal(stream, 'should return the stream');
+ });
+
+ it('should pipe to stream with Stream', function(done) {
+ var testChunk = new Buffer("test");
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: new Stream.PassThrough()
+ };
+ var file = new File(options);
+ var stream = new Stream.PassThrough();
+ stream.on('data', function(chunk:any) {
+ should.exist(chunk);
+ (chunk instanceof Buffer).should.equal(true, 'should write as a buffer');
+ chunk.toString('utf8').should.equal(testChunk.toString('utf8'));
+ done();
+ });
+ stream.on('end', function(chunk:any) {
+ throw new Error("should not end");
+ });
+ var ret = file.pipe(stream, {end: false});
+ ret.should.equal(stream, 'should return the stream');
+
+ file.contents.write(testChunk);
+ });
+
+ it('should do nothing with null', function(done) {
+ var options = {
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: null
+ };
+ var file = new File(options);
+ var stream = new Stream.PassThrough();
+ stream.on('data', function(chunk:any) {
+ throw new Error("should not write");
+ });
+ stream.on('end', function(chunk:any) {
+ throw new Error("should not end");
+ });
+ var ret = file.pipe(stream, {end: false});
+ ret.should.equal(stream, 'should return the stream');
+ process.nextTick(done);
+ });
+ });
+
+ describe('inspect()', function() {
+ it('should return correct format when no contents and no path', function(done) {
+ var file = new File();
+ file.inspect().should.equal('');
+ done();
+ });
+
+ it('should return correct format when Buffer and no path', function(done) {
+ var val = new Buffer("test");
+ var file = new File({
+ contents: val
+ });
+ file.inspect().should.equal('>');
+ done();
+ });
+
+ it('should return correct format when Buffer and relative path', function(done) {
+ var val = new Buffer("test");
+ var file = new File({
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: val
+ });
+ file.inspect().should.equal('>');
+ done();
+ });
+
+ it('should return correct format when Buffer and only path and no base', function(done) {
+ var val = new Buffer("test");
+ var file = new File({
+ cwd: "/",
+ path: "/test/test.coffee",
+ contents: val
+ });
+ delete file.base;
+ file.inspect().should.equal('>');
+ done();
+ });
+
+ it('should return correct format when Stream and relative path', function(done) {
+ var file = new File({
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: new Stream.PassThrough()
+ });
+ file.inspect().should.equal('>');
+ done();
+ });
+
+ it('should return correct format when null and relative path', function(done) {
+ var file = new File({
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee",
+ contents: null
+ });
+ file.inspect().should.equal('');
+ done();
+ });
+ });
+
+ describe('contents get/set', function() {
+ it('should work with Buffer', function(done) {
+ var val = new Buffer("test");
+ var file = new File();
+ file.contents = val;
+ file.contents.should.equal(val);
+ done();
+ });
+
+ it('should work with Stream', function(done) {
+ var val = new Stream.PassThrough();
+ var file = new File();
+ file.contents = val;
+ file.contents.should.equal(val);
+ done();
+ });
+
+ it('should work with null', function(done) {
+ var val:any = null;
+ var file = new File();
+ file.contents = val;
+ (file.contents === null).should.equal(true);
+ done();
+ });
+
+ it('should not work with string', function(done) {
+ var val = "test";
+ var file = new File();
+ try {
+ file.contents = val;
+ } catch (err) {
+ should.exist(err);
+ done();
+ }
+ });
+ });
+
+ describe('relative get/set', function() {
+ it('should error on set', function(done) {
+ var file = new File();
+ try {
+ file.relative = "test";
+ } catch (err) {
+ should.exist(err);
+ done();
+ }
+ });
+
+ it('should error on get when no base', function(done) {
+ var a:any;
+ var file = new File();
+ delete file.base;
+ try {
+ a = file.relative;
+ } catch (err) {
+ should.exist(err);
+ done();
+ }
+ });
+
+ it('should error on get when no path', function(done) {
+ var a:any;
+ var file = new File();
+ try {
+ a = file.relative;
+ } catch (err) {
+ should.exist(err);
+ done();
+ }
+ });
+
+ it('should return a relative path from base', function(done) {
+ var file = new File({
+ cwd: "/",
+ base: "/test/",
+ path: "/test/test.coffee"
+ });
+ file.relative.should.equal("test.coffee");
+ done();
+ });
+
+ it('should return a relative path from cwd', function(done) {
+ var file = new File({
+ cwd: "/",
+ path: "/test/test.coffee"
+ });
+ file.relative.should.equal("test/test.coffee");
+ done();
+ });
+ });
+
+});
diff --git a/vinyl/vinyl.d.ts b/vinyl/vinyl.d.ts
new file mode 100644
index 0000000000..72b688a5f1
--- /dev/null
+++ b/vinyl/vinyl.d.ts
@@ -0,0 +1,41 @@
+// Type definitions for vinyl
+// Project: https://github.com/wearefractal/vinyl
+// Definitions by: vvakame
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///
+
+declare module Vinyl {
+ interface IOptions {
+ cwd?:string;
+ base?:string;
+ path?:string;
+ contents?:any; // Buffer or Stream
+ }
+
+ interface IFileStatic {
+ new (file?:IOptions):IFile;
+ }
+
+ interface IFile {
+ cwd:string;
+ base:string;
+ path:string;
+ stat:any; // stat = fs stats object
+ contents:any; // Buffer or Stream
+ relative:string;
+
+ isBuffer():boolean;
+ isStream():boolean;
+ isNull():boolean;
+ isDirectory():boolean;
+ clone():IFile;
+ pipe(stream:T, opts?:{ end?: boolean; }):T;
+ inspect():string;
+ }
+}
+
+declare module "vinyl" {
+ var _:Vinyl.IFileStatic;
+ export = _;
+}