wiki-plugin-mech 0.1.18 → 0.1.20

package/client/mech.js

@@ -519,11 +519,22 @@
   // http://localhost:3000/plugin/mech/run/testing-mechs-synchronization/5e269010fc81aebe?args=WyJoZWxsbyIsIndvcmxkIl0
   async function get_emit({elem,command,args,body,state}) {
     if (!body) return trouble(elem,`GET expects indented commands to run on the server.`)
-    const site = state.context.site
+    let share = {}
+    let where = state.context.site
+    if (args.length) {
+      for(const arg of args) {
+        if (arg in state) {
+          inspect(elem,arg,state)
+          share[arg] = state[arg]}
+        else if (arg.match(/\./)) where=arg
+        else {return trouble(elem,`GET expected "${arg}" to name state or site.`)}
+      }
+    }
+    // const site = state.context.site
     const slug = state.context.slug
     const itemId = state.context.itemId
-    const query = `args=${btoa(JSON.stringify(body))}`
-    const url = `//${site}/plugin/mech/run/${slug}/${itemId}?${query}`
+    const query = `mech=${btoa(JSON.stringify(body))}&state=${btoa(JSON.stringify(share))}`
+    const url = `//${where}/plugin/mech/run/${slug}/${itemId}?${query}`
     elem.innerHTML = command + ` ⇒ in progress`
     const start = Date.now()
     let result
@@ -534,15 +545,45 @@
       return trouble(elem,`RUN failed with "${err.message}"`)
     }
     state.result = result
-    for(const arg of result.args.flat(9)){
+    for(const arg of result.mech.flat(9)){
       const elem = document.getElementById(arg.key)
       if('status' in arg) elem.innerHTML = arg.command + ` ⇒ ${arg.status}`
       if('trouble' in arg) trouble(elem,arg.trouble)
     }
+    if('debug' in result.state) delete result.state.debug
+    Object.assign(state,result.state)
     const elapsed = ((Date.now() - start)/1000).toFixed(3)
     elem.innerHTML = command + ` ⇒ ${elapsed} seconds`
   }
 
+  function delta_emit({elem,command,args,body,state}) {
+    const copy = obj => JSON.parse(JSON.stringify(obj))
+    const size = obj => JSON.stringify(obj).length
+    if (args.length < 1) return trouble(elem,`DELTA expects argument, "have" or "apply" on client.`)
+    if (body) return trouble(elem,`DELTA doesn't expect indented input.`)
+    switch (args[0]) {
+    case 'have':
+      const edits = state.context.page.journal
+        .filter(item => item.type != 'fork')
+      state.recent = edits[edits.length-1].date
+      elem.innerHTML = command + ` ⇒ ${new Date(state.recent).toLocaleString()}`
+      break
+    case 'apply':
+      if(!('actions' in state)) return trouble(elem,`DELTA apply expect "actions" as input.`)
+      inspect(elem,'actions',state)
+      const page = copy(state.context.page)
+      const before = size(page)
+      for (const action of state.actions)
+        apply(page,action)
+      state.page = page
+      const after = size(page)
+      elem.innerHTML = command + ` ⇒ ∆ ${((after-before)/before*100).toFixed(1)}%`
+      break
+    default:
+      trouble(elem,`DELTA doesn't know "${args[0]}".`)
+    }
+  }
+
 
 // C A T A L O G
 
@@ -566,7 +607,8 @@
     RANDOM:  {emit:random_emit},
     SLEEP:   {emit:sleep_emit},
     TOGETHER:{emit:together_emit},
-    GET:     {emit:get_emit}
+    GET:     {emit:get_emit},
+    DELTA:   {emit:delta_emit}
   }
 
 
@@ -792,4 +834,83 @@
       return this.direction}
   }
 
