sptc 0.0.0 → 0.0.2

package/README.md

@@ -1,3 +1,75 @@
 # Simple Pretreat Toolkit CLI
 
 This project is developing..
+
+---
+
+### sptc
+
+```
+Usage: sptc [options]
+
+sptc
+
+Options:
+  -V, --version            output the version number
+  -f, --filename <string>  Sptc filename.
+  -d, --defines <string>   Macro definition switches. If you want to use multiple switches, separate them with ",".
+                           (default: "")
+  -h, --help               display help for command
+```
+
+### sptcd
+```
+Usage: sptc http server [options]
+
+A simple http server
+
+Options:
+  -V, --version           output the version number
+  -p, --port <number>     Serve port. (default: 9090)
+  -l, --locally           Only accepts local connections.
+  -w, --workdir <string>  Specify the working directory. (default: ".")
+  -r, --router <string>   Specify a file as the router entry. If specified, all requests will pass to this file.
+  -e, --exts <string>     Specify the valid extensions of executable sptc files. (default: ".sjs,.shtml")
+  -n, --workers <number>  Workers count. (default: 1)
+  -s, --slient            Slient mode.
+  -h, --help              display help for command
+```
+
+### webpack loader
+```
+Usage:
+
+Webpack configuration:
+
+{
+  test: /\.(jsx?)$/,
+  exclude: /node_modules/,
+  options: {
+    file: path.resolve(__dirname+'/sptc.inject.js'),
+  },
+  loader: 'sptc/dist/webpack.loader.js',
+}
+
+
+
+**sptc.inject.js**
+
+module.exports={
+  EXTENDS: (ctx)=>({
+    get_module_dir: _=>{
+      return ctx.fn.replace(/\\+/g, '/').replace(/(^.*?src\/modules\/[^/]+).*$/, '$1')+'/'
+    },
+    IS_NODE_TARGET: ctx.webpackLoaderThis.target==='node',
+  }),
+  TPLS: [
+    /\.jsx?$/, ctx=>{
+      let {str, fn}=ctx
+      return `console.log("// ${fn}")\n`+str
+    }
+  ],
+}
+
+
+```

package/bin/sptc.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const {executeSptcFile}=require('../engine')
+const {Command}=require('commander')
+const version=require('../package.json').version
+const program=new Command()
+  .name(`sptc`)
+  .description(`sptc`)
+  .version(version)
+  .requiredOption('-f, --filename <string>', 'Sptc filename.')
+  .option('-d, --defines <string>', 'Macro definition switches. If you want to use multiple switches, separate them with ",".', '')
+  .action(({
+    filename,
+    defines,
+  })=>{
+    executeSptcFile(filename, {}, {
+    	write: x=>process.stdout.write(x),
+    	onError: e=>console.log(e),
+      __DEV__: true,
+      macroOption: {
+        defs: defines.split(',').map(x=>x.trim()).filter(x=>x),
+      },
+    })
+  })
+  .parse()

package/bin/sptcd.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+const {FastCGI, FastCGI_FPM}=require('../dist/httpServer')
+const {Command}=require('commander')
+const version=require('../package.json').version
+const program=new Command()
+  .name(`sptc http server`)
+  .description(`A simple http server`)
+  .version(version)
+  .requiredOption('-p, --port <number>', 'Serve port.', 9090)
+  .option('-l, --locally', 'Only accepts local connections.')
+  .option('-w, --workdir <string>', 'Specify the working directory.', '.')
+  .option('-r, --router <string>', 'Specify a file as the router entry. If specified, all requests will pass to this file.')
+  .option('-e, --exts <string>', 'Specify the valid extensions of executable sptc files.', '.sjs,.shtml')
+  .option('-n, --workers <number>', 'Workers count.', 1)
+  .option('-s, --slient', 'Slient mode.')
+  .action(({
+    port,
+    locally,
+    workdir,
+    router,
+    exts,
+    workers,
+    slient,
+  })=>{
+    const argv=[port, locally, {
+      serverDir: workdir,
+      routerEntry: router,
+      exts: exts.split(',').map(x=>x.trim()).filter(x=>x),
+      debug: true,
+      slientMode: slient,
+    }]
+    if(workers>1) {
+      FastCGI_FPM(workers, ...argv)
+    }else{
+      FastCGI(...argv)
+    }
+  })
+  .parse()

