var cache = {}, layoutsCache = {}, fs = require('fs'),
    path        = require('path'),
    // import railway utils
    utils       = require('./railway_utils'),
    safe_merge  = utils.safe_merge,
    camelize    = utils.camelize,
    classify    = utils.classify,
    underscore  = utils.underscore,
    singularize = utils.singularize,
    pluralize   = utils.pluralize,
    $           = utils.stylize.$,
    log         = utils.debug,
    runCode     = utils.runCode;1
var IS_NODE_04 = process.versions.node < '0.6';1
var ctlParams = {};1
var id = 0;1
var CommonjsController = require('./commonjs_controller');1
/**
 * Controller encapsulates http request handling layer. It allows to 
 * render response, redirect, and tons of other related stuff.
 *
 * Instance of controller is actual response handler, it's not a 
 * like in RoR, you can not inherit controllers, just load, mix.
 *
 * Inheritance in controllers is bad idea.
 *
 * @param {String} name - name of controller
 */
function Controller(name, root) {
    var self = this;11
    this.id = ++id;11
    this._beforeFilters = [];11
    this._afterFilters = [];11
    this._actions = {};11
    this._layout = null;11
    this._buffer = {};11
    ctlParams[this.id] = {};11
    this.root = this.__dirname = root || app.root;11
    if (!layoutsCache[name]) {
        // TODO: what if view engine name differs from extension?
        layoutsCache[name] = railway.utils.existsSync(app.root + '/app/views/layouts/' + name + '_layout.' + app.settings['view engine']) ? name : 'application';6
    }
    ctlParams[this.id].baseLayout =
    ctlParams[this.id].layout = layoutsCache[name];11
    // allow to disable layout by default for all views
    // using app.settings['view options'].layout = false
    if ((app.set('view options') || {}).layout === false) {
        ctlParams[this.id].baseLayout = false;
    }
    this.controllerName = name;11
    this.controllerFile = Controller.index[this.root][name];11
    if (!this.controllerFile) {
        throw new Error('Controller ' + name + ' is not defined');
    }
    // import outer context
    var outerContext = Controller.context[this.root][name];11
    if (outerContext) {
        Object.keys(outerContext).forEach(function (key) {
            self[key] = outerContext[key].bind(self);11
        });11
    }
    // fix object inheritance broken when using as context
    Object.keys(Controller.prototype).forEach(function (method) {
        self[method] = Controller.prototype[method].bind(self);319
    });11
    this._filterParams = ['password'];11
    if (!IS_NODE_04) {
        this.__defineGetter__('response',  function () { return this.ctx.res }.bind(this));11
        this.__defineGetter__('res',       function () { return this.ctx.res }.bind(this));11
        this.__defineGetter__('request',   function () { return this.ctx.req }.bind(this));11
        this.__defineGetter__('req',       function () { return this.ctx.req }.bind(this));11
        this.__defineGetter__('session',   function () { return this.ctx.req.session }.bind(this));11
        this.__defineGetter__('params',    function () { return this.ctx.req.params }.bind(this));11
        this.__defineGetter__('body',      function () { return this.ctx.req.body }.bind(this));11
        this.__defineGetter__('next',      function () { return this.ctx.next }.bind(this));11
        this.__defineGetter__('actionName',function () { return this.ctx.action }.bind(this));11
        this.__defineGetter__('path_to',   function () { return this.ctx.paths }.bind(this));11
    }
    this.t = T();11
    this.t.locale = app.settings.defaultLocale || 'en';11
    this.T = T;11
    if (global.__cov && !this.__cov) {
        this.__cov = global.__cov;11
    }
}
/**
 * Publish some object or function to use in another controller
 */
Controller.prototype.publish = function (name, obj) {
    if (typeof name === 'function') {
        obj = name;5
        this._buffer[obj.name] = obj;5
    } else if (typeof name === 'string') {
        this._buffer[name] = obj;5
    }
};1
/**
 * Get some object or function published in another controller
 */
Controller.prototype.use = function (name) {
    var what = this._buffer[name];2
    if (typeof what === 'undefined') throw new Error(name + ' is not defined');2
    return what;2
};1
/**
 * Configure which query params should be filtered from logging
 * @param {String} param 1 name
 * @param {String} param 2 name
 * @param ...
 * @param {String} param n name
 */
Controller.prototype.filterParameterLogging = function (args) {
    this._filterParams = this._filterParams.concat(Array.prototype.slice.call(arguments));5
};1
/**
 * Initialize controller (called on first request)
 * @private
 */
Controller.prototype._init = function initializeController() {
    // reset scope variables
    this._actions = {};11
    this._beforeFilters = [];11
    this._afterFilters = [];11
    this._buffer = {};11
    ctlParams[this.id].layout = ctlParams[this.id].baseLayout;11
    // publish models
    if (app.models) {
        Object.keys(app.models).forEach(function (className) {
            this[className] = app.models[className];
        }.bind(this));11
    }
    runCode(this.controllerFile, this);11
};1
/**
 * @param {String} name - name of filter to skip
 * @param {Array} or {String} only - choose actions to skip filter
 */
Controller.prototype.skipBeforeFilter = function (name, only) {
    this._beforeFilters.forEach(function (filter, i) {
        if (filter[0] && filter[0].customName && name === filter[0].customName) {
            skipFilter(this._beforeFilters, i, only ? only.only : null);4
        }
    }.bind(this));4
};1
/**
 * @param {String} name - name of filter to skip
 * @param {Array} or {String} only - choose actions to skip filter
 */
Controller.prototype.skipAfterFilter = function (name, only) {
    this._afterFilters.forEach(function (filter, i) {
        if (filter[0] && filter[0].customName && name === filter[0].customName) {
            skipFilter(this._afterFilters, i, only ? only.only : null);
        }
    }.bind(this));
};1
/**
 * @param {Array} filters collection
 * @param {Number} index of filter to skip
 * @param {Array} or {String} only - choose actions to skip filter
 * @private
 */
function skipFilter(filters, index, only) {
    if (!only) {
        delete filters[index];2
    } else if (filters[index][0]) {
        if (!filters[index][1]) {
            filters[index][1] = {except: []};2
        }
        if (!filters[index][1].except) {
            filters[index][1].except = [];
        } else if (typeof filters[index][1].except === 'string') {
            filters[index][1].except = [filters[index][1].except];
        }
        if (typeof only === 'string') {
            filters[index][1].except.push(only);
        } else if (only && only.constructor.name === 'Array') {
            only.forEach(function (name) {
                filters[index][1].except.push(name);2
            });2
        }
    }
}
/**
 * Define controller action
 *
 * @param name String - optional (if missed, named function required as first param)
 * @param action Funcion - required, should be named function if first arg missed
 *
 * @example
 * ```
 * action(function index() {
 *     Post.all(function (err, posts) {
 *         render({posts: posts});
 *     });
 * });
 * ```
 *
 */
Controller.prototype.action = function (name, action) {
    if (typeof name === 'function') {
        action = name;14
        name = action.name;14
        if (!name) {
            throw new Error('Named function required when `name` param omitted');
        }
    }
    action.isAction = true;16
    action.customName = name;16
    this._actions[name] = action;16
};1
/**
 * Internal request handler. Serves request using railway env:
 *
 * - update context links: req, res, next and other req-sensitive stuff
 * - run before filters
 * - run action
 * - run after filters
 *
 * `perform` method called by `ControllerBridge`
 *
 * @param {String} actionName
 * @param {IncomingMessage} req - incoming http request
 * @param {ServerResponse} res - http server response
 * @private
 */