+  // adapted from wiki-client/lib/revision.coffee
+
+  // This module interprets journal actions in order to update
+  // a story or even regenerate a complete story from some or
+  // all of a journal.
+
+  function apply(page, action) {
+    const order = () => {
+      return (page.story || []).map(item => item?.id);
+    };
+
+    const add = (after, item) => {
+      const index = order().indexOf(after) + 1;
+      page.story.splice(index, 0, item);
+    };
+
+    const remove = () => {
+      const index = order().indexOf(action.id);
+      if (index !== -1) {
+        page.story.splice(index, 1);
+      }
+    };
+
+    page.story = page.story || [];
+
+    switch (action.type) {
+      case 'create':
+        if (action.item) {
+          if (action.item.title != null) {
+            page.title = action.item.title;
+          }
+          if (action.item.story != null) {
+            page.story = action.item.story.slice();
+          }
+        }
+        break;
+      case 'add':
+        add(action.after, action.item);
+        break;
+      case 'edit':
+        const index = order().indexOf(action.id);
+        if (index !== -1) {
+          page.story.splice(index, 1, action.item);
+        } else {
+          page.story.push(action.item);
+        }
+        break;
+      case 'move':
+        // construct relative addresses from absolute order
+        const moveIndex = action.order.indexOf(action.id);
+        const after = action.order[moveIndex - 1];
+        const item = page.story[order().indexOf(action.id)];
+        remove();
+        add(after, item);
+        break;
+      case 'remove':
+        remove();
+        break;
+    }
+
+    page.journal = page.journal || [];
+    if (action.fork) {
+      // implicit fork
+      page.journal.push({ type: 'fork', site: action.fork, date: action.date - 1 });
+    }
+    page.journal.push(action);
+  }
+
+  function create(revIndex, data) {
+    revIndex = +revIndex;
+    const revJournal = data.journal.slice(0, revIndex + 1);
+    const revPage = { title: data.title, story: [] };
+    for (const action of revJournal) {
+      apply(revPage, action || {});
+    }
+    return revPage;
+  }
+
+
 }).call(this)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiki-plugin-mech",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Federated Wiki - Mechanism Scripting Plugin",
   "keywords": [
     "mech",

package/server/server.js

@@ -5,28 +5,29 @@
 (function() {
 
   const fs = require('fs')
+  const path = require('path')
   const process = require('process')
 
+  function cors (req, res, next) {
+    res.header('Access-Control-Allow-Origin', '*')
+    next()
+  }
+
   function startServer(params) {
     var app = params.app,
         argv = params.argv
 
-    return app.get('/plugin/mech/run/:slug([a-z-]+)/:itemId', (req, res, next) => {
+    return app.get('/plugin/mech/run/:slug([a-z-]+)/:itemId', cors, (req, res, next) => {
       console.log(req.params)
       try {
         const slug = req.params.slug
         const itemId = req.params.itemId
-        const args = JSON.parse(atob(req.query.args || 'W10='))
-        const path = `${argv.db}/${slug}`
-        // fs.readFile(path,(err,data) => {
-        //   const page = JSON.parse(data)
-        //   const item = page.story.find(item => item.id == itemId) || null
-        //   return res.json({err,item,args});
-        // })
-        const context = {path}
-        const state = {context,debug:true}
-        run(args,state)
-          .then(() => {return res.json({args,state})})
+        const mech = JSON.parse(atob(req.query.mech || 'W10='))
+        const share = JSON.parse(atob(req.query.state ||'W10='))
+        const context = {argv,slug}
+        const state = Object.assign(share,{context})
+        run(mech,state)
+          .then(() => {delete state.context; return res.json({mech,state})})
           .catch(err => {console.log(err); return res.json({err:err.message+' from promise'})})
       } catch(err) {
         return res.json({err:err.message+' from try'})
@@ -98,13 +99,51 @@
     })
   }
 
+  async function commons_emit ({elem,args,state}) {
+    const readdir = dir => new Promise((res,rej) =>
+      fs.readdir(dir,(e,v) => e ? rej(e) : res(v)));
+    const stat = file => new Promise((res,rej) =>
+      fs.stat(file,(e,v) => e ? rej(e) : res(v)));
+    const tally = async dir => {
+      const count = {files:0,bytes:0}
+      const items = await readdir(dir)
+      for(const item of items) {
+        const itemPath = path.join(dir, item)
+        const stats = await stat(itemPath)
+        if (state.debug) console.log({itemPath,stats})
+        if (stats.isFile()) {
+          count.files++
+          count.bytes+=stats.size
+        }
+      }
+      return count
+    }
+    const all = await tally(state.context.argv.commons)
+    const here = await tally(path.join(state.context.argv.data,'assets','plugins','image'))
+    state.commons = {all,here}
+    status(elem,`${(all.bytes/1000000).toFixed(3)} mb in ${all.files} files`)
+  }
+
+  async function delta_emit ({elem,args,state}) {
+    const readFile = path => new Promise((res,rej) =>
+      fs.readFile(path,(e,v) => e ? rej(e) : res(v)));
+    if(!state.recent) return trouble(elem,`DELTA expects "recent" update time in state.`)
+    const file = path.join(state.context.argv.db,state.context.slug)
+    const page = JSON.parse(await readFile(file))
+    state.actions = page.journal
+      .filter(action => action.date > state.recent)
+    status(elem,`${state.actions.length} recent actions`)
+  }
+
 
   // C A T A L O G
 
   const blocks = {
     HELLO:   {emit:hello_emit},
     UPTIME:  {emit:uptime_emit},
-    SLEEP:   {emit:sleep_emit}
+    SLEEP:   {emit:sleep_emit},
+    COMMONS: {emit:commons_emit},
+    DELTA:   {emit:delta_emit}
   }