package/dist/httpServer.js

@@ -0,0 +1,147 @@
+const {
+	fpm,
+	safe_path,
+	fileExists,
+	getExtension,
+	getLocalIpv4Addresses,
+}=require('../utils')
+const {executeSptcFile}=require('../engine')
+
+process.on('uncaughtException', e=>{
+  console.log('uncaughtException:', e)
+})
+
+function FastCGI_FPM(n, port, locally, option={}) {
+	option.env={
+		RUNTIME: 'FastCGI_FPM',
+	}
+	fpm(n, _=>FastCGI(port, locally, option))
+}
+
+function FastCGI(port, locally, option) {
+	const http=require('http')
+	const path=require('path')
+	const {
+		serverDir='.',
+		routerEntry=null,
+		slientMode=false,
+		..._option
+	}=option
+	_option.env=_option.env || {
+		RUNTIME: 'FastCGI',
+	}
+	_option.srvDir=path.resolve(serverDir)
+	_option.router=routerEntry? safe_path(_option.srvDir, routerEntry): null
+	http.createServer((req, res)=>{
+		CGI(req, res, _option)
+	}).listen(port, locally? '127.0.0.1': '0.0.0.0', _=>{
+		console.log()
+		console.log('`sptc-http-server` has been launched with the following option:')
+		const o={
+			workdir: _option.srvDir,
+			routerEntry: _option.router,
+		}
+		if(locally) {
+			o.serve='127.0.0.1:'+port
+		}else{
+			o.serves=getLocalIpv4Addresses().map(x=>x+':'+port)
+		}
+		console.log(o)
+		console.log()
+	})
+}
+
+function CGI(req, res, option) {
+	const {
+		srvDir,
+		exts=['.sjs', '.shtml'],
+		debug=false,
+		router=null,
+		env,
+	}=option
+	const [reqCtx, handler]=buildRequestContext(req, res, {srvDir, debug, env})
+	const file=reqCtx.$_REQUEST_FILE || {}
+	const fn=router || file.fullname
+	if(!fileExists(fn)) {
+		res.writeHead(404, {'content-type': 'text/plain'})
+		res.end(`\`${router || file.pathname}\` does not exist`)
+		return
+	}
+	const ext=getExtension(fn)
+	if(!exts.includes(ext)) {
+		res.writeHead(403, {'content-type': 'text/plain'})
+		res.end(`\`${ext}\` does not match`)
+		return
+	}
+	executeSptcFile(fn, reqCtx, handler)
+}
+
+function buildRequestContext(req, res, {srvDir, debug, env}) {
+	const {fullname, pathname}=getRequestFile(req, srvDir)
+	const reqCtx={
+		$_RAW_REQUEST: req,
+		$_RAW_RESPONSE: res,
+		$_ENV: env,
+		$_REQUEST_FILE: {
+			fullname,
+			pathname,
+		},
+		$_DEBUG: debug,
+		$_WORKDIR: srvDir,
+	}
+	reqCtx.$_GLOBAL=reqCtx
+
+	const state={
+		statusCode: 200,
+		statusText: 'OK',
+		responseHeaders: {'content-type': 'text/html'},
+		error: null,
+		headerFlushed: false,
+	}
+	function flushHeader() {
+		if(state.headerFlushed) return;
+		state.headerFlushed=true
+		res.writeHead(state.statusCode, state.statusText, state.responseHeaders)
+	}
+
+	reqCtx.setStatus=(code, text)=>{
+		state.statusCode=200
+		if(text!==undefined) state.statusText=text
+	}
+	reqCtx.setResponseHeaders=headers=>{
+		Object.assign(state.responseHeaders, headers)
+	}
+	reqCtx.flushHeader=_=>{
+		flushHeader()
+	}
+	reqCtx.setDebug=x=>{
+		reqCtx.$_DEBUG=x
+	}
+
+	return [reqCtx, {
+		write: x=>{
+			flushHeader()
+			res.write(x)
+		},
+		end: _=>{
+			flushHeader()
+			res.end()
+		},
+		onError: e=>{
+			if(reqCtx.$_DEBUG) console.log(e)
+		},
+	}]
+}
+function getRequestFile(req, srvDir) {
+	const _url=require('url')
+	const {pathname}=_url.parse(req.url)
+	return {
+		fullname: safe_path(srvDir, pathname),
+		pathname,
+	}
+}
+
+module.exports={
+	FastCGI,
+	FastCGI_FPM,
+}

