spa

fs = require('fs') vm = require("vm") walker = require('fs-walk-glob-rules') globrules = require('glob-rules') path = require('path') clc = require('cli-color') mkdirpSync = require('mkdirp').sync detectiveCJS = require('detective') detectiveAMD = require('detective-amd') definition = require('module-definition').fromSource amdType = require('get-amd-module-type').fromSource yaml = require('js-yaml') ejs = require("ejs") _ = require('lodash') _.string = require('underscore.string') _.mixin(_.string.exports()) crypto = require("crypto") resolve = require("resolve") console = require("./console") packagejson = ( -> packagepath = path.resolve(__dirname, '../package.json') return JSON.parse(fs.readFileSync(packagepath, 'utf8')) )() class CyclicDependenciesError extends Error constructor: (@loop) -> @name = @constructor.name @message = "Can't sort modules. Loop found: \n#{@loop}" class UnresolvedDependencyError extends Error constructor: (@path, @alias) -> @name = @constructor.name @message = "Can't resolve dependency `#{@alias}` "+ "inside module `#{@path}`" class ExternalDependencyError extends Error constructor: (@path, @alias, @dep) -> @name = @constructor.name @message = "Module at path `#{dep}` is required from `#{path}` " + "as `#{alias}`, but it cant be found inside building scope." class NoCopyingRuleError extends Error constructor: (@path) -> @name = @constructor.name @message = "No copying rule for module to be crypter at path `#{@path}`" class ModuleTypeError extends Error constructor: (@path, @error) -> @name = @constructor.name @message = "Can't determine type of module at `#{@path}`: #{@error?.toString()}" class ModuleFileOverwritingError extends Error constructor: (@path) -> @name = @constructor.name @message = "Several modules are about to be wrote into `#{@path}`. Please revisit your `copying` rules." class HostingUrlOverwritingError extends Error constructor: (@url) -> @name = @constructor.name @message = "Several modules are about to be hosted `#{@url}`. Please revisit your `hosting` rules." class Loop constructor: () -> @_parts = [] prepend: (path, alias) -> @_parts.unshift([path, alias]) return this toString: -> return "" if @_parts.length == 0 p = @_parts.concat([@_parts[0]]) return (for i in [0..@_parts.length-1] "#{p[i][0]} --[#{p[i][1]}]--> #{p[i+1][0]}" ).join("\n") class Logger constructor: (@prefix) -> info: (args...) -> console.info(args.join(" ")) warn: (args...) -> console.warn(clc.bgYellow.bold(@prefix), clc.yellow(args.join(" "))) error: (args...) -> console.error(clc.bgRed.bold(@prefix), clc.red.bold(args.join(" "))) class DB constructor: (@filename) -> if @filename? and fs.existsSync(@filename) @_data = JSON.parse(fs.readFileSync(@filename)) else @_data = {} get: (key) -> content = @_data[key] if content? return JSON.parse(content) set: (key, value) -> @_data[key] = JSON.stringify(value) del: (key) -> delete @_data[key] has: (key) -> return @_data.hasOwnProperty(key) flush: -> fs.writeFileSync(@filename, JSON.stringify(@_data)) sandbox = -> window = {} window.window = window result = ArrayBuffer: Object.freeze(ArrayBuffer) Buffer: Object.freeze(Buffer) Uint8Array: Object.freeze(Uint8Array) console: Object.freeze(console) window: Object.freeze(window) Uint32Array: Object.freeze(Uint32Array) return result eval_file = (p, s) -> return vm.runInNewContext(fs.readFileSync(path.resolve(__dirname, p), "utf8"), sandbox()) hashers = md5: (data) -> crypto.createHash("md5").update(data).digest('hex') ripemd160: (data) -> crypto.createHash("ripemd160").update(data).digest('hex') sha1: (data) -> crypto.createHash("sha1").update(data).digest('hex') sha224: (data) -> crypto.createHash("sha224").update(data).digest('hex') sha256: (data) -> crypto.createHash("sha256").update(data).digest('hex') sha384: (data) -> crypto.createHash("sha384").update(data).digest('hex') sha512: (data) -> crypto.createHash("sha512").update(data).digest('hex') sha3: eval_file("./assets/hash/sha3.js") encoders = "aes-ccm": eval_file("./assets/encode/aes-ccm.js") "aes-gcm": eval_file("./assets/encode/aes-gcm.js") "aes-ocb2": eval_file("./assets/encode/aes-ocb2.js") class Builder constructor: (options) -> @_built_ins = ["loader", "require", "module", "exports"] @options = options @options.logger ?= "SPA" if _.isString(options.logger) @logger = @_create_logger() else @logger = options.logger @root = path.resolve(process.cwd(), options.root) + "/" @extensions = options.extensions ? [".js"] @excludes = options.excludes ? [] @paths = options.paths ? {} @hosting = for pattern, template of options.hosting ? {} test: globrules.tester(pattern) transform: globrules.transformer(pattern, template) @hosting_map = options.hosting_map @copying = for pattern, template of options.copying ? {} test: globrules.tester(pattern) transform: globrules.transformer(pattern, template) @default_loader = options.default_loader ? "cjs" @loaders = for pattern, type of options.loaders ? {} test: globrules.tester(pattern) type: type @bundle = options.bundle @manifest = options.manifest @index = options.index @pretty = options.pretty ? false @grab = options.grab ? false @print_stats = options.print_stats ? true @print_roots = options.print_roots ? true @assets = appcache_template: path.join(__dirname, "assets/appcache.tmpl") index_template: path.join(__dirname, "assets/index.tmpl") for own name, value of options.assets @assets[name] = value @appcache = options.appcache @cached = options.cached ? [] @hash_func = options.hash_func ? "md5" @randomize_urls = options.randomize_urls ? true @coding_func = options.coding_func @cache = @_create_db(path.resolve(@root, options.cache_file ? ".spacache")) # ________________________________ UTILS _________________________________ # _create_db: (path) -> return new DB(path) _create_logger: (name) -> return new Logger(name) _filter: (filepath) -> expected = path.extname(filepath) return false unless _(@extensions).any (ext) -> expected is ext return true calc_hash: (content) -> return hashers[@hash_func](content) encode: (content, module) -> encoder = encoders[@coding_func.name] return encoder(content, module, this) _relativate: (filepath) -> return @walker.normalize(filepath) _get_copying: (filepath) -> for rule in @copying continue unless rule.test(filepath) return rule.transform(filepath) return _host_path: (relative)-> for rule in @hosting continue unless rule.test(relative) return rule.transform(relative) @logger.error("No hosting rules for `#{relative}`") _resolve_to_file: (filepath) -> if fs.existsSync(filepath) stats = fs.statSync(filepath) if stats.isFile() return filepath return _resolve_to_directory: (dirpath) -> if fs.existsSync(dirpath) stats = fs.statSync(dirpath) if stats.isDirectory() return @_resolve_to_file(path.join(dirpath, "index.js")) return _get_type: (module, source) -> for rule in @loaders continue unless rule.test(module.relative) return rule.type try return switch definition(module.source) when "commonjs" then "cjs" when "amd" then "amd" catch error throw new ModuleTypeError(module.path, error) return @default_loader _resolve: (module, dep) -> for alias, prefix of @paths continue unless _.startsWith(dep, alias) if (dep[alias.length] || "/") is "/" dep = dep.replace(alias, prefix) break if _.startsWith(dep, "/") dep = path.join(@root, dep) else if _.startsWith(dep, "./") or _.startsWith(dep, "../") basedir = path.dirname(module.path) dep = path.resolve(basedir, dep) else try return resolve.sync dep, basedir: path.dirname(module.path) extensions: @extensions catch return null return @_resolve_to_file(dep) ? @_resolve_to_file(dep + ".js") ? @_resolve_to_directory(dep) _find_loop: (candidates) -> for candidate in candidates walked = [] _go_deep = (current) => module = @_by_path[current] relative = module.relative deps = module.deps_paths for alias, dep of deps continue unless dep in candidates continue if dep in walked return new Loop().prepend(relative, alias) if dep is candidate walked.push(dep) deep = _go_deep(dep) walked.pop() return deep.prepend(relative, alias) if deep? has_loop = _go_deep(candidate) return has_loop if has_loop? _write_file: (destination, content) -> filepath = path.resolve(@root, destination) @logger.info("Writing #{filepath}. #{content.length} bytes.") mkdirpSync(path.dirname(filepath)) fs.writeFileSync(filepath, content) _stringify_json: (data) -> return JSON.stringify(data, null, if @pretty then " ") _inject_inline: (relative) -> filepath = path.resolve(__dirname, "assets", relative) return fs.readFileSync(filepath, encoding: "utf8") # _______________________________ STAGES _________________________________ # _clear: -> @_modules = [] @_by_path = {} @_by_id = {} @_manifest_content = undefined @_index_content = undefined _enlist: () -> @walker = new walker.SyncWalker root: @root excludes: @excludes for data in @walker.walk() continue unless @_filter(data.relative) module = path: data.path relative: data.relative @_by_path[data.path] = module @_modules.push(module) return _analyze: -> modules = @_modules.concat() while modules.length > 0 module = modules.shift() source = fs.readFileSync(module.path) module.source = source.toString('utf8') module.deps_paths = {} module.type = @_get_type(module) switch module.type when "amd" module.amdtype = amdType(module.source) module.source_hash = @calc_hash(source) module.source_length = source.length deps = switch module.type when "cjs" then detectiveCJS(module.source) when "amd" then detectiveAMD(module.source) else [] #3 ISSUE. Add hardcoded dependencies from config here for dep in deps continue if dep in @_built_ins resolved = @_resolve(module, dep) unless resolved? throw new UnresolvedDependencyError(module.relative, dep) module.deps_paths[dep] = resolved if @grab and not @_by_path[resolved] submodule = path: resolved relative: @_relativate(resolved) @_by_path[resolved] = submodule @_modules.push(submodule) modules.push(submodule) return _host: -> urls = {} for module in @_modules url = @_host_path(module.relative) continue unless url if url of urls #TODO: maybe better comparison will be needed throw new HostingUrlOverwritingError(url) urls[url] = module module.url = url return _set_ids: -> for module in @_modules ext = path.extname(module.path) root = path.dirname(module.path) id = path.basename(module.path, ext) if id is "index" id = path.basename(root) root = path.dirname(root) while id of @_by_id id = path.basename(root) + "/" + id newroot = path.dirname(root) break if newroot is root root = newroot id = id.split(/[^a-zA-Z0-9]/g).join("_") while id of @_by_id id = "_" + id @_by_id[id] = module module.id = id return _link: -> for module in @_modules module.deps_ids = {} for dep, resolved of module.deps_paths if @_by_path[resolved]? module.deps_ids[dep] = @_by_path[resolved].id else throw new ExternalDependencyError(module.relative, dep, resolved) _sort: -> left = (module.path for module in @_modules) order = [] while left.length > 0 use = [] for mpath in left deps = @_by_path[mpath].deps_paths use.push(mpath) unless _(deps).any((dep) -> dep not in order) if use.length == 0 throw new CyclicDependenciesError(@_find_loop(left)) order.push(use...) left = left.filter((mpath) -> mpath not in use) @_modules = (@_by_path[mpath] for mpath in order) _encode: -> _contents = [] if @coding_func? paths = {} for module in @_modules destination = @_get_copying(module.relative) unless destination? throw new NoCopyingRuleError(module.relative) if destination of paths #TODO: maybe better comparison will be needed throw new ModuleFileOverwritingError(destination) paths[destination] = module source = fs.readFileSync(module.path) output = @encode(source, module) if @bundle _contents.push(output) @_write_file(destination, output) module.hash = @calc_hash(output) module.size = output.length else for module in @_modules module.hash = module.source_hash module.size = module.source_length if @bundle source = fs.readFileSync(module.path) _contents.push(source) @_bundle_content = _contents.join("") return _create_manifest: -> modules = for module in @_modules id: module.id url: module.url hash: module.hash size: module.size type: module.type amdtype: module.amdtype deps: module.deps_ids decoding: module.decoding @_manifest_content = version: packagejson.version hash_func: @hash_func modules: modules if @bundle filepath = path.resolve(@root, @bundle) relative = @_relativate(filepath) url = @_host_path(relative) bundle = hash: @calc_hash(new Buffer(@_bundle_content, "utf8")) url: url @_manifest_content.bundle = bundle if @coding_func? @_manifest_content.decoder_func = @coding_func.name return @_manifest_content _create_hosting_map: -> files = {} for module in @_modules files[module.url] = module.relative map = version: packagejson.version files: files if @bundle filepath = path.resolve(@root, @bundle) relative = @_relativate(filepath) url = @_host_path(relative) if url? map.bundle = path: relative url: url if @manifest filepath = path.resolve(@root, @manifest) relative = @_relativate(filepath) url = @_host_path(relative) if url? map.manifest = path: relative url: url if @index filepath = path.resolve(@root, @index) relative = @_relativate(filepath) url = @_host_path(relative) if url? map.index = path: relative url: url if @appcache? filepath = path.resolve(@root, @appcache) relative = @_relativate(filepath) url = @_host_path(relative) if url? map.appcache = path: relative url: url return map _create_index: -> assets = {} namespace = assets: assets for own name, value of @assets content = fs.readFileSync(value, encoding: "utf8") namespace[name] = content assets[name] = content namespace["manifest_location"] = "manifest.json" namespace["randomize_urls"] = @randomize_urls namespace["inline"] = (relative) => @_inject_inline(relative) namespace["version"] = packagejson.version namespace["hash_name"] = @hash_func namespace["decoder_name"] = if @coding_func? then @coding_func.name else "identity" namespace["passcode_required"] = @coding_func? if @manifest? filepath = path.resolve(@root, @manifest) relative = @_relativate(filepath) url = @_host_path(relative) if url? namespace["manifest_location"] = url else @logger.warn("Manifest file hosted as `#{relative}` and will be accesible relatively") if @appcache? filepath = path.resolve(@root, @appcache) relative = @_relativate(filepath) url = @_host_path(relative) if url? namespace["appcache_location"] = url else @logger.warn("AppCache manifest file location can't be automatically calculated for index.html") compiled = ejs.compile(assets["index_template"]) @_index_content = compiled(namespace) return @_index_content _create_appcache: -> assets = {} for filename in @cached filepath = path.resolve(@root, filename) relative = @_relativate(filepath) url = @_host_path(relative) continue unless url? content = fs.readFileSync(filepath, encoding: "utf8") assets[url] = @calc_hash(content) if @index? filepath = path.resolve(@root, @index) relative = @_relativate(filepath) url = @_host_path(relative) if url? filename = path.resolve(@root, @index) assets[url] = @calc_hash(@_index_content) if Object.keys(assets).length == 0 if @index? @logger.warn("No hosting rule for `#{@index}` file. AppCache manifest `#{@appcache}` appears to be empty") else @logger.warn("There are no assets to be included into AppCache manifest `#{@appcache}`") template = @assets["appcache_template"] compiled = ejs.compile(fs.readFileSync(template, encoding: "utf8")) content = compiled cached: assets return content _print_roots: -> all_deps = [] for module in @_modules for dep_path, dep of module.deps_ids all_deps.push(dep) roots = [] for module in @_modules continue if module.id in all_deps roots.push(module) return if roots.length == 0 @logger.info("Possible roots: ") for num, module of roots message = _.sprintf "%(num)3s %(module.relative)s", num: parseInt(num) + 1 module: module @logger.info(message) _print_stats: -> @logger.info("Statistics: ") total = 0 for num, module of @_modules total += module.size message = _.sprintf "%(num)3s %(module.relative)-40s %(module.size)7s %(type)-11s %(module.hash)s", num: parseInt(num) + 1 module: module type: if module.type == "amd" then module.type + "/" + module.amdtype else module.type @logger.info(message) @logger.info("Total #{total} bytes in #{@_modules.length} files") build: -> @_clear() @_enlist() @_analyze() @_host() @_set_ids() @_link() @_print_roots() if @print_roots @_sort() @_encode() @_write_file(@manifest, @_stringify_json(@_create_manifest())) if @manifest? @_write_file(@hosting_map, @_stringify_json(@_create_hosting_map())) if @hosting_map? @_write_file(@index, @_create_index()) if @index? @_write_file(@appcache, @_create_appcache()) if @appcache? @_write_file(@bundle, @_bundle_content) if @bundle? @_print_stats() if @print_stats @cache.flush() return @_manifest_content hasBOM = (data) -> return false if data.length < 3 return false unless data[0] is 0xef return false unless data[1] is 0xbb return false unless data[2] is 0xbf return true load_json = (filepath) -> return unless filepath? source = fs.readFileSync(filepath) return JSON.parse(source) load_yaml = (filepath) -> return unless filepath? data = fs.readFileSync(filepath) source = data.toString("utf8", if hasBOM(data) then 3 else 0) return yaml.safeLoad(source) get_config_content = (filepath) -> switch path.extname(filepath) when ".yaml", ".yml" return load_yaml(filepath) when ".json" return load_json(filepath) # ________________________________ EXPORTS ___________________________________ # Builder.from_config = (config_path, options) -> basedir = path.dirname(config_path) config = get_config_content(config_path) for own name, value of options ? {} config[name] = value config.root ?= "." config.root = path.resolve(basedir, config.root) return new Builder(config) exports.Builder = Builder exports.CyclicDependenciesError = CyclicDependenciesError exports.UnresolvedDependencyError = UnresolvedDependencyError exports.ExternalDependencyError = ExternalDependencyError exports.ModuleTypeError = ModuleTypeError exports.ModuleFileOverwritingError = ModuleFileOverwritingError exports.HostingUrlOverwritingError = HostingUrlOverwritingError exports.Loop = Loop exports.Logger = Logger exports.DB = DB exports.hashers = hashers exports.encoders = encoders