Controller.prototype.perform = function (actionName, req, res, nextRoute) {
    res.info = {
        controller: this.controllerName,
        action: actionName,
        startTime: Date.now()
    };12
    res.actionHistory = [];12
    if (!this.initialized) {
        this.initialized = true;5
        if (IS_NODE_04) {
            this.actionName = actionName;
            this.request = this.req = req;
            this.request.sandbox = {};
            this.response = this.res = res;
            this.params = req.params;
            this.session = res.session;
            this.body = req.body;
            this.next = next;
            this.path_to = Controller.getPathTo(actionName);
        }
        this._init();5
    }
    var ctl = this, timeStart = false, prevMethod;12
    // need to track uniqueness of filters by name
    var queueIndex = {};12
    this.ctx = {
        req: req,
        res: res,
        next: next,
        action: actionName,
        paths: Controller.getPathTo(actionName)
    };12
    req.sandbox = {};12
    log('');12
    log($((new Date).toString()).yellow + ' ' + $(this.id).bold);12
    log($(req.method).bold, $(req.url).grey, 'controller:', $(this.controllerName).cyan, 'action:', $(this.actionName).blue);12
    if (req.query && Object.keys(req.query).length) {
        log($('Query: ').bold + JSON.stringify(req.query));
    }
    if (req.body && req.method !== 'GET') {
        var filteredBody = {};3
        Object.keys(req.body).forEach(function (param) {
            if (!ctl._filterParams.some(function (filter) {return param.search(filter) !== -1;})) {
                filteredBody[param] = req.body[param];1
            } else {
                filteredBody[param] = '[FILTERED]';1
            }
        });3
        log($('Body:  ').bold + JSON.stringify(filteredBody));3
    }
    // build queue using before-, after- filters and action
    var queue = [];12
    enqueue(this._beforeFilters, queue);12
    queue.push(getCaller(this._actions[actionName]));12
    enqueue(this._afterFilters, queue);12
    if (app.disabled('model cache')) {
        // queue.push(getCaller(app.disconnectSchemas));
    }
    if (app.enabled('eval cache')) {
        queue.push(getCaller(function () {
            backToPool(ctl);
        }));
    }
    // start serving request
    next();12
    var logActions = app.enabled('log actions');12
    function next(err) {
        if (logActions && timeStart && prevMethod) {
            log('<<< ' + prevMethod.customName + ' [' + (Date.now() - timeStart) + ' ms]');17
        }
        if (err && err.constructor.name === 'Error') {
            return nextRoute(err);1
        }
        if (timeStart && prevMethod) {
            res.actionHistory.push({name: prevMethod.customName, time: Date.now() - timeStart});16
        }
        // run next method in queue (if any callable method)
        var method = queue.shift();29
        if (typeof method == 'function') {
            process.nextTick(function () {
                method.call(ctl.request.sandbox, next);27
            });27
        } else {
            res.info.appTime = Date.now() - res.info.startTime;2
        }
    }
    function getCaller(method) {
        if (!method) {
            throw new Error('Undefined action');
        }
        return function (next) {29
            req.inAction = method.isAction;27
            if (logActions && method.customName) {
                if (method.isAction) {
                    log('>>> perform ' + $(method.customName).bold.cyan);10
                } else {
                    log('>>> perform ' + $(method.customName).bold.grey);16
                }
            }
            timeStart = Date.now();27
            prevMethod = method;27
            method.call(this, next);27
        }
    }
    function enqueue(collection, queue) {
        collection.forEach(function (f) {
            var params = f[1];26
            if (!params) {
                enqueue();6
            } else if (params.only && params.only.indexOf(actionName) !== -1 && (!params.except || params.except.indexOf(actionName) === -1)) {
                enqueue();3
            } else if (params.except && params.except.indexOf(actionName) === -1) {
                enqueue();8
            }
            function enqueue() {
                if (f[2]) {
                    if (queueIndex[f[2]]) return;16
                    queueIndex[f[2]] = true;16
                }
                queue.push(getCaller(f[0]));17
            }
        });24
    }
};1
/**
 * Layout setter/getter
 *
 * - when called without arguments, used as getter,
 * - when called with string, used as setter
 *
 * When `layout` not called controller trying to get guess which layout to use.
 * First of all controller looking for layout with the same name as controller,
 * for example `users_controller` will choose `users_laout`, if there's no 
 * layout with this name, controller using `application_layout`.
 *
 * If you do not want to use any layout by default, you can just set it up:
 *
 *     app.set('view options', {layout: false});
 *
 * this will prevent you from repeating `layout(false)` in each controller where
 * you do not want to use layout, for example in api controllers.
 *
 * - choose 
 *
 * @param {String} layout - [optional] layout name
 */
Controller.prototype.layout = function layout(l) {
    if (typeof l !== 'undefined') {
        ctlParams[this.id].layout = l;3
    }
    return ctlParams[this.id].layout ? ctlParams[this.id].layout + '_layout' : null;5
};1
function filter(args) {
    if (typeof args[0] === 'string' && typeof args[1] === 'function') {
        // change order
        args[1].customName = args[0];
        return [args[1], args[2], args[0]];
    } else {
        // normal order
        args[0].customName = args[0].name;19
        return [args[0], args[1], args[0].name];19
    }
}
/**
 * Schedule before filter to the end of queue. This method can be called
 * with named function as single param, or with two params: name and 
 * anonimous function
 *
 * Examples:
 * ```
 * before('some named filter', function () {});
 * before(function namedMethod() {});
 * ```
 *
 * This filters can be skipped using this names in future. Examples:
 * ```
 * skipBeforeFilter('some named filter');
 * skipBeforeFilter('namedMethod');
 * ```
 *
 * Please note, that every named filter only can be scheduled once:
 * ```
 * before(function myMethod() {
 *     ~~~C15~~~
 * });
 * before(function myMethod() {
 *     ~~~C16~~~
 * });
 * ```
 * This will only schedule first method!
 *
 * @alias beforeFilter
 * @param {Funcion} f
 * @param {Object} params
 */
Controller.prototype.before = function before(f, params) {
    this._beforeFilters.push(filter(arguments));19
};1
Controller.prototype.beforeFilter = Controller.prototype.before;1
/**
 * Schedule before filter to the start of queue. This method can be called
 * with named function as single param, or with two params: name and 
 * anonimous function.
 *
 * @alias prependBeforeFilter
 * @param {Funcion} f
 * @param {Object} params
 */
Controller.prototype.prependBefore = function prependBefore(f, params) {
    this._beforeFilters.unshift(filter(arguments));
};1
Controller.prototype.prependBeforeFilter = Controller.prototype.prependBefore;1
/**
 * @override default controller string representation
 */
Controller.prototype.toString = function toString() {
    return 'Controller ' + this.controllerName;
};1
/**
 * @param {String} name - name of action
 * @returns whether controller responds to action
 */
Controller.prototype.respondTo = function respondTo(name) {
    return typeof this._actions[name] == 'function';
};1
/**
 * Append after filter to the end of queue. This method can be called
 * with named function as single param, or with two params: name and 
 * anonimous function.
 *
 * @param {Function} f
 * @param {Object} params
 */
Controller.prototype.after = function after(f, params) {
    this._afterFilters.push(filter(arguments));
};1
Controller.prototype.afterFilter = Controller.prototype.after;1
/**
 * Prepend after filter to the start of queue. This method can be called
 * with named function as single param, or with two params: name and 
 * anonimous function.
 *
 * @param {Function} f
 * @param {Object} params
 */
Controller.prototype.prependAfter = function prependAfter(f, params) {
    this._afterFilters.unshift(filter(arguments));
};1
Controller.prototype.prependAfterFilter = Controller.prototype.prependAfter;1
/**
 * Set current locale. This setting will affect all views locale-specific helpers.
 *
 * @param locale
 */
Controller.prototype.setLocale = function (locale) {
    this.t.locale = T.localeSupported(locale) ? locale : app.settings.defaultLocale;
};1
/**
 * Get current locale
 *
 * @returns {String} locale name
 */
Controller.prototype.getLocale = function () {
    return this.t.locale;
};1
/**
 * Load another controller code in this context
 *
 * @param {String} controller - name of controller (without _controller suffix)
 */
Controller.prototype.load = function (controller, alias) {
    var root = Controller.aliases[alias] || this.root;4
    var ctl = Controller.index[root][controller];4
    if (!ctl) {
        throw new Error('Controller ' + controller + ' is not defined. Please note that namespaced controllers names should include namespace when loading');
    }
    runCode(ctl, this);4
};1
/**
 * Send response, as described in ExpressJS guide:
 *
 * This method is a high level response utility allowing you
 * to pass objects to respond with json, strings for html,
 * Buffer instances, or numbers representing the status code.
 * The following are all valid uses:
 * ```
 * send(); ~~~C17~~~
 * send(new Buffer('wahoo'));
 * send({ some: 'json' });
 * send('&lt;p>some html&lt;/p>');
 * send('Sorry, cant find that', 404);
 * send('text', { 'Content-Type': 'text/plain' }, 201);
 * send(404);
 * ```
 *
 */
Controller.prototype.send = function (x) {
    log('Send to client: ' + x);1
    this.response.send.apply(this.response, Array.prototype.slice.call(arguments));1
    if (this.request.inAction) this.next();1
};1
/**
 * Set or get response header
 *
 * @param {String} key - name of header
 * @param {String} val - value of header (optional)
 *
 * When second argument is omitted method acts as getter.
 *
 * Example:
 * ```
 * header('Content-Length');
 * ~~~C18~~~
 *
 * header('Content-Length', 123);
 * ~~~C19~~~
 * 
 * header('Content-Length');
 * ~~~C20~~~
 * ```
 */
Controller.prototype.header = function (key, val) {
    return this.response.header.call(this.response, key, val);
};1
/**
 * Redirect to `path`
 */
