@trebco/treb 28.11.1 → 28.15.0

package/treb-parser/src/parser.ts

@@ -34,10 +34,11 @@ import type {
   ParserFlags,
   UnitStructuredReference,
   RenderOptions,
-  PersistedParserConfig} from './parser-types';
+} from './parser-types';
 import {
   ArgumentSeparatorType,
-  DecimalMarkType
+  DecimalMarkType,
+  DefaultParserConfig
 } from './parser-types';
 
 interface PrecedenceList {
@@ -152,31 +153,47 @@ const unary_operators: PrecedenceList = { '-': 100, '+': 100 };
  * which runs synchronously). one benefit of using a singleton would be
  * consistency in decimal mark, we'd only have to set once.
  *
+ * FIXME: the internal state is starting to grate. there's no reason for
+ * it and it just confuses things because parsing is stateless (except for
+ * configuration). internal state just keeps results from the last parse
+ * operation. we should refactor so parsing is clean and returns all 
+ * results directly, caller can store if necessary.
+ * 
  * FIXME: split rendering into a separate class? would be a little cleaner.
+ * 
+ * FIXME: we don't currently handle full-width punctuation. it would be 
+ * simple to parse, a little more complicated to keep track of if we wanted
+ * to be able to rewrite. TODO/FIXME.
+ * 
  */
 export class Parser {
  
-  /**
-   * argument separator. this can be changed prior to parsing/rendering.
-   * FIXME: use an accessor to ensure type, outside of ts?
+  /** 
+   * accessor replacing old field. the actual value is moved to flags,
+   * and should be set via the SetLocaleSettings method.
    */
-  public argument_separator = ArgumentSeparatorType.Comma;
+  public get argument_separator(): ArgumentSeparatorType {
+    return this.flags.argument_separator;
+  }
 
-  /**
-   * decimal mark. this can be changed prior to parsing/rendering.
-   * FIXME: use an accessor to ensure type, outside of ts?
+  /** 
+   * accessor replacing old field. the actual value is moved to flags,
+   * and should be set via the SetLocaleSettings method.
    */
-  public decimal_mark = DecimalMarkType.Period;
+  public get decimal_mark(): DecimalMarkType {
+    return this.flags.decimal_mark;
+  }
 
   /**
    * unifying flags
    */
-  public flags: Partial<ParserFlags> = {
-    spreadsheet_semantics: true,
-    dimensioned_quantities: false,
-    fractions: true,
+  public flags: ParserFlags = {
+    ...DefaultParserConfig,
   };
 
+  /** 
+   * FIXME: why is this a class member? at a minimum it could be static 
+   */
   protected r1c1_regex = /[rR]((?:\[[-+]{0,1}\d+\]|\d+))[cC]((?:\[[-+]{0,1}\d+\]|\d+))$/;
 
   /**
@@ -249,7 +266,36 @@ export class Parser {
    */
   protected full_reference_list: Array<UnitAddress | UnitRange | UnitIdentifier | UnitStructuredReference> = [];
 
-  protected parser_state: string[] = [];
+  /**
+   * cache for storing/restoring parser state, if we toggle it
+   */
+  protected parser_state_cache: string[] = [];
+
+  /**
+   * step towards protecting these values and setting them in one
+   * operation. 
+   * 
+   * UPDATE: switch order. argument separator is optional and implied.
+   */
+  public SetLocaleSettings(decimal_mark: DecimalMarkType, argument_separator?: ArgumentSeparatorType) {
+
+    if (typeof argument_separator === 'undefined') {
+      argument_separator = (decimal_mark === DecimalMarkType.Comma) ? 
+        ArgumentSeparatorType.Semicolon : 
+        ArgumentSeparatorType.Comma ;
+    }
+
+    // I suppose semicolon and period is allowable, although no one 
+    // uses it. this test only works because we know the internal type
+    // representation, but that's fragile and not a good idea. FIXME
+
+    if ((argument_separator as any) === (decimal_mark as any)) {
+      throw new Error('invalid locale setting');
+    }
+
+    this.flags.argument_separator = argument_separator;
+    this.flags.decimal_mark = decimal_mark;
+  }
 
   /**
    * save local configuration to a buffer, so it can be restored. we're doing
@@ -265,12 +311,7 @@ export class Parser {
    * 
    */
   public Save() {
-    const config: PersistedParserConfig = {
-      flags: this.flags,
-      argument_separator: this.argument_separator,
-      decimal_mark: this.decimal_mark,
-    }
-    this.parser_state.push(JSON.stringify(config));
+    this.parser_state_cache.push(JSON.stringify(this.flags));
   }
 
   /**
@@ -278,13 +319,10 @@ export class Parser {
    * @see Save
    */
   public Restore() {
-    const json = this.parser_state.shift();
+    const json = this.parser_state_cache.shift();
     if (json) {
       try {
-        const config = JSON.parse(json) as PersistedParserConfig;
-        this.flags = config.flags;
-        this.argument_separator = config.argument_separator;
-        this.decimal_mark = config.decimal_mark;
+        this.flags = JSON.parse(json) as ParserFlags;
       }
       catch (err) {
         console.error(err);
@@ -421,7 +459,7 @@ export class Parser {
 
     // use default separator, unless we're explicitly converting.
 
-    let separator = this.argument_separator + ' ';
+    let separator = this.flags.argument_separator + ' ';
     if (convert_argument_separator === ArgumentSeparatorType.Comma) {
       separator = ', ';
     }
@@ -438,13 +476,13 @@ export class Parser {
 
     const decimal = convert_decimal === DecimalMarkType.Comma ? ',' : '.';
     const decimal_rex =
-      this.decimal_mark === DecimalMarkType.Comma ? /,/ : /\./;
+      this.flags.decimal_mark === DecimalMarkType.Comma ? /,/ : /\./;
 
     // we need this for complex numbers, but I don't want to change the 
     // original at the moment, just in case. we can run through that later.
 
     const decimal_rex_g = 
-      this.decimal_mark === DecimalMarkType.Comma ? /,/g : /\./g;
+      this.flags.decimal_mark === DecimalMarkType.Comma ? /,/g : /\./g;
 
     switch (unit.type) {
       case 'address':
@@ -517,13 +555,13 @@ export class Parser {
           // and convert if necessary.
 
           let imaginary_text = Math.abs(unit.imaginary).toString();
-          if (convert_decimal === DecimalMarkType.Comma || this.decimal_mark === DecimalMarkType.Comma) {
+          if (convert_decimal === DecimalMarkType.Comma || this.flags.decimal_mark === DecimalMarkType.Comma) {
             imaginary_text = imaginary_text.replace(/\./, ',');
           }
 
           if (unit.real) {
             let real_text = unit.real.toString();
-            if (convert_decimal === DecimalMarkType.Comma || this.decimal_mark === DecimalMarkType.Comma) {
+            if (convert_decimal === DecimalMarkType.Comma || this.flags.decimal_mark === DecimalMarkType.Comma) {
               real_text = real_text.replace(/\./, ',');
             }
   
@@ -568,7 +606,7 @@ export class Parser {
             let text = unit.text;
             if (
               convert_decimal === DecimalMarkType.Comma &&
-              this.decimal_mark === DecimalMarkType.Period
+              this.flags.decimal_mark === DecimalMarkType.Period
             ) {
               text = text.replace(/,/g, ''); // remove grouping
             }
@@ -699,7 +737,7 @@ export class Parser {
     this.id_counter = 0;
 
     // set separator
-    switch (this.argument_separator) {
+    switch (this.flags.argument_separator) {
       case ArgumentSeparatorType.Semicolon:
         this.argument_separator_char = SEMICOLON;
         break;
@@ -709,7 +747,7 @@ export class Parser {
     }
 
     // and decimal mark
-    switch (this.decimal_mark) {
+    switch (this.flags.decimal_mark) {
       case DecimalMarkType.Comma:
         this.decimal_mark_char = COMMA;
         break;
@@ -765,8 +803,8 @@ export class Parser {
       error: this.error,
       error_position: this.error_position,
       dependencies: this.dependencies,
-      separator: this.argument_separator,
-      decimal_mark: this.decimal_mark,
+      separator: this.flags.argument_separator,
+      decimal_mark: this.flags.decimal_mark,
       full_reference_list: this.full_reference_list.slice(0),
     };
   }