package/dist/webpack.loader.js

@@ -0,0 +1,48 @@
+const {executeSptcFileEx}=require('../engine')
+const path=require(`path`)
+
+module.exports=async function(str) {
+  let query=this.query || {}
+  if(this.query) {
+    const {file}=this.query
+    if(file) {
+      query=Object.assign({}, require(file))
+    }
+  }
+
+  const {
+    EXTENDS=(wCtx=>({})),
+    TPLS=[],
+    DEFINES=[],
+  }=query
+
+  let wCtx={
+    str: str,
+    fn: path.resolve(this.resourcePath).replace(/\\+/g, '/'),
+    webpackLoaderThis: this,
+  }
+  const globals=Object.assign(EXTENDS(wCtx), {wCtx})
+  wCtx.runtimeGlobals=globals
+
+  let callback=this.async()
+  try{
+    const output=await executeSptcFileEx(wCtx.fn, globals, {
+      __DEV__: true,
+      macroOption: {
+        defs: DEFINES,
+      },
+      mockFileContent: wCtx.str,
+    })
+
+    wCtx.str=output
+
+    for(let i=0; i<TPLS.length; i+=2){
+      const [_match, _handler]=[TPLS[i], TPLS[i+1]]
+      if(wCtx.fn.match(_match)) wCtx.str=_handler(wCtx, globals)
+    }
+    callback(null, wCtx.str)
+  }catch(e) {
+    callback(e)
+  }
+
+}

package/engine/compiler-macro.js