Controller.prototype.redirect = function (path) {
    log('Redirected to', $(path).grey);
    this.response.redirect(path.toString());
    if (this.request.inAction) this.next();
};1
/**
 * Render response.
 *
 * @param {String} view name [optional]
 * @param {Object} locals - data passed to view as local variables [optional]
 *
 * When first parameter is omitted action name used as view name:
 * ```
 * action(function index() {
 *     render(); ~~~C21~~~
 * });
 * ```
 *
 * Second argument is optional too, you can set local variables using `this` inside
 * action:
 * ```
 * action('new', function () {
 *     this.title = 'Create new post';
 *     this.post = new Post;
 *     render();
 * });
 * ```
 * will result the same as
 * ```
 * action('new', function () {
 *     render({
 *         title: 'Create new post',
 *         post: new Post
 *     });
 * });
 * ```
 */
Controller.prototype.render = function (arg1, arg2, cb) {
    var view, params;2
    if (typeof arg1 == 'string') {
        view = arg1;
        params = arg2;
    } else {
        view = this.actionName;2
        params = arg1;2
    }
    params = params || {};2
    params.controllerName = params.controllerName || this.controllerName;2
    params.actionName = params.actionName || this.actionName;2
    params.path_to = this.path_to;2
    params.request = this.request;2
    params.params = this.request.params;2
    params.t = this.t;2
    var layout = this.layout(),
        file = this.controllerName + '/' + view;2
    if (this.response.renderCalled) {
        log('Rendering', $(file).grey, 'using layout', $(layout).grey, 'called twice.', $('render() can be called only once!').red);
        return;
    }
    var helper;2
    try {
        helper = require(this.root + '/app/helpers/' + this.controllerName + '_helper');
    } catch(e) {
        helper = {};2
    }
    var appHelper;2
    try {
        appHelper = require(this.root + '/app/helpers/application_helper');
    } catch(e) {
        appHelper = {};2
    }
    log('Rendering', $(file).grey, 'using layout', $(layout).grey);2
    var helpers = railway.helpers.personalize(this);2
    app.set('views', this.root + '/app/views');2
    this.response.renderCalled = true;2
    this.response.render(file, {
        locals: safe_merge(params, this.request.sandbox, this.path_to, helpers, helpers.__proto__, helper, appHelper),
        layout: layout ? 'layouts/' + layout : false,
        debug:  false
    }, cb);2
    if (this.request.inAction) this.next();2
};1
/**
 * Add flash error to display in next request
 *
 * @param {String} type
 * @param {String} message
 */
Controller.prototype.flash = function flash(type, message) {
    this.request.flash.apply(this.request, Array.prototype.slice.call(arguments));
};1
/**
 * Respond to .:format
 * @param {Function} block
 *
 * Example (respond to json and html):
 *
 *     action(function index() {
 *         var fruits = this.fruits = ['apple', 'banana', 'kiwi'];
 *         respondTo(function (format) {
 *             format.html(render);
 *             format.json(function () {
 *                 send(fruits);
 *             });
 *         });
 *     });
 */
Controller.prototype.respondTo = function respondTo(block) {
    var f = this.request.params.format || 'html';
    block({
        html: function (c) {
            if (f === 'html') {
                c();
            }
        },
        json: function (c) {
            if (f === 'json') {
                c();
            }
        }
    });
};1
var pool = {};1
function backToPool(ctl) {
    pool[ctl.root][ctl.controllerName].push(ctl);
}
exports.load = function (name, root) {
    if (app.disabled('eval cache')) {
        return new Controller(name, root);11
    } else {
        if (!pool[root]) pool[root] = {};
        if (!pool[root][name]) pool[root][name] = [];
        var ctl = pool[root][name].shift();
        if (!ctl) {
            ctl = new Controller(name, root);
        }
        return ctl;
    }
};1
exports.loadNew = function (name, root) {
    if (app.disabled('eval cache')) {
        return CommonjsController.load(name, root);
    } else {
        if (!pool[root]) pool[root] = {};
        if (!pool[root][name]) pool[root][name] = [];
        var ctl = pool[root][name].shift();
        if (!ctl) {
            ctl = CommonjsController.load(name, root);
        }
        return ctl;
    }
};1
exports.loadAll = function (root) {
    Object.getOwnPropertyNames(Controller.index[root || app.root]).forEach(function(c) {
        exports.load(c, root)._init();6
    });1
};1
/**
 * @private
 */
Controller.getPathTo = function () {
    return railway.routeMapper.pathTo;12
};1
/**
 * Add custom base controller dir to railway pool. It allows you to build
 * extensions with your own controllers, and build app
 * breaken by modules
 *
 * @param {String} basePath
 * @param {String} prefix
 * @param {Object} context - controller context tweaks, all members of
 * this object will be accesible in controller
 *
 * @public railway.controller.addBasePath
 */
function addBasePath(basePath, prefix, context, root) {
    prefix = prefix || '';2
    if (!railway.utils.existsSync(basePath)) return;1
    root = root || app.root;1
    Controller.index[root] = Controller.index[root] || {};1
    Controller.context[root] = Controller.context[root] || {};1
    fs.readdirSync(basePath).forEach(addContoller);1
    function addContoller(file) {
        var stat = fs.statSync(path.join(basePath, file));6
        if (stat.isFile()) {
            var m = file.match(/(.*?)_?[cC]ontroller\.(js|coffee)$/);6
            if (m) {
                var ctl = prefix + m[1];6
                Controller.index[root][ctl] = Controller.index[root][ctl] || path.join(basePath, file);6
                Controller.context[root][ctl] = Controller.context[root][ctl] || context;6
            }
        } else if (stat.isDirectory()) {
            exports.addBasePath(path.join(basePath, file), prefix + file + '/', context, root);
        }
    }
};1
exports.addBasePath = addBasePath;1
exports.Controller = Controller;1
exports.init = function (root) {
    cache = {};1
    CommonjsController.index = Controller.index = Controller.index || {};1
    Controller.aliases = Controller.aliases || {};1
    Controller.context = Controller.context || {};1
    exports.addBasePath(root + '/app/controllers', null, null, root);1
};1
/**
 * Enables CSRF Protection
 *
 * This filter will check `authenticity_token` param of POST request 
 * and compare with token calculated by session token and app-wide secret
 *
 * @param {String} secret
 * @param {String} paramName
 *
 * @example `app/controllers/application_controller.js`
 * ```
 * before('protect from forgery', function () {
 *     protectFromForgery('415858f8c3f63ba98546437f03b5a9a4ddea301f');
 * });
 * ```
 */
Controller.prototype.protectFromForgery = function protectFromForgery(secret, paramName) {
    var req = this.request;5
    if (!req.session) {
        return this.next();1
    }
    if (!req.session.csrfToken) {
        req.session.csrfToken = Math.random();1
        req.csrfParam = paramName || 'authenticity_token';1
        req.csrfToken = sign(req.session.csrfToken);1
        return this.next();1
    }
    // publish secure credentials
    req.csrfParam = paramName || 'authenticity_token';3
    req.csrfToken = sign(req.session.csrfToken);3
    if (req.originalMethod == 'POST') {
        var token = req.param('authenticity_token');2
        if (!token || token !== sign(req.session.csrfToken)) {
            railway.logger.write('Incorrect authenticity token');1
            this.send(403);1
        } else {
            this.next();1
        }
    } else {
        this.next();1
    }
    function sign(n) {
        return require('crypto').createHash('sha1').update(n.toString()).update(secret.toString()).digest('hex');5
    }
};1
Controller.prototype.protectedFromForgery = function () {
    return this.request.csrfToken && this.request.csrfParam;1
};1

/**
 * Module dependencies
 */
var path      = require('path');1
var fs        = require('fs');1
var sys = require('util');1
/**
 * Shortcut required railway utils
 */
var pluralize = railway.utils.pluralize;1
var camelize  = railway.utils.camelize;1
var $         = railway.utils.stylize.$;1
var exec      = require('child_process').exec
/**
 * Command line options
 * populated by parseOptions method
 *
 * @api private
 */
var options   = {};1
/**
 * Generators collection hash
 *
 * @type Hash
 * @api private
 */
var collection = {};1
/**
 * Add generator to collection
 *
 * @param name
 * @param callback
 * @param meta Object {description: String, examples: [String]}
 * @api public
 */
function addGenerator(name, callback, meta) {
    meta = meta || {};5
    callback.meta = meta;5
    collection[name] = callback;5
    if (meta.alias) {
        collection[meta.alias] = callback;1
    }
}
exports.addGenerator = addGenerator;1
/**
 * Check whether generator exists
 * @param name - name of generator
 * @api public
 */
