gulp-auto-angular/main.js

var gulp = require("gulp");
var $ = require('gulp-load-plugins')();
var through = require("through2");
var fs = require("fs");
var Path = require("path");
var events = require('events');
// 创建 eventEmitter 对象
var eventEmitter = new events.EventEmitter();
/**
 * 主要是开发时使用，实现对目录的监听、打包等
 */
var config = {
    modulename: "starter",
    browserify: {
        public: {
            entry: "main/main.js",
            concatWith: "lib/ionic/js/ionic.bundle.min.js",
            name: "concat.js",
            mini: true
        },
        default: {
            dest: "./"
        },
        deploy: {
            dest: "dist"
        }
    },
    grammer: {
        default: {
            "dev": "qianzhixiang"
        },
        deploy: {
            "dev": "qianzhixiasdasdang"
        },
        public: {

        }
    },
    less: {
        public: {
            src: "style.less",
            concatWith: "lib/ionic/css/ionic.min.css",
            dest: "./",
            name: "style.css",
            mini: true
                // relaySrcPath: ""
        },
        default: {

        },
        deploy: {
            dest: "dist"
        }
    },
    static: {
        deploy: {
            src: ["lib/ionic/fonts/*", "index.html"],
            dest: ["dist", "../../server/views"]
        }
    },
    deploy: ["dist", "../../server/views"],
    watch: ['style.less', 'main/**'],
    angular: {
        provider: {
            directory: [/\-provider$/gi, /\-prvd/gi, /\-svc/gi],
            file: [/\-provider/gi, /\-prvd/gi, /\-svc/gi],
        },
        controller: {
            directory: [/\-controller/gi, /\-ctrl/gi],
            file: [/\-controller/gi, /\-ctrl/gi],
        },
        config: {
            directory: [/\-config/gi, /\-cfg/gi],
            file: [/\-config/gi, /\-cfg/gi]
        },
        directive: {
            directory: [/\-directive/gi, /\-direct/gi],
            file: [/\-directive/gi, /\-direct/gi],
        },
        filter: {
            directory: [/\-filter/gi, /\-flt/gi],
            file: [/\-filter/gi, /\-flt/gi],

        },
        run: {
            directory: [/\-run/gi],
            file: [/\-run/gi]
        },
        factory: {
            directory: [/\-factory/gi, /\-fct/gi, /\-services$/gi],
            file: [/\-factory/gi, /\-fct/gi],
        }
    }
}
var watcher = function(name) {
    var me = this;
    me.name = name;
    console.log("开始监听", name)
    gulp.watch(name, function(file) {
        if (me.isLegal(file)) {
            // 是个合法的路径
            var parse = me.parse(file.path);
            if (parse.extname == ".html") {
                // 将html转为js
                used.html2js(file, function() {})
            }
            if (file.type == "added") {
                if (parse.type == "directory") {
                    // 是个文件夹
                    me.initDirectory(file.path, function() {
                        // 建立完成  
                    });
                }
                if (parse.type == "file") {
                    // 是个文件 文件有可能是我手动建立时添加的，这个同样的是会被监听到的，得防止这类的处理，否则browserify等处理就很重复
                    if (parse.extname == ".less") {
                        // 将less 添加到父目录
                        me.initParent(file.path, "style.less", function() {

                        }, true);
                    }
                    if (parse.extname == ".js") {
                        if (parse.filename !== "main") {
                            // 将js 添加到父目录
                            me.initParent(file.path, "main.js", function() {

                            }, true);
                            // 将内容写到js
                            console.log(parse.filename, "发生了改变！");
                            for (var i in config.angular) {
                                var item = config.angular[i];
                                var flag = 0;
                                for (var j in item.file) {
                                    var reg = item.file[j];
                                    if (reg.test(parse.filename)) {
                                        reg.lastIndex = 0;
                                        // 将`-`拼接起来的名称转为驼峰法的命名
                                        var arr = parse.filename.split("-");
                                        var str = arr[0] || "";
                                        for (var k = 1; k < arr.length; k++) {
                                            var p = arr[k];
                                            p = p.replace(/\w/i, function(a, b) { return a.toUpperCase() })
                                            str += p;
                                        }
                                        console.log("匹配到了", i)
                                            // 匹配的上
                                        i == "config" || i == "run" ?
                                            fs.writeFileSync(file.path, "angular.module('" + config.modulename + "')\n    ." + i + "(function(){\n    \n})") :
                                            fs.writeFileSync(file.path, "angular.module('" + config.modulename + "')\n    ." + i + "('" + str + "',function(){\n    \n})");
                                        flag++;
                                        break;
                                    }
                                }
                                if (flag <= 0) {
                                    // file没找到 到目录找
                                    for (var j in item.directory) {
                                        var reg = item.directory[j];
                                        // 父目录
                                        if (reg.test(parse.parent)) {
                                            reg.lastIndex = 0;
                                            var arr = parse.filename.split("-");
                                            var str = arr[0] || "";
                                            for (var k = 1; k < arr.length; k++) {
                                                var p = arr[k];
                                                p = p.replace(/\w/i, function(a, b) { return a.toUpperCase() })
                                                str += p;
                                            }
                                            // 匹配的上
                                            i == "config" || i == "run" ?
                                                fs.writeFileSync(file.path, "angular.module('" + config.modulename + "')\n    ." + i + "(function(){\n    \n})") :
                                                fs.writeFileSync(file.path, "angular.module('" + config.modulename + "')\n    ." + i + "('" + str + "',function(){\n    \n})");
                                            flag++;
                                            break;
                                        }
                                    }
                                }
                                if (flag > 0) {
                                    break;
                                }
                            }
                        } else {
                            console.log("是main.js")
                        }
                    }
                }
            } else {
                if (parse.type == "file") {
                    // 是个文件 文件有可能是我手动建立时添加的，这个同样的是会被监听到的，得防止这类的处理，否则browserify等处理就很重复
                    if (parse.extname == ".less") {
                        // 将less 添加到父目录
                        used.less(false, function() {

                        })
                    }
                    if (parse.extname == ".js") {
                        // 编译
                        used.browserify(false, function() {

                        })
                    }
                }
            }

        }
    })
};
watcher.prototype.isLegal = function(file) {
    var me = this;
    try {
        var arr = me.name.split("*");
        // 由于gulp-watch本身的bug,比如监听某个文件，其实他会监听当前所在的目录，容易出现bug
        var watch_root = Path.join(process.cwd(), arr[0]);
        // 判断是自己需要监听的目录
        if (watch_root && file.path.indexOf(watch_root) >= 0) {
            return true;
        }
    } catch (e) {
        return false;
    }
    return false;
};
watcher.prototype.parse = function(path) {
    var me = this;
    var extname = Path.extname(path);
    var dirname = Path.dirname(path);
    return {
        extname: extname,
        dirname: dirname,
        filename: Path.basename(path, extname),
        parent: Path.basename(dirname),
        type: me.getType(path)
    }
};
watcher.prototype.getType = function(path) {
    try {
        var stat = fs.statSync(path);
        if (stat.isFile()) {
            return "file";
        } else if (stat.isDirectory()) {
            return "directory";
        } else {
            return null;
        }
    } catch (e) {
        // 不存在
        return null;
    }
    return null;
};
/**
 * [initDirectory description] 去父目录加上require
 * @param  {[type]}   path [description]
 * @param  {Function} cb   [description]
 * @return {[type]}        [description]
 */
