Fixtures for tests are now in tests/fixtures/json

The basic*.lol files have been consolidated into simple_values.lol.
The examples use more tangible strings, like "Firefox" and "Aurora".
Add tests for nested arrays and hashes
split nested_values.js into nested arrays and nested hashes
Add stub macro tests: fib and fac
clean up the code, make it look better when using folds
remove Entity.prototype.getEntity
Clean up the defualts resolution

Abstract the default resolution logic into private _resolve and _yield
funcitons available to the expressions.

_resolve will always try to return a string or a number.  It's meant to
be used with indexes, propertyExpressions and attributeExpressions (the
right hand side), binaryExpressions and complexStrings.

_yield, given an expressions `expr`, returns an expression
corresponding to its first-level value.  It's meant to be used with
indentifiers and hashLiterals in propertyExpressions.
Merge branch 'master' of github.com:l20n/l20n.js into compiler
ComplexString's dirty should not be shared by all complexStrings

When dirty was defined as a variable in the ComplexString scope, it was
avilable and effectively shared by all complexStrings.  This change
moves into the return function so that it's only available to one
complexString, and moves all the expression logic into a closure so
that dirty's state persists across mutlitple calls to the same
complexString.
Simplify Compiler's API used by the Context

Context passes the AST, the entries and the globals to the compiler,
which compiles the AST into the entries object.

Calls to individual entities and attributes take only one argument:
data, which is the context data provided by the developer (per-context
and per-call).

2 tests in the attributes.js testcase are still failing.
Call parent expressions in member expressions in a nicer way

Call the parent expressions in member expressions in a clearer way.
Remove _yield, as it was used only in ProertyExpression.
Resolve the argument(s) of conditional, logical, binary and unary expressions
all expressions return a tuple (newLocals, evaluated_expr)
Remove _step

The _step function was called every time there was a need to convert
an expression's [locals, memberExpr]-typed return value into a
{locals: locals, self: memberExpr}-typed one.

Removed _step in favor of a destructing assignment-like syntax.  The
actual destructing assignment (with its benefits) is part of JS1.8
which is a superset of features over ES5.  V8 only supports ES5, so
it's not possible to do `var [locales, memberExpr] = expr(...)` and be
cross-engine compatible at the same time.
Change how variables are stored in locals (+tests)

Macro arguments are no longer resolved in the callExpression.  This
made it impossible to pass an entity or a hash to a macro, and resulted
in weird behavior when passing a macro.

Instead, argument expressions are now simply called once, so that the
actual arguments passed to the macro are objects, not expressions, and
they have their own locals stored in the macro's locals, too.

For instance, in a callExpression like this one:

  plural(7)

'7' is a stringLiteral expression, and calling it returns 7, which is
then passed to the macro expression.

Similarly, for a macro call like so:

  getDefaultValue(brandName)

'brandName' is an indentifier expression, and calling it return the
entity object called 'brandName.'

Note that we must call the expression before passing it to the macro
expression.  Otherwise, we would be passing expression functions around
(e.g., propertyExpressions) instead of actual objects that they
evaluate to, and then we'd call these expression functions with wrong
locals.
Add more tests

Add 'mixed' testcases using various features of L20n at once.  They are
suppose to mimic real-life applications of the language.
use strict
Don't use `new` for contructing expressions

Expression contructors return functions anyways, and the `new` operator
loses its purpose.  It still creates an object that it wants to return
from the constructor, however.

Not using `new` results in ~20% speed boost.  Faster code for free?
Yes, please.
Correctly set the value of `this` for the module
Default key for arrays is always 0