function exists(name) {
    return !!collection[name];
}
exports.exists = exists;1
/**
 * Call generator method
 */
function perform(name, args) {
    collection[name](args);5
}
exports.perform = perform;1
exports.list = function () {
    return Object.keys(collection).join(' ');
};1
/**
 * Add built-in generators
 */
(function () {
    addGenerator('init', initGenerator);1
    addGenerator('model', modelGenerator);1
    addGenerator('controller', controllerGenerator);1
    addGenerator('features', featuresGenerator);1
    addGenerator('crud', crudGenerator, {alias: 'scaffold'});1
    /**
     * Application initialization generator. Can be called with leading
     * appname param, or without it (init in current dir).
     *
     * When destination
     * is not empty old files wouldn't be overwritten by this generator, it's safe
     * to call generator again and again to restore some non-existing files
     * initial state
     *
     * @api public
     */
    function initGenerator(args) {
        parseOptions('appname');1
        [ 'app/',
          'app/models/',
          'app/controllers/',
          'app/observers/',
          'app/helpers/',
          'app/views/',
          'app/views/layouts/',
          'db/',
          'db/seeds/',
          'db/seeds/development/',
          'log/',
          'public/',
          'public/images',
          'public/stylesheets/',
          'public/javascripts/',
          'node_modules/',
          'config/',
          'config/locales/',
          'config/initializers/',
          'config/environments/'
        ].forEach(createDir);1
        if (options.stylus) {
            createDir('app/assets/');1
            createDir('app/assets/styles/');1
            createFileByTemplate('app/assets/styles/example.styl', 'example.styl');1
        }
        var db = options.db;1
        createFileByTemplate('config/initializers/db-tools', 'db-tools');1
        createFileByTemplate('config/routes', 'config/routes');1
        // createFileByTemplate('config/requirements.json', 'requirements.json');
        var srv = createFileByTemplate('server', 'server');1
        var secret = require('crypto').createHash('sha1').update(Math.random().toString()).digest('hex');1
        if (options.coffee) {
            createFile('app/controllers/application_controller.coffee', 'before \'protect from forgery\', ->\n    protectFromForgery \'' + secret + '\'\n\n');
        } else {
            createFile('app/controllers/application_controller.js', 'before(\'protect from forgery\', function () {\n    protectFromForgery(\'' + secret + '\');\n});\n');1
        }
        createFileByTemplate('config/environment',              'config/environment', [ replaceViewEngine, replacePrependMiddleware ]);1
        createFileByTemplate('config/environments/test',        'config/environments/test');1
        createFileByTemplate('config/environments/development', 'config/environments/development');1
        createFileByTemplate('config/environments/production',  'config/environments/production');1
        createFileByTemplate('config/database.~',               'config/database_' + db + '.~', replaceAppname);1
        createFileByTemplate('db/schema', 'schema');1
        createViewByTemplate('app/views/layouts/application_layout', 'application_layout');1
        createFileByTemplate('public/index.html', 'index.html');1
        createFile('.gitignore', fs.readFileSync(path.join(__dirname, '/../templates/gitignore')));1
        
        // bootstrap files
        createFileByTemplate('public/stylesheets/bootstrap-responsive.css', 'bootstrap-responsive.css');1
        createFileByTemplate('public/stylesheets/bootstrap.css', 'bootstrap.css');1
        createFileByTemplate('public/images/glyphicons-halflings-white.png', 'glyphicons-halflings-white.png');1
        createFileByTemplate('public/images/glyphicons-halflings.png', 'glyphicons-halflings.png');1
        createFileByTemplate('public/javascripts/bootstrap.js', 'bootstrap.js');1
        
        createFileByTemplate('public/stylesheets/style.css', 'style.css');1
        createFileByTemplate('public/javascripts/rails.js', 'rails.js');1
        createFile('public/javascripts/application.js', '// place your application-wide javascripts here\n');1
        createFileByTemplate('npmfile', 'npmfile', replaceViewEngine);1
        createFileByTemplate('public/favicon.ico', 'favicon.ico');1
        var fileExtension = options.coffee ? '.coffee' : '.js';1
        var engine = options.coffee ? 'coffee' : 'node';1
        // this file is only needed for heroku deployments
        // maybe not produce it by default
        createFile('Procfile', 'web: ' + engine + ' server' + fileExtension);1
        createFileByTemplate('package.json', 'package.json', [replaceAppname, replaceViewEngine]);1
        fs.chmodSync(srv, 0755);1
        process.exit();1
    }
    /**
     * Generates model. Accepts list of params: first one is model name, then
     * fieldnames as name:type, by default type is string.
     *
     * This generator accepts --coffee modifier to generate code in coffee
     *
     * Example:
     *
     *     railway generate User email birthdate:Date isAdmin:Boolean
     *
     * Affected files:
     *
     * - db/schema.js
     * - app/models/ModelName.js
     *
     * @api public
     */
    function modelGenerator(args) {
        parseOptions('model');2
        var model = options.model, code = '';2
        if (!model) { 
            sys.puts($('Model name required').red.bold);
            return;
        }
        if (model.match(/\//)) {
            model = model.match(/\/([^\/]+)$/)[1];
        }
        if (model.match(/\./)) {
            model = model.match(/\.([^\.]+)$/)[1];
        }
        var fileExtension = options.coffee ? '.coffee' : '.js';2
        var Model = model[0].toUpperCase() + model.slice(1);2
        var attrs = [], result = [];2
        options.forEach(function (arg) {
            var property = arg.split(':')[0],
            plainType = arg.split(':')[1],
            type = formatType(plainType);4
            if (options.coffee) {
                attrs.push('    property \'' + property + '\', ' + type);
            } else {
                attrs.push('    property(\'' + property + '\', ' + type + ');');4
            }
            result.push({name: property, type: type, plainType: plainType});4
        });2
        createDir('app/');2
        createDir('app/models/');2
        createFile('app/models/' + model + fileExtension, '');2
        if (options.coffee) {
            code = Model + ' = describe \'' + Model + '\', () ->\n' +
            attrs.join('\n') + '\n';
        } else {
            code = 'var ' + Model + ' = describe(\'' + Model + '\', function () {\n' +
            attrs.join('\n') + '\n});';2
        }
        railway.utils.appendToFile('db/schema' + fileExtension, code);2
        return result;2
    }
    /**
     * Generates single controller and related views. Accepts arguments:
     *
     *  - controller name
     *  - action names
     *  - `--coffee` modifier can be passed to generate code in coffee
     *
     * Affected files:
     *
     *  - app/controllers/controller_name_controller.js
     *  - app/views/controller_name/action1.ejs
     *  - app/views/controller_name/action2.ejs
     *
     * @api public
     */
    function controllerGenerator(args) {
        parseOptions('controller');1
        var controller = options.controller;1
        if (!controller) {
            console.log('Usage example: railway g controller controllername actionName anotherActionName');
            console.log('               railway g controller controllername actionName anotherActionName --coffee');
            return;
        }
        var fileExtension;1
        var actions;1
        if (options.coffee) {
            fileExtension = '.coffee';
            actions = ['load \'application\''];
            options.forEach(function (action) {
                actions.push('action \'' + action + '\', () -> \n    render\n        title: "' + controller + '#' + action + '"');
            });
        } else {
            fileExtension = '.js';1
            actions = ['load(\'application\');'];1
            options.forEach(function (action) {
                actions.push('action(\'' + action + '\', function () {\n    render({\n        title: "' + controller + '#' + action + '"\n    });\n});');6
            });1
        }
        var ns = controller.split('/');1
        ns.pop();1
        createDir('app/');1
        createDir('app/controllers/');1
        createParents(ns, 'app/controllers/');1
        // controller
        var filename = 'app/controllers/' + controller + '_controller'  + fileExtension;1
        createFile(filename, actions.join('\n\n'));1
        createDir('app/helpers/');1
        createParents(ns, 'app/helpers/');1
        // helper
        filename = 'app/helpers/' + controller + '_helper.js';1
        createFile(filename, 'module.exports = {\n};');1
        // views
        createDir('app/views/');1
        createParents(ns, 'app/views/');1
        createDir('app/views/' + controller + '/');1
        options.forEach(function (action) {
            createView('app/views/' + controller + '/' + action, 'default_action_view', [controller, action]);6
        });1
    }
    /**
     * Cucumis features generator
     * @deprecated
     * @api public
     */
    function featuresGenerator() {
        createDir('features/');1
        createDir('features/step_definitions/');1
        createFileByTemplate('features/step_definitions/web_steps.js',   'features/step_definitions/web_steps.js');1
        createFileByTemplate('features/step_definitions/email_steps.js', 'features/step_definitions/email_steps.js');1
        createFileByTemplate('features/step_definitions/jquery.js',      'features/step_definitions/jquery.js');1
        try {
            require('cucumis');
        } catch(e) {
            sys.puts($('Cucumis is not installed').red + ' please run ' + $('npm install cucumis').yellow);1
        }
    }
    /**
     * Resource scaffolding generator. Accepts same arguments as model generator:
     * name of model (singilar) and list of model properties in
     * `property:type` format
     *
     * It creates ready-to-use model, controller, controller tests (nodeunit),
     * routing rule, views and layout
     *
     * @api public
     */
    function crudGenerator(args) {
        var model = args[0].split('.').pop();1
        var parents = args[0].split('.').slice(0, -1);1
        var models = pluralize(model).toLowerCase();1
        if (!model) {
            console.log('Usage example: railway g crud post title:string content:string published:boolean');
            console.log('               railway g crud post title:string content:string published:boolean --coffee');
            return;
        }
        var ns = models.split('/');1
        ns.pop();1
        createDir('app/');1
        createDir('app/controllers/');1
        createParents(ns, 'app/controllers/');1
        var result = modelGenerator.apply(this, Array.prototype.slice.call(arguments));1
        var fileExtension = options.coffee ? '.coffee' : '.js';1
        createFile('app/controllers/' + models + '_controller' + fileExtension, controllerCode(args[0], result));1
        createDir('app/helpers/');1
        createParents(ns, 'app/helpers/');1
        function replaceModel(code) {
            return code1
                .replace(/new_model/g, addParents('new_', parents, model))
                .replace(/edit_model/g, addParents('edit_', parents, model, true))
                .replace(/path_to\.models/g, addParents('path_to.', parents, models))
                .replace(/path_to\.model/g, addParents('path_to.', parents, model, true))
                .replace(/(path_to\..*?\()model/g, addParents('$1', parents.map(function (p) { return 'params.' + p + '_id';}), model, true, ', '))
                .replace(/models/g, models)
                .replace(/model/g, model.toLowerCase())
                .replace(/Model/g, camelize(model, true))
                .replace(/VALID_ATTRIBUTES/, result.map(function (attr) { return attr.name + ": ''" }).join(',\n        '));
        }
        // helper
        createFile('app/helpers/' + models + '_helper.js', 'module.exports = {\n};');1
        // tests
        createDir('test/');1
        createFileByTemplate('test/test_helper.js', 'test_helper.js');1
        createDir('test/controllers');1
        createParents(ns, 'test/controllers/');1
        createFileByTemplate('test/controllers/' + models + '_controller_test.js', 'crud_controller_test.js', replaceModel);1
        // views
        // _form partial
        createDir('app/views/');1
        createParents(ns, 'app/views/');1
        createParents(ns, 'app/views/layouts/');1
        // layout
        createViewByTemplate('app/views/layouts/' + models + '_layout', 'scaffold_layout', replaceModel);1
        createDir('app/views/' + models + '/');1
        createView('app/views/' + models + '/_form', 'scaffold_form', result, replaceModel);1
        createView('app/views/' + models + '/show', 'scaffold_show', result, replaceModel);1
        ['new', 'edit', 'index'].forEach(function (template) {
            createViewByTemplate('app/views/' + models + '/' + template, 'scaffold_' + template, replaceModel);3
        });1
        // route
        var routesConfig = process.cwd() + '/config/routes.' + (options.coffee ? 'coffee' : 'js'),
            routes = fs.readFileSync(routesConfig, 'utf8')
                .toString()
                .replace(/\s+$/g, '')
                .split('\n'),
            firstLine         = routes.shift(),
            firstLineRegexp   = options.coffee ? /^exports\.routes = \(map\)\->/ : /^exports\.routes = function \(map\) \{/,
            mapRouteResources = options.coffee ? '  map.resources \'' + models + '\'' : '    map.resources(\'' + models + '\');'
        if (firstLine.match() && !routes.some(containRoute)) {
            routes.unshift(mapRouteResources);1
            routes.unshift(firstLine);1
            fs.writeFileSync(routesConfig, routes.join('\n'));1
            sys.puts($('patch').bold.blue + '  ' + routesConfig);1
        }
        function containRoute(line) {
            var m = line.match(/^\s*map\.resources(\(|\s)'([^']+)'/);6
            return m && m[1] == models;6
        }
    }
    /**
     * Get controller code
     * @private
     */
    function controllerCode(model, result) {
        var fileExtension = options.coffee ? '.coffee' : '.js';1
        var code;1
        var parents = model.split('.').slice(0, -1);1
        model = model.split('.').pop();1
        var models = pluralize(model).toLowerCase();1
        code = fs.readFileSync(__dirname + '/../templates/crud_controller' + fileExtension);1
        code = code
            .toString('utf8')
            .replace(/new_model/g, addParents('new_', parents, model))
            .replace(/edit_model/g, addParents('edit_', parents, model, true))
            .replace(/path_to\.models/g, addParents('path_to.', parents, models))
            .replace(/path_to\.model/g, addParents('path_to.', parents, model, true))
            .replace(/(path_to\..*?\()this\.model/g, addParents('$1', parents.map(function (p) { return 'params.' + p + '_id';}), 'this.' + model, true, ', '))
            .replace(/models/g, models)
            .replace(/model/g, model.toLowerCase())
            .replace(/Model/g, camelize(model, true))
            .replace(/FILTER_PROPERTIES/g, '[' + result.map(function (p) {
                return "'" + p.name + "'";2
            }).join(', ') + ']');1
        return code;1
    }
    function addParents(prefix, parents, base, skipParams, join) {
        var name;10
        if (!join) join = '_';10
        if (parents.length) {
            name = prefix + parents.join(join) + join + base;
        } else {
            name = prefix + base;10
        }
        if (skipParams) return name;4
        return name + '(' + parents.map(function (p) {4
            return 'params.' + p + '_id';
        }).join(', ') + ')';
    }
    /**
     * Parse command line options
     * @private
     */
    function parseOptions(defaultKeyName) {
        options = [];4
        options.tpl = app.settings['view engine'] || 'ejs';4
        options.coffee = app.enabled('coffee');4
        options.db = 'memory';4
        options.stylus = false;4
        var key = defaultKeyName || false;4
        args.forEach(function (arg) {
            if (arg.slice(0, 2) == '--') {
                key = arg.slice(2);1
                options[key] = true;1
            } else if (arg[0] == '-') {
                key = arg.slice(1);
                options[key] = true;
            } else if (key) {
                options[key] = arg;3
                key = false;3
            } else {
                options.push(arg);10
            }
        });4
        if (options.nocoffee) {
            options.coffee = false;
        }
    }
    /**
     * Create directory
     * @private
     */
    function createDir(dir) {
        var root = process.cwd();40
        if (options.appname && !createDir.rootCreated) {
            createDir.rootCreated = true;
            createDir('');
        }
        if (options.appname) {
            dir = path.join(options.appname, dir);
        }
        if (railway.utils.existsSync(path.join(root, dir))) {
            sys.puts($('exists').bold.grey + '  ' + dir);2
        } else {
            fs.mkdirSync(path.join(root, dir), 0755);38
            sys.puts($('create').bold.green + '  ' + dir);38
        }
    }
    /**
     * Append `contents` to a file
     *
     * @param {String} filename
     * @param {String} contents
     * @private
     */
    function appendToFile(filename, contents) {
        var root = process.cwd(),
            fd = fs.openSync(path.join(root, filename), 'a');
        fs.writeSync(fd, contents);
        fs.closeSync(fd);
    }
    railway.utils.appendToFile = appendToFile;1
    /**
     * Create file with given `contents`
     *
     * @param {String} filename
     * @param {String} contents
     * @private
     */
    function createFile(filename, contents) {
        var root = process.cwd();36
        if (options.appname) {
            filename = path.join(options.appname, filename);
        }
        var fullPath = root + '/' + filename;36
        if (railway.utils.existsSync(fullPath)) {
            sys.puts($('exists').bold.grey + '  ' + filename);2
        } else {
            fs.writeFileSync(fullPath, contents);34
            sys.puts($('create').bold.green + '  ' + filename);34
        }
        return fullPath;36
    }
    /**
     * Create file with name `filename` using contents of `template` file.
     * Run `prepare` function before returning result
     *
     * @param {String} filename
     * @param {String} template
     * @param {Function} prepare - called with (text: {String}),
     * should return {String}
     *
     * @private
     */
    function createFileByTemplate(filename, template, prepare) {
        var configFilenameRegexp = /\.~$/;26
        if (template.match(configFilenameRegexp)) {
            var fileExtension = options.coffee ? '.yml' : '.json';1
            template = template.replace(configFilenameRegexp, fileExtension);1
            filename = filename.replace(configFilenameRegexp, fileExtension);1
        }
        else if (!template.match(/\..+$/)) {
            var fileExtension = options.coffee ? '.coffee' : '.js';9
            template += fileExtension;9
            filename += fileExtension;9
        }
        var text = fs.readFileSync(path.join(__dirname, '/../templates/', template));26
        if (prepare) {
            text = text.toString('utf8');5
            if (typeof prepare === 'function') {
                prepare = [prepare];3
            }
            prepare.forEach(function (p) {
                text = p(text);7
            });5
        }
        return createFile(filename, text);26
    }
    /**
     * Create view file with name `filename` using contents of `template` file.
     * Run `prepare` function before returning result. It look for -tpl option
     * and result file with proper extension and contents
     *
     * @param {String} filename
     * @param {String} template
     * @param {Function} prepare - called with (text: {String}),
     * should return {String}
     *
     * @private
     */
    function createViewByTemplate(filename, template, prepare) {
        options.tpl = options.tpl || 'ejs';5
        var package = options.tpl + '-ext', tpl;5
        try {
            tpl = require(package);
        } catch(e) {
            sys.puts($('Templating engine ' + options.tpl + ' is not supported').red);5
            return;5
        }
        var text = fs.readFileSync(tpl.template(template));
        if (prepare) {
            text = prepare(text.toString('utf8'));
        }
        return createFile(filename + tpl.extension, text);
    }
    function createView(filename, template, data, fn) {
        options.tpl = options.tpl || 'ejs';8
        var package = options.tpl + '-ext';8
        try {
            var tpl = require(package);
        } catch(e) {
            sys.puts($('Templating engine ' + options.tpl + ' is not supported').red);8
            return;8
        }
        var text = tpl.templateText(template, data);
        if (typeof fn === 'function') {
            text = fn(text.toString());
        }
        return createFile(filename + tpl.extension, text);
    }
    function createParents(ns, d) {
        ns.forEach(function (dir) {
            d = path.join(d, dir);
            createDir(d);
        });8
    }
    function formatType(name) {
        name = (name || 'string').toLowerCase();4
        switch (name) {
        case 'text': return 'Text';
        case 'string':   return 'String';
        case 'date':     return 'Date';
        case 'bool':
        case 'boolean':  return 'Boolean';
        case 'int':
        case 'real':
        case 'float':
        case 'decimal':
        case 'number':   return 'Number';
        }
        return '"' + camelize(name, true) + '"';
    }
    function replaceAppname(template) {
        return template.replace(/APPNAME/g, options.appname || 'default');2
    }
    function replaceViewEngine(template) {
        return template.replace(/VIEWENGINE/g, options.tpl || 'ejs');3
    }
    function replacePrependMiddleware(template) {
        var mw = [];1
        if (options.stylus) {
            if (options.coffee) {
                mw.push("app.use require('stylus').middleware\n        force: true, src: app.root + '/app/assets', dest: app.root + '/public', compress: true".replace(/, /g, ',\n        '));
            } else {
                mw.push("app.use(require('stylus').middleware({\n        force: true, src: app.root + '/app/assets', dest: app.root + '/public', compress: true\n    }));".replace(/, /g, ',\n        '));1
            }
        }
        return template.replace(/PREPEND_MIDDLEWARE/g, mw.join('\n    '));1
    };1
    function loadConfig(filename) {
        var filenameExt = /\.([^\.]+)$/.exec(filename)[1];
        switch (filenameExt) {
          case '~':
            var config = null;
            ['.json','.yml'].forEach(function(testExt){
              try {
                var testFilename = filename.replace(/\.~$/, testExt)
                var stats = fs.lstatSync(testFilename);
                if (stats.isFile())
                  config = loadConfig(testFilename);
              }
              catch(e) {}
            });
            if (config != null) return config;
            throw new Error( sys.format('Can not find configuration file by path template "%s"', filename) );
            break;
          case 'json':
            return JSON.parse(fs.readFileSync(filename, 'utf8'));
          case 'yml':
            return require(filename).shift();
          default:
            throw new Error( sys.format('Unknown configuration file name extension "%s"', filenameExt) );
        }
    };1
})();1

/**
 * Module dependencies
 */
var path       = require('path'),
    fs         = require('fs'),
    crypto     = require('crypto'),
    exists     = fs.exists || path.exists;1
/**
 * Import utilities
 */
var htmlTagParams = require('./railway_utils').html_tag_params,
    safe_merge = require('./railway_utils').safe_merge,
    humanize   = require('./railway_utils').humanize,
    undef;1
/**
 * Config
 */
var regexps = {
  'cached': /^cache\//,
  'isHttp': /^https?:\/\/|\/\//
},
exts = {
  'css': '.css',
  'js' : '.js'
},
paths = {
  'css': '/stylesheets/',
  'js' : '/javascripts/'
},
merged = {
    stylesheets: {ext: exts.css},
    javascripts: {ext: exts.js}
};1
/**
 * Publish HelperSet
 */
module.exports = new HelperSet(null);1
module.exports.HelperSet = HelperSet;1
/**
 * Set of helper methods
 * 
 * @namespace
 * @param {Object} ctl Controller object
 */
function HelperSet(ctl) {
    var controller = ctl;3
    this.controller = ctl;3
    /**
     * CSRF Meta Tag generation
     *
     * @returns {String} Meta tags against CSRF-attacks
     */
    this.csrf_meta_tag = function () {
        return controller && controller.protectedFromForgery() ? [
            '<meta name="csrf-param" content="' + controller.request.csrfParam + '"/>',
            '<meta name="csrf-token" content="' + controller.request.csrfToken + '"/>'
        ].join('\n') : '';
    }
}
/**
 * Make helpers local to query
 *
 * @param {Object} controller Controller Object
 * @returns {Object} containing all helpers
 */
module.exports.personalize = function (controller) {
    return new module.exports.HelperSet(controller);2
};1
/**
 * Return bunch of stylesheets link tags
 *
 * Example in ejs:
 *
 *      <%- stylesheet_link_tag('bootstrap', 'style') %>
 *
 * This returns:
 *
 *      <link media="screen" rel="stylesheet" type="text/css" href="/stylesheets/bootstrap.css" />
 *      <link media="screen" rel="stylesheet" type="text/css" href="/stylesheets/style.css" />
 *
 * @param {String} stylesheet filename
 * @returns {String} HTML code to the stylesheets in the parameters
 */
HelperSet.prototype.stylesheetLinkTag = function stylesheetLinkTag() {
    if (!paths.css || !paths.stylesheets) {
      paths.css = app.settings.cssDirectory || '/stylesheets/';1
      paths.stylesheets = paths.css;1
    }
  
    var args = Array.prototype.slice.call(arguments);4
    var options = {media: 'screen', rel: 'stylesheet', type: 'text/css'};4
    var links = [];4
    if (typeof args[args.length - 1] == 'object') {
        options = safe_merge(options, args.pop());
    }
    mergeFiles('stylesheets', args).forEach(function (file) {
        delete options.href;5
        // there should be an option to change the /stylesheets/ folder
        var href = checkFile('css', file);5
        links.push(genericTagSelfclosing('link', options, { href: href }));5
    });4
    return links.join('\n    ');4
};1
HelperSet.prototype.stylesheet_link_tag = HelperSet.prototype.stylesheetLinkTag;1
/**
 * Generates set of javascript includes composed from arguments
 *
 * Example in ejs:
 *
 *     <%- javascript_include_tag('rails', 'application') %>
 *
 * This returns:
 *
 *     <script type="text/javascript" src="/javascripts/rails.js"></script>
 *     <script type="text/javascript" src="/javascripts/application.js"></script>
 *
 * @param {String} script filename
 * @returns {String} the generated &lt;script&gt; tags
 */
HelperSet.prototype.javascriptIncludeTag = function javascriptIncludeTag() {
    if (!paths.js || !paths.javascripts) {
      paths.js = app.settings.jsDirectory || '/javascripts/'
      paths.javascripts = paths.js;1
    }
    var args = Array.prototype.slice.call(arguments);4
    var options = {type: 'text/javascript'};4
    if (typeof args[args.length - 1] == 'object') {
        options = safe_merge(options, args.pop());
    }
    var scripts = [];4
    mergeFiles('javascripts', args).forEach(function (file) {
        // there should be an option to change the /javascripts/ folder
        var href = checkFile('js', file);5
        delete options.src;5
        scripts.push(genericTag('script', '', options, {src: href}));5
    });4
    return scripts.join('\n    ');4
};1
HelperSet.prototype.javascript_include_tag = HelperSet.prototype.javascriptIncludeTag;1
/**
 * Merge files when caching enabled
 *
 * You can enable merging manually with the following configuration:
 *
 *     app.set('merge javascripts')
 *     app.set('merge stylesheets')
 *
 * @param {String} scope Scope which is merged, e.g. javascripts or stylesheets
 * @param {Array} files Array of files which should be merged
 * @see https:~~~C4~~~
 * @returns {String} Pathname to the merged file
 */
function mergeFiles(scope, files) {
    // ensure that feature is enabled
    if (app.disabled('merge ' + scope)) {
        return files;8
    }
    var ext  = merged[scope].ext,
      result = [],
      shasum = crypto.createHash('sha1'),
      minify = [],
      directory = merged[scope].directory = paths[scope].replace(/(\/+)/g, '');
    // only merge local files
    files.forEach(function (file) {
        if (!regexps.isHttp.test(file)) {
            shasum.update(file);
            minify.push(file);
        } else {
            result.push(file);
        }
    });
    // calculate name of new script based on names of merged files
    var digest = shasum.digest('hex');
    // check cache state (undefined = not cached, false = cache in progress, String = cached)
    var cached = merged[scope][digest];
    if (cached) {
        // push resulted filename to result
        result.push(cached);
    } else {
        // we have no cache at the moment, just return files
        result = result.concat(minify);
        // if caching process is not started yet
        if (cached !== false) {
            // mark caching process as started
            merged[scope][digest] = false;
            // write resulted script as merged `minify` files
            var stream = fs.createWriteStream(path.join(app.root, 'public', directory, 'cache_' + digest + ext));
            var counter = 0;
            var fileContents = {};
            minify.forEach(function (file) {
                var filename = path.join(app.root, 'public', directory, file + ext);
                exists(filename, function (exists) {
                    if (exists) {
                        counter += 1;
                        
                        fs.readFile(filename, 'utf8', function (err, data) {
                            fileContents[file] = data;
                            done();
                        });
                    }
                })
            });
            function done() {
                if (--counter === 0) {
                    minify.forEach(function (file) {
                      data = fileContents[file];
                      stream.write('~~~C52~~~ \n');
                      stream.write(data + '\n');
                    });
                    
                    stream.end();
                }
            }
            // save name of resulted file to the merge scope registry
            stream.on('close', function () {
                merged[scope][digest] = ['cache', digest].join('_');
            })
        }
    }
    return result;
}
/**
 * Link helper
 *
 * Example in ejs:
 *
 *      <%- link_to("Home", '/') %>
 *
 * This returns:
 *
 *      <a href="/">Home</a>
 *
 * @param {String} text Text of the link
 * @param {String} url Url where the link points to
 * @param {Object} params Set of html params (class, style, etc..)
 * @returns {String} Generated html for link
 */
HelperSet.prototype.linkTo = function linkTo(text, url, params) {
    ['remote', 'method', 'jsonp', 'confirm'].forEach(dataParam.bind(params));
    return genericTag('a', text, {href: url}, params);
};1
HelperSet.prototype.link_to = HelperSet.prototype.linkTo;1
/**
 * Form tag helper
 *
 * @methodOf HelperSet.prototype
 * @param {Object} params
 * @param {Function} block
 */
HelperSet.prototype.formTag = function (params, block) {
    var self = this;4
    var buf = arguments.callee.caller.buf;4
    // helper may be called with block only
    if (typeof params === 'function') {
        block = params;1
        params = {};1
    }
    if (typeof params === 'undefined') {
        params = {}
    }
    // default method is POST
    if (!params.method) {
        params.method = 'POST';2
    }
    // hook up alternative methods (PUT, DELETE)
    var _method;4
    var method = _method = params.method.toUpperCase();4
    if (method != 'GET' && method != 'POST') {
        _method = method;2
        params.method = 'POST';2
    }
    // hook up data-params
    ['remote', 'jsonp', 'confirm'].forEach(dataParam.bind(params));4
    // push output
    buf.push('<form' + htmlTagParams(params) + '>');4
    buf.push( this.csrf_tag() );4
    // alternative method?
    if (_method !== params.method) {
        buf.push(HelperSet.prototype.input_tag({type: "hidden", name: "_method", value: _method }));2
    }
    
    // function?
    if (typeof block === 'function') {
        block();2
    }
    buf.push('</form>');4
};1
HelperSet.prototype.form_tag = HelperSet.prototype.formTag;1
/**
 * Prints error messages for the model instance
 *
 * @methodOf HelperSet.prototype
 * @param {ModelInstance} resource
 * @returns {String} Error messages from the model instance
 */
HelperSet.prototype.errorMessagesFor = function errorMessagesFor(resource) {
    var out = '';
    var h = this;
    if (resource.errors) {
        out += genericTag('div', printErrors(), {class: 'alert alert-error'});
    }
    return out;
    function printErrors() {
        var out = '<p>';
        out += genericTag('strong', 'Validation failed. Fix following errors before you continue:');
        out += '</p>';
        for (var prop in resource.errors) {
            if (resource.errors.hasOwnProperty(prop)) {
                out += '<ul>';
                resource.errors[prop].forEach(function (msg) {
                    out += genericTag('li', prop + ' ' + msg, {class: 'error-message'});
                });
                out += '</ul>';
            }
        }
        return out;
    }
};1
/**
 * Form fields for resource helper
 *
 * @methodOf HelperSet.prototype
 * @param {ModelInstance} resource
 * @param {Function} block
 * @namespace
 */
HelperSet.prototype.fields_for = function (resource, block) {
    arguments.callee.buf = arguments.callee.caller.buf;
    resource = resource || {};
    var self = this;
    var resourceName = resource && resource.constructor && resource.constructor.modelName || false;
    var complexNames = (app.set('view options') || {}).complexNames;
    /**
     * Generates a name
     *
     * @requires resourceName
     * @param {String} name Name of the element
     * @returns {String} returns the generated name
     */
    function makeName(name) {
        return complexNames && resourceName ? (resourceName + '[' + name + ']') : name;
    }
    /**
     * Generates an id field
     *
     * @requires resourceName
     * @param {String} name Name of the element
     * @returns {String} returns the generated id name
     */
    function makeId(name) {
        return complexNames && resourceName ? (resourceName + '_' + name) : name;
    }
    
    block({
        /**
         * Input tag helper
         *
         * Example in ejs:
         *
         *      <%- form.input("test") %>
         *
         * This returns:
         *
         *      <input name="test"/>
         *
         * @param {String} name Name of the element
         * @param {Object} params Additional parameters
         */
        input: function (name, params) {
            params = params || {};
            if (params.value === undef) {
                params.value = resource.hasOwnProperty(name) ? resource[name] : '';
            }
            return HelperSet.prototype.input_tag({
                name: makeName(name),
                id: makeId(name)
            }, params);
        },
        checkbox: function (name, params) {
            params = params || {};
            if (params.value === undef) {
                params.value = resource[name] || 1;
            }
            if (params.checked === undef) {
                if(resource[name]) {
                    params.checked = 'checked';
                }
            } else if (params.checked === false) {
                delete params.checked;
            }
            return HelperSet.prototype.input_tag({
                name: makeName(name),
                id: makeId(name),
                type: 'checkbox'
            }, params);
        },
        file: function (name, params) {
            return HelperSet.prototype.input_tag({
                name: makeName(name),
                id: makeId(name),
                type: 'file'
            }, params);
        },
        /*
         * Label helper
         *
         * Example in ejs:
         *
         *      <%- form.label("test", false, {class: "control-label"}) %>
         *
         * This returns:
         *
         *      <label for="test" class="control-label">Test</label>
         *
         * @param {String} name Name of the element
         * @param {String} caption Optional different caption of the elemt
         * @param {Object} params Additional parameters
         */
        label: function (name, caption, params) {
            return HelperSet.prototype.label_tag(
                caption || self.controller.t('models.' + resource.constructor.modelName + '.fields.' + name, humanize(name)),
                {for: makeId(name) },
                params);
        },
        submit: function (name, params) {
            return genericTag('button', name || 'Commit', {type: 'submit'}, params);
        },
        textarea: function (name, params) {
            return genericTag('textarea', sanitizeHTML(resource[name] || ''), {name: makeName(name), id: makeId(name)}, params);
        },
        /*
         * Provides a select tag
         *
         * In ejs:
         *
         *      <%- form.select("state", states, {fieldname: 'name', fieldvalue: '_id'}) %>
         *
         * Possible params:
         * * blank: {STRING} Blank value to be added at the beginning of the list
         * * fieldname: {STRING} Sets the name of the field in "options" field where the displayed values can be found. Default: "value"
         * * fieldvalue: {STRING} Sets the name of the field in "options" field where the submitted values can be found. Default = fieldname
         * * multiple: Can be set to false if size >1 to only select one value.
         * * select: Select a value. If fieldname and fieldvalue are different, the value is compared with fieldvalue otherwise with fieldname.
         * * size: Sets the displayed size of the select field
         *
         * @author [Uli Wolf](https:~~~C22~~~
         * @param {String} name Name of the select tag
         * @param {Object} options Array of possible options
         * @param {Object} params Additional parameters
         */
        select: function (name, options, params) {
            var options = options || '';
            var params = params || {};
            
            // optional: Holds the displayed fieldname where the data can be found in 'options'
            var optionFieldname = params.fieldname || 'value';
            delete params.fieldname;
            // optional: Holds the submittable fieldvalue where the data can be found in 'options'
            var optionFieldvalue = params.fieldvalue || optionFieldname;
            delete params.fieldvalue;
            // optional: Holds the number of entries that can be seen at once
            // If size > 1, multiple values can be selected (can be switched off via multiple:false)
            // If size = 1, only one value is selectable (Drop-Down)
            if (params.size === undef) {
                params.size = 1;
            } else {
                if (params.size > 1) {
                    if (params.multiple === undef || params.multiple === true) {
                        params.multiple = 'multiple';
                    } else {
                        delete params.multiple;
                    }
                }
            }
            // optional: Preselect an entry
            if (params.select === undef) {
                params.select = resource[name] || '';
            }
            var optionSelected = params.select;
            delete params.select;
            // Render the options
            var innerOptions = '';
            // optional: Add a blank field at the beginning
            if (params.blank !== undef) {
                innerOptions += HelperSet.prototype.option_tag(sanitizeHTML(params.blank), {value: ''})
            }
            for (var optionsNr in options) {
                var option = options[optionsNr];
                var optionParameters = new Array();
                
                // Is the value in a seperate field?
                if (option[optionFieldvalue] != option[optionFieldname]) {
                    optionParameters.value = option[optionFieldvalue];
                }
                
                if(activeValue(option[optionFieldvalue], optionSelected)) {
                    optionParameters.selected = 'selected';
                }
                
                // Generate the option Tags
                innerOptions += HelperSet.prototype.option_tag(sanitizeHTML(option[optionFieldname]), optionParameters)
            }
            // Render the select
            return HelperSet.prototype.select_tag(innerOptions, {name: makeName(name), id: makeId(name)}, params);
        }
    });
};1
/**
 * Form for resource helper
 *
 * @methodOf HelperSet.prototype
 * @param {ModelInstance} resource
 * @param {Object} params
 * @param {Function} block
 */
HelperSet.prototype.formFor = function formFor(resource, params, block) {
    var self = this;1
    var buf = arguments.callee.buf = arguments.callee.caller.buf;1
    if (resource && resource.modelName) {
        if (typeof params !== 'object') {
            params = {};1
        }
        if (!params.method) {
            params.method = 'PUT';1
        }
        if (!params.action) {
            params.action = railway.routeMapper.pathTo[railway.utils.underscore(resource.modelName)](resource);1
        }
    }
    this.form_tag(params, function () {
        arguments.callee.buf = buf;1
        if (block) self.fields_for(resource, block);1
    });1
};1
HelperSet.prototype.form_for = HelperSet.prototype.formFor;1
/**
 * Input tag helper
 *
 * @methodOf HelperSet.prototype
 * @param {String} text - inner html
 * @param {Object} params - set of tag attributes
 * @param {Object} override - set params to override params in previous arg 
 * @returns {String} Finalized input tag
 */
HelperSet.prototype.input_tag = function (params, override) {
    return '<input' + htmlTagParams(params, override) + ' />';2
};1
/**
 * Label tag helper
 *
 * Result:
 *
 *     <label>text</label>
 *
 * @methodOf HelperSet.prototype
 * @param {String} text - inner html
 * @param {Object} params - set of tag attributes
 * @param {Object} override - set params to override params in previous arg 
 * @returns {String} Finalized label tag
 */
HelperSet.prototype.label_tag = function (text, params, override) {
    return genericTag('label', text, params, override);
};1
/**
 * Cross-site request forgery hidden inputs
 *
 * @methodOf HelperSet.prototype
 * @returns {String} CSRF-Tag with parameters
 */
HelperSet.prototype.csrf_tag = function() {
    return '<input type="hidden" name="' + this.controller.request.csrfParam + '" value="' + this.controller.request.csrfToken + '" />';4
}
/**
 * Select tag helper
 *
 * Result:
 *
 *     <select>innerOptions</select>
 *
 * @methodOf HelperSet.prototype
 * @author [Uli Wolf](https:~~~C34~~~
 * @param {String} innerOptions Inner html of the select tag
 * @param {Object} params Set of tag attributes
 * @param {Object} override Set params to override params in previous arg 
 * @returns {String} Finalized select tag
 */
HelperSet.prototype.select_tag = function (innerOptions, params, override) {
    return genericTag('select', innerOptions, params, override);
};1
/**
 * Option tag helper
 *
 * Result:
 *
 *     <option>text</option>
 * 
 * @methodOf HelperSet.prototype
 * @author [Uli Wolf](https:~~~C35~~~
 * @param {String} text Inner html
 * @param {Object} params Set of tag attributes
 * @param {Object} override Set params to override params in previous arg 
 * @returns {String} Finalized option tag
 */
HelperSet.prototype.option_tag = function (text, params, override) {
    return genericTag('option', text, params, override);
};1
/**
 * Private util methods
 */
/**
 * Returns html code of one tag with contents
 *
 * @param {String} name name of tag
 * @param {String} inner inner html
 * @param {Object} params set of tag attributes
 * @param {Object} override set params to override params in previous arg
 * @returns {String} Finalized generic tag
 */
function genericTag(name, inner, params, override) {
    return '<' + name + htmlTagParams(params, override) + '>' + inner + '</' + name + '>';5
}
/**
 * Returns html code of a selfclosing tag
 *
 * @param {String} name name of tag
 * @param {Object} params set of tag attributes
 * @param {Object} override set params to override params in previous arg
 * @returns {String} Finalized generic selfclosing tag
 */
function genericTagSelfclosing(name, params, override) {
    return '<' + name + htmlTagParams(params, override) + ' />';5
}
/**
 * Prefixes key with 'data-'
 *
 * @param {String} key name of key
 */
function dataParam(key) {
    if (this[key]) {
        this['data-' + key] = this[key];
        delete this[key];
    }
}
/**
 * Compares a string against a string or an array
 *
 * @author [Uli Wolf](https:~~~C36~~~
 * @param {String} value Content of the String to be compared
 * @param {String|Array} selectvalue String or Array of possiblities to be equal to the first string
 * @returns {Boolean} True if the string matches the other string or array. False when not.
 */
function activeValue(value, selectvalue) {
    var returnBool = false;
    
    // If this is an Array (e.g. when multiple values should be selected), iterate
    if (Object.prototype.toString.call(selectvalue) === '[object Array]') {
        // This is an Array (e.g. when multiple values should be selected), iterate
        for (var selectvalueNr in selectvalue) {
            // Cast to String as these might be objects.
            if (String(value) == String(selectvalue[selectvalueNr])) {
                returnBool = true
                continue;
            }
        }
    } else {
        // This is just one entry
        // Cast to String as these might be objects.
        if (String(value) == String(selectvalue)) {
            returnBool = true
        }
    }
    return returnBool;
}
/**
 * Escape &, < and > symbols
 * 
 * @param {String} html String with possible HTML-Elements
 * @returns {String} resulting string with escaped characters
 */
function sanitizeHTML(html) {
    return html.replace(/&/g, '&amp;').replace(/>/g, '&gt;').replace(/</g, '&lt;');
}
HelperSet.prototype.sanitize = sanitizeHTML;1
/**
 * Checks if the environment is production
 * 
 * @returns {Boolean} True if production, otherwise false
 */
function checkProd() {
  return app.settings.env === 'production';10
}
/**
 * Provides the link to a file. Checks if a file needs to be suffixed with a timestamp
 * 
 * @param {String} type Type of the file, e.g. css or js
 * @param {String} file name (local file) or link (external) to the file
 * @returns {String} Final Link to the file
 */
function checkFile(type, file) {
  var isExternalFile = regexps.isHttp.test(file),
    isCached         = file.match(regexps.cached),
    href             = !isExternalFile ? paths[type] + file + exts[type] : file,
    isProd           = checkProd();10
  if (!isCached && !isProd && !isExternalFile && !app.disabled('assets timestamps')) {
      href += '?' + Date.now()
  }
  return href;10
}