Note: This project is in early development, and versioning is a little different. Read this for more details.
There are two other libraries that already attempt to provide a common compiler interface: consolidate.js and JSTransformers. After reviewing & using both of them, we designed accord to provide a more maintainable code base and way of writing adapters.
npm install accord
Since some templating engines are async and others are not, accord keeps things consistent by returning a promise for any task (using when.js). Here's an example in CoffeeScript:
fs = require 'fs'accord = require 'accord'jade = accordload'jade'# render a stringjaderender'body\n .test'doneconsolelogbindconsole# or a filejaderenderFile'./example.jade'doneconsolelogbindconsole# or compile a string to a function# (only some to-html compilers support this, see below)jadecompile'body\n .test'doneconsolelogbindconsole# or a filejadecompileFile'./example.jade'doneconsolelogbindconsole# compile a client-side js templatejadecompileClient'body\n .test'done consolelogresresulttoString# or a filejadecompileFileClient'./example.jade'done consolelogresresulttoString
It's also important to note that accord returns an object rather than a string from each of these methods. You can access the compiled result on the
result property of this object. If the adapter supports source maps, the source map will also be on this object if you have passed in the correct options. Docs below should explain the methods executed in the example above.
accord.load(string, object) - loads the compiler named in the first param, npm package with the name must be installed locally, or the optional second param must be the compiler you are after. The second param allows you to load the compiler from elsewhere or load an alternate version if you want, but be careful.
accord.supports(string) - quick test to see if accord supports a certain compiler. accepts a string, which is the name of language (like markdown) or a compiler (like marked), returns a boolean.
adapter.render(string, options)- render a string to a compiled string
adapter.renderFile(path, options)- render a file to a compiled string
adapter.compile(string, options)- compile a string to a function
adapter.compileFile(path, options)- compile a file to a function
adapter.compileClient(string, options)- compile a string to a client-side-ready function
adapter.compileFileClient(string, options)- compile a file to a client-side-ready function
adapter.extensions- array of all file extensions the compiler should match
adapter.output- string, expected output extension
adapter.engine- the actual compiler, no adapter wrapper, if you need it
As of version
0.20.0, accord ships with a system that can be used to offer full support for any engine across any version, so that the interface remains consistent even in the face of breaking changes to the adapter's API. With this feature in place, you can freely upgrade accord without worrying about any breakage in any libraries you are using, ever.
So for example, if you are using sass and they release a breaking version bump, we will release a new adapter for the new version and cut a new release of accord that includes support for this version. However, if you are still using the old version, it will still work as before so you have as much time as you need to upgrade to the new version.
This does not mean that we immediately support every version of every library infinitely into the past. However, going forward, we will support any new updates to libraries from now on to ensure that nothing breaks for users.
This is a feature that is unique to accord and we are beyond excited to make it available to everyone.
We are always looking to add compile support for more languages, but it can be difficult, as client-side template support isn't always the first thing on language authors' minds. Any contributions that help to expand this list are greatly appreciated!
When using a language supporting client-side templates, make sure to check the docs for that language for more details. In general, you'll get back a stringified function from the
compileFileClient methods, and a string of client helpers from the
clientHelpers methods. You can take these, organize them, and write them to files however you wish. Usually the best way is to write the helpers to a file first, then iterate through each of the client-compiled functions, assigning them a name so they can be accessed later on.
Want to add more languages? We have put extra effort into making the adapter pattern structure understandable and easy to add to and test. Rather than requesting that a language be added, please add a pull request and add it yourself! We are quite responsive and will quickly accept if the implementation is well-tested.
Details on running tests and contributing can be found here
Accord now supports source map generation for any language that also supports source maps. At the moment, this includes the following languages:
sourcemap key. If there are multiple sourcemaps generated, alternate ones will be avaiable under different keys, which you can find on the object returned from accord after a compile.
To generate a sourcemap, you can pass
sourcemap: true as an option to any compiler and you will get back a sourcemap with the file names, sources, and mappings correctly specified, guaranteed. Each compiler also has it's own way of specifying source map options. If you'd like to dive into those details to customize the output, you are welcome to do so, but it is at your own risk.
If there is a language that now supports sourcemaps and you'd like support for them to be added, get a pull request going and we'll make it happen!
Licensed under MIT