Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Extensible JavaScript Transformations
JavaScript Makefile

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
benchmarks
bin
doc
lib
test
.gitignore
CHANGELOG.md
GNUmakefile
README.md
package.json

README.md

 ___ ___    _____  _______  _______
|   |   | _|     ||     __||_     _|
|-     -||       ||__     |  |   |
|___|___||_______||_______|  |___|

What is XJST?

XJST is a performance oriented data matcher implemented for node.js. It's partially inspired by the XSLT and built on top of the ometajs.

Data Matcher?

Yes, match data recursively over a conditions' set to generate any output.

XJST can be used as url router or as a template engine, more info below.

Installation

npm install xjst

Public API

var xjst = require('xjst');

var fn = xjst.compile('template string', 'filename.xjst', options);

fn({ your: 'data' });

Syntax

XJST extends javascript syntax with a following keywords: template, local, apply.

Template

template(expression1 === value1 && ... && expressionN === valueN) {
  // will be run if condition above equals to true
}

Multiple template statements will be grouped to construct optimal conditions graph. Order of the template statements matters, the priority decreases from the bottom to the top.

Local

var x = 1;

console.log(local(x = 2) x); // 2
console.log(x); // 1

local allows you to make temporary changes to a visible variables scope. Every assignment put inside parens will be reverted immediately after the expression execution.

You can make multiple assignments in the one statement:

local(this.x = 2, this.y = 3) ...

Or use local with a block:

local(...) { var a = 1; return a * 2; }

Or as an expression:

var newX = local(x = 2) x;

Apply

template(true) {
  return apply(this.type = 'first');
}

template(this.type === 'first') {
  return apply({ type: 'second' });
}

template(this.type === 'second') {
  return 'here am I';
}

XJST is intended to be applied recursively to the same data, while making small reversible changes to it. apply keyword works exactly like a local (applying changes in the parens and reverting them after the execution), but with small distinction - apply doesn't have a body, so it's just doing some changes to the data and applying template recursively (the context will be preserved).

CLI interface

$ bin/xjst --help

Usage:
  xjst [OPTIONS] [ARGS]


Options:
  -h, --help : Help
  -i INPUT, --input=INPUT : Input file (default: stdin)
  -o OUTPUT, --output=OUTPUT : Output file (default: stdout)

$ bin/xjst -i template.xjst

.... some code ...

Optimizations

XJST takes all the template statements and produces a tree with comparisons in nodes and template's bodies in leafs. apply are handled and replaced by direct calls to the tree's nodes (some of comparisons can be skipped, using known context's state).

Input:

template(this.type === 'a') {
  // body 1
}
template(this.type === 'b') {
  // body 2
}

Output (simplified):

switch (this.type) {
  case 'a':
    // body 1
    break;
  case 'b':
    // body 2
    break;
}

Documentation

Here is the documented source.

Some technical details (in Russian) can be found in doc/tech.ru.md.

Authors

Something went wrong with that request. Please try again.