spec: add required specs

Author: krishpranav

spec/ast/node_spec.cr

@@ -0,0 +1,42 @@
+require "../spec_helper"
+
+describe MoonScript::Ast::Node do
+  context "#contains?" do
+    it "checks if the location is contained within the node" do
+      example =
+        <<-MOON
+        component Test {
+          fun render : Html {
+            <div></div>
+          }
+        }
+        MOON
+
+      node =
+        MoonScript::Parser
+          .parse(example, "example.moonscript")
+          .components
+          .first
+          .functions
+          .first
+
+      {node.from.line, node.from.column}.should eq({2, 2})
+
+      # actually {4, 2} but all parsers go over by 1
+      {node.to.line, node.to.column}.should eq({4, 3})
+
+      # First line
+      node.contains?(2, 1).should eq(false) # space before `f`
+      node.contains?(2, 3).should eq(true)  # `f` of `fun`
+
+      # Middle line
+      node.contains?(3, 0).should eq(true)
+      node.contains?(3, 9).should eq(true)
+      node.contains?(3, 1000).should eq(true)
+
+      # End line
+      node.contains?(4, 2).should eq(true)  # `}`
+      node.contains?(4, 3).should eq(false) # space after `}`
+    end
+  end
+end

spec/compilers/access

@@ -0,0 +1,19 @@
+type X {
+  name : String
+}
+
+component Main {
+  fun render : String {
+    { name: "test" }.name
+  }
+}
+--------------------------------------------------------------------------------
+import { record as A } from "./runtime.js";
+
+export const
+  a = A(`X`),
+  B = () => {
+    return a({
+      name: `test`
+    }).name
+  };

spec/compilers/access_deep

@@ -0,0 +1,41 @@
+type Locale {
+  level1: Level1
+}
+
+type Level1 {
+  level2: Level2
+}
+
+type Level2 {
+  name : String
+}
+
+store Settings {
+  state locale : Locale = { level1: { level2: { name: "Test" }} }
+}
+
+component Main {
+  fun render : String {
+    Settings.locale.level1.level2.name
+  }
+}
+--------------------------------------------------------------------------------
+import {
+  signal as B,
+  record as A
+} from "./runtime.js";
+
+export const
+  a = A(`Level2`),
+  b = A(`Level1`),
+  c = A(`Locale`),
+  d = B(c({
+    level1: b({
+      level2: a({
+        name: `Test`
+      })
+    })
+  })),
+  C = () => {
+    return d.value.level1.level2.name
+  };

spec/compilers/argument

@@ -0,0 +1,19 @@
+component Main {
+  fun test (a : String, b : Number) : Number {
+    b
+  }
+
+  fun render : String {
+    test("", 0)
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const a = (b, c) => {
+    return c
+  };
+  a(``, 0);
+  return ``
+};

spec/compilers/argument_with_default

@@ -0,0 +1,19 @@
+component Main {
+  fun test (a : String, b : Number = 0) : Number {
+    b
+  }
+
+  fun render : String {
+    test("")
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const a = (b, c = 0) => {
+    return c
+  };
+  a(``);
+  return ``
+};

spec/compilers/argument_with_default_inline_function

@@ -0,0 +1,20 @@
+component Main {
+  fun render : String {
+    let test =
+      (a : String, b : Number = 0) : Number {
+        b
+      }
+
+    test("")
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const a = (b, c = 0) => {
+    return c
+  };
+  a(``);
+  return ``
+};

spec/compilers/array_literal

@@ -0,0 +1,20 @@
+component Main {
+  fun render : String {
+    [
+      "Hello",
+      "Blah",
+      "Joe"
+    ]
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  [
+    `Hello`,
+    `Blah`,
+    `Joe`
+  ];
+  return ``
+};

spec/compilers/block

@@ -0,0 +1,12 @@
+component Main {
+  fun render : String {
+    let a = "Some string..."
+
+    a + ", other string..."
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const a = `Some string...`;
+  return a + `, other string...`
+};

spec/compilers/block_with_await

@@ -0,0 +1,27 @@
+component Main {
+  fun promise : Promise(String) {
+    `` as Promise(String)
+  }
+
+  fun promiseTest : Promise(String) {
+    await promise()
+  }
+
+  fun render : String {
+    promiseTest()
+
+    "Hello"
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const
+    a = () => {
+      return undefined
+    },
+    b = async () => {
+      return await a()
+    };
+  b();
+  return `Hello`
+};

spec/compilers/block_with_early_return

@@ -0,0 +1,33 @@
+type Test {
+  A(String)
+  B(String)
+}
+
+component Main {
+  fun render : String {
+    let Test.A(a) =
+      Test.A("Some string...") or return "RETURN"
+
+    a
+  }
+}
+--------------------------------------------------------------------------------
+import {
+  patternVariable as E,
+  destructure as B,
+  newVariant as C,
+  pattern as D,
+  variant as A
+} from "./runtime.js";
+
+export const
+  F = A(1, `Test.A`),
+  G = A(1, `Test.B`),
+  H = () => {
+    const a = B(C(F)(`Some string...`), D(F, [E]));
+    if (a === false) {
+      return `RETURN`
+    };
+    const [b] = a;
+    return b
+  };

spec/compilers/block_with_early_return_await

@@ -0,0 +1,40 @@
+type Test {
+  A(String)
+  B(String)
+}
+
+component Main {
+  fun render : String {
+    {
+      let Test.A(a) =
+        await Test.A("Some string...") or return "RETURN"
+
+      a
+    }
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+import {
+  patternVariable as E,
+  destructure as B,
+  newVariant as C,
+  pattern as D,
+  variant as A
+} from "./runtime.js";
+
+export const
+  F = A(1, `Test.A`),
+  G = A(1, `Test.B`),
+  H = () => {
+    (async () => {
+      const a = B(await C(F)(`Some string...`), D(F, [E]));
+      if (a === false) {
+        return `RETURN`
+      };
+      const [b] = a;
+      return b
+    })();
+    return ``
+  };

spec/compilers/block_with_tuple_destructuring

@@ -0,0 +1,18 @@
+component Main {
+  fun render : String {
+    let {a, b} = {"Some string...", "B"}
+
+    a + ", other string..."
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  const [
+    a,
+    b
+  ] = [
+    `Some string...`,
+    `B`
+  ];
+  return a + `, other string...`
+};

spec/compilers/bool_literal_false

@@ -0,0 +1,12 @@
+component Main {
+  fun render : String {
+    false
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  false;
+  return ``
+};

spec/compilers/bool_literal_true

@@ -0,0 +1,12 @@
+component Main {
+  fun render : String {
+    true
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+export const A = () => {
+  true;
+  return ``
+};

spec/compilers/bracket_access

@@ -0,0 +1,43 @@
+type Maybe(a) {
+  Nothing
+  Just(a)
+}
+
+component Main {
+  fun render : String {
+    [
+      "Hello",
+      "Blah",
+      "Joe"
+    ][1]
+
+    [][1]
+
+    { "key" => "value" }["key"]
+
+    ""
+  }
+}
+--------------------------------------------------------------------------------
+import {
+  bracketAccess as B,
+  mapAccess as C,
+  variant as A
+} from "./runtime.js";
+
+export const
+  D = A(0, `Maybe.Nothing`),
+  E = A(1, `Maybe.Just`),
+  F = () => {
+    B([
+      `Hello`,
+      `Blah`,
+      `Joe`
+    ], 1, E, D);
+    B([], 1, E, D);
+    C([[
+      `key`,
+      `value`
+    ]], `key`, E, D);
+    return ``
+  };