goldstein 2.0.0 → 2.1.0

package/ChangeLog

@@ -1,3 +1,10 @@
+2022.06.25, v2.1.0
+
+feature:
+- goldstein: integrate 'should'
+- add should keyword (#5)
+
+
 2022.06.22, v2.0.0
 
 feature:

package/README.md

@@ -9,11 +9,13 @@
 [CoverageURL]: https://coveralls.io/github/coderaiser/goldstein?branch=master
 [CoverageIMGURL]: https://coveralls.io/repos/coderaiser/goldstein/badge.svg?branch=master&service=github
 
+![image](https://user-images.githubusercontent.com/1573141/175353192-9867d3ba-beaf-46d5-adbc-e2eb736bfef1.png)
+
 > *"You haven't a real appreciation of Newspeak, Winston," he said almost sadly. "Even when you write it you're still thinking in Oldspeak. I've read some of those pieces that you write in The Times occasionally. They're good enough, but they're translations. In your heart you'd prefer to stick to Oldspeak, with all its vagueness and its useless shades of meaning. You don't grasp the beauty of the destruction of words. Do you know that Newspeak is the only language in the world whose vocabulary gets smaller every year?"*
 >
 > *(c) “1984”, George Orwell*
 
-JavaScript with no limits.
+JavaScript with no limits 🤫.
 
 Language ruled by the users, [create an issue](https://github.com/coderaiser/goldstein/issues/new/choose) with ideas of a new language construction and what is look like in JavaScript, and most likely we implement it :).
 
@@ -49,7 +51,7 @@ import {compile} from 'goldstein';
 
 compile(`
     fn hello() {
-        guard (text !== "world") else {
+        guard text !== "world" else {
             return ""
         }
         
@@ -147,6 +149,23 @@ import tryToCatch from 'try-catch';
 const [error, result] = await tryToCatch(1, 2, 3);
 ```
 
+### `should`
+
+`should` can be used as an expression (just like [`try`](https://github.com/coderaiser/goldstein/edit/master/README.md#try)).
+This keyword is useful if you want to prevent a function call (also async) to throw an error because you don't need to have any result and the real execution is just optional (so runs if supported).
+
+```gs
+should hello()
+```
+
+Is the same as:
+
+```gs
+try hello();
+```
+
+> ☝️ *Warning: this feature can be helpful but also dangerous especially if you're debugging your application. In fact, this is made to be used as an optional function call (ex. should load content, but not necessary and knowing this feature is optional), if you call a function in this way while debugging, no error will be printed and the application will continue run as nothing happened.*
+
 ### `if`
 
 You can omit parens. But you must use braces in this case.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "goldstein",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "type": "module",
   "commitType": "colon",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",

package/packages/goldstein/index.js

@@ -5,12 +5,16 @@ import {extendParser} from '../parser/index.js';
 import keywordFn from '../keyword-fn/index.js';
 import keywordGuard from '../keyword-guard/index.js';
 import keywordTry from '../keyword-try/index.js';
+import keywordShould from '../keyword-should/index.js';
+import stringInterpolation from '../string-interpolation/index.js';
 
 export const compile = (source) => {
     const {parse} = extendParser([
         keywordFn,
         keywordGuard,
         keywordTry,
+        keywordShould,
+        stringInterpolation,
     ]);
     
     const ast = parse(source);

package/packages/keyword-if/index.js

@@ -8,6 +8,7 @@ export default function fn(Parser) {
             this.next();
             
             const isParenL = this.eat(tt.parenL);
+            
             node.test = this.parseExpression();
             const isParenR = this.eat(tt.parenR);
             

package/packages/keyword-should/index.js

@@ -0,0 +1,91 @@
+import {types} from 'putout';
+import {
+    addKeyword,
+    TokenType,
+    tokTypes as tt,
+} from '../operator/index.js';
+
+const {
+    isCallExpression,
+    isAwaitExpression,
+} = types;
+
+export default function newSpeak(Parser) {
+    const {keywordTypes} = Parser.acorn;
+    keywordTypes.should = new TokenType('should', {
+        keyword: 'should',
+    });
+    
+    return class extends Parser {
+        parse() {
+            this.keywords = addKeyword('should', this.keywords);
+            return super.parse();
+        }
+        parseStatement(context, topLevel, exports) {
+            if (this.type === keywordTypes.should) {
+                return this.parseShould();
+            }
+            
+            return super.parseStatement(context, topLevel, exports);
+        }
+        
+        parseShould() {
+            this.next();
+            
+            const node = super.startNode();
+            
+            if (this.type === tt.braceL)
+                return this.raise(this.start, `After 'should' only 'await' and 'function call' can come, brakets are not supported`);
+            
+            const expression = this.parseExpression();
+            
+            if (isCallExpression(expression))
+                node.expression = {
+                    type: 'TryStatement',
+                    block: {
+                        type: 'BlockStatement',
+                        body: [{
+                            type: 'ExpressionStatement',
+                            expression: {
+                                type: 'CallExpression',
+                                callee: expression.callee,
+                                arguments: expression.arguments.slice(),
+                            },
+                        }],
+                    },
+                    handler: {
+                        type: 'CatchClause',
+                        body: {
+                            type: 'BlockStatement',
+                            body: [],
+                        },
+                    },
+                };
+            
+            else if (isAwaitExpression(expression))
+                node.expression = {
+                    type: 'TryStatement',
+                    block: {
+                        type: 'BlockStatement',
+                        body: [{
+                            type: 'ExpressionStatement',
+                            expression,
+                        }],
+                    },
+                    handler: {
+                        type: 'CatchClause',
+                        body: {
+                            type: 'BlockStatement',
+                            body: [],
+                        },
+                    },
+                };
+            
+            else
+                this.raise(this.start, `After 'should' only 'await' and 'function call' can come`);
+            
+            return super.finishNode(node, 'ExpressionStatement');
+        }
+    };
+}
+

package/packages/keyword-try/index.js

@@ -24,6 +24,7 @@ export default function newSpeak(Parser) {
         
         parseTryStatement() {
             this.next();
+            
             const node = super.startNode();
             
             if (this.type === tt.braceL)

package/packages/string-interpolation/index.js

@@ -0,0 +1,65 @@
+import {template} from 'putout';
+const {assign} = Object;
+
+export default function stringInterpolation(Parser) {
+    return class extends Parser {
+        parseLiteral(value) {
+            const chars = value.split('');
+            
+            let literalOpened = false;
+            let parenthesis = 0;
+            const out = [];
+            let isTemplateLiteral = false;
+            
+            for (let [index, char] of chars.entries()) {
+                if (char === '(') {
+                    // keep count of parenthesis
+                    parenthesis++;
+                    
+                    // check if previous token was "/" (only if literal is not opened yet)
+                    const prev = index - 1;
+                    
+                    if (chars[prev] === '/' && !literalOpened) {
+                        // set previous char to "$"
+                        out[prev] = '$';
+                        // set current char to "{"
+                        char = '{';
+                        
+                        // set literalOpened to true
+                        literalOpened = true;
+                        // match TemplateLiteral instead of StringLiteral
+                        isTemplateLiteral = true;
+                    }
+                } else if (char === ')') {
+                    parenthesis--;
+                    
+                    if (parenthesis === 0 && literalOpened) {
+                        char = '}';
+                        
+                        // reset literalOpened to false
+                        literalOpened = false;
+                    }
+                }
+                
+                out.push(char);
+            }
+            
+            if (isTemplateLiteral) {
+                const node = this.startNode();
+                this.next();
+                
+                const {quasis, expressions} = template.ast('`' + out.join('') + '`');
+                
+                assign(node, {
+                    quasis,
+                    expressions,
+                });
+                
+                return this.finishNode(node, 'TemplateLiteral');
+            }
+            
+            return super.parseLiteral(out.join(''));
+        }
+    };
+}
+