pasaran / yate Goto Github PK

<div>
    <h1>
        "Hello"
    </>
</>

match /.foo.bar { // ERROR
    "Hello"
}

match / {
    apply .blocks.app
}

match .blocks.app {
    name()
}

match / {
  <div/>
}

match / {
    "Hello, '{ .username }'"
    'Hello, "{ .username }"'
}

match / {
    hello("hello")
}

func hello(text) {
    if text { // Here!
        text
    }
}

 match / {
     <div>
         @class = apply . class
         "Hello"
     </div>
 }

 match / class {
     "b-hello"
 }

$ ./yate a.yate

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
Error: ERROR: Cannot convert type from xml to scalar apply
at (18, 3) in /.../a.yate:
        @class = apply . class
-----------------^
    at [object Object].error (/.../yatelib.js:209:11)
    at [object Object].cast (/.../yatelib.js:362:18)
    at [object Object].setTypes (/.../yatelib.js:2601:16)
    at /.../yatelib.js:3919:13
    at [object Object].walkBefore (/.../yatelib.js:316:5)
    at [object Object].walkBefore (/.../yatelib.js:785:18)
    at [object Object].walkBefore (/.../yatelib.js:323:19)
    at [object Object].walkBefore (/.../yatelib.js:323:19)
    at [object Object].walkBefore (/.../yatelib.js:323:19)
    at [object Object].walkBefore (/.../yatelib.js:785:18)

{
    "sOK": "OK",
    "sEmpty": "", // false
    "sZero": "0",
    "bTrue": true,
    "bFalse": false, // false
    "nZero": 0, // false
    "nOne": 1,
    "Null": null, // false
    "Undef": undefined,
    "oEmpty": {},
    "oOne": { "a": 1 },
    "aEmpty": [],
    "aZero": [0],
    "aOne": [1]
}

match / {
    "sOK: "
    if .sOK { "true" } else { "false" }
    "\n"
    "sEmpty: "
    if .sEmpty { "true" } else { "false" }
    "\n"
    "sZero: "
    if .sZero { "true" } else { "false" }
    "\n"
    "bTrue: "
    if .bTrue { "true" } else { "false" }
    "\n"
    "bFalse: "
    if .bFalse { "true" } else { "false" }
    "\n"
    "nZero: "
    if .nZero { "true" } else { "false" }
    "\n"
    "nOne: "
    if .nOne { "true" } else { "false" }
    "\n"
    "Null: "
    if .Null { "true" } else { "false" }
    "\n"
    "Undef: "
    if .Undef { "true" } else { "false" }
    "\n"
    "oEmpty: "
    if .oEmpty { "true" } else { "false" }
    "\n"
    "oOne: "
    if .oOne { "true" } else { "false" }
    "\n"
    "aEmpty: "
    if .aEmpty { "true" } else { "false" }
    "\n"
    "aZero: "
    if .aZero { "true" } else { "false" }
    "\n"
    "aOne: "
    if .aOne { "true" } else { "false" }
}

sOK: true
sEmpty: true
sZero: true
bTrue: true
bFalse: true
nZero: true
nOne: true
Null: true
Undef: false
oEmpty: true
oOne: true
aEmpty: false
aZero: true
aOne: true

match / class {
    apply .foo.bar "{ . }-content"
}

match .foo.bar class-content {
    "b-foo"
}

if () {}
else if () {}
else {}

if () {}
else {
    if () {}
    else {}
}

{ item: [ [ 13, 42 ] ] }

a = .foo.bar // lazy
b = 42 // constant

Считать следующий символ в строке.
Если это '<' - значит это начало xml тэга.
Пока не найден символ '>' прибавлять к текущей строке следующую строку.
Считать тэгом всё, что оказалось между первым '<' и найденым в процессе '>'.

<div>
    @{ name } = "b-hello"
    "Hello"
</div>

key(.items.item, .id + .title) {
  .
}

apply .node mode
match .node mode { ... }

apply .node mode
match node mode { ... }

match .*[count()] {
}

// count()
function p0(c0, index, count) {
    return count;
};

var j0 = [ 0, "*", 3, count ]; // .*[ count() ]

match .*[3 == count()] {}

Error: ERROR: Cannot convert type from boolean to scalar inline_eq
at (10, 1) in /.../count.yate:
match .*[3 == count()] {}

match .foo content {
    "Hello"
    apply .bar content
}

match .foo #content {
    "Hello"
    apply .bar #content
}

match / {
    v = f()
}
func f() { }

...
    // match /
    var t0 = {
        jpath: null,
        body: function(c0, a0, index, count) {
            var r0 = '';

            var v0 = f0(c0, /*====>*/ a1 /*<=====*/, index, count);

            return r0;
        }
    };
...

./yate a.yate tests/01.json 

node.js:201
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
ReferenceError: a1 is not defined
    at Object.body (evalmachine.<anonymous>:381:29)
    at [object Object].applyValue (evalmachine.<anonymous>:61:35)
    at Function.run (evalmachine.<anonymous>:20:18)
    at evalmachine.<anonymous>:438:8
    at Object.run (/home/lynn/Public/yate/lib/yate.js:117:22)
    at Object.<anonymous> (/home/lynn/Public/yate/yate:42:23)
    at Module._compile (module.js:441:26)
    at Object..js (module.js:459:10)
    at Module.load (module.js:348:31)
    at Function._load (module.js:308:12)

var = "<"
var2 = "&"
match / {
    <tag a="<" b="{var}">
        @c=var
    </>
    <tag a="<" b="{var}">
    </>
    "\n"
    <tag a="&" b="{var2}">
        @c=var2
    </>
    "\n"
    <tag a="&" b="{var2}">
    </>
}

match / {
    <h1>
        @class += if 1 { "b-hello" }
        "Hello, { .username }"
    </h1>
}

<h1 class="undefinedb-hello">Hello, nop</h1>

match / {
    <div> // No comments here
        <div></div> // And here
    </div>
}

match / {
    <div>
        @x = 0
    </div>
}

func f1(x) {
  ...
}
func f2(x) {
  ...
}
...

match / {
    <div id="{.id}">
        @class = "b-hello"
        "Hello"
    </div>
}

match .photo controls {
  foo( "" ) // empty string as a param
}

func foo( p ) {
  // We get bug here: r0 += scalar2xml( f2(c0, index, count,) ); :3402 Uncaught SyntaxError: Unexpected token )
  // A comma is missing after count variable.
}

external scalar upperCase(scalar)
...
upperCase(.summary | .post | .title | .url)

upperCase("" + (.summary | .post | .title | .url))