Combine rules and children

src/ast.ts

 
   export class RuleSet extends Node {
     public selectors: Selector[];
-    public rules: Rule[];
-    public children: RuleSet[];
+    public children: (RuleSet | Rule)[];
 
     public constructor(
       selectors: Selector[],
-      rules: Rule[],
-      children: RuleSet[] = []
+      children: (RuleSet | Rule)[] = []
     ) {
       super();
       this.selectors = selectors;
-      this.rules = rules;
       this.children = children;
     }
 
       const lineages = ([] as string[]).concat(
         ...this.selectors.map((sel) => sel.getLineages())
       );
-      const rules = this.rules.map((rule: Rule) => rule.compile(env, opts));
-      const rulesError = rules.find((rule) => rule instanceof EnvError);
+
+      const rules: Array<string | EnvError> = this.children
+        .filter((child) => child instanceof Rule)
+        .map(
+        (child): string | EnvError => {
+          return child.compile(env, opts);
+        }
+      );
+      const rulesError = rules.find((child) => child instanceof EnvError);
       if (rulesError !== undefined) return rulesError;
 
       const compiledRules = rules.join(lineSpacer);
 
-      const children: Array<string | EnvError> = this.children.map(
-        (child: RuleSet): string | EnvError => {
+      const children: Array<string | EnvError> = this.children
+      .filter((child) => child instanceof RuleSet).map(
+        (child): string | EnvError => {
           return child.compile(env, opts);
         }
       );

src/moss.ts

 import Lexer, { LexerError } from './lexer';
 import Parser, { ParserError } from './parser';
 
-// import { inspect } from 'util';
-// const print = (obj: any) => {
-//   console.log(inspect(obj, { depth: null }));
-// };
+import { inspect } from 'util';
+const print = (obj: any) => {
+  console.log(inspect(obj, { depth: null }));
+};
 
 const rawArgs = minimist(process.argv.slice(2));
 
   } else {
     const parser = new Parser(tokens);
     const tree = parser.parse();
+    print(tree);
     if (tree instanceof ParserError) {
       return tree;
     } else {

src/parser.ts

       selectors.push(selector);
     }
 
-    const rules: AST.Rule[] = [];
-    const children: AST.RuleSet[] = [];
+    const children: (AST.Rule | AST.RuleSet)[] = [];
 
     while (
       [TokenTypes.PROPERTY, TokenTypes.LPAREN].includes(
         const value = this.value();
         if (value instanceof ParserError) return value;
 
-        rules.push(new AST.Rule(property, value));
+        children.push(new AST.Rule(property, value));
       } else if (this.currentToken().type === TokenTypes.LPAREN) {
         const ruleSet = this.ruleSet(selectors);
         if (ruleSet instanceof ParserError) return ruleSet;
     const rParen = this.eat(TokenTypes.RPAREN);
     if (rParen instanceof ParserError) return rParen;
 
-    return new AST.RuleSet(selectors, rules, children);
+    return new AST.RuleSet(selectors, children);
   }
 
   private value():

src/tests/parser.test.ts

     t.deepEqual(result.tree, [
       new AST.RuleSet(
         [new AST.Selector(literalToken('body'))],
-        [new AST.Rule(property('color'), literalNode('black'))],
         [
+          new AST.Rule(property('color'), literalNode('black')),
           new AST.RuleSet(
             [
               new AST.Selector(literalToken('div'), [
                 new AST.Selector(literalToken('body')),
               ]),
             ],
-            [new AST.Rule(property('color'), literalNode('blue'))],
             [
+              new AST.Rule(property('color'), literalNode('blue')),
               new AST.RuleSet(
                 [
                   new AST.Selector(literalToken('span'), [
       result.tree[0],
       new AST.RuleSet(
         [new AST.Selector(literalToken('div'))],
-        [new AST.Rule(property('color'), literalNode('green'))],
         [
           new AST.RuleSet(
             [
             ],
             [new AST.Rule(property('color'), literalNode('blue'))]
           ),
+          new AST.Rule(property('color'), literalNode('green')),
+        ]
+      )
+    );
+  }
+});
+
+test('combine rules and children', (t) => {
+  t.plan(2);
+  const result = parse('(div :color green (span :color blue))');
+  t.false(result instanceof ParserError);
+  if (!(result instanceof LexerError) && !(result instanceof ParserError)) {
+    t.deepEqual(
+      result.tree[0],
+      new AST.RuleSet(
+        [new AST.Selector(literalToken('div'))],
+        [
+          new AST.Rule(property('color'), literalNode('green')),
+          new AST.RuleSet(
+            [
+              new AST.Selector(literalToken('span'), [
+                new AST.Selector(literalToken('div')),
+              ]),
+            ],
+            [new AST.Rule(property('color'), literalNode('blue'))]
+          ),
         ]
       )
     );