galileo_mustache4dart

Description:

galileo mustache4dart

Mustache for Dart #


A simple implementation of Mustache for the
Dart language, which passes happily all the
mustache v1.1.2+λ specs. If you want to have a look at how it works,
just check the tests. For more info, just read further.
Using it #
In order to use the library, just add it to your pubspec.yaml as a dependency
dependencies:
mustache4dart2: '>= 2.0.0 < 3.0.0'
copied to clipboard
and then import the package
import 'package:mustache4dart2/mustache4dart2.dart';
copied to clipboard
and you are good to go. You can use the render toplevel function to render your
template.
For example:
var salutation = render('Hello {{name}}!', {'name': 'Bob'});
print(salutation); //shoud print Hello Bob!
copied to clipboard
Context objects #
mustache4dart will look at your given object for operators, fields or methods.
For example, if you give the template {{firstname}} for rendering,
mustache4dart will try the followings

use the [] operator with firstname as the parameter
search for a field named firstname
search for a getter named firstname
search for a method named firstname (see Lambdas support)

in each case the first valid value will be used.
@MirrorsUsed
In order to do the stuff described above the mirror library is being used which
could lead to big js files when compiling the library with dartjs. In order to
preserve the type information you have to annotate the objects used as
contextes with @MirrorsUsed. Have in mind though that as documented
this is experimental.
In order to avoid the use of the mirrors package, make sure that you compile
your library with dart2js -DMIRRORS=false . In that case though you must
always make sure that your context object have a right implementation of the
[] operator as no other checks on the object will be available.
Partials #
mustache4dart support partials but it needs somehow to know how to find a
partial. You can do that by providing a function that returns a template
given a name:
String partialProvider(String partialName) => "this is the partial with name: ${partialName}";
expect(render('[{{>p}}]', null, partial: partialProvider), '[this is the partial with name: p]'));
copied to clipboard
Compiling to functions #
If you have a template that you are going to reuse with different contexts,
you can compile it to a function using the toplevel function compile:
var salut = compile('Hello {{name}}!');
print(salut({'name': 'Alice'})); //should print Hello Alice!
copied to clipboard
Lambdas support #
The library passes all the optional lambda specs based on
which lambdas must be treatable as arity 0 or 1 functions.
As dart provides optional named parameters, you can pass to a given lambda
function the nestedContext. In that case the current nested context will be
given as parameter to the lambda function.
Developing #
The project passes all the Mustache specs. You have to make sure
though that you've downloaded them. Just make sure that you have done the
steps described below.
git clone git://github.com/valotas/mustache4dart.git
git submodule init
git submodule update
pub get
copied to clipboard
If you are with Linux, you can use what travis does:
./build.sh
copied to clipboard
Alternatively, if you have Dart Test Runner installed you can
just do:
pub global run test_runner
copied to clipboard
Observatory #
To start the observatory after running test:
dart --pause-isolates-on-exit --enable-vm-service=NNNN ./test/mustache_all.dart
copied to clipboard
Then coverage can be used in order to collect and format data:
pub global run coverage:collect_coverage --uri=http://... -o /tmp/mustache4dart.coverage.json --resume-isolates
pub global run coverage:format_coverage --packages=app_package/.packages -i /tmp/mustache4dart.coverage.json
copied to clipboard
Contributing #
If you found a bug, just create a new issue or even better fork
and issue a pull request with you fix.
Versioning #
The library will follow a semantic versioning