node-sitefile

path = require 'path' fs = require 'fs' minimatch = require 'minimatch' glob = require 'glob' _ = require 'lodash' nodelib = require 'nodelib' Context = nodelib.Context expand_path = ( src, ctx ) -> base = ctx.sfdir+'/' if src.startsWith 'sitefile:' return src.replace 'sitefile:', base libdir = base+'lib/sitefile/' if src.startsWith 'sitefile-lib:' return src.replace 'sitefile-lib:', libdir if src.startsWith 'sitefile-client:' return src.replace 'sitefile-client:', libdir+'client/' src expand_paths_spec_to_route = ( rctx ) -> spec = rctx.route.spec if spec and '#' != spec # Expand non-glob from spec to paths srcs = minimatch.braceExpand spec else # Or fall back to verbatim route name as path srcs = [ rctx.name ] for src, idx in srcs srcs[idx] = expand_path src, rctx return srcs # Load default options from Sitefile resolve_route_options = ( ctx, route, router_name ) -> opts = {} if 'options' of ctx.sitefile # Global sitefile options (per router) if ctx.sitefile.options.global and router_name if router_name of ctx.sitefile.options.global global_opts = null #ctx.get "sitefile.options.global.#{router_name}" try global_opts = ctx.resolve "sitefile.options.global.#{router_name}" catch error null if global_opts opts = _.defaults {}, global_opts, opts # Local (per route) sitefile options if ctx.sitefile.options.local and route if route of ctx.sitefile.options.local local_opts = null esc = route.replace '.', '\\.' try local_opts = ctx.resolve "sitefile.options.local.#{esc}" catch error null if local_opts opts = _.defaultsDeep {}, local_opts, opts opts builtin = # TODO: extend redir spec for status code redir: ( rctx, url=null, status=302 ) -> if not url url = rctx.site.base + rctx.name p = rctx.site.base + rctx.route.spec # 301: Moved (Permanently) # 302: Found # 303: See Other rctx.context.log 'redir', url, p if rctx.route.handler == 'temp' rctx.context.redir 302, url, p else if rctx.route.handler == 'perm' rctx.context.redir 301, url, p else #rctx.context.redir status, url, p rctx.context.app.all url, ( req, res ) -> res.redirect p rctx.context.log ' ', url: url, '->', url: p static: ( rctx ) -> url = rctx.res.ref srcs = expand_paths_spec_to_route rctx rctx.context.app.use url, [ rctx.context.static_proto src for src in srcs ] rctx.context.log 'Static', url: url, '=', path: rctx.route.spec # Take care of rendering from a rctx with data, for a (data) handler that does # not care too itself since it is a very common task. data: ( rctx ) -> ( req, res ) -> res.type 'json' res.write JSON.stringify \ if "function" is typeof rctx.res.data then rctx.res.data() else rctx.res.data res.end() Base = name: 'Express' label: 'Express-Sitefile resource publisher' usage: """ Static path /path: <router[.handler-generator]>:<handler-spec> Leading underscore (accepts file glob handler-spec) _route_id: <router[.handler-generator]>:<handler-spec> TODO: maybe, later: Dollar path. /data/$record: <router[.handler-generator]>:<handler-spec> Prefix path /prefix$: <router[.handler-generator]>:<handler-spec> Also: handler-spec vs. glob-spec. Routers should parse own args. Router.Base provide some standard resolvers: - path/to/file-name.ext1.ext2 - path/to/dir """ # TODO: resource types? to use as 'backend' for fe route handlers.. resources: 'core.sitefile': null # Sitefile instance? 'core.sitefilerc': null # Subset mapped to ctx 'core.sitefile.extension': null # JS or coffee file 'core.sitefile.route.autocomplete': null # jQuery autcomplete API 'core.sitefile.route': null # Dynamic routes API? # XXX: clean me up, route spec parsing #parse_spec: ( route_spec, handler_spec, ctx ) -> # process parametrized rule #else if '$' in route # url = ctx.site.base + route.replace('$', ':') # log route, url: url # app.all url, handler.generator '.'+url, ctx # Return handler for path generate: ( ctx ) -> # XXX: register: ( app, ctx ) -> # Return resource sub-context for local file resource file_res_ctx: ( ctx, init, file_path ) -> init.res = { ref: ctx.site.base + file_path path: file_path extname: path.extname file_path dirname: path.dirname file_path } init.res.basename = path.basename file_path, init.res.extname # Create resolver sub-context ctx.getSub init prepare_dyn_path_res: ( rctx, ctx ) -> if rctx.res.dirname == '.' rctx.res.ref = ctx.site.base + rctx.res.basename else rctx.res.ref = \ "#{ctx.site.base}#{rctx.res.dirname}/#{rctx.res.basename}" dirurl = ctx.site.base + rctx.res.dirname # XXX: dir tracking if not ctx.routes.directories.hasOwnProperty dirurl ctx.routes.directories[ dirurl ] = [ rctx.res.basename ] else ctx.routes.directories[ dirurl ].push rctx.res.basename #rctx.path = dirurl default_resource_options: ( rctx, ctx, updateRef=false ) -> router = rctx.route.name if updateRef if 'string' is typeof updateRef rctx.res.ref = updateRef else Base.prepare_dyn_path_res rctx, ctx # Now parse dynamic path back from ref and look for defaults route = rctx.res.ref.substr ctx.site.base.length rctx.route.options = resolve_route_options( ctx, route, router ) # Return resource paths resolve: ( route, router_name, handler_name, handler_spec, ctx ) -> # List for resource contexts rs = [] rsctxinit = name: route route: name: router_name handler: handler_name spec: handler_spec # Route is RegEx if route.startsWith 'r:' init = res: ref: ctx.site.base + route.substr 2 match: new RegExp route.substr 2 _.defaultsDeep init, rsctxinit rctx = ctx.getSub init Base.default_resource_options rctx, ctx rs.push rctx # Use exact route as fs path else if fs.existsSync route rctx = Base.file_res_ctx ctx, rsctxinit, route Base.default_resource_options rctx, ctx rs.push rctx # Use route as ID for glob spec (a set of existing fs paths) else if route.startsWith '_' ctx.log 'Dynamic', url: route, '', path: handler_spec for name in glob.sync handler_spec rctx = Base.file_res_ctx ctx, rsctxinit, name Base.default_resource_options rctx, ctx, true rs.push rctx else if fs.existsSync handler_spec rctx = Base.file_res_ctx ctx, rsctxinit, handler_spec Base.default_resource_options rctx, ctx, ctx.site.base + route rs.push rctx # Use route as is else init = res: ref: ctx.site.base + route _.defaultsDeep init, rsctxinit rctx = ctx.getSub init Base.default_resource_options rctx, ctx rs.push rctx return rs initialize: ( router_type, rctx ) -> ctx = rctx.context # routes.resources: Track all paths to router instances ctx.routes.resources[rctx.res.ref] = rctx # generate: let router_type return handlers for given resource if rctx.route.handler g = ctx._routers.generator '.'+rctx.route.handler, rctx else g = ctx._routers.generator rctx.route.name # invoke routers selected generate function, expect a route handler object h = g rctx ref = if rctx.res.match then rctx.res.match else rctx.res.ref if 'function' is typeof h # Add as regular Express route handler rctx.context.app.all ref, ( req, res ) -> _.defaultsDeep rctx.route.options, req.query h req, res ctx.log rctx.name, url: rctx.res.ref, '=', ( if 'path' of rctx.res \ then path: rctx.res.path \ else res: rctx.route.name ), id: rctx.route.spec else if h and 'object' is typeof h # XXX: The object could have data, meta etc. attr and play as JSON API doc # For now just extend the resource context with the object it returned. rctx.prepare_from_obj h _.merge rctx._data, h if h.res and 'data' of h.res rctx.context.app.all ref, builtin.data rctx ctx.log "Extension at ", url: rctx.res.ref, \ "from", ( name: rctx.route.name+'.'+rctx.route.handler ), \ id: rctx.route.spec, "at", path: rctx.name else if not h module.exports.warn "Router not recognized", "Router #{rctx.route.name} returned nothing recognizable for #{rctx.name}, ignored" module.exports = builtin: builtin Base: Base # Current way of 'instantiating' router define: ( mixin ) -> _.assign {}, Base, mixin resolve_route_options: resolve_route_options # XXX: spec parse helper expand_paths_spec_to_route: expand_paths_spec_to_route expand_path: expand_path # XXX: spec parse helper parse_kw_spec: ( rctx ) -> kw = {} specs = rctx.route.spec.split ';' for spec in specs x = spec.indexOf '=' k = spec.substr(0, x) kw[k] = spec.substr x+1 kw # XXX: Read JSON + jspath read_xref: ( ctx, spec ) -> if '#' not in spec throw new Error spec [ jsonf, spec ] = spec.split '#' jsonf = expand_path jsonf, ctx if not jsonf.startsWith path.sep jsonf = path.join ctx.cwd, jsonf p = spec.split '/' if not p[0] p.shift() o = require jsonf c = o while p.length e = p.shift() c = c[e] return c