@dra2020/baseclient 1.0.11 → 1.0.14

package/lib/filterexpr/filterexpr.ts

@@ -484,45 +484,6 @@ function wordyDate(s: string): string
   return s;
 }
 
-function clauseEqual(c1: Clause, c2: Clause): boolean
-{
-  if (c1 == null && c2 == null) return true;
-  if (c1 == null || c2 == null) return false;
-  if (c1.op.tt === c2.op.tt)
-  {
-    if (c1.op.tt === TokType.Text)
-      return c1.op.text === c2.op.text;
-    else
-      return clauseEqual(c1.operand1, c2.operand1) && clauseEqual(c1.operand2, c2.operand2);
-  }
-  else
-    return false;
-}
-
-function containsClause(c: Clause, s: Clause): boolean
-{
-  if (clauseEqual(c, s))
-    return true;
-  if (c == null || s == null) return false;
-  return containsClause(c.operand1, s) || containsClause(c.operand2, s);
-}
-
-function removeClause(c: Clause, s: Clause): Clause
-{
-  if (c == null || (c.op.tt === TokType.Text && c.op.tt !== s.op.tt))
-    return c;
-  else if (clauseEqual(c, s))
-    return null;
-  else
-  {
-    c.operand1 = removeClause(c.operand1, s);
-    c.operand2 = removeClause(c.operand2, s);
-    if ((c.op.tt === TokType.And || c.op.tt === TokType.Or) && (c.operand1 == null || c.operand2 == null))
-      return c.operand1 || c.operand2;
-    return c;
-  }
-}
-
 export class FilterExpr
 {
   lexer: Lexer;
@@ -551,47 +512,12 @@ export class FilterExpr
     return this.asStringClause(this.parser.clause);
   }
 
-  containsClause(expr: string): boolean
-  {
-    let sub = new FilterExpr(this.lexer.coder, expr);
-    return containsClause(this.parser.clause, sub.parser.clause);
-  }
-
-  addClause(expr: string): void
-  {
-    let sub = new FilterExpr(this.lexer.coder, expr);
-    if (! containsClause(this.parser.clause, sub.parser.clause))
-    {
-      if (this.parser.clause)
-        this.parser.clauses = [ { op: { tt: TokType.And }, operand1: this.parser.clause, operand2: sub.parser.clause } ];
-      else
-        this.parser.clauses = [ sub.parser.clause ];
-    }
-  }
-
-  removeClause(expr: string): void
-  {
-    if (this.containsClause(expr))
-    {
-      let sub = new FilterExpr(this.lexer.coder, expr);
-      this.parser.clauses = [ removeClause(this.parser.clause, sub.parser.clause) ];
-    }
-  }
-
   asStringClause(clause: Clause): string
   {
     if (clause == null) return '';
-    if (clause.op.tt == TokType.Text)
-    {
-      this.lexer.set(clause.op.text);
-      if (this.lexer.tokens.length == 1 && this.lexer.tokens[0].tt === TokType.Text)
-        return clause.op.text;
-      else
-        return `'${clause.op.text}'`;
-    }
+    if (clause.op.tt == TokType.Text) return `'${clause.op.text}'`;
     let a: string[] = [];
-    if (clause !== this.parser.clause)
-      a.push('(');
+    a.push('(');
     switch (clause.op.tt)
     {
       case TokType.And:
@@ -609,7 +535,8 @@ export class FilterExpr
         a.push(this.asStringClause(clause.operand1));
         break;
       case TokType.Colon:
-        a.push(`${this.asStringClause(clause.operand1)}:`);
+        a.push(this.asStringClause(clause.operand1));
+        a.push(':');
         a.push(this.asStringClause(clause.operand2));
         break;
       case TokType.Equal:
@@ -624,8 +551,7 @@ export class FilterExpr
       default:
         throw 'Unexpected token in asString';
     }
-    if (clause !== this.parser.clause)
-      a.push(')');
+    a.push(')');
     return a.join(' ');
   }
 

package/lib/fsm/fsm.ts

