feat: Convert methods to start recording multiple errors.

Author: ramitha

packages/@css-blocks/core/src/BlockParser/BlockFactory.ts

@@ -39,13 +39,14 @@ export class BlockFactory {
   blockNames: ObjectDictionary<number>;
   parser: BlockParser;
   preprocessors: Preprocessors;
+  faultTolerant: boolean;
 
   private promises: ObjectDictionary<Promise<Block>>;
   private blocks: ObjectDictionary<Block>;
   private paths: ObjectDictionary<string>;
   private preprocessQueue: PromiseQueue<PreprocessJob, ProcessedFile>;
 
-  constructor(options: Options, postcssImpl = postcss) {
+  constructor(options: Options, postcssImpl = postcss, faultTolerant = false) {
     this.postcssImpl = postcssImpl;
     this.configuration = resolveConfiguration(options);
     this.importer = this.configuration.importer;
@@ -58,6 +59,7 @@ export class BlockFactory {
     this.preprocessQueue = new PromiseQueue(this.configuration.maxConcurrentCompiles, (item: PreprocessJob) => {
       return item.preprocessor(item.filename, item.contents, this.configuration);
     });
+    this.faultTolerant = faultTolerant;
   }
 
   reset() {
@@ -75,9 +77,26 @@ export class BlockFactory {
    * @returns The Block object promise.
    */
   parse(root: postcss.Root, identifier: string, name: string): Promise<Block> {
+    // TODO: this function is referenced only in tests. Use parseSync if we need
+    // to catch errors
     return this.promises[identifier] = this.parser.parse(root, identifier, name);
   }
 
+  /**
+   * Parse a `postcss.Root` into a Block object. Save the Block promise and return it.
+   * Also assert that the block is valid so that we can catch any errors that
+   * the block contains
+   * This function is only used in tests
+   * @param root The postcss.Root to parse.
+   * @param identifier A unique identifier for this Block file.
+   * @param name Default name for the block.
+   * @returns The Block object promise.
+   */
+  async parseSync(root: postcss.Root, identifier: string, name: string): Promise<Block> {
+    const block = await this.parser.parse(root, identifier, name);
+    return this._surfaceBlockErrors(block);
+  }
+
   /**
    * In some cases (like when using preprocessors with native bindings), it may
    * be necessary to wait until the block factory has completed current
@@ -130,6 +149,10 @@ export class BlockFactory {
 
         // Ensure this block name is unique.
         block.setName(this.getUniqueBlockName(block.name));
+
+        // if the block has any errors, surface them here
+        this._surfaceBlockErrors(block);
+
         return this.blocks[block.identifier] = block;
       })
       .catch((error) => {
@@ -146,6 +169,19 @@ export class BlockFactory {
       });
   }
 
+  /**
+   * Depending on whether the blockFactory is fault tolerant or not, it either
+   * surfaces the errors or swallows them and reexports the block interface
+   * @param block the block to check for errors
+   */
+  _surfaceBlockErrors(block: Block): Block {
+    if (this.faultTolerant) {
+      return block;
+    } else {
+      return block.assertValid();
+    }
+  }
+
   /**
    * Parse the file into a `Block`.
    **/
@@ -198,6 +234,7 @@ export class BlockFactory {
       originalSyntax: file.syntax,
       dependencies: preprocessResult.dependencies || [],
     };
+
     return this.parser.parseSource(source);
   }
 

packages/@css-blocks/core/src/BlockParser/features/construct-block.ts

@@ -66,8 +66,11 @@ export async function constructBlock(configuration: Configuration, root: postcss
       let keySel = iSel.key;
       let sel: CompoundSelector | undefined = iSel.selector;
 
-      // Assert this selector is well formed according to CSS Blocks' selector rules.
+      // Assert this selector is well formed according to CSS Blocks' selector
+      // rules.
       assertValidSelector(configuration, block, rule, iSel, file);
+      // this should list all the errors
+      // block.assertValid();
 
       // For each `CompoundSelector` in this rule, configure the `Block` object
       // depending on the BlockType.
@@ -137,9 +140,9 @@ function assertValidSelector(configuration: Configuration, block: Block, rule: p
   // Verify our key selector targets a block object, but not one from an another block.
   let keyObject = assertBlockObject(configuration, block, selector.key, rule, file);
   if (keyObject.blockName) {
-    throw new errors.InvalidBlockSyntax(
+    block.addError(new errors.InvalidBlockSyntax(
       `Cannot style values from other blocks: ${rule.selector}`,
-      range(configuration, block.stylesheet, file, rule, keyObject.node));
+      range(configuration, block.stylesheet, file, rule, keyObject.node)));
   }
 
   // Fetch and validate our first `CompoundSelector`
@@ -167,45 +170,45 @@ function assertValidSelector(configuration: Configuration, block: Block, rule: p
     // Don't allow weird combinators like the column combinator (`||`)
     // or the attribute target selector (e.g. `/for/`)
     if (!LEGAL_COMBINATORS.has(combinator)) {
-      throw new errors.InvalidBlockSyntax(
+      block.addError(new errors.InvalidBlockSyntax(
         `Illegal Combinator '${combinator}': ${rule.selector}`,
         range(configuration, block.stylesheet, file, rule, currentCompoundSel.next.combinator),
-      );
+      ));
     }
 
     // Class level objects cannot be ancestors of root level objects
     if (isClassLevelObject(currentObject) && nextLevelIsRoot && SIBLING_COMBINATORS.has(combinator)) {
-      throw new errors.InvalidBlockSyntax(
+      block.addError(new errors.InvalidBlockSyntax(
         `A class is never a sibling of a ${blockTypeName(nextObject.blockType)}: ${rule.selector}`,
         range(configuration, block.stylesheet, file, rule, selector.selector.nodes[0]),
-      );
+      ));
     }
 
     // Once you go to the class level there's no combinator that gets you back to the root level
     if (foundClassLevel && nextLevelIsRoot) {
-      throw new errors.InvalidBlockSyntax(
+      block.addError(new errors.InvalidBlockSyntax(
         `Illegal scoping of a ${blockTypeName(currentObject.blockType)}: ${rule.selector}`,
         range(configuration, block.stylesheet, file, rule, currentCompoundSel.next.combinator),
-      );
+      ));
     }
 
     // You can't reference a new root level object once you introduce descend the hierarchy
     if (foundRootLevel && nextLevelIsRoot && foundCombinators.some(c => HIERARCHICAL_COMBINATORS.has(c))) {
       // unless it's only referencing the same object.
       if (!foundObjects.every(f => f.node.toString() === nextObject.node.toString())) {
-        throw new errors.InvalidBlockSyntax(
+        block.addError(new errors.InvalidBlockSyntax(
           `Illegal scoping of a ${blockTypeName(currentObject.blockType)}: ${rule.selector}`,
           range(configuration, block.stylesheet, file, rule, currentCompoundSel.next.combinator),
-        );
+        ));
       }
     }
 
     // class-level and root-level objects cannot be siblings.
     if (isRootLevelObject(currentObject) && nextLevelIsClass && SIBLING_COMBINATORS.has(combinator)) {
-      throw new errors.InvalidBlockSyntax(
+      block.addError(new errors.InvalidBlockSyntax(
         `A ${blockTypeName(nextObject.blockType)} cannot be a sibling with a ${blockTypeName(currentObject.blockType)}: ${rule.selector}`,
         range(configuration, block.stylesheet, file, rule, currentCompoundSel.next.combinator),
-      );
+      ));
     }
 
     // Class-level objects cannot be combined with each other. only with themselves.
@@ -214,15 +217,15 @@ function assertValidSelector(configuration: Configuration, block: Block, rule: p
       if (conflictObj) {
         // slightly better error verbiage for objects of the same type.
         if (conflictObj.blockType === nextObject.blockType) {
-          throw new errors.InvalidBlockSyntax(
+          block.addError(new errors.InvalidBlockSyntax(
             `Distinct ${blockTypeName(conflictObj.blockType, { plural: true })} cannot be combined: ${rule.selector}`,
             range(configuration, block.stylesheet, file, rule, nextObject.node),
-          );
+          ));
         } else {
-          throw new errors.InvalidBlockSyntax(
+          block.addError(new errors.InvalidBlockSyntax(
             `Cannot combine a ${blockTypeName(conflictObj.blockType)} with a ${blockTypeName(nextObject.blockType)}}: ${rule.selector}`,
             range(configuration, block.stylesheet, file, rule, nextObject.node),
-          );
+          ));
         }
       }
     }
@@ -302,10 +305,10 @@ function assertBlockObject(configuration: Configuration, block: Block, sel: Comp
       else if (isAttributeNode(n)) {
         // Assert this state node uses a valid operator if specifying a value.
         if (n.value && n.operator !== "=") {
-          throw new errors.InvalidBlockSyntax(
+          block.addError(new errors.InvalidBlockSyntax(
             `A state with a value must use the = operator (found ${n.operator} instead).`,
             range(configuration, block.stylesheet, file, rule, n),
-          );
+          ));
         }
         if (n.attribute === "scope") {
           throw new errors.InvalidBlockSyntax(
@@ -344,19 +347,19 @@ function assertBlockObject(configuration: Configuration, block: Block, sel: Comp
           };
         } else {
           if (found.blockType === BlockType.root) {
-            throw new errors.InvalidBlockSyntax(
+            block.addError(new errors.InvalidBlockSyntax(
               `${n} cannot be on the same element as ${found.node}: ${rule.selector}`,
-              range(configuration, block.stylesheet, file, rule, sel.nodes[0]));
+              range(configuration, block.stylesheet, file, rule, sel.nodes[0])));
           } else if (found.blockType === BlockType.class) {
             if (n.toString() !== found.node.toString()) {
-              throw new errors.InvalidBlockSyntax(
+              block.addError(new errors.InvalidBlockSyntax(
                 `Two distinct classes cannot be selected on the same element: ${rule.selector}`,
-                range(configuration, block.stylesheet, file, rule, n));
+                range(configuration, block.stylesheet, file, rule, n)));
             }
           } else if (found.blockType === BlockType.classAttribute || found.blockType === BlockType.attribute) {
-            throw new errors.InvalidBlockSyntax(
+            block.addError(new errors.InvalidBlockSyntax(
               `The class must precede the state: ${rule.selector}`,
-              range(configuration, block.stylesheet, file, rule, sel.nodes[0]));
+              range(configuration, block.stylesheet, file, rule, sel.nodes[0])));
           }
         }
       }

packages/@css-blocks/core/src/BlockTree/Block.ts

@@ -198,11 +198,11 @@ export class Block
    * Checks for errors on the block
    * @returns true if the block is valid else throws the errors on the block
    */
-  assertValid(): Boolean {
+  assertValid(): Block {
     if (this._blockErrors.length) {
       throw new MultipleCssBlockErrors(this._blockErrors);
     }
-    return true;
+    return this;
   }
 
   /**

packages/@css-blocks/core/src/errors.ts

@@ -132,15 +132,22 @@ export class BlockPathError extends CssBlockError {
  * Acts as a collection of CssBlockErrors along with utility methods to add and
  * clear errors
  */
-export class MultipleCssBlockErrors extends Error {
+export class MultipleCssBlockErrors extends CssBlockError {
+  static prefix = "MultipleCssBlocksError";
   private _errors: CssBlockError[] = [];
-  constructor(errors: CssBlockError[]) {
-    super();
+
+  constructor(errors: CssBlockError[], location?: ErrorLocation, details?: string) {
+    super(MultipleCssBlockErrors.prefix, location);
     this._errors = errors;
+    if (details) { this.message += `\n${details}`; }
   }
-  add(error:CssBlockError) {
+
+  add(error: CssBlockError) {
     this._errors.push(error);
   }
+  get errors(): CssBlockError[] {
+    return this._errors;
+  }
   clear() {
     this._errors = [];
   }