@@ -0,0 +1,237 @@
+
+const vm=require('vm')
+const {compileFile}=require('../utils')
+
+const Tokens={
+  T_IFDEF: '#ifdef',
+  T_ELSE: '#else',
+  T_ENDIF: '#endif',
+  T_IFNDEF: '#ifndef',
+
+  T_DEF: '#def',
+  T_UNDEF: '#undef',
+
+  T_INCLUDE: '#include',
+
+  T_DEFINE: '#define',
+  T_CALL_DEFINE: '@',
+}
+
+function lexer(content) {
+  const {
+    T_IFDEF,
+    T_ELSE,
+    T_ENDIF,
+    T_IFNDEF,
+
+    T_DEF,
+    T_UNDEF,
+
+    T_INCLUDE,
+
+    T_DEFINE,
+    T_CALL_DEFINE,
+  }=Tokens
+
+  const tokens=[]
+  const lines=content.split('\n')
+  let reStr='((?:'+[
+    T_IFDEF,
+    T_ELSE,
+    T_ENDIF,
+    T_IFNDEF,
+    T_DEF,
+    T_UNDEF,
+    T_INCLUDE,
+    T_DEFINE,
+  ].join('|')+')\\b)((?:\\s+).+)?|(.+)'
+  const re=new RegExp('^'+reStr, 'g')
+  const subre=new RegExp(T_CALL_DEFINE+'([A-Za-z\\d_]+)(\\([^)]*?\\)|\\b)|(.)', 'g')
+
+  for(let i=0; i<lines.length; i++) {
+    if(!lines[i]) {
+      tokens.push({frags: true, str: '\n'})
+      continue
+    }
+    lines[i].replace(re, (_, tk, tk_params, subline)=>{
+      if(tk) {
+        tokens.push({tk, tk_params: (tk_params || '').trim()})
+      }else if(subline) {
+        subline.replace(subre, (_, call_define, call_define_params, frags)=>{
+          if(call_define) {
+            tokens.push({call_define, call_define_params, source: _})
+          }else if(frags) {
+            tokens.push({frags: true, str: frags})
+          }
+        })
+        tokens.push({frags: true, str: '\n'})
+      }
+    })
+  }
+  const v=tokens.pop()
+  if(!(v.frags===true && v.str==='\n')) {
+    tokens.push(v)
+  }
+  return tokens
+}
+
+const O_IFDEF=Symbol()
+const O_STR=Symbol()
+const O_DEFINE_CONST=Symbol()
+const O_DEFINE_CALL=Symbol()
+const O_CALL_CONST=Symbol()
+const O_CALL_DEFINE=Symbol()
+const O_DEF=Symbol()
+const O_INCLUDE=Symbol()
+const O_UNDEF=Symbol()
+function transformToAst(tokens) {
+  const {
+    T_IFDEF,
+    T_ELSE,
+    T_ENDIF,
+    T_IFNDEF,
+
+    T_DEF,
+    T_UNDEF,
+
+    T_INCLUDE,
+
+    T_DEFINE,
+    T_CALL_DEFINE,
+  }=Tokens
+
+  const tree=[]
+  const if_stacks=[]
+  function _get_if_stack() {
+    if(!if_stacks.length) return;
+    const p=if_stacks[if_stacks.length-1]
+    const {_push_consequent, _reverse, consequent, alternate}=p
+    let cd=[consequent, alternate]
+    if(_reverse) cd.reverse()
+    return cd[_push_consequent? 0: 1] // .push(if_statement)
+  }
+
+  for(let i=0; i<tokens.length; i++) {
+    const x=tokens[i]
+    if(x.tk===T_IFDEF || x.tk===T_IFNDEF) {
+      const if_statement={
+        type: O_IFDEF,
+        match: x.tk_params,
+        consequent: [],
+        alternate: [],
+        _push_consequent: true,
+        _reverse: x.tk===T_IFNDEF,
+      }
+      const _cur_if_stack=_get_if_stack()
+      _cur_if_stack && _cur_if_stack.push(if_statement)
+      if_stacks.push(if_statement)
+    }else if(x.tk===T_ELSE) {
+      const t=if_stacks[if_stacks.length-1]
+      if(!t || t.type!==O_IFDEF) throw new Error('not match '+T_ELSE)
+      t._push_consequent=false
+    }else if(x.tk===T_ENDIF) {
+      const t=if_stacks[if_stacks.length-1]
+      if(!t || t.type!==O_IFDEF) throw new Error('not match '+T_ENDIF)
+      const p=if_stacks.pop()
+      if(!if_stacks.length) {
+        tree.push(p)
+      }
+    }else{
+      let d={}
+      if(x.tk===T_DEF) {
+        Object.assign(d, {
+          type: O_DEF,
+          def: x.tk_params,
+        })
+      }else if(x.tk===T_UNDEF) {
+        Object.assign(d, {
+          type: O_UNDEF,
+          def: x.tk_params,
+        })
+      }else if(x.tk===T_INCLUDE) {
+        Object.assign(d, {
+          type: O_INCLUDE,
+          include: x.tk_params,
+        })
+      }else if(x.tk===T_DEFINE) {
+        const re_define_func=/^([A-Za-z\d_]+)\(([^)]+)\)\s+(.+)/
+        const re_define_const=/^([A-Za-z\d_]+)\s+(.+)/
+        const matched_func=x.tk_params.match(re_define_func)
+        const matched_const=x.tk_params.match(re_define_const)
+        if(matched_func) {
+          const [, funcname, argv, func_body]=matched_func
+          Object.assign(d, {
+            type: O_DEFINE_CALL,
+            fname: funcname,
+            fcall: new vm.Script(`(${argv})=>(${func_body})`).runInNewContext({require}),
+          })
+        }else if(matched_const) {
+          const [, constant, value]=matched_const
+          Object.assign(d, {
+            type: O_DEFINE_CONST,
+            cname: constant,
+            cvalue: value+'',
+          })
+        }else{
+          throw new Error('unsupported token: '+JSON.stringify(x))
+        }
+      }else if(x.call_define) {
+        if(x.call_define_params) {
+          const argv=x.call_define_params.substr(1, x.call_define_params.length-2).split(',').map(a=>a.trim())
+          Object.assign(d, {
+            type: O_CALL_DEFINE,
+            call: x.call_define,
+            argv,
+            source: x.source,
+          })
+        }else{
+          Object.assign(d, {
+            type: O_CALL_CONST,
+            call: x.call_define,
+            source: x.source,
+          })
+        }
+      }else if(x.frags) {
+        Object.assign(d, {
+          type: O_STR,
+          str: x.str,
+        })
+      }else{
+        throw new Error('unsupported token: '+JSON.stringify(x))
+      }
+      const ad=_get_if_stack() || tree
+      const _f=ad[ad.length-1]
+      if(d.type===O_STR && _f && _f.type===O_STR) {
+        _f.str+=d.str
+      }else{
+        ad.push(d)
+      }
+    }
+  }
+  return tree
+}
+
+const caches={}
+function compileSptcMacroFile(filename, mockFileContent) {
+  return compileFile(filename, {
+    customCache: caches,
+    compileFunc: content=>transformToAst(lexer(content)),
+    mockFileContent,
+  })
+}
+
+
+module.exports={
+  compileSptcMacroFile,
+  MACRO_TYPES: {
+    O_IFDEF,
+    O_STR,
+    O_DEFINE_CONST,
+    O_DEFINE_CALL,
+    O_CALL_CONST,
+    O_CALL_DEFINE,
+    O_DEF,
+    O_INCLUDE,
+    O_UNDEF,
+  },
+}

