// Generated by CoffeeScript 1.7.1
                        "use strict";
                        var Helpers, LineUp, Promise, Sync, fs, lineup, path, register, tree, util, _;
                        
                        tree = require("read-package-tree");
                        
                        _ = require("lodash");
                        
                        path = require("path");
                        
                        fs = require("fs");
                        
                        util = require("util");
                        
                        Promise = require("bluebird");
                        
                        Helpers = require("../util/Helpers");
                        
                        register = new Helpers();
                        
                        LineUp = require("lineup");
                        
                        lineup = new LineUp();
                        
                        
                        /**
                         * Class to sync bundled / local hooks , helps in registering hooks in short
                         * @class Sync
                         * @constructor
                         */
                        
                        Sync = (function() {
                          function Sync() {
                        
                            /**
                               * @property content_path
                               * @type {String} path to content directory to save bundled and app specific hooks
                             */
                            this.content_path = path.join(__dirname, "../../content");
                        
                            /**
                               * @property project_path
                               * @type {String} path to ngCli root
                             */
                            this.project_path = path.join(__dirname, "../../");
                          }
                        
                        
                          /**
                             * @method init
                             * @param type {String} bundled or nothing
                             * @return {promise} Returns promise object with config(if not bundled) and project root
                           */
                        
                          Sync.prototype.init = function(type) {
                            var config, defer;
                            defer = Promise.defer();
                            if (type) {
                              this.modules = path.join(this.content_path, "bundled.js");
                              config = {};
                              config.project_root = this.project_path;
                              defer.resolve(config);
                            } else {
                              this.modules = path.join(this.content_path, "modules.js");
                              register.getConfig(function(err, config) {
                                if (err) {
                                  defer.reject(err);
                                } else {
                                  defer.resolve(config);
                                }
                              });
                            }
                            return defer.promise;
                          };
                        
                        
                          /**
                             * @method fetchModules
                             * @param config {Object} config object to obtain project root and scan npm modules for ng hooks
                             * @return {promise} Returns promise with list of ng hooks
                           */
                        
                          Sync.prototype.fetchModules = function(config) {
                            var defer, project_root;
                            defer = Promise.defer();
                            project_root = config.project_root;
                            tree(project_root, function(err, modules) {
                              var hooks;
                              if (err) {
                                return defer.reject(err);
                              } else {
                                hooks = {};
                                _.each(modules.children, function(values) {
                                  if (values["package"]["ng-hook"]) {
                                    hooks[values.realpath] = values["package"]["ng-hook"];
                                  }
                                });
                                return defer.resolve(hooks);
                              }
                            });
                            return defer.promise;
                          };
                        
                        
                          /**
                             * @method registerModules
                             * @param modules {Object} Hooks object to register standalone and dependent hooks as local js modules
                             * @return {String} Returns promise with success or error on saving hooks
                           */
                        
                          Sync.prototype.registerModules = function(modules) {
                            var defer, depends, module_string, self, standalone;
                            defer = Promise.defer();
                            self = this;
                            standalone = [];
                            depends = [];
                            _.each(modules, function(v, k) {
                              v.weight = v.weight || 0;
                              if (v["hook-for"] && v.name) {
                                if (v.after) {
                                  _.each(v.after, function(after) {
                                    return depends.push({
                                      after: after,
                                      name: v.name,
                                      path: k,
                                      weight: v.weight,
                                      attached: v["hook-for"]
                                    });
                                  });
                                } else {
                                  standalone.push({
                                    name: v.name,
                                    path: k,
                                    weight: v.weight,
                                    attached: v["hook-for"]
                                  });
                                }
                              }
                            });
                            modules = {
                              standalone: standalone,
                              depends: depends
                            };
                            modules = JSON.stringify(modules);
                            module_string = "module.exports = " + util.inspect(modules);
                            fs.writeFileSync(self.modules, module_string);
                            defer.resolve("Registered modules successfully");
                            return defer.promise;
                          };
                        
                          return Sync;
                        
                        })();
                        
                        module.exports = Sync;