jostraca 0.5.0 → 0.7.0

package/src/op/CopyOp.ts

@@ -5,15 +5,25 @@ import type { Node } from '../jostraca'
 
 import { getx } from '../jostraca'
 
+import { BINARY_EXT } from '../utility'
+
+import { FileOp } from './FileOp'
+
 
 const CopyOp = {
 
   before(node: Node, ctx$: any, buildctx: any) {
-    const name = node.name
-    const from = node.from
+    const fs = buildctx.fs
+
+    // TODO: do these need null checks here?
+    const name = node.name as string
+    const from = node.from as string
+
+    const fromStat = fs.statSync(from)
 
-    // console.log('COPY START', node)
-    if (from && name) {
+    if (fromStat.isFile()) {
+      FileOp.before(node, ctx$, buildctx)
+      const topath = buildctx.current.file.path
       const state = {
         fileCount: 0,
         folderCount: 0,
@@ -21,18 +31,66 @@ const CopyOp = {
         ctx$,
         buildctx,
       }
-      walk(state, from, name)
-      // console.log('COPY END', state)
+      const spec = { name, frompath: from, topath }
+
+      let content = processTemplate(state, fs.readFileSync(from).toString(), spec)
+
+      buildctx.current.file.content.push(content)
+      node.after = node.after || {}
+      node.after.kind = 'file'
+    }
+
+    else if (fromStat.isDirectory()) {
+      if (null != from && '' != from) {
+        node.after = node.after || {}
+        node.after.kind = 'copy'
+      }
+    }
+
+    else {
+      throw new Error('Unable to process file: ' + from)
     }
   },
 
-  after(_node: Node, _ctx$: any, buildctx: any) {
+
+  after(node: Node, ctx$: any, buildctx: any) {
+    const info = buildctx.info
+    const kind = node.after.kind
+
+    const frompath = node.from as string
+    const topath = buildctx.current.folder.path.join('/')
+
+    let exclude = node.exclude
+    if (info && true === exclude) {
+      return
+    }
+
+    if ('file' === kind) {
+      FileOp.after(node, ctx$, buildctx)
+    }
+    else if ('copy' === kind) {
+      const state = {
+        fileCount: 0,
+        folderCount: 0,
+        tmCount: 0,
+        ctx$,
+        buildctx,
+      }
+
+      // TODO: node.path is wrong
+      // change prop.name to prop.to and account for subfolders
+
+      walk(state, node.path, frompath, topath)
+    }
+    else {
+      throw new Error('Unknown kind=' + kind + ' for file: ' + frompath)
+    }
   },
 
 }
 
 
-function walk(state: any, from: string, to: string) {
+function walk(state: any, nodepath: string[], from: string, to: string) {
   const buildctx = state.buildctx
   const fs = buildctx.fs
   const entries = fs.readdirSync(from)
@@ -44,29 +102,99 @@ function walk(state: any, from: string, to: string) {
 
     if (stat.isDirectory()) {
       state.folderCount++
-      walk(state, frompath, topath)
+      walk(state, nodepath.concat(name), frompath, topath)
     }
     else if (isTemplate(name)) {
+      if (excludeFile(state, nodepath, name, topath)) { continue }
       const src = fs.readFileSync(frompath, 'utf8')
       const out = genTemplate(state, src, { name, frompath, topath })
-      // console.log('writeFileSync', frompath, topath)
-      fs.mkdirSync(Path.dirname(topath), { recursive: true })
-      fs.writeFileSync(topath, out, 'utf8')
+      writeFileSync(buildctx, topath, out)
       state.fileCount++
       state.tmCount++
     }
     else {
-      // console.log('copyFileSync', frompath, topath)
-      fs.mkdirSync(Path.dirname(topath), { recursive: true })
-      fs.copyFileSync(frompath, topath)
+      if (excludeFile(state, nodepath, name, topath)) { continue }
+      copyFileSync(buildctx, frompath, topath)
       state.fileCount++
     }
   }
 }
 
 
+function excludeFile(state: any, nodepath: string[], name: string, topath: string) {
+  const { fs, info } = state.buildctx
+  let exclude = false
+
+  // NOT Path.sep - needs to be canonical
+  const rpath = nodepath.concat(name).join('/')
+
+  if (info) {
+    exclude = info.exclude.includes(rpath)
+    let stat, timedelta
+    if (!exclude) {
+      stat = fs.statSync(topath, { throwIfNoEntry: false })
+      if (stat) {
+        timedelta = stat.mtimeMs - info.last
+        if (stat && (timedelta > 0 && timedelta < stat.mtimeMs)) {
+          exclude = true
+          console.log('COPYOP-STAT', rpath, timedelta, exclude, stat?.mtimeMs, info.last)
+        }
+      }
+    }
+
+    // if ('sdk.js' === name) {
+    // console.log('COPYSTAT', rpath, frompath,
+    //   timedelta,
+    //   info.exclude.includes(rpath),
+    //   stat?.mtimeMs - info.last,
+    //   stat?.mtimeMs, info.last, exclude)
+    // }
+  }
+
+  if (exclude && info && !info.exclude.includes(rpath)) {
+    // NOT Path.sep - has to be canonical
+    info.exclude.push(rpath)
+  }
+
+  // console.log('COPY-EXCLUDE', rpath, exclude)
+  return exclude
+}
+
+
+function writeFileSync(buildctx: any, path: string, content: string) {
+  // console.log('WF', path)
+  const fs = buildctx.fs
+  // TODO: check excludes
+  fs.mkdirSync(Path.dirname(path), { recursive: true })
+  fs.writeFileSync(path, content, 'utf8', { flush: true })
+}
+
+
+function copyFileSync(buildctx: any, frompath: string, topath: string) {
+  const fs = buildctx.fs
+
+  const isBinary = BINARY_EXT.includes(Path.extname(frompath))
+
+  // TODO: check excludes
+  fs.mkdirSync(Path.dirname(topath), { recursive: true })
+  const contents = fs.readFileSync(frompath, isBinary ? undefined : 'utf8')
+  fs.writeFileSync(topath, contents, { flush: true })
+}
+
+
+function processTemplate(
+  state: any,
+  src: any,
+  spec: { name: string, frompath: string, topath: string }) {
+  if (isTemplate(spec.name)) {
+    return genTemplate(state, src, spec)
+  }
+  return src
+}
+
 function isTemplate(name: string) {
-  return name.match(/\.(ts|js|json|txt|xml|toml|yml|yaml|py|php|rb|go|java|c|cpp|cs|sh|bat)$/i)
+  // TODO: need a better way; alsp should be configurable
+  return !name.match(/\.(gif|jpe?g|png|ico|bmp|tiff)$/i)
 }
 
 // NOTE: $$foo.bar$$ format used as explicit start and end markers mean regex can be used

package/src/op/FileOp.ts

@@ -0,0 +1,58 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+
+const FileOp = {
+
+  before(node: Node, _ctx$: any, buildctx: any) {
+    const cfile: any = buildctx.current.file = node
+    cfile.filepath = buildctx.current.folder.path.join('/') + '/' + node.name
+    cfile.content = []
+  },
+
+
+  after(node: Node, _ctx$: any, buildctx: any) {
+    // console.log('FB-INFO', buildctx.info)
+
+    const { fs, info, current } = buildctx
+    const cfile = current.file
+    const content = cfile.content.join('')
+    const rpath = cfile.path.join('/') // NOT Path.sep - needs to be canonical
+    let exclude = node.exclude
+
+    // console.log('FILE-a exclude', rpath, exclude, !!info)
+
+    if (info && null == exclude) {
+      exclude = info.exclude.includes(rpath)
+      if (!exclude) {
+        const stat = fs.statSync(cfile.filepath, { throwIfNoEntry: false })
+        if (stat) {
+          let timedelta = stat.mtimeMs - info.last
+          if ((timedelta > 0 && timedelta < stat.mtimeMs)) {
+            exclude = true
+            console.log('FILEOP-STAT', rpath, timedelta, exclude, stat?.mtimeMs, info.last)
+          }
+        }
+      }
+    }
+
+    // console.log('FILE-a write', rpath, exclude) // , content.substring(0, 111))
+
+    if (!exclude) {
+      fs.writeFileSync(cfile.filepath, content, { flush: true })
+    }
+    else {
+      if (!info.exclude.includes(rpath)) {
+        info.exclude.push(rpath)
+      }
+    }
+  },
+
+}
+
+
+export {
+  FileOp
+}

package/src/op/FolderOp.ts

@@ -0,0 +1,31 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+
+const FolderOp = {
+
+  before(node: Node, _ctx$: any, buildctx: any) {
+    const cfolder = buildctx.current.folder = (buildctx.current.folder || {})
+
+    cfolder.node = node
+    cfolder.path = (cfolder.path || [buildctx.current.folder.parent])
+    cfolder.path.push(node.name)
+
+    let fullpath = cfolder.path.join(Path.sep)
+    buildctx.fs.mkdirSync(fullpath, { recursive: true })
+  },
+
+
+  after(_node: Node, _ctx$: any, buildctx: any) {
+    const cfolder = buildctx.current.folder
+    cfolder.path.length = cfolder.path.length - 1
+  },
+
+}
+
+
+export {
+  FolderOp
+}

package/src/op/NoneOp.ts

@@ -0,0 +1,14 @@
+
+
+import type { Node } from '../jostraca'
+
+
+const NoneOp = {
+  before(node: Node, _ctx$: any, buildctx: any) { },
+  after(_node: Node, _ctx$: any, buildctx: any) { },
+}
+
+
+export {
+  NoneOp
+}

package/src/op/ProjectOp.ts

@@ -0,0 +1,33 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+
+const ProjectOp = {
+
+  before(node: Node, ctx$: any, buildctx: any) {
+    // console.log('PROJECT-B', node.folder, ctx$.folder)
+
+    node.folder = null == node.folder || '' === node.folder ? '.' : node.folder
+    node.folder = Path.isAbsolute(node.folder) ? node.folder : Path.join(ctx$.folder, node.folder)
+
+    // console.log('PROJECT-B folder', node.folder)
+
+    buildctx.current.project = { node }
+    buildctx.current.folder = {
+      node,
+      path: node.folder.split(Path.sep),
+    }
+
+    buildctx.fs.mkdirSync(node.folder, { recursive: true })
+  },
+
+  after(_node: Node, _ctx$: any, _buildctx: any) { },
+
+}
+
+
+export {
+  ProjectOp
+}