package/engine/compiler.js

@@ -0,0 +1,81 @@
+
+const vm=require('vm')
+const path=require('path')
+
+const {compileFile}=require('../utils')
+
+const T_JS=Symbol()
+const T_TEXT=Symbol()
+function lexer(content) {
+  const FLAG_OPEN='<?js'
+  const FLAG_CLOSE='?>'
+  const tokens=[]
+  const _t_flags=[]
+  let c1=-1, c2=-1
+  function _append_token(tk, left, right) {
+    const tk_params=content.substr(left, right-left)
+    if(!tk_params.length) return;
+    tokens.push({tk, tk_params})
+  }
+  for(;;) {
+    c1=content.indexOf(FLAG_OPEN, c1)
+    c2=content.indexOf(FLAG_CLOSE, c2)
+    if(c1===-1 && c1===-1) break
+    if(c1>-1) {
+      _t_flags.push({fk: FLAG_OPEN, idx: c1})
+      c1+=FLAG_OPEN.length
+    }
+    if(c2>-1) {
+      _t_flags.push({fk: FLAG_CLOSE, idx: c2})
+      c2+=FLAG_CLOSE.length
+    }
+  }
+  if(_t_flags.length) {
+    const p=_t_flags[_t_flags.length-1]
+    if(p.fk!==FLAG_CLOSE) _t_flags.push({
+      fk: FLAG_CLOSE,
+      idx: content.length,
+    })
+    for(let i=0; i<_t_flags.length; i+=2) {
+      _append_token(T_TEXT, i>0? _t_flags[i-1].idx+FLAG_CLOSE.length: 0, _t_flags[i].idx)
+      _append_token(T_JS, _t_flags[i].idx+FLAG_OPEN.length, _t_flags[i+1].idx)
+    }
+    _append_token(T_TEXT, _t_flags[_t_flags.length-1].idx+FLAG_CLOSE.length, content.length)
+  }else{
+    tokens.push({
+      tk: T_TEXT,
+      tk_params: content,
+    })
+  }
+  return tokens
+}
+
+function transformToAst(tokens, filename) {
+  let ret=''
+
+  const __filefullname=path.resolve(filename)
+  const {dir: __dirname, base: __filename}=path.parse(__filefullname)
+  const ctx0={__dirname, __filename, __filefullname}
+  for(let k in ctx0) {
+    ret+=`const ${k}=${JSON.stringify(ctx0[k])};`
+  }
+  for(let i=0; i<tokens.length; i++) {
+    if(tokens[i].tk===T_JS) {
+      ret+=tokens[i].tk_params+'\n'
+    }else if(tokens[i].tk===T_TEXT) {
+      ret+='\necho('+JSON.stringify(tokens[i].tk_params)+');\n'
+    }
+  }
+  return [ctx0, new vm.Script(ret+'; Symbol()[0]=_=>0', filename)]
+}
+
+function compileSptcFile(filename, option) {
+  return compileFile(filename, {
+    compileFunc: content=>transformToAst(lexer(content), filename),
+    ...(option || {}),
+  })
+}
+
+module.exports={
+  compileSptcFile,
+}