hem

fs = require('fs-extra') path = require('path') uglifyjs = require('uglify-js') uglifycss = require('uglifycss') Dependency = require('./dependency') Stitch = require('./stitch') utils = require('./utils') events = require('./events') log = require('./log') versioning = require('./versioning') # ------- Variables set by hem during startup _hem = undefined _argv = undefined # ------- Application Class class Application constructor: (name, config = {}) -> @name = name @route = config.route @root = config.root # apply defaults if (config.defaults) try # make sure we don't modify the original assets (which is cached by require) loadedDefaults = utils.loadAsset('defaults/' + config.defaults) defaults = utils.extend({}, loadedDefaults) catch err log.error "ERROR: Invalid 'defaults' value provided: " + config.defaults process.exit 1 # create updated config mapping by merging with default values config = utils.extend(defaults, config) # set root variable unless @root # if application name is also a directory then assume that is root if utils.isDirectory(@name) @root = @name @route or= "/#{@name}" # otherwise just work from top level directory else @root = "/" @route or= "/" # make sure route has a value @static = [] @packages = [] # configure static routes with base root and route values for route, value of config.static @static.push url : @applyBaseRoute(route) path : @applyRootDir(value)[0] # configure js/css packages for key, value of config packager = undefined # determine package type if key is 'js' or utils.endsWith(key,'.js') packager = JsPackage value.name = key else if key is 'css' or utils.endsWith(key,'.css') packager = CssPackage value.name = key # add to @packages array if packager @packages.push(new packager(@, value)) # configure test structure if config.test config.test.name = "test" @packages.push(new TestPackage(@, config.test)) # configure versioning if config.version verType = versioning[config.version.type] unless verType log.errorAndExit "Incorrect type value for version configuration: (#{config.version.type})" @versioning = new verType(@, config.version) getTestPackage: -> for pkg in @packages return pkg if pkg.constructor.name is "TestPackage" isMatchingRoute: (route) -> # strip out any versioning applied to file if @versioning route = @versioning.trim(route) # compare against package route values for pkg in @packages return pkg if route is pkg.route.toLowerCase() # return nothing return unlink: -> log("Removing application: <green>#{@name}</green>") pkg.unlink() for pkg in @packages build: -> log("Building application: <green>#{@name}</green>") pkg.build() for pkg in @packages watch: -> log("Watching application: <green>#{@name}</green>") dirs = (pkg.watch() for pkg in @packages) # make sure dirs has valid values if dirs.length log.info("- Watching directories: <yellow>#{dirs}</yellow>") else log.info("- No directories to watch...") version: -> log("Versioning application: <green>#{@name}</green>") if @versioning @versioning.update() else log.errorAndExit "ERROR: Versioning not enabled in slug.json" applyRootDir: (value) -> # TODO: eventually use the Hem.home directory value if the home # TODO: value is different from the process.cwd() value?! values = utils.toArray(value) values = values.map (value) => if utils.startsWith(value, "." + path.sep) value else utils.cleanPath(@root, value) values applyBaseRoute: (values...) -> values.unshift(@route) if @route utils.cleanRoute.apply(utils, values) # ------- Package Classes class Package constructor: (app, config) -> @app = app @name = config.name @src = @app.applyRootDir(config.src or "") @target = @app.applyRootDir(config.target or "")[0] # determine target filename if utils.isDirectory(@target) # determine actual file name if @name is @ext targetFile = @app.name else targetFile = @name @target = utils.cleanPath(@target, targetFile) # make sure correct extension is present unless utils.endsWith(@target, ".#{@ext}") @target = "#{@target}.#{@ext}" # determine url from configuration if config.route if utils.startsWith(@target,"/") @route = config.route else @route = @app.applyBaseRoute(config.route) # use the static urls to determine the package @route else for route in @app.static when not @route if utils.startsWith(@target, route.path) regexp = new RegExp("^#{route.path.replace(/\\/g,"\\\\")}(\\\\|\/)?") targetUrl = @target.replace(regexp,"") @route = utils.cleanRoute(route.url, targetUrl) # make sure we have a route to use when using server command if _argv.command is "server" and not @route log.errorAndExit("Unable to determine route for <yellow>#{@target}</yellow>") handleCompileError: (ex) -> # check for method on _hem to allow override of behavior if _hem.handleCompileError _hem.handleCompileError(ex) return # TODO: construct better error message, one that works for all precompilers, log.error(ex.message) log.error(ex.path) if ex.path # only return when in server/watch mode, otherwise exit switch _argv.command when "server" if @ext is "js" return "alert(\"HEM: #{ex}\\n\\n#{ex.path}\");" else return "" when "watch" return "" else process.exit(1) unlink: -> if fs.existsSync(@target) log.info "- removing <yellow>#{@target}</yellow>" fs.unlinkSync(@target) build: (file) -> # remove the files module from Stitch so its recompiled Stitch.clear(file) if file # extrea logging extra = (_argv.compress and " <b>--using compression</b>") or "" log.info("- Building target: <yellow>#{@target}</yellow>#{extra}") # compile source source = @compile() # determine if we need to write to filesystem write = _argv.command isnt "server" if source and write dirname = path.dirname(@target) fs.mkdirsSync(dirname) unless fs.existsSync(dirname) fs.writeFileSync(@target, source) source watch: -> watchOptions = { persistent: true, interval: 1, ignoreDotFiles: true, maxListeners: 128 } # get dirs to watch dirs = [] for fileOrDir in @getWatchedDirs() continue unless fs.existsSync(fileOrDir) if utils.isDirectory(fileOrDir) dirs.push fileOrDir else dirs.push path.dirname(fileOrDir) dirs = utils.removeDuplicateValues(dirs) # start watch process for dir in dirs require('watch').watchTree dir, watchOptions, (f, curr, prev) => if (typeof f is "object" && prev is null and curr is null) # Finished walking the tree return # f was changed console.log 'build', f @build(f) # emit watch event events.emit("watch", @app, @, f) # return dirs that are watched dirs getWatchedDirs: -> return @src ext: "" # ------- Child Classes class JsPackage extends Package constructor: (app, config) -> # call parent super(app, config) # javascript only configurations @commonjs = config.commonjs or 'require' @libs = @app.applyRootDir(config.libs or []) @modules = utils.toArray(config.modules or []) # javascript to add before/after the stitch file @before = utils.arrayToString(config.before or "") @after = utils.arrayToString(config.after or "") compile: -> try result = [@before, @compileLibs(), @compileModules(), @after].join("\n") result = uglifyjs.minify(result, {fromString: true}).code if _argv.compress result catch ex @handleCompileError(ex) compileModules: -> # TODO use detective to load only those modules that are required ("required")? # or use the modules [] to specifiy which modules if any to load? or # set to false to never load any node_modules even if they are required in # javascript files. Would have to determine files needed from the stitched # files first... # TODO: also for testing we can remove the specs that don't match and optional parameter @depend or= new Dependency(@modules) @stitch or= new Stitch(@src) _modules = @depend.resolve().concat(@stitch.resolve()) if _modules Stitch.template(@commonjs, _modules) else "" compileLibs: (files = @libs, parentDir = "") -> # TODO: need to perform similar operation as stitch in that only # compilable code is used... refactor Stitch class to handle this?? except # we don't want the code actually stitched in a template, just plain old js # check if folder or file results = [] for file in files # treat as normal javascript string if utils.endsWith(file,";") results.join(file) # else load as file/dir else slash = if parentDir is "" then "" else path.sep # ignore files that start with "_", used for template files that process # includes (ex stylus), so they don't get compiled twice. continue if file.startsWith("_") # set full path for following code checks file = parentDir + slash + file if fs.existsSync(file) stats = fs.lstatSync(file) if (stats.isDirectory()) dir = fs.readdirSync(file) results.push @compileLibs(dir, file) else if stats.isFile() and path.extname(file) in ['.js','.coffee'] results.push fs.readFileSync(file, 'utf8') results.join("\n") getWatchedDirs: -> @src.concat @libs ext: "js" class TestPackage extends JsPackage constructor: (app, config) -> super(app, config) # test configurations @depends = utils.toArray(config.depends) # get test home directory based on target file location @testHome = path.dirname(@target) @framework = _hem.options.hem.test.frameworks # test to make sure framework is set correctly if @framework not in ['jasmine','mocha'] log.errorAndExit("Test frameworks value is not valid: #{@framework}") # javascript to run at end of specs file @after += """ // HEM: load in specs from test js file var onlyMatchingModules = \"#{_argv.grep or ""}\"; for (var key in #{@commonjs}.modules) { if (onlyMatchingModules && key.indexOf(onlyMatchingModules) == -1) { continue; } #{@commonjs}(key); } """ build: (file) -> @createTestFiles() super(file) getAllTestTargets: (relative = true) -> targets = [] homeRoute = path.dirname(@route) # create function to determine route/path relativeFn = (home, target, url = true) -> value = "" if relative value = path.relative(home, target) else value = target if url # deal with windows :o( value.replace(/\\/g, "/") else value # first get dependencies for dep in @depends for depapp in _hem.allApps when depapp.name is dep for pkg in depapp.packages continue unless pkg.constructor.name is "JsPackage" url = relativeFn(homeRoute, pkg.route) pth = relativeFn(@testHome, pkg.target) targets.push({ url: url, path: pth }) # get app targets for pkg in @app.packages continue unless pkg.constructor.name is "JsPackage" url = relativeFn(homeRoute, pkg.route) pth = relativeFn(@testHome, pkg.target) targets.push({ url: url, path: pth }) # finally add main test target file url = relativeFn(homeRoute, pkg.route) pth = relativeFn(@testHome, pkg.target) targets.push({ url: url, path: pth }) targets getFrameworkFiles: -> targets = [] frameworkPath = path.resolve(__dirname, "../assets/testing/#{@framework}") for file in fs.readdirSync(frameworkPath) if path.extname(file) in [".js",".css"] url = "#{@framework}/#{file}" targets.push({ url: url, path: url }) targets getTestIndexFile: -> path.resolve(@testHome,'index.html') # TODO: only do this for browser tests??? createTestFiles: -> # create index file and libs if they currently don't exist indexFile = @getTestIndexFile() unless fs.existsSync(indexFile) files = [] files.push.apply(files, @getFrameworkFiles()) files.push.apply(files, @getAllTestTargets()) template = utils.tmpl("testing/index", { commonjs: @commonjs, files: files, before: @before } ) fs.outputFileSync(indexFile, template) # copy the framework files if they aren't present frameworkPath = path.resolve(__dirname, "../assets/testing/#{@framework}") for file in fs.readdirSync(frameworkPath) if path.extname(file) in [".js",".css"] filepath = path.resolve(@testHome, "#{@framework}/#{file}") utils.copyFile(path.resolve(frameworkPath, file), filepath) class CssPackage extends Package constructor: (app, config) -> super(app, config) compile: () -> try output = [] # helper function to perform compiles requireCss = (filepath) -> filepath = require.resolve(path.resolve(filepath)) delete require.cache[filepath] require(filepath) # loop over path values for fileOrDir in @src # if directory loop over all top level files only if utils.isDirectory(fileOrDir) for file in fs.readdirSync(fileOrDir) when require.extensions[path.extname(file)] file = path.resolve(fileOrDir, file) output.push requireCss(file) else output.push requireCss(fileOrDir) # join and minify result = output.join("\n") result = uglifycss.processString(result) if _argv.compress result catch ex @handleCompileError(ex) ext: "css" # ------- Public Functions create = (name, config, hem, argv) -> _hem or= hem _argv or= argv return new Application(name, config) module.exports.create = create