@trebco/treb 23.6.5 → 25.0.0-rc1

package/treb-format/src/format_parser.ts

@@ -0,0 +1,723 @@
+/*
+ * This file is part of TREB.
+ *
+ * TREB is free software: you can redistribute it and/or modify it under the 
+ * terms of the GNU General Public License as published by the Free Software 
+ * Foundation, either version 3 of the License, or (at your option) any 
+ * later version.
+ *
+ * TREB is distributed in the hope that it will be useful, but WITHOUT ANY 
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more 
+ * details.
+ *
+ * You should have received a copy of the GNU General Public License along 
+ * with TREB. If not, see <https://www.gnu.org/licenses/>. 
+ *
+ * Copyright 2022-2023 trebco, llc. 
+ * info@treb.app
+ * 
+ */
+
+import { NumberFormatSection } from './number_format_section';
+import { TextPartFlag, TextPart } from 'treb-base-types';
+// import { NumberFormat } from './format';
+
+const ASTERISK = 0x2A;  // TODO
+const UNDERSCORE = 0x5F;  // TODO
+
+const QUESTION_MARK = 0x3F;
+const ZERO = 0x30;
+const PERIOD = 0x2E;
+// const SPACE = 0x20;
+const COMMA = 0x2C;
+const PERCENT = 0x25;
+const DOUBLE_QUOTE = 0x22;
+const NUMBER_SIGN = 0x23;
+const SEMICOLON = 0x3B;
+const BACKSLASH = 0x5C;
+// const FORWARDSLASH = 0x2F;
+const AT = 0x40;
+const LEFT_BRACE = 0x5B;
+const RIGHT_BRACE = 0x5D;
+
+const UPPERCASE_E = 0x45;
+const LOWERCASE_E = 0x65;
+
+const UPPERCASE_H = 0x48;
+const LOWERCASE_H = 0x68;
+const UPPERCASE_M = 0x4D;
+const LOWERCASE_M = 0x6D;
+const UPPERCASE_S = 0x53;
+const LOWERCASE_S = 0x73;
+const UPPERCASE_D = 0x44;
+const LOWERCASE_D = 0x64;
+const UPPERCASE_Y = 0x59;
+const LOWERCASE_Y = 0x79;
+const UPPERCASE_A = 0x41;
+const LOWERCASE_A = 0x61;
+
+enum NumberPart {
+  Integer = 0,
+  Decimal = 1,
+}
+
+export class FormatParser {
+
+  protected static date_pattern = false;
+  protected static pattern = '';
+  protected static char_index = 0;
+  protected static characters: number[] = [];
+  protected static sections: NumberFormatSection[] = [];
+  protected static current_section: NumberFormatSection = new NumberFormatSection();
+  protected static preserve_formatting_characters = false; // true;
+
+  // FIXME: localization
+
+  protected static decimal_mark = PERIOD;
+  protected static group_separator = COMMA;
+
+  /**
+   * parser is static (essentially a singleton). state is ephemeral.
+   *
+   * it's a little hard to unify parsing for dates and numbers.
+   * luckily we don't have to parse that often; only when a format
+   * is created. so we will do some extra work here.
+   */
+  public static Parse(pattern: string): NumberFormatSection[] {
+
+    // local
+    this.pattern = pattern;
+
+    // convert to numbers
+    this.characters = pattern.split('').map((char) => char.charCodeAt(0));
+
+    // pointer
+    this.char_index = 0;
+
+    // allocate initial section
+    this.current_section = new NumberFormatSection();
+    this.sections = [this.current_section];
+
+    // check if it's a date, if so we can move on
+    if (this.ParseDatePattern()) {
+      return this.sections;
+    }
+
+    // not a date; reset and try again
+    this.char_index = 0;
+    this.current_section = new NumberFormatSection();
+    this.sections = [this.current_section];
+
+    // parse
+    while (this.char_index < this.characters.length) {
+      this.ConsumeChar();
+    }
+
+    // result
+    return this.sections;
+
+  }
+
+  protected static ConsumeString(): string {
+    let text = '';
+    if (this.preserve_formatting_characters) {
+      text += this.pattern[this.char_index]; // "
+    }
+    for (++this.char_index; this.char_index < this.characters.length; this.char_index++) {
+      const char = this.characters[this.char_index];
+      switch (char) {
+        case BACKSLASH: // escape character
+          if (this.preserve_formatting_characters) {
+            text += this.pattern[this.char_index];
+          }
+          if ((this.char_index + 1) < this.characters.length) {
+            text += this.pattern[++this.char_index];
+          }
+          break;
+        case DOUBLE_QUOTE:
+          if (this.preserve_formatting_characters) {
+            text += this.pattern[this.char_index]; // "
+          }
+          this.char_index++;
+          return text;
+        default:
+          text += this.pattern[this.char_index];
+          break;
+      }
+    }
+    throw new Error('unterminated string');
+  }
+
+  protected static ConsumeFormatting(): string {
+    let text = '';
+    for (++this.char_index; this.char_index < this.characters.length; this.char_index++) {
+      const char = this.characters[this.char_index];
+      switch (char) {
+        case BACKSLASH:
+          throw new Error('invalid escape character in formatting block');
+
+        case RIGHT_BRACE:
+          this.char_index++;
+          return text;
+
+        default:
+          text += this.pattern[this.char_index];
+          break;
+      }
+    }
+    throw new Error('unterminated format');
+  }
+
+  /** 
+   * pre-scan for fractional format, check for legal/illegal chars.
+   * fraction format has an optional integer, spaces, then the fractional
+   * part. 
+   * 
+   * except for the denominator, all characters are represented as # or ?, 
+   * but formats seem to be a little forgiving (not sure we have to be). 
+   * essentially, should look something like
+   * ```
+   * # ##/##
+   * ? ??/??
+   * #/32
+   * #/64
+   * # #/16
+   * ```
+   */
+  protected static ScanFractionFormat(): boolean {
+
+    const fraction_regex = /^([#?]+ +){0,1}([#?]+)\/([#?0-9]+)(?:$|[^#?0-9])/;
+    const text = this.pattern.substr(this.char_index);
+
+    const match = text.match(fraction_regex);
+    if (!match) { 
+      return false; 
+    }
+
+    const len = (match[1] || '').length + match[2].length + match[3].length + 1;
+
+    // flag
+    this.current_section.fraction_format = true;
+
+    // has integer section
+    this.current_section.fraction_integer = !!match[1];
+
+    // fixed denominator
+    const fixed_denominator = Number(match[3]);
+    if (!isNaN(fixed_denominator)) {
+      this.current_section.fraction_denominator = fixed_denominator;
+    }
+
+    // we do this regardless; it's used when collapsing values to zero
+    this.current_section.decimal_max_digits = this.current_section.fraction_denominator_digits = match[3].length;
+    
+    this.char_index += len;
+    this.current_section.has_number_format = true;
+
+    return true;
+  }
+
+  /**
+   * number format proper contains only the following characters:
+   * +-0#.,
+   * anything else will be ignored
+   * 
+   * [UPDATE] fractional number formats can contain spaces and 
+   * the / character (in fact they would have to contain that).
+   * 
+   */
+  protected static ConsumeNumberFormat(): void {
+
+    let number_part = NumberPart.Integer;
+
+    for (this.char_index; this.char_index < this.characters.length; this.char_index++) {
+      const char = this.characters[this.char_index];
+      switch (char) {
+
+        case this.group_separator:
+          {
+            // the behavior of this token is different at the end of the number
+            // format. in that case, each comma represents 'scale by 1000'. so
+            // we need to do lookahead... but we only one character?
+
+            let lookahead_digit = false;
+            for (let i = this.char_index + 1; !lookahead_digit && i < this.characters.length; i++) {
+              const next_char = this.characters[i];
+              if (next_char === this.decimal_mark
+                || next_char === NUMBER_SIGN
+                || next_char === ZERO) {
+                lookahead_digit = true;
+              }
+              else if (next_char !== COMMA) { break; }
+            }
+            if (lookahead_digit) {
+              if (number_part === NumberPart.Decimal) {
+                throw new Error('invalid grouping in decimal part');
+              }
+              this.current_section.grouping = true;
+            }
+            else {
+              this.current_section.scaling = (this.current_section.scaling || 1) * 1000;
+            }
+          }
+          break;
+
+        case this.decimal_mark:
+          if (number_part === NumberPart.Decimal) {
+            throw new Error('too many decimal marks');
+          }
+          number_part = NumberPart.Decimal;
+          break;
+
+        case NUMBER_SIGN:
+
+          // spacing. allowing for some junk, we treat these as required
+          // if they're inside of zeros (after in the case of integer, before
+          // in the case of decimal)
+
+          if (number_part === NumberPart.Decimal) {
+            this.current_section.decimal_max_digits++;
+          }
+          else if (this.current_section.integer_min_digits) {
+            this.current_section.integer_min_digits++;
+          }
+
+          break;
+
+        case ZERO:
+
+          // required digit.
+
+          if (number_part === NumberPart.Decimal) {
+            this.current_section.decimal_max_digits++;
+            this.current_section.decimal_min_digits = this.current_section.decimal_max_digits;
+          }
+          else {
+            this.current_section.integer_min_digits++;
+          }
+          break;
+
+        default:
+
+          // non-number format character; we're done?
+
+          return;
+
+      }
+    }
+
+  }
+
+  protected static AppendCharAsText(advance_pointer = true): void {
+    if (this.current_section.has_number_format) {
+      this.current_section.suffix[this.current_section.suffix.length - 1].text += this.pattern[this.char_index];
+    }
+    else {
+      this.current_section.prefix[this.current_section.prefix.length - 1].text += this.pattern[this.char_index];
+    }
+    if (advance_pointer) {
+      this.char_index++;
+    }
+  }
+
+  protected static AppendString(text: string): void {
+    if (this.current_section.has_number_format) {
+      this.current_section.suffix[this.current_section.suffix.length - 1].text += text;
+    }
+    else {
+      this.current_section.prefix[this.current_section.prefix.length - 1].text += text;
+    }
+  }
+
+  protected static AppendTextPart(part: TextPart): void {
+    if (this.current_section.has_number_format) {
+      this.current_section.suffix.push(part);
+      this.current_section.suffix.push({ text: '' });
+    }
+    else {
+      this.current_section.prefix.push(part);
+      this.current_section.prefix.push({ text: '' });
+    }
+  }
+
+  protected static ConsumeChar(): void {
+
+    const char = this.characters[this.char_index];
+
+    // check for fraction format. this can't happen in a string section,
+    // and if there's already a number format then treat it as text (garbage).
+
+    if (char === QUESTION_MARK || char === NUMBER_SIGN) {
+      if (!this.current_section.has_number_format && 
+          !this.current_section.string_format &&
+           this.ScanFractionFormat()) {
+        return;
+      }
+    }
+
+    switch (char) {
+      case SEMICOLON:
+
+        // FIXME: there's a concept of an "empty" section, which is
+        // zero-length text between semicolons (or before the first
+        // semicolon). we should treat those as cloned or synthentic.
+
+        // actually, is that legal for the first section? possibly not.
+
+        this.char_index++; // discard
+        this.current_section = new NumberFormatSection();
+        if (this.sections.length === 3) this.current_section.string_format = true;
+        this.sections.push(this.current_section);
+        break;
+
+      case AT:
+
+        this.char_index++;
+        this.AppendTextPart({
+          text: '@', flag: TextPartFlag.literal,
+        });
+        this.current_section.string_format = true; // force
+        break;
+
+      case ZERO:
+      case NUMBER_SIGN:
+      case PERIOD:
+      case COMMA:
+
+        // only one actual format. anything else is treated as text.
+        // also skip for string format (#4)
+
+        if (!this.current_section.has_number_format && !this.current_section.string_format) {
+          this.ConsumeNumberFormat();
+          this.current_section.has_number_format = true;
+        }
+        else {
+          this.AppendCharAsText();
+        }
+        break;
+
+      case LEFT_BRACE:
+        this.AppendTextPart({ text: this.ConsumeFormatting(), flag: TextPartFlag.formatting });
+        break;
+
+      case DOUBLE_QUOTE:
+        this.AppendString(this.ConsumeString());
+        break;
+
+      case QUESTION_MARK: // this is like _0
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText();
+        }
+        else {
+          this.AppendTextPart({
+            text: '0',
+            flag: TextPartFlag.hidden,
+          });
+          this.char_index++;
+        }
+        break;
+
+      case UNDERSCORE:
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText();
+        }
+        else {
+          if (++this.char_index >= this.characters.length) {
+            throw new Error('invalid pad character at end');
+          }
+          this.AppendTextPart({
+            text: this.pattern[this.char_index++],
+            flag: TextPartFlag.hidden,
+          });
+        }
+        break;
+
+      case ASTERISK:
+        if (this.current_section.has_asterisk) {
+          throw new Error(`we don't support multiple asterisks`);
+        }
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText();
+        }
+        else {
+          if (++this.char_index >= this.characters.length) {
+            throw new Error('invalid pad character at end');
+          }
+          this.AppendTextPart({
+            text: this.pattern[this.char_index++],
+            flag: TextPartFlag.padded,
+          });
+          this.current_section.has_asterisk = true;
+        }
+        break;
+
+      case LOWERCASE_E:
+      case UPPERCASE_E:
+
+        if (this.current_section.percent ||
+          this.current_section.exponential ||
+          this.current_section.string_format) {
+          this.AppendCharAsText();
+        }
+        else {
+          this.current_section.exponential = true;
+          this.char_index++;
+        }
+        break;
+
+      case PERCENT:
+
+        if (!this.current_section.exponential && !this.current_section.string_format) {
+          this.current_section.percent = true;
+        }
+        this.AppendCharAsText();
+        break;
+
+      case BACKSLASH:
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText(false);
+        }
+        if (++this.char_index >= this.characters.length) {
+          throw new Error('invalid escape character at end');
+        }
+        this.AppendCharAsText();
+        break;
+
+      default:
+        this.AppendCharAsText();
+
+    }
+  }
+
+  /**
+   * we treat it as a date pattern if there's an unquoted date/time letter
+   * (one of [hmsdyHMSDY]). technically mixing date formats and number
+   * formats (#0) is illegal. we will just drop into number formats for those.
+   */
+  protected static ParseDatePattern(): boolean {
+    this.date_pattern = true;
+    while (this.date_pattern && this.char_index < this.pattern.length) {
+      this.DatePatternConsumeChar();
+    }
+
+    // one more check: there has to be a date format part in there
+    if (this.date_pattern) {
+      this.date_pattern = false;
+      for (const section of this.sections) {
+        for (const part of section.prefix) {
+          // tslint:disable-next-line: no-bitwise
+          if (part.flag && (part.flag & (TextPartFlag.date_component | TextPartFlag.date_component_minutes))) {
+            this.date_pattern = true;
+          }
+        }
+      }
+    }
+
+    // if it _is_ a date pattern, set the section flag.
+    if (this.date_pattern) {
+      this.sections[0].date_format = true;
+
+      // check for minutes, and set the flag (actually state in the text
+      // part). in date formats mm means months _unless_ it is preceded
+      // by an hh or followed by an ss.
+
+      this.sections[0].prefix.forEach((item, index) => {
+        if (item.flag === TextPartFlag.date_component && (item.text === 'mm' || item.text === 'm')) {
+          if (index) {
+            for (let i = index - 1; i; i--) {
+              const test = this.sections[0].prefix[i];
+              if (test.flag === TextPartFlag.date_component) {
+                if (/h/i.test(test.text)) {
+                  item.flag = TextPartFlag.date_component_minutes;
+                  item.text = item.text.toLowerCase(); // normalize
+                }
+                break;
+              }
+            }
+          }
+          if (index < this.sections[0].prefix.length - 1) {
+            for (let i = index + 1; i < this.sections[0].prefix.length; i++) {
+              const test = this.sections[0].prefix[i];
+              if (test.flag === TextPartFlag.date_component) {
+                if (/s/i.test(test.text)) {
+                  item.flag = TextPartFlag.date_component_minutes;
+                  item.text = item.text.toLowerCase(); // normalize
+                }
+                break;
+              }
+            }
+          }
+        }
+      });
+
+    }
+    return this.date_pattern;
+  }
+
+  /**
+   * date parts are repeated sequences (e.g. ddd). we allow
+   * fractional seconds with ss.00.
+   */
+  protected static ConsumeDatePart(): TextPart {
+    const initial_char = this.pattern[this.char_index++];
+    const normalized = initial_char.toLowerCase();
+
+    const part: TextPart = {
+      text: initial_char,
+      flag: TextPartFlag.date_component,
+    };
+
+    while (this.pattern[this.char_index] && (this.pattern[this.char_index].toLowerCase() === normalized)) {
+      part.text += (this.pattern[this.char_index++]);
+    }
+
+    // partial seconds
+
+    if (normalized === 's' && this.pattern[this.char_index] === '.') {
+      part.text += (this.pattern[this.char_index++]);
+      while (this.pattern[this.char_index] === '0') {
+        part.text += (this.pattern[this.char_index++]);
+      }
+    }
+
+    return part;
+  }
+
+  /**
+   * special patterns for am/pm in date formats
+   */
+  protected static ConsumeAMPM(): TextPart | undefined {
+
+    let test = this.pattern.substr(this.char_index, 5);
+    if (test === 'am/pm' || test === 'AM/PM') {
+      this.char_index += 5;
+      this.sections[0].twelve_hour = true;
+      return { text: test, flag: TextPartFlag.date_component };
+    }
+
+    test = this.pattern.substr(this.char_index, 3);
+    if (test === 'a/p' || test === 'A/P') {
+      this.char_index += 3;
+      this.sections[0].twelve_hour = true;
+      return { text: test, flag: TextPartFlag.date_component };
+    }
+
+    return undefined;
+  }
+
+  protected static DatePatternConsumeChar(): void {
+
+    const char = this.characters[this.char_index];
+
+    switch (char) {
+      case SEMICOLON:
+
+        // only one section allowed for dates (not sure why). just ignore
+        // everything after the semicolon, but don't invalidate the pattern.
+        this.char_index = this.characters.length; // end
+        break;
+
+      case ZERO:
+      case NUMBER_SIGN:
+      case LOWERCASE_E:
+      case UPPERCASE_E:
+      case PERCENT:
+      case AT:
+      // case PERIOD:
+      // case COMMA:
+
+        // this is not a date format.
+        this.date_pattern = false;
+        break;
+
+      case UPPERCASE_H:
+      case LOWERCASE_H:
+      case UPPERCASE_M:
+      case LOWERCASE_M:
+      case UPPERCASE_S:
+      case LOWERCASE_S:
+      case UPPERCASE_D:
+      case LOWERCASE_D:
+      case UPPERCASE_Y:
+      case LOWERCASE_Y:
+        this.AppendTextPart(this.ConsumeDatePart());
+        break;
+
+      case UPPERCASE_A:
+      case LOWERCASE_A:
+        {
+          const ampm = this.ConsumeAMPM();
+          if (ampm) this.AppendTextPart(ampm);
+          else this.AppendCharAsText();
+        }
+        break;
+
+      case DOUBLE_QUOTE:
+        this.AppendString(this.ConsumeString());
+        break;
+
+      case QUESTION_MARK: // this is like _0
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText();
+        }
+        else {
+          this.AppendTextPart({
+            text: '0',
+            flag: TextPartFlag.hidden,
+          });
+          this.char_index++;
+        }
+        break;
+
+      case UNDERSCORE:
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText();
+        }
+        else {
+          if (++this.char_index >= this.characters.length) {
+            throw new Error('invalid pad character at end');
+          }
+          this.AppendTextPart({
+            text: this.pattern[this.char_index++],
+            flag: TextPartFlag.hidden,
+          });
+        }
+        break;
+
+      case ASTERISK:
+        if (this.current_section.has_asterisk) {
+          throw new Error(`we don't support multiple asterisks`);
+        }
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText();
+        }
+        else {
+          if (++this.char_index >= this.characters.length) {
+            throw new Error('invalid pad character at end');
+          }
+          this.AppendTextPart({
+            text: this.pattern[this.char_index++],
+            flag: TextPartFlag.padded,
+          });
+          this.current_section.has_asterisk = true;
+        }
+        break;
+
+      case BACKSLASH:
+        if (this.preserve_formatting_characters) {
+          this.AppendCharAsText(false);
+        }
+        if (++this.char_index >= this.characters.length) {
+          throw new Error('invalid escape character at end');
+        }
+        this.AppendCharAsText();
+        break;
+
+      default:
+        this.AppendCharAsText();
+
+    }
+  }
+
+}