watcher.prototype.initDirectory = function(path, cb) {
    var me = this;
    cb = cb || function() {};
    var js = Path.join(path, "main.js");
    var less = Path.join(path, "style.less");
    var flag = 0;
    me.initParent(path, "main.js", function() {
        flag++;
        if (flag == 4) {
            cb();
        }
    });
    me.initParent(path, "style.less", function() {
        flag++;
        if (flag == 4) {
            cb();
        }
    });
    fs.writeFile(js, "angular.module('" + config.modulename + "')\n    ", function() {
        flag++;
        if (flag == 4) {
            cb();
        }
    });
    fs.writeFile(less, "\n", function() {
            flag++;
            if (flag == 4) {
                cb();
            }
        })
        // 在父层级的main 以及 less 加上对应的后缀

};
watcher.prototype.initParent = function(path, filename, cb, isFile) {
    var dirname = Path.dirname(path);
    var basename = Path.basename(path);
    var parent = isFile ? Path.join(dirname, filename) : Path.join(dirname, filename);
    var extname = Path.extname(filename);
    var pre = "";
    if (fs.existsSync(parent)) {
        var stream = gulp.src(parent)
        if (!isFile) {
            if (extname == ".js") {
                stream = stream.pipe($.footer("require('./" + basename + Path.sep + filename + "');\n"))
            };
            if (extname == ".less") {
                stream = stream.pipe($.footer("@import './" + basename + Path.sep + filename + "';\n"))
            }
        } else {
            if (extname == ".js") {
                stream = stream.pipe($.footer("require('./" + basename + "');\n"))
            };
            if (extname == ".less") {
                stream = stream.pipe($.footer("@import './" + basename + "';\n"))
            }
        }
        // .pipe($.footer(pre + "('./" + basename + Path.sep + filename + "')\n"))
        stream.pipe(gulp.dest(dirname))
            .on("end", function() {
                cb();
            })
    } else {
        console.log(parent, " is not exists")
    }
}
var used = {
    mix: (function(a, b) {
        var mix = function(a, b) {
            if (typeof b == "object" && !(b instanceof Array)) {
                for (var i in b) {
                    if (!a.hasOwnProperty(i)) {
                        a[i] = b[i];
                    } else {
                        // 有
                        a[i] = mix(a[i], b[i]);
                    }
                }
            } else {
                a = b;
            }
            return a;
        };
        return mix;
    })(),
    html2js: function(file, cb) {
        var me = this;
        cb = cb || function() {};
        var dirname = Path.dirname(file.path);
        var relative = Path.relative(process.cwd(), dirname) + "/";
        gulp.src(file.path)
            .pipe($.plumber({
                errorHandler: me.errorHandler
            }))
            .pipe($.ngHtml2js({
                moduleName: config.modulename,
                prefix: relative,
                standalone: true
            }))
            .pipe($.footer("module.exports='<%= name %>';", { name: relative + Path.basename(file.path) }))
            .pipe(gulp.dest(dirname))
            .on("end", function() {
                cb();
            })
    },
    browserify: function(isDeploy, cb) {
        var me = this;
        cb = cb || function() {};
        console.log("browserify begin")
        var rename = me.getPro(isDeploy, "browserify", "name")
        var entry = me.getPro(isDeploy, "browserify", "entry")
        var stream = gulp.src(entry)
            .pipe($.plumber({
                errorHandler: me.errorHandler
            }))
            .pipe($.browserify()) // browserify的操作
            .pipe($.ngAnnotate()) // 加上依赖
            // 匹配语法
            .pipe(through.obj(function(file, enc, cb) {
                file.contents = new Buffer(me.formatGrammer(file.contents.toString("utf8"), isDeploy));
                this.push(file);
                cb();
            }))
            // 压缩
        if (me.getPro(isDeploy, "browserify", "mini")) {
            stream = stream.pipe($.uglify())
        }
        stream = stream.pipe(through.obj(function(file, enc, cb) {
                var contents = '';
                var me_ = this;
                // 打包合并
                gulp.src(me.getPro(isDeploy, "browserify", "concatWith"))
                    .pipe($.concat("concat.js"))
                    .pipe(through.obj(function(f, e, c) {
                        contents += f.contents.toString("utf8");
                        file.contents = new Buffer(contents + file.contents);
                        // this.push(f)
                        c(null, f);

                        me_.push(file);
                        cb();
                    }))
            }))
            .pipe($.rename(rename))
        var destPath = me.getPro(isDeploy, "browserify", "dest");
        if (destPath instanceof Array) {
            destPath.forEach(function(p) {
                stream = stream.pipe(gulp.dest(p));
            })
        } else if (typeof destPath == "string") {
            stream = stream.pipe(gulp.dest(destPath));
        } else {
            stream = stream.pipe(gulp.dest("./"));
        }
        stream.on("end", function() {
            console.log("browserify end")
            cb();
        })
    },
    less: function(isDeploy, cb) {
        var me = this;
        console.log("less begin");
        var stream = gulp.src(me.getPro(isDeploy, "less", "src"))
            .pipe($.less());
        if (me.getPro(isDeploy, "less", "mini")) {
            stream = stream.pipe($.minifyCss())
        }
        // 合并
        stream = stream.pipe(through.obj(function(file, enc, cb) {
                var me_ = this;
                gulp.src(me.getPro(isDeploy, "less", "concatWith"))
                    .pipe(through.obj(function(f, e, c) {
                        f.contents = new Buffer(me.transformCssPath(f.contents.toString("utf8"), f.path));
                        this.push(f);
                        c();
                    }))
                    .pipe($.concat(me.getPro(isDeploy, "less", "name")))
                    .pipe(through.obj(function(f, e, c) {
                        file.contents = new Buffer(f.contents.toString("utf8") + file.contents.toString("utf8"));
                        c();
                        me_.push(file);
                        cb();
                    }))
            }))
            // 存放在路径
        var destPath = me.getPro(isDeploy, "less", "dest");
        if (destPath instanceof Array) {
            destPath.forEach(function(p) {
                stream = stream.pipe(gulp.dest(p));
            })
        } else if (typeof destPath == "string") {
            stream = stream.pipe(gulp.dest(destPath));
        } else {
            stream = stream.pipe(gulp.dest("./"));
        }
        stream.on("end", function() {
            console.log("less end")
            cb();
        })
    },
    formatGrammer: function(content, isDeploy) {
        var reg = /\$\{\s*([$_a-zA-Z0-9]+)\s*\}/gi;
        content = content.replace(reg, function(content, cloak) {
            var grammer;
            if (isDeploy) {
                // 发布环境
                grammer = config.grammer.deploy;
            } else {
                // 非发布环境
                grammer = config.grammer.default;
            };
            if (grammer.hasOwnProperty(cloak)) {
                // 是否有对应的属性
                return grammer[cloak];
            } else {
                return config.grammer.public[cloak];
            }
        })
        return content;
    },
    errorHandler: function(err) {
        console.log(err.toString());
    },
    getPro: function(isDeploy, type, pro) {
        return isDeploy ?
            (function() {
                if (pro == "dest" && config.deploy) {
                    return config.deploy;
                }
                return (config[type]['deploy'][pro] ? config[type]['deploy'][pro] : config[type]['public'][pro]);
            })() :
            (config[type]['default'][pro] ? config[type]['default'][pro] : config[type]['public'][pro])
    },
    transformCssPath: function(content, path, point) {
        var reg = /url\(([^\(\)]+)\)/gi;
        var data_reg = /data\:.+/gi;
        content = content.replace(reg, function(content, cloak) {
            cloak = cloak.trim();
            arr = cloak.match(data_reg);
            if (!arr) {
                var relativedir = Path.dirname(Path.relative(process.cwd(), path));
                cloak = Path.join(relativedir, cloak);
            }
            return cloak;
        })
        return content;
    },
    mkdir: function(dir, mode) {
        var pathTemp = '/';
        dir.split(Path.sep).forEach(function(dirname) {
            pathTemp = Path.join(pathTemp, dirname);
            if (!fs.existsSync(pathTemp)) {
                console.log("不存在", pathTemp)
                    // 不存在，新建
                fs.mkdirSync(pathTemp, mode)
            }
        })
    },
    writeFileSync: function(file) {
        var me = this;
        var filepath = file.path;
        var contents = file.contents.toString("utf8");
        var dir = Path.dirname(filepath);
        me.mkdir(dir);
        fs.writeFileSync(filepath, contents);
    },
    del: (function() {
        function iterator(url, dirs) {
            var stat = fs.statSync(url);
            if (stat.isDirectory()) {
                dirs.unshift(url); //收集目录
                inner(url, dirs);
            } else if (stat.isFile()) {
                fs.unlinkSync(url); //直接删除文件
            }
        }

        function inner(path, dirs) {
            var arr = fs.readdirSync(path);
            for (var i = 0, el; el = arr[i++];) {
                iterator(path + "/" + el, dirs);
            }
        }
        return function(dir, cb) {
            cb = cb || function() {};
            var dirs = [];
            try {
                iterator(dir, dirs);
                for (var i = 0, el; el = dirs[i++];) {
                    fs.rmdirSync(el); //一次性删除所有收集到的目录
                }
                cb()
            } catch (e) { //如果文件或目录本来就不存在，fs.statSync会报错，不过我们还是当成没有异常发生
                e.code === "ENOENT" ? cb() : cb(e);
            }
        }
    })()
};
var auto = {
    watchConfig: function(path) {

        fs.watch(path, function(e, filename) {
            delete require.cache[path];
            var cfg = require(path);
            used.mix(config, cfg);
        })
    },
    start: function(cfg, func) {
        var me = this;
        var cfg_ = require(cfg);
        used.mix(config, cfg_);
        func = func || function() {};
        gulp.task("default", function() {
            var flag = 0;
             me.watchConfig(cfg);
            eventEmitter.on("relayend", function() {
                if (config.watch) {
                    if (typeof config.watch == 'string') {
                        config.watch = [config.watch];
                    } else if (!(config.watch instanceof Array)) {
                        config.watch = []
                    }
                }
                config.watch.forEach(function(src) {
                    new watcher(src);
                })
            });
            used.browserify(false, function() {
                flag++;
                if (flag == 2) {
                    eventEmitter.emit("relayend")
                }
            })
            used.less(false, function() {
                flag++;
                if (flag == 2) {
                    eventEmitter.emit("relayend")
                }
            })
            func()
        });
        gulp.task("deploy", function() {
            var dest = [];
            if (config.deploy) {
                if (typeof config.deploy == "string") {
                    dest.push(config.deploy);
                } else if (config.deploy instanceof Array) {
                    dest = config.deploy;
                }
            } else if (typeof config.static.deploy.dest == "string") {
                dest.push(config.static.deploy.dest);
            } else if (config.static.deploy.dest instanceof Array) {
                dest = config.static.deploy.dest;
            };
            dest.forEach(function(destname) {
                used.del(destname);
            })
            gulp.src(config.static.deploy.src)
                .pipe(through.obj(function(file, enc, cb) {
                    var relative = Path.relative(process.cwd(), file.path);
                    dest.forEach(function(destname) {
                        var destPath = Path.join(Path.resolve(destname), relative);
                        file.path = destPath;
                        used.writeFileSync(file);
                    })
                    this.push(file);
                    cb();
                }))
            used.browserify(true, function() {

            });
            used.less(true, function() {

            })
        })
    }
}
module.exports = auto;