@@ -291,7 +291,6 @@ export class FsmOnDone extends Fsm
 export class FsmSleep extends Fsm
 {
   delay: number;
-  timeoutHandle: any;
 
   constructor(env: FsmEnvironment, delay: number)
     {
@@ -301,19 +300,10 @@ export class FsmSleep extends Fsm
 
   tick(): void
     {
-      // This allows canceling by simply setting state to done
-      if (this.done && this.timeoutHandle !== undefined)
-      {
-        clearTimeout(this.timeoutHandle);
-        delete this.timeoutHandle;
-      }
-      else if (this.ready && this.state === FSM_STARTING)
+      if (this.ready && this.state === FSM_STARTING)
       {
         this.setState(FSM_PENDING);
-        this.timeoutHandle = setTimeout(() => {
-            delete this.timeoutHandle;
-            this.setState(FSM_DONE)
-          }, this.delay);
+        setTimeout(() => { this.setState(FSM_DONE); }, this.delay);
       }
     }
 }

package/lib/fsmfile/all.ts

@@ -0,0 +1 @@
+export * from './fsmfile';

package/lib/fsmfile/fsmfile.ts

@@ -0,0 +1,236 @@
+// Node libraries
+import * as fs from 'fs';
+
+// Shared libraries
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+
+export interface Environment
+{
+  log: LogAbstract.ILog;
+  fsmManager: FSM.FsmManager;
+}
+
+const FSM_READING = FSM.FSM_CUSTOM1;
+const FSM_WRITING = FSM.FSM_CUSTOM1;
+
+export class FsmUnlink extends FSM.Fsm
+{
+  path: string;
+  err: any;
+
+  constructor(env: Environment, path: string)
+  {
+    super(env);
+    this.path = path;
+    this.err = null;
+  }
+
+  tick(): void
+  {
+    if (this.ready && this.state === FSM.FSM_STARTING)
+    {
+      this.setState(FSM.FSM_PENDING);
+      fs.unlink(this.path, (err: any) => {
+          if (err)
+          {
+            this.setState(FSM.FSM_ERROR);
+            this.err = err;
+          }
+          else
+            this.setState(FSM.FSM_DONE);
+        });
+    }
+  }
+}
+
+export class FsmMkdir extends FSM.Fsm
+{
+  dir: string;
+  bAllowExist: boolean;
+  err: any;
+
+  constructor(env: Environment, dir: string, bAllowExist: boolean = true)
+  {
+    super(env);
+    this.dir = dir;
+    this.err = null;
+    this.bAllowExist = true;
+  }
+
+  tick(): void
+  {
+    if (this.ready && this.state == FSM.FSM_STARTING)
+    {
+      this.err = null;
+      this.setState(FSM.FSM_PENDING);
+      fs.mkdir(this.dir, 0o777, (err: any) => {
+          // ignore EEXISTS errors
+          if (err === null || (this.bAllowExist && err.code === 'EEXIST'))
+            this.setState(FSM.FSM_DONE);
+          else
+          {
+            this.err = err;
+            this.setState(FSM.FSM_ERROR);
+          }
+        });
+    }
+  }
+}
+
+export class FsmRmdir extends FSM.Fsm
+{
+  dir: string;
+  err: any;
+
+  constructor(env: Environment, dir: string)
+  {
+    super(env);
+    this.dir = dir;
+  }
+
+  tick(): void
+  {
+    if (this.ready && this.state == FSM.FSM_STARTING)
+    {
+      this.err = null;
+      this.setState(FSM.FSM_PENDING);
+      fs.rmdir(this.dir, (err: any) => {
+          // ignore ENOENT errors
+          if (err === null || err.code === 'ENOENT')
+            this.setState(FSM.FSM_DONE);
+          else
+          {
+            this.err = err;
+            this.setState(FSM.FSM_ERROR);
+          }
+        });
+    }
+  }
+}
+
+export class FsmLs extends FSM.Fsm
+{
+  dir: string;
+  err: any;
+  entries: string[];
+
+  constructor(env: Environment, dir: string)
+  {
+    super(env);
+    this.dir = dir;
+    this.err = null;
+  }
+
+  tick(): void
+  {
+    if (this.ready)
+    {
+      switch (this.state)
+      {
+        case FSM.FSM_STARTING:
+          this.setState(FSM.FSM_PENDING);
+          fs.readdir(this.dir, (err: any, entries: string[]) => {
+            if (err)
+            {
+              this.err = err;
+              this.setState(FSM.FSM_ERROR);
+            }
+            else
+            {
+              this.entries = entries;
+              this.setState(FSM.FSM_DONE);
+            }
+          });
+        break;
+      }
+    }
+  }
+}
+
+export class FsmReadFile extends FSM.Fsm
+{
+  path: string;
+  result: string;
+  err: any;
+
+  constructor(env: Environment, path: string)
+  {
+    super(env);
+
+    this.path = path;
+    this.result = null;
+    this.err = null;
+  }
+
+  tick(): void
+  {
+    if (this.ready)
+    {
+      switch (this.state)
+      {
+        case FSM.FSM_STARTING:
+          this.err = null;
+          this.result = null;
+          this.setState(FSM_READING);
+          fs.readFile(this.path, 'utf8', (err: any, data: string) => {
+              if (err)
+              {
+                this.result = null;
+                this.err = err;
+                this.setState(FSM.FSM_ERROR);
+              }
+              else
+              {
+                this.err = null;
+                this.result = data;
+                this.setState(FSM.FSM_DONE);
+              }
+            });
+          break;
+      }
+    }
+  }
+}
+
+export class FsmWriteFile extends FSM.Fsm
+{
+  path: string;
+  contents: string | Buffer;
+  err: any;
+
+  constructor(env: Environment, path: string, contents: string | Buffer)
+  {
+    super(env);
+
+    this.path = path;
+    this.contents = contents;
+    this.err = null;
+  }
+
+  tick(): void
+  {
+    if (this.ready)
+    {
+      switch (this.state)
+      {
+        case FSM.FSM_STARTING:
+          this.err = null;
+          this.setState(FSM_WRITING);
+          fs.writeFile(this.path, this.contents, (err: any) => {
+              if (err)
+              {
+                this.err = err;
+                this.setState(FSM.FSM_ERROR);
+              }
+              else
+              {
+                this.err = null;
+                this.setState(FSM.FSM_DONE);
+              }
+            });
+          break;
+      }
+    }
+  }
+}

package/lib/jsonstream/all.ts

@@ -0,0 +1 @@
+export * from './jsonstream';