├── server
    ├── __init__.py
    ├── test_settings.py
    ├── templates
    │   ├── include
    │   │   ├── jquery.html
    │   │   ├── ember.html
    │   │   ├── csrf.html
    │   │   └── head.html
    │   └── application.html
    ├── wsgi.py
    ├── urls.py
    └── settings.py
├── users
    ├── __init__.py
    ├── views.py
    ├── serializers.py
    ├── fixtures
    │   └── initial_data.json
    └── tests.py
├── session
    ├── __init__.py
    ├── views.py
    └── tests.py
├── circle.yml
├── assets
    ├── js
    │   ├── templates
    │   │   ├── application.handlebars
    │   │   └── session.handlebars
    │   └── app.js
    ├── tests
    │   ├── integration_test_helper.js
    │   └── integration_tests.js
    └── vendor
    │   ├── adapter.js
    │   ├── jquery.mockjax.js
    │   └── handlebars.js
├── package.json
├── requirements.txt
├── .gitignore
├── manage.py
├── Makefile
├── karma.conf.js
└── README.md


/server/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/users/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/session/__init__.py:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/server/test_settings.py:
--------------------------------------------------------------------------------
1 | from server.settings import *
2 | 
3 | 
4 | DATABASES['default']['NAME'] = ':memory:'
5 | 


--------------------------------------------------------------------------------
/circle.yml:
--------------------------------------------------------------------------------
1 | dependencies:
2 |   override:
3 |     - make develop
4 | 
5 | test:
6 |   override:
7 |     - make test
8 | 


--------------------------------------------------------------------------------
/server/templates/include/jquery.html:
--------------------------------------------------------------------------------
1 | {% load static %}
2 | 
3 | <script src="{% static 'vendor/jquery.js' %}"></script>


--------------------------------------------------------------------------------
/assets/js/templates/application.handlebars:
--------------------------------------------------------------------------------
1 | <div class="container">
2 |     <h1>Django/Ember Authentication</h1>
3 |     {{render 'session'}}
4 |     {{outlet}}
5 | </div>


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 |   "dependencies": {
3 |     "django-ember-precompile": "1.0.9",
4 |     "karma-ember-preprocessor": "*",
5 |     "karma-qunit": "*",
6 |     "karma": "0.10.2"
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | -e git+https://github.com/django/django.git@1.6b4#egg=django
2 | djangorestframework==2.3.8
3 | -e git+https://github.com/jezdez/django_compressor.git@9cf68a04e473b0bccf7e#egg=django_compressor
4 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.db
 2 | *.swp
 3 | *.pyc
 4 | *.pyo
 5 | *.tar
 6 | *.tgz
 7 | *.tar.gz
 8 | *.bak
 9 | *.log
10 | .DS_Store
11 | .coverage
12 | env
13 | venv
14 | /media/
15 | /static/
16 | /node_modules/
17 | *.sqlite3
18 | /vendor/
19 | 


--------------------------------------------------------------------------------
/users/views.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth.models import User
 2 | from rest_framework import viewsets
 3 | 
 4 | from users import serializers
 5 | 
 6 | 
 7 | class UserViewSet(viewsets.ModelViewSet):
 8 |     model = User
 9 |     serializer_class = serializers.UserSerializer
10 | 


--------------------------------------------------------------------------------
/users/serializers.py:
--------------------------------------------------------------------------------
1 | from django.contrib.auth.models import User
2 | from rest_framework import serializers
3 | 
4 | 
5 | class UserSerializer(serializers.ModelSerializer):
6 |     class Meta:
7 |         model = User
8 |         fields = ('id', 'username', 'first_name', 'last_name')
9 | 


--------------------------------------------------------------------------------
/manage.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | import os
 3 | import sys
 4 | 
 5 | if __name__ == "__main__":
 6 |     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "server.settings")
 7 | 
 8 |     from django.core.management import execute_from_command_line
 9 | 
10 |     execute_from_command_line(sys.argv)
11 | 


--------------------------------------------------------------------------------
/server/templates/include/ember.html:
--------------------------------------------------------------------------------
1 | {% load static %}
2 | 
3 | <script src="{% static 'vendor/handlebars.js' %}"></script>
4 | <script src="{% static 'vendor/ember.js' %}"></script>
5 | <script src="{% static 'vendor/ember-data.js' %}"></script>
6 | <script src="{% static 'vendor/adapter.js' %}"></script>
7 | 


--------------------------------------------------------------------------------
/server/templates/include/csrf.html:
--------------------------------------------------------------------------------
1 | <script>
2 |   jQuery(document).ajaxSend(function(event, xhr, settings) {
3 |     if (!(/^http:.*/.test(settings.url) || /^https:.*/.test(settings.url))) {
4 |       var token = $('meta[name="csrf-token"]').attr('content');
5 |       xhr.setRequestHeader("X-CSRFToken", token);
6 |     }
7 |   });
8 | </script>


--------------------------------------------------------------------------------
/users/fixtures/initial_data.json:
--------------------------------------------------------------------------------
 1 | [
 2 | {
 3 |     "pk": 1,
 4 |     "model": "auth.user",
 5 |     "fields": {
 6 |         "username": "dustin",
 7 |         "first_name": "Dustin",
 8 |         "last_name": "Farris",
 9 |         "is_active": true,
10 |         "password": "pbkdf2_sha256$10000$FxH0AVklG2MS$dmRkwyW/mFunUykRypX/X7K8k5CF8zSxrdxXPlwXqfQ="
11 |     }
12 | }
13 | ]
14 | 


--------------------------------------------------------------------------------
/server/wsgi.py:
--------------------------------------------------------------------------------
 1 | """
 2 | WSGI config for server project.
 3 | 
 4 | It exposes the WSGI callable as a module-level variable named ``application``.
 5 | 
 6 | For more information on this file, see
 7 | https://docs.djangoproject.com/en/dev/howto/deployment/wsgi/
 8 | """
 9 | 
10 | import os
11 | os.environ.setdefault("DJANGO_SETTINGS_MODULE", "server.settings")
12 | 
13 | from django.core.wsgi import get_wsgi_application
14 | application = get_wsgi_application()
15 | 


--------------------------------------------------------------------------------
/assets/tests/integration_test_helper.js:
--------------------------------------------------------------------------------
 1 | document.write('<div id="ember-testing-container"><div id="ember-testing"></div></div>');
 2 | 
 3 | App.rootElement = '#ember-testing';
 4 | App.setupForTesting();
 5 | App.injectTestHelpers();
 6 | 
 7 | function exists(selector) {
 8 |     return !!find(selector).length;
 9 | }
10 | 
11 | function httpStub(url, json) {
12 |     $.mockjax({
13 |         url: url,
14 |         dataType: 'json',
15 |         responseText: json
16 |     });
17 | }
18 | 
19 | $.mockjaxSettings.logging = false;
20 | $.mockjaxSettings.responseTime = 0;


--------------------------------------------------------------------------------
/server/urls.py:
--------------------------------------------------------------------------------
 1 | from django.conf.urls import include, patterns, url
 2 | from django.views.generic import TemplateView
 3 | from rest_framework.routers import DefaultRouter
 4 | 
 5 | from session.views import SessionView
 6 | from users.views import UserViewSet
 7 | 
 8 | 
 9 | router = DefaultRouter()
10 | router.register(r'users', UserViewSet)
11 | 
12 | 
13 | urlpatterns = patterns(
14 |     '',
15 | 
16 |     # Authentication
17 |     url(r'^session/$', SessionView.as_view()),
18 | 
19 |     # API
20 |     url(r'api/', include(router.urls)),
21 | 
22 |     # Application
23 |     url(r'^$', TemplateView.as_view(template_name='application.html'))
24 | )
25 | 


--------------------------------------------------------------------------------
/assets/js/templates/session.handlebars:
--------------------------------------------------------------------------------
 1 | {{#if isAuthenticated}}
 2 |   <p class="welcome">Welcome back, {{first_name}}!</p>
 3 |   <button class="btn" {{action 'logout'}}>Logout</button>
 4 | {{else}}
 5 |   <form class="form-inline" {{action login on="submit"}}>
 6 |     <div class="form-group">
 7 |       {{input class="username" value=username type="text" placeholder="Username"}}
 8 |     </div>
 9 |     <div class="form-group">
10 |       {{input class="password" value=password type="password" placeholder="Password"}}
11 |     </div>
12 |     {{input class="submit btn" type="submit" value="Login"}}
13 |   </form>
14 |   {{#if errorMessage}}<span class="text-danger">{{errorMessage}}</span>{{/if}}
15 | {{/if}}


--------------------------------------------------------------------------------
/server/templates/application.html:
--------------------------------------------------------------------------------
 1 | {% load compress static %}
 2 | 
 3 | {% include "head.html" %}
 4 | 
 5 | <body>
 6 | 
 7 |   <div id="ember"></div>
 8 | 
 9 | 
10 |   {# Vendor javascripts #}
11 |   {% include "jquery.html" %}
12 |   {% include "csrf.html" %}
13 |   {% include "ember.html" %}
14 | 
15 |   {# Application #}
16 |   <script src="{% static 'js/app.js' %}"></script>
17 | 
18 |   {# Handlebars templates #}
19 |   {% compress js %}
20 |     <script type="text/x-handlebars" src="{% static 'js/templates/application.handlebars' %}"></script>
21 |     <script id="session" type="text/x-handlebars" src="{% static 'js/templates/session.handlebars' %}"></script>
22 |   {% endcompress js %}
23 | </body>
24 | </html>


--------------------------------------------------------------------------------
/server/templates/include/head.html:
--------------------------------------------------------------------------------
 1 | {% load static compress %}
 2 | <!DOCTYPE html>
 3 | <!--[if lt IE 7]>      <html class="no-js lt-ie9 lt-ie8 lt-ie7"> <![endif]-->
 4 | <!--[if IE 7]>         <html class="no-js lt-ie9 lt-ie8"> <![endif]-->
 5 | <!--[if IE 8]>         <html class="no-js lt-ie9"> <![endif]-->
 6 | <!--[if gt IE 8]><!--> <html class="no-js"> <!--<![endif]-->
 7 | <head>
 8 |   <meta charset="utf-8">
 9 |   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
10 |   <title>{% block title %}Django/Ember Authentication{% endblock title %}</title>
11 |   <meta name="csrf-token" content="{{ csrf_token }}">
12 |   <link rel="stylesheet" href="//netdna.bootstrapcdn.com/bootstrap/3.0.0/css/bootstrap.min.css">
13 | </head>


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | test: lint test-python test-js
 2 | 
 3 | lint:
 4 | 	@echo "Linting Python files"
 5 | 	flake8 --ignore=E121,W404,F403,E501 --exclude=./docs/*,./env/*,./venv/*,migrations,.git,./tests/functional/features,./tests/functional/steps . || exit 1
 6 | 	@echo ""
 7 | 
 8 | test-python:
 9 | 	@echo "Running Python tests"
10 | 	python manage.py test --settings=server.test_settings || exit 1
11 | 	@echo ""
12 | 
13 | test-js:
14 | 	@echo "Running QUnit Javascript tests"
15 | 	node_modules/.bin/karma start --reporters=dots || exit 1
16 | 	@echo ""
17 | 
18 | develop:
19 | 	npm install
20 | 	pip install --upgrade setuptools
21 | 	pip install --upgrade "flake8>=2.0"
22 | 	pip install --upgrade -r requirements.txt
23 | 	python manage.py syncdb --noinput
24 | 
25 | run:
26 | 	python manage.py runserver 0.0.0.0:8000
27 | 


--------------------------------------------------------------------------------
/karma.conf.js:
--------------------------------------------------------------------------------
 1 | module.exports = function(karma) {
 2 |     karma.set({
 3 |         basePath: 'assets',
 4 | 
 5 |         files: [
 6 |           "vendor/jquery.js",
 7 |           "vendor/handlebars.js",
 8 |           "vendor/ember.js",
 9 |           "vendor/ember-data.js",
10 |           "vendor/adapter.js",
11 |           "vendor/jquery.mockjax.js",
12 |           "js/app.js",
13 |           "tests/*.js",
14 |           "js/templates/*.handlebars"
15 |         ],
16 | 
17 |         logLevel: karma.LOG_ERROR,
18 |         browsers: ['PhantomJS'],
19 |         singleRun: true,
20 |         autoWatch: false,
21 | 
22 |         frameworks: ["qunit"],
23 | 
24 |         plugins: [
25 |             'karma-qunit',
26 |             'karma-chrome-launcher',
27 |             'karma-ember-preprocessor',
28 |             'karma-phantomjs-launcher'
29 |         ],
30 | 
31 |         preprocessors: {
32 |             "**/*.handlebars": 'ember'
33 |         }
34 |     });
35 | };
36 | 


--------------------------------------------------------------------------------
/assets/tests/integration_tests.js:
--------------------------------------------------------------------------------
 1 | module('integration tests', {
 2 |     setup: function() {
 3 |         Ember.run(function() {
 4 |             App.reset();
 5 |         });
 6 |     },
 7 |     teardown: function() {
 8 |         $.mockjaxClear();
 9 |     }
10 | });
11 | 
12 | test("user gives bad credentials and receives error message", function() {
13 |     var login_response = {success: false, message: "bad user!", user_id: null}
14 |     httpStub('/session/', login_response);
15 | 
16 |     visit("/").then(function() {
17 |         fillIn(".username", "dustin");
18 |         fillIn(".password", "wrong");
19 |         return click(".submit");
20 |     }).then(function() {
21 |         equal(find(".text-danger").text(), "bad user!", "error message was not detected")
22 |     })
23 | });
24 | 
25 | test("user logs in and receives welcome message", function() {
26 |     var dustin = {id: 1, username: "dustin", first_name: "Dustin", last_name: "Farris"}
27 |     var login_response = {success: true, user_id: 1}
28 |     httpStub('/session/', login_response);
29 |     httpStub('/api/users/1/', dustin);
30 | 
31 |     visit("/").then(function() {
32 |         fillIn(".username", "dustin");
33 |         fillIn(".password", "right");
34 |         return click('.submit');
35 |     }).then(function() {
36 |         equal(find("p.welcome").text(), "Welcome back, Dustin!", "welcome message was not detected");
37 |     });
38 | });
39 | 


--------------------------------------------------------------------------------
/users/tests.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth.models import User
 2 | from django.core.urlresolvers import reverse
 3 | from rest_framework import status
 4 | from rest_framework.test import APITestCase
 5 | 
 6 | from users.serializers import UserSerializer
 7 | 
 8 | 
 9 | class CreateUserTest(APITestCase):
10 |     def setUp(self):
11 |         self.data = {'username': 'fred', 'first_name': 'Fred', 'last_name': 'Willums'}
12 | 
13 |     def test_can_create_user(self):
14 |         response = self.client.post(reverse('user-list'), self.data)
15 |         self.assertEqual(response.status_code, status.HTTP_201_CREATED)
16 | 
17 | 
18 | class ReadUserTest(APITestCase):
19 |     def setUp(self):
20 |         self.user = User.objects.create(username="jake")
21 | 
22 |     def test_can_read_user_list(self):
23 |         response = self.client.get(reverse('user-list'))
24 |         self.assertEqual(response.status_code, status.HTTP_200_OK)
25 | 
26 |     def test_can_read_user_detail(self):
27 |         response = self.client.get(reverse('user-detail', args=[self.user.id]))
28 |         self.assertEqual(response.status_code, status.HTTP_200_OK)
29 | 
30 | 
31 | class UpdateUserTest(APITestCase):
32 |     def setUp(self):
33 |         self.user = User.objects.create(username="jake", first_name="Jake")
34 |         self.data = UserSerializer(self.user).data
35 |         self.data.update({'first_name': 'Changed'})
36 | 
37 |     def test_can_update_user(self):
38 |         response = self.client.put(reverse('user-detail', args=[self.user.id]), self.data)
39 |         self.assertEqual(response.status_code, status.HTTP_200_OK)
40 | 
41 | 
42 | class DeleteUserTest(APITestCase):
43 |     def setUp(self):
44 |         self.user = User.objects.create(username="jake")
45 | 
46 |     def test_can_delete_user(self):
47 |         response = self.client.delete(reverse('user-detail', args=[self.user.id]))
48 |         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
49 | 


--------------------------------------------------------------------------------
/server/settings.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | BASE_DIR = os.path.dirname(os.path.dirname(__file__))
 3 | TEMPLATE_DIRS = (
 4 |     os.path.join(BASE_DIR, 'server', 'templates'),
 5 |     os.path.join(BASE_DIR, 'server', 'templates', 'include'),
 6 | )
 7 | STATICFILES_DIRS = (
 8 |     os.path.join(BASE_DIR, 'assets'),
 9 | )
10 | STATIC_ROOT = os.path.join(BASE_DIR, 'static')
11 | MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
12 | FIXTURE_DIRS = (
13 |     os.path.join(BASE_DIR, 'users', 'fixtures'),
14 | )
15 | 
16 | SECRET_KEY = 'v6)j@i0-she6pi-l*k2k395cu^*ic&8v1f0h=@q9p%pezu8607'
17 | DEBUG = True
18 | TEMPLATE_DEBUG = True
19 | ALLOWED_HOSTS = []
20 | 
21 | 
22 | # Application definition
23 | 
24 | INSTALLED_APPS = (
25 |     'django.contrib.auth',
26 |     'django.contrib.contenttypes',
27 |     'django.contrib.sessions',
28 |     'django.contrib.staticfiles',
29 |     'compressor',
30 | )
31 | 
32 | MIDDLEWARE_CLASSES = (
33 |     'django.contrib.sessions.middleware.SessionMiddleware',
34 |     'django.middleware.common.CommonMiddleware',
35 |     'django.middleware.csrf.CsrfViewMiddleware',
36 |     'django.contrib.auth.middleware.AuthenticationMiddleware',
37 |     'django.middleware.clickjacking.XFrameOptionsMiddleware',
38 | )
39 | 
40 | ROOT_URLCONF = 'server.urls'
41 | 
42 | WSGI_APPLICATION = 'server.wsgi.application'
43 | 
44 | 
45 | # Database
46 | 
47 | DATABASES = {
48 |     'default': {
49 |         'ENGINE': 'django.db.backends.sqlite3',
50 |         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
51 |     }
52 | }
53 | 
54 | 
55 | # Compressor
56 | 
57 | NODE_ROOT = os.path.join(BASE_DIR, 'node_modules')
58 | HANDLEBARS_PATH = os.path.join(NODE_ROOT, 'django-ember-precompile', 'bin', 'django-ember-precompile')
59 | COMPRESS_PRECOMPILERS = (
60 |     ('text/x-handlebars', '{} {{infile}}'.format(HANDLEBARS_PATH)),
61 | )
62 | 
63 | 
64 | # Static files (CSS, JavaScript, Images)
65 | 
66 | STATIC_URL = '/static/'
67 | STATICFILES_FINDERS = (
68 |     'django.contrib.staticfiles.finders.FileSystemFinder',
69 |     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
70 |     'compressor.finders.CompressorFinder',
71 | )
72 | 


--------------------------------------------------------------------------------
/session/views.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth import authenticate, login, logout
 2 | from rest_framework import status
 3 | from rest_framework.views import APIView
 4 | from rest_framework.response import Response
 5 | 
 6 | 
 7 | class SessionView(APIView):
 8 |     """
 9 |     View to retrieve the current session if one exists, create a new
10 |     session using a valid username and password, or destroy the session.
11 |     """
12 |     error_messages = {
13 |         'invalid': "Invalid username or password",
14 |         'disabled': "Sorry, this account is suspended"
15 |     }
16 | 
17 |     def _error_response(self, message_key):
18 |         """
19 |         Return an error message.
20 |         """
21 |         data = {
22 |             'success': False,
23 |             'message': self.error_messages[message_key],
24 |             'user_id': None,
25 |         }
26 |         return Response(data)
27 | 
28 |     def get(self, request, *args, **kwargs):
29 |         """
30 |         Return the user id associated with this session if one exists.
31 |         """
32 |         if request.user.is_authenticated():
33 |             return Response({'user_id': request.user.id})
34 |         return Response({'user_id': None})
35 | 
36 |     def post(self, request, *args, **kwargs):
37 |         """
38 |         Authenticate a user with a username and password.  Return
39 |         appropriate success flag, error messages, and user id.
40 |         """
41 |         username = request.POST.get('username')
42 |         password = request.POST.get('password')
43 |         user = authenticate(username=username, password=password)
44 |         if user is not None:
45 |             if user.is_active:
46 |                 login(request, user)
47 |                 data = {'success': True, 'user_id': user.id}
48 |                 return Response(data)
49 |             return self._error_response('disabled')
50 |         return self._error_response('invalid')
51 | 
52 |     def delete(self, request, *args, **kwargs):
53 |         """
54 |         Destroy the active session, effectively logging out the
55 |         current user.
56 |         """
57 |         logout(request)
58 |         return Response(status=status.HTTP_204_NO_CONTENT)
59 | 


--------------------------------------------------------------------------------
/assets/js/app.js:
--------------------------------------------------------------------------------
 1 | App = Ember.Application.create();
 2 | 
 3 | 
 4 | // == Controllers ==
 5 | 
 6 | App.SessionController = Ember.ObjectController.extend({
 7 |     username: null,
 8 |     password: null,
 9 |     errorMessage: null,
10 | 
11 |     reset: function() {
12 |         this.setProperties({
13 |             username: null,
14 |             password: null,
15 |             errorMessage: null,
16 |             model: null
17 |         });
18 |     },
19 | 
20 |     isAuthenticated: function() {
21 |         return (!Ember.isEmpty(this.get('model')));
22 |     }.property('model'),
23 | 
24 |     setCurrentUser: function(user_id) {
25 |         if (!Ember.isEmpty(user_id)) {
26 |             var currentUser = this.store.find('user', user_id);
27 |             this.set('model', currentUser);
28 |         }
29 |     },
30 | 
31 |     actions: {
32 |         login: function() {
33 |             var self = this, data = this.getProperties('username', 'password');
34 |             $.post('/session/', data, null, 'json').then(function (response) {
35 |                 Ember.run(function() {
36 |                     self.set('errorMessage', response.message);
37 |                     self.setCurrentUser(response.user_id);
38 |                 });
39 |             });
40 |         },
41 |         logout: function() {
42 |             $.ajax({url: '/session/', type: 'delete'});
43 |             this.reset();
44 |             this.transitionToRoute('index');
45 |         }
46 |     }
47 | });
48 | 
49 | 
50 | // == Models ==
51 | 
52 | var attr = DS.attr;
53 | 
54 | App.User = DS.Model.extend({
55 |     username: attr(),
56 |     first_name: attr(),
57 |     last_name: attr(),
58 | });
59 | 
60 | 
61 | // == Routes ==
62 | 
63 | App.Router.map(function() {
64 |     this.resource("session");
65 | });
66 | 
67 | App.ApplicationRoute = Ember.Route.extend({
68 |     setupController: function(controller, model) {
69 |         var self = this;
70 |         Ember.$.getJSON('/session/').then(function(response) {
71 |             self.controllerFor('session').reset()
72 |             self.controllerFor('session').setCurrentUser(response.user_id);
73 |         });
74 |     }
75 | });
76 | 
77 | 
78 | // == Adapter/Store ==
79 | 
80 | App.ApplicationAdapter = DS.DjangoRESTAdapter.extend({
81 |     namespace: 'api'
82 | });
83 | 


--------------------------------------------------------------------------------
/session/tests.py:
--------------------------------------------------------------------------------
 1 | from django.contrib.auth.models import User
 2 | from rest_framework import status
 3 | from rest_framework.test import APITestCase
 4 | 
 5 | 
 6 | class SessionViewTest(APITestCase):
 7 |     def setUp(self):
 8 |         self.user = User.objects.create(
 9 |             username="bob",
10 |             first_name="Bob",
11 |             last_name="Barker")
12 |         self.user.set_password("correct")
13 |         self.user.save()
14 | 
15 |     def tearDown(self):
16 |         self.user.delete()
17 | 
18 |     def test_get_session_with_active_session(self):
19 |         """
20 |         Should return a hash containing the current user's id.
21 |         """
22 |         self.client.force_authenticate(user=self.user)
23 |         response = self.client.get('/session/')
24 |         expected = {'user_id': self.user.id}
25 |         self.assertEqual(response.data, expected)
26 | 
27 |     def test_get_session_with_no_active_session(self):
28 |         """
29 |         Should return a hash with `user_id` set to None.
30 |         """
31 |         response = self.client.get('/session/')
32 |         expected = {'user_id': None}
33 |         self.assertEqual(response.data, expected)
34 | 
35 |     def test_create_session_with_valid_credentials(self):
36 |         """
37 |         Should log the user in and return a JSON object with a success
38 |         flag and the user's id.
39 |         """
40 |         data = {'username': 'bob', 'password': 'correct'}
41 |         response = self.client.post('/session/', data)
42 |         expected = {'success': True, 'user_id': self.user.id}
43 |         self.assertEqual(response.data, expected)
44 |         self.assertEqual(self.client.session['_auth_user_id'], self.user.id)
45 | 
46 |     def test_create_session_with_invalid_credentials(self):
47 |         """
48 |         Should not log the user in and return a JSON object with a
49 |         failing success flag and error message.
50 |         """
51 |         data = {'username': 'bob', 'password': 'wrong'}
52 |         response = self.client.post('/session/', data)
53 |         expected = {'success': False, 'user_id': None, 'message': 'Invalid username or password'}
54 |         self.assertEqual(response.data, expected)
55 |         self.assertNotIn('_auth_user_id', self.client.session)
56 | 
57 |     def test_create_session_when_user_is_not_active(self):
58 |         """
59 |         Should not log the user in and return a JSON object with a
60 |         failing success flag and error message.
61 |         """
62 |         self.user.is_active = False
63 |         self.user.save()
64 |         data = {'username': 'bob', 'password': 'correct'}
65 |         response = self.client.post('/session/', data)
66 |         expected = {'success': False, 'user_id': None, 'message': 'Sorry, this account is suspended'}
67 |         self.assertEqual(response.data, expected)
68 |         self.assertNotIn('_auth_user_id', self.client.session)
69 | 
70 |     def test_destroy_session(self):
71 |         """
72 |         Should log the user out and return an empty response.
73 |         """
74 |         self.client.force_authenticate(user=self.user)
75 |         response = self.client.delete('/session/')
76 |         self.assertEqual(response.status_code, status.HTTP_204_NO_CONTENT)
77 |         self.assertNotIn('_auth_user_id', self.client.session)
78 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Django/Ember Authenticate
 2 | 
 3 | ![CircleCI build status](https://circleci.com/gh/dustinfarris/django-ember-authentication.png)
 4 | 
 5 | A simple how-to-do-it app that demonstrates one way to perform session-based authentication
 6 | in [Ember](http://emberjs.com) using [Django](http://djangoproject.com/) as a backend.  This 
 7 | application uses the latest builds of:
 8 | 
 9 | *  [Django][]
10 | *  [Ember][]
11 | *  [Ember Data][]
12 | *  [Ember Data Django REST Adapter][]
13 | 
14 | 
15 | You should have [virtualenvwrapper][] installed.
16 | 
17 | ### Installation
18 | 
19 | ```console
20 | git clone git@github.com:dustinfarris/django-ember-authentication.git
21 | mkvirtualenv django-ember-authentication
22 | cd django-ember-authentication
23 | make develop
24 | ```
25 | 
26 | ### Run the tests
27 | 
28 | ```console
29 | make
30 | ```
31 | 
32 | ### Fire up a temp server
33 | 
34 | ```console
35 | make run
36 | ```
37 | 
38 | Navigate to http://localhost:8000 and log in with username **dustin** and password **correct**.
39 | 
40 | ## Summary
41 | 
42 | Authentication is probably one of the biggest initial hurdles when putting Ember to practical use. At
43 | least that has been my experience. Fortunately, with the right architecture, authenticating can be
44 | implemented with minimal code, and pain-free.
45 | 
46 | I chose session-based authentication because it is built into Django and it relieves me of having to
47 | hack together token variables and remembering to include them on all my headers etc..  Most of the
48 | token-based solutions I've seen to date have not been pretty. Django's session backend does the 
49 | majority of the work for you, really your only responsibility is the check the username and password
50 | (which Django has helpers for as well).
51 | 
52 | ### Session
53 | 
54 | A challenge I encountered every way I tried this was preserving the "current user" after successful 
55 | authentication.  Since the current user is really just a manifestation of the current session, I
56 | decided to call the resource "session" which, in my Ember implementation, has user properties. If
57 | this sounds confusing it will make sense when you look at the code.
58 | 
59 | The session is its own resource, with its own route mapping and controller.  On the server side,
60 | Django responds to three HTTP methods at the /session/ endpoint: GET, POST, and DELETE. GET gets the
61 | current session (if there is one), POST checks username/password credentials and then creates a
62 | session. DELETE logs the user out. Using regular HTTP methods this way makes it easy to integrate
63 | with both Ember and Django REST Framework.
64 | 
65 | When Ember successfully authenticates, it queries the appropriate user and sets the session model to
66 | be that user.  The user's properties then become instantly available to the session template,
67 | and to anything else with access to the SessionController.
68 | 
69 | ## Acknowledgements
70 | 
71 | Big thank you to the Ember team and [Tom Christie][] for Django REST Framework.  These two projects 
72 | have had a profound impact on modern web development and are very very exciting to work with.
73 | 
74 | Also thanks to [Toran Billups][] for creating Ember Data Django REST Adapter without which combining
75 | Django and Ember would not be possible—or at least not as straight-forward. Also his [screencast] on 
76 | integration testing Ember is an absolute must-watch.
77 | 
78 | 
79 | [Django]: https://github.com/django/django/releases/tag/1.6b4
80 | [Ember]: http://emberjs.com/builds/#/beta/latest
81 | [Ember Data]: http://emberjs.com/builds/#/canary/latest
82 | [Ember Data Django REST Adapter]: https://github.com/toranb/ember-data-django-rest-adapter/tree/ember1.0
83 | [virtualenvwrapper]: http://virtualenvwrapper.readthedocs.org/en/latest/
84 | [Tom Christie]: https://github.com/tomchristie
85 | [Toran Billups]: https://github.com/toranb
86 | [screencast]: http://www.toranbillups.com/blog/archive/2013/07/21/Integration-testing-your-emberjs-app-with-QUnit-and-Karma/
87 | 


--------------------------------------------------------------------------------
/assets/vendor/adapter.js:
--------------------------------------------------------------------------------
  1 | // Version: 0.13.1-13-gd5fad5d
  2 | // Last commit: d5fad5d (2013-09-15 20:29:23 -0500)
  3 | 
  4 | 
  5 | (function() {
  6 | var define, requireModule;
  7 | 
  8 | (function() {
  9 |   var registry = {}, seen = {};
 10 | 
 11 |   define = function(name, deps, callback) {
 12 |     registry[name] = { deps: deps, callback: callback };
 13 |   };
 14 | 
 15 |   requireModule = function(name) {
 16 |     if (seen[name]) { return seen[name]; }
 17 |     seen[name] = {};
 18 | 
 19 |     var mod, deps, callback, reified , exports;
 20 | 
 21 |     mod = registry[name];
 22 | 
 23 |     if (!mod) {
 24 |       throw new Error("Module '" + name + "' not found.");
 25 |     }
 26 | 
 27 |     deps = mod.deps;
 28 |     callback = mod.callback;
 29 |     reified = [];
 30 |     exports;
 31 | 
 32 |     for (var i=0, l=deps.length; i<l; i++) {
 33 |       if (deps[i] === 'exports') {
 34 |         reified.push(exports = {});
 35 |       } else {
 36 |         reified.push(requireModule(deps[i]));
 37 |       }
 38 |     }
 39 | 
 40 |     var value = callback.apply(this, reified);
 41 |     return seen[name] = exports || value;
 42 |   };
 43 | })();
 44 | (function() {
 45 | var get = Ember.get, set = Ember.set, isNone = Ember.isNone;
 46 | 
 47 | DS.DjangoRESTSerializer = DS.JSONSerializer.extend({
 48 | 
 49 |     init: function() {
 50 |         this._super.apply(this, arguments);
 51 |     },
 52 | 
 53 |     extractDjangoPayload: function(store, type, payload) {
 54 |         for (var item in payload) {
 55 |             if (typeof(payload[item][0]) !== 'number') {
 56 |                 if (payload[item].constructor.name === 'Array') {
 57 |                     var singular_type = Ember.String.singularize(item);
 58 |                     /*jshint loopfunc:true*/
 59 |                     var ids = payload[item].map(function(related) {
 60 |                         store.push(singular_type, related);
 61 |                         return related.id; //todo find pk (not always id)
 62 |                     });
 63 |                     payload[item] = ids;
 64 |                 }
 65 |             }
 66 |         }
 67 |     },
 68 | 
 69 |     extractSingle: function(store, type, payload) {
 70 |         this.extractDjangoPayload(store, type, payload);
 71 |         return payload;
 72 |     },
 73 | 
 74 |     extractArray: function(store, type, payload) {
 75 |         var self = this;
 76 |         for (var j = 0; j < payload.length; j++) {
 77 |             self.extractDjangoPayload(store, type, payload[j]);
 78 |         }
 79 |         return payload;
 80 |     }
 81 | 
 82 | });
 83 | 
 84 | })();
 85 | 
 86 | 
 87 | 
 88 | (function() {
 89 | var get = Ember.get, set = Ember.set, isNone = Ember.isNone;
 90 | 
 91 | DS.DjangoRESTAdapter = DS.RESTAdapter.extend({
 92 |     defaultSerializer: "DS/djangoREST",
 93 | 
 94 |     createRecord: function(store, type, record) {
 95 |         var url = this.getCorrectPostUrl(record, this.buildURL(type.typeKey));
 96 |         var data = store.serializerFor(type.typeKey).serialize(record);
 97 |         return this.ajax(url, "POST", { data: data });
 98 |     },
 99 | 
100 |     updateRecord: function(store, type, record) {
101 |         var data = store.serializerFor(type.typeKey).serialize(record);
102 |         var id = get(record, 'id'); //todo find pk (not always id)
103 |         return this.ajax(this.buildURL(type.typeKey, id), "PUT", { data: data });
104 |     },
105 | 
106 |     findMany: function(store, type, ids, parent) {
107 |         var adapter, root, url;
108 |         adapter = this;
109 | 
110 |         if (parent) {
111 |             url = this.buildFindManyUrlWithParent(type, parent);
112 |         } else {
113 |             Ember.assert("You need to add belongsTo for type (" + type.typeKey + "). No Parent for this record was found");
114 |         }
115 | 
116 |         return this.ajax(url, "GET");
117 |     },
118 | 
119 |     ajax: function(url, type, hash) {
120 |         hash = hash || {};
121 |         hash.cache = false;
122 | 
123 |         return this._super(url, type, hash);
124 |     },
125 | 
126 |     buildURL: function(type, id) {
127 |         var url = this._super(type, id);
128 | 
129 |         if (url.charAt(url.length -1) !== '/') {
130 |             url += '/';
131 |         }
132 | 
133 |         return url;
134 |     },
135 | 
136 |     getBelongsTo: function(record) {
137 |         var totalParents = [];
138 |         record.eachRelationship(function(name, relationship) {
139 |             if (relationship.kind === 'belongsTo') {
140 |                 totalParents.push(name);
141 |             }
142 |         }, this);
143 |         return totalParents;
144 |     },
145 | 
146 |     getNonEmptyRelationships: function(record, totalParents) {
147 |         var totalHydrated = [];
148 |         totalParents.forEach(function(item) {
149 |             if (record.get(item) !== null) {
150 |                 totalHydrated.push(item);
151 |             }
152 |         }, this);
153 |         return totalHydrated;
154 |     },
155 | 
156 |     getCorrectPostUrl: function(record, url) {
157 |         var totalParents = this.getBelongsTo(record);
158 |         var totalHydrated = this.getNonEmptyRelationships(record, totalParents);
159 |         if (totalParents.length > 1 && totalHydrated.length <= 1) {
160 |             return this.buildUrlWithParentWhenAvailable(record, url, totalHydrated);
161 |         }
162 | 
163 |         if (totalParents.length === 1 && totalHydrated.length === 1) {
164 |             var parent_value = record.get(totalParents[0]).get('id'); //todo find pk (not always id)
165 |             var parent_plural = Ember.String.pluralize(totalParents[0]);
166 |             var endpoint = url.split('/').reverse()[1];
167 |             return url.replace(endpoint, parent_plural + "/" + parent_value + "/" + endpoint);
168 |         }
169 | 
170 |         return url;
171 |     },
172 | 
173 |     buildUrlWithParentWhenAvailable: function(record, url, totalHydrated) {
174 |         if (record && url && totalHydrated) {
175 |             var parent_type = totalHydrated[0];
176 |             var parent_pk = record.get(parent_type).get('id'); //todo find pk (not always id)
177 |             var parent_plural = Ember.String.pluralize(parent_type);
178 |             var endpoint = url.split('/').reverse()[1];
179 |             url = url.replace(endpoint, parent_plural + "/" + parent_pk + "/" + endpoint);
180 |         }
181 |         return url;
182 |     },
183 | 
184 |     buildFindManyUrlWithParent: function(type, parent) {
185 |         var root, url, endpoint, parentValue;
186 | 
187 |         endpoint = Ember.String.pluralize(type.typeKey);
188 |         parentValue = parent.get('id'); //todo find pk (not always id)
189 |         root = parent.constructor.typeKey;
190 |         url = this.buildURL(root, parentValue);
191 | 
192 |         return url + endpoint + '/';
193 |     }
194 | 
195 | });
196 | 
197 | })();
198 | 
199 | 
200 | 
201 | (function() {
202 | 
203 | })();
204 | 
205 | 
206 | })();
207 | 


--------------------------------------------------------------------------------
/assets/vendor/jquery.mockjax.js:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * MockJax - jQuery Plugin to Mock Ajax requests
  3 |  *
  4 |  * Version:  1.5.2
  5 |  * Released:
  6 |  * Home:   http://github.com/appendto/jquery-mockjax
  7 |  * Author:   Jonathan Sharp (http://jdsharp.com)
  8 |  * License:  MIT,GPL
  9 |  *
 10 |  * Copyright (c) 2011 appendTo LLC.
 11 |  * Dual licensed under the MIT or GPL licenses.
 12 |  * http://appendto.com/open-source-licenses
 13 |  */
 14 | (function($) {
 15 | 	var _ajax = $.ajax,
 16 | 		mockHandlers = [],
 17 | 		mockedAjaxCalls = [],
 18 | 		CALLBACK_REGEX = /=\?(&|$)/,
 19 | 		jsc = (new Date()).getTime();
 20 | 
 21 | 
 22 | 	// Parse the given XML string.
 23 | 	function parseXML(xml) {
 24 | 		if ( window.DOMParser == undefined && window.ActiveXObject ) {
 25 | 			DOMParser = function() { };
 26 | 			DOMParser.prototype.parseFromString = function( xmlString ) {
 27 | 				var doc = new ActiveXObject('Microsoft.XMLDOM');
 28 | 				doc.async = 'false';
 29 | 				doc.loadXML( xmlString );
 30 | 				return doc;
 31 | 			};
 32 | 		}
 33 | 
 34 | 		try {
 35 | 			var xmlDoc = ( new DOMParser() ).parseFromString( xml, 'text/xml' );
 36 | 			if ( $.isXMLDoc( xmlDoc ) ) {
 37 | 				var err = $('parsererror', xmlDoc);
 38 | 				if ( err.length == 1 ) {
 39 | 					throw('Error: ' + $(xmlDoc).text() );
 40 | 				}
 41 | 			} else {
 42 | 				throw('Unable to parse XML');
 43 | 			}
 44 | 			return xmlDoc;
 45 | 		} catch( e ) {
 46 | 			var msg = ( e.name == undefined ? e : e.name + ': ' + e.message );
 47 | 			$(document).trigger('xmlParseError', [ msg ]);
 48 | 			return undefined;
 49 | 		}
 50 | 	}
 51 | 
 52 | 	// Trigger a jQuery event
 53 | 	function trigger(s, type, args) {
 54 | 		(s.context ? $(s.context) : $.event).trigger(type, args);
 55 | 	}
 56 | 
 57 | 	// Check if the data field on the mock handler and the request match. This
 58 | 	// can be used to restrict a mock handler to being used only when a certain
 59 | 	// set of data is passed to it.
 60 | 	function isMockDataEqual( mock, live ) {
 61 | 		var identical = true;
 62 | 		// Test for situations where the data is a querystring (not an object)
 63 | 		if (typeof live === 'string') {
 64 | 			// Querystring may be a regex
 65 | 			return $.isFunction( mock.test ) ? mock.test(live) : mock == live;
 66 | 		}
 67 | 		$.each(mock, function(k) {
 68 | 			if ( live[k] === undefined ) {
 69 | 				identical = false;
 70 | 				return identical;
 71 | 			} else {
 72 | 				if ( typeof live[k] == 'object' ) {
 73 | 					identical = identical && isMockDataEqual(mock[k], live[k]);
 74 | 				} else {
 75 | 					if ( $.isFunction( mock[k].test ) ) {
 76 | 						identical = identical && mock[k].test(live[k]);
 77 | 					} else {
 78 | 						identical = identical && ( mock[k] == live[k] );
 79 | 					}
 80 | 				}
 81 | 			}
 82 | 		});
 83 | 
 84 | 		return identical;
 85 | 	}
 86 | 
 87 | 	// Check the given handler should mock the given request
 88 | 	function getMockForRequest( handler, requestSettings ) {
 89 | 		// If the mock was registered with a function, let the function decide if we
 90 | 		// want to mock this request
 91 | 		if ( $.isFunction(handler) ) {
 92 | 			return handler( requestSettings );
 93 | 		}
 94 | 
 95 | 		// Inspect the URL of the request and check if the mock handler's url
 96 | 		// matches the url for this ajax request
 97 | 		if ( $.isFunction(handler.url.test) ) {
 98 | 			// The user provided a regex for the url, test it
 99 | 			if ( !handler.url.test( requestSettings.url ) ) {
100 | 				return null;
101 | 			}
102 | 		} else {
103 | 			// Look for a simple wildcard '*' or a direct URL match
104 | 			var star = handler.url.indexOf('*');
105 | 			if (handler.url !== requestSettings.url && star === -1 ||
106 | 					!new RegExp(handler.url.replace(/[-[\]{}()+?.,\\^$|#\s]/g, "\\$&").replace(/\*/g, '.+')).test(requestSettings.url)) {
107 | 				return null;
108 | 			}
109 | 		}
110 | 
111 | 		// Inspect the data submitted in the request (either POST body or GET query string)
112 | 		if ( handler.data && requestSettings.data ) {
113 | 			if ( !isMockDataEqual(handler.data, requestSettings.data) ) {
114 | 				// They're not identical, do not mock this request
115 | 				return null;
116 | 			}
117 | 		}
118 | 		// Inspect the request type
119 | 		if ( handler && handler.type &&
120 | 				handler.type.toLowerCase() != requestSettings.type.toLowerCase() ) {
121 | 			// The request type doesn't match (GET vs. POST)
122 | 			return null;
123 | 		}
124 | 
125 | 		return handler;
126 | 	}
127 | 
128 | 	// Process the xhr objects send operation
129 | 	function _xhrSend(mockHandler, requestSettings, origSettings) {
130 | 
131 | 		// This is a substitute for < 1.4 which lacks $.proxy
132 | 		var process = (function(that) {
133 | 			return function() {
134 | 				return (function() {
135 | 					var onReady;
136 | 
137 | 					// The request has returned
138 | 					this.status     = mockHandler.status;
139 | 					this.statusText = mockHandler.statusText;
140 | 					this.readyState	= 4;
141 | 
142 | 					// We have an executable function, call it to give
143 | 					// the mock handler a chance to update it's data
144 | 					if ( $.isFunction(mockHandler.response) ) {
145 | 						mockHandler.response(origSettings);
146 | 					}
147 | 					// Copy over our mock to our xhr object before passing control back to
148 | 					// jQuery's onreadystatechange callback
149 | 					if ( requestSettings.dataType == 'json' && ( typeof mockHandler.responseText == 'object' ) ) {
150 | 						this.responseText = JSON.stringify(mockHandler.responseText);
151 | 					} else if ( requestSettings.dataType == 'xml' ) {
152 | 						if ( typeof mockHandler.responseXML == 'string' ) {
153 | 							this.responseXML = parseXML(mockHandler.responseXML);
154 | 							//in jQuery 1.9.1+, responseXML is processed differently and relies on responseText
155 | 							this.responseText = mockHandler.responseXML;
156 | 						} else {
157 | 							this.responseXML = mockHandler.responseXML;
158 | 						}
159 | 					} else {
160 | 						this.responseText = mockHandler.responseText;
161 | 					}
162 | 					if( typeof mockHandler.status == 'number' || typeof mockHandler.status == 'string' ) {
163 | 						this.status = mockHandler.status;
164 | 					}
165 | 					if( typeof mockHandler.statusText === "string") {
166 | 						this.statusText = mockHandler.statusText;
167 | 					}
168 | 					// jQuery 2.0 renamed onreadystatechange to onload
169 | 					onReady = this.onreadystatechange || this.onload;
170 | 
171 | 					// jQuery < 1.4 doesn't have onreadystate change for xhr
172 | 					if ( $.isFunction( onReady ) ) {
173 | 						if( mockHandler.isTimeout) {
174 | 							this.status = -1;
175 | 						}
176 | 						onReady.call( this, mockHandler.isTimeout ? 'timeout' : undefined );
177 | 					} else if ( mockHandler.isTimeout ) {
178 | 						// Fix for 1.3.2 timeout to keep success from firing.
179 | 						this.status = -1;
180 | 					}
181 | 				}).apply(that);
182 | 			};
183 | 		})(this);
184 | 
185 | 		if ( mockHandler.proxy ) {
186 | 			// We're proxying this request and loading in an external file instead
187 | 			_ajax({
188 | 				global: false,
189 | 				url: mockHandler.proxy,
190 | 				type: mockHandler.proxyType,
191 | 				data: mockHandler.data,
192 | 				dataType: requestSettings.dataType === "script" ? "text/plain" : requestSettings.dataType,
193 | 				complete: function(xhr) {
194 | 					mockHandler.responseXML = xhr.responseXML;
195 | 					mockHandler.responseText = xhr.responseText;
196 | 					mockHandler.status = xhr.status;
197 | 					mockHandler.statusText = xhr.statusText;
198 | 					this.responseTimer = setTimeout(process, mockHandler.responseTime || 0);
199 | 				}
200 | 			});
201 | 		} else {
202 | 			// type == 'POST' || 'GET' || 'DELETE'
203 | 			if ( requestSettings.async === false ) {
204 | 				// TODO: Blocking delay
205 | 				process();
206 | 			} else {
207 | 				this.responseTimer = setTimeout(process, mockHandler.responseTime || 50);
208 | 			}
209 | 		}
210 | 	}
211 | 
212 | 	// Construct a mocked XHR Object
213 | 	function xhr(mockHandler, requestSettings, origSettings, origHandler) {
214 | 		// Extend with our default mockjax settings
215 | 		mockHandler = $.extend(true, {}, $.mockjaxSettings, mockHandler);
216 | 
217 | 		if (typeof mockHandler.headers === 'undefined') {
218 | 			mockHandler.headers = {};
219 | 		}
220 | 		if ( mockHandler.contentType ) {
221 | 			mockHandler.headers['content-type'] = mockHandler.contentType;
222 | 		}
223 | 
224 | 		return {
225 | 			status: mockHandler.status,
226 | 			statusText: mockHandler.statusText,
227 | 			readyState: 1,
228 | 			open: function() { },
229 | 			send: function() {
230 | 				origHandler.fired = true;
231 | 				_xhrSend.call(this, mockHandler, requestSettings, origSettings);
232 | 			},
233 | 			abort: function() {
234 | 				clearTimeout(this.responseTimer);
235 | 			},
236 | 			setRequestHeader: function(header, value) {
237 | 				mockHandler.headers[header] = value;
238 | 			},
239 | 			getResponseHeader: function(header) {
240 | 				// 'Last-modified', 'Etag', 'content-type' are all checked by jQuery
241 | 				if ( mockHandler.headers && mockHandler.headers[header] ) {
242 | 					// Return arbitrary headers
243 | 					return mockHandler.headers[header];
244 | 				} else if ( header.toLowerCase() == 'last-modified' ) {
245 | 					return mockHandler.lastModified || (new Date()).toString();
246 | 				} else if ( header.toLowerCase() == 'etag' ) {
247 | 					return mockHandler.etag || '';
248 | 				} else if ( header.toLowerCase() == 'content-type' ) {
249 | 					return mockHandler.contentType || 'text/plain';
250 | 				}
251 | 			},
252 | 			getAllResponseHeaders: function() {
253 | 				var headers = '';
254 | 				$.each(mockHandler.headers, function(k, v) {
255 | 					headers += k + ': ' + v + "\n";
256 | 				});
257 | 				return headers;
258 | 			}
259 | 		};
260 | 	}
261 | 
262 | 	// Process a JSONP mock request.
263 | 	function processJsonpMock( requestSettings, mockHandler, origSettings ) {
264 | 		// Handle JSONP Parameter Callbacks, we need to replicate some of the jQuery core here
265 | 		// because there isn't an easy hook for the cross domain script tag of jsonp
266 | 
267 | 		processJsonpUrl( requestSettings );
268 | 
269 | 		requestSettings.dataType = "json";
270 | 		if(requestSettings.data && CALLBACK_REGEX.test(requestSettings.data) || CALLBACK_REGEX.test(requestSettings.url)) {
271 | 			createJsonpCallback(requestSettings, mockHandler, origSettings);
272 | 
273 | 			// We need to make sure
274 | 			// that a JSONP style response is executed properly
275 | 
276 | 			var rurl = /^(\w+:)?\/\/([^\/?#]+)/,
277 | 				parts = rurl.exec( requestSettings.url ),
278 | 				remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
279 | 
280 | 			requestSettings.dataType = "script";
281 | 			if(requestSettings.type.toUpperCase() === "GET" && remote ) {
282 | 				var newMockReturn = processJsonpRequest( requestSettings, mockHandler, origSettings );
283 | 
284 | 				// Check if we are supposed to return a Deferred back to the mock call, or just
285 | 				// signal success
286 | 				if(newMockReturn) {
287 | 					return newMockReturn;
288 | 				} else {
289 | 					return true;
290 | 				}
291 | 			}
292 | 		}
293 | 		return null;
294 | 	}
295 | 
296 | 	// Append the required callback parameter to the end of the request URL, for a JSONP request
297 | 	function processJsonpUrl( requestSettings ) {
298 | 		if ( requestSettings.type.toUpperCase() === "GET" ) {
299 | 			if ( !CALLBACK_REGEX.test( requestSettings.url ) ) {
300 | 				requestSettings.url += (/\?/.test( requestSettings.url ) ? "&" : "?") +
301 | 					(requestSettings.jsonp || "callback") + "=?";
302 | 			}
303 | 		} else if ( !requestSettings.data || !CALLBACK_REGEX.test(requestSettings.data) ) {
304 | 			requestSettings.data = (requestSettings.data ? requestSettings.data + "&" : "") + (requestSettings.jsonp || "callback") + "=?";
305 | 		}
306 | 	}
307 | 
308 | 	// Process a JSONP request by evaluating the mocked response text
309 | 	function processJsonpRequest( requestSettings, mockHandler, origSettings ) {
310 | 		// Synthesize the mock request for adding a script tag
311 | 		var callbackContext = origSettings && origSettings.context || requestSettings,
312 | 			newMock = null;
313 | 
314 | 
315 | 		// If the response handler on the moock is a function, call it
316 | 		if ( mockHandler.response && $.isFunction(mockHandler.response) ) {
317 | 			mockHandler.response(origSettings);
318 | 		} else {
319 | 
320 | 			// Evaluate the responseText javascript in a global context
321 | 			if( typeof mockHandler.responseText === 'object' ) {
322 | 				$.globalEval( '(' + JSON.stringify( mockHandler.responseText ) + ')');
323 | 			} else {
324 | 				$.globalEval( '(' + mockHandler.responseText + ')');
325 | 			}
326 | 		}
327 | 
328 | 		// Successful response
329 | 		jsonpSuccess( requestSettings, callbackContext, mockHandler );
330 | 		jsonpComplete( requestSettings, callbackContext, mockHandler );
331 | 
332 | 		// If we are running under jQuery 1.5+, return a deferred object
333 | 		if($.Deferred){
334 | 			newMock = new $.Deferred();
335 | 			if(typeof mockHandler.responseText == "object"){
336 | 				newMock.resolveWith( callbackContext, [mockHandler.responseText] );
337 | 			}
338 | 			else{
339 | 				newMock.resolveWith( callbackContext, [$.parseJSON( mockHandler.responseText )] );
340 | 			}
341 | 		}
342 | 		return newMock;
343 | 	}
344 | 
345 | 
346 | 	// Create the required JSONP callback function for the request
347 | 	function createJsonpCallback( requestSettings, mockHandler, origSettings ) {
348 | 		var callbackContext = origSettings && origSettings.context || requestSettings;
349 | 		var jsonp = requestSettings.jsonpCallback || ("jsonp" + jsc++);
350 | 
351 | 		// Replace the =? sequence both in the query string and the data
352 | 		if ( requestSettings.data ) {
353 | 			requestSettings.data = (requestSettings.data + "").replace(CALLBACK_REGEX, "=" + jsonp + "$1");
354 | 		}
355 | 
356 | 		requestSettings.url = requestSettings.url.replace(CALLBACK_REGEX, "=" + jsonp + "$1");
357 | 
358 | 
359 | 		// Handle JSONP-style loading
360 | 		window[ jsonp ] = window[ jsonp ] || function( tmp ) {
361 | 			data = tmp;
362 | 			jsonpSuccess( requestSettings, callbackContext, mockHandler );
363 | 			jsonpComplete( requestSettings, callbackContext, mockHandler );
364 | 			// Garbage collect
365 | 			window[ jsonp ] = undefined;
366 | 
367 | 			try {
368 | 				delete window[ jsonp ];
369 | 			} catch(e) {}
370 | 
371 | 			if ( head ) {
372 | 				head.removeChild( script );
373 | 			}
374 | 		};
375 | 	}
376 | 
377 | 	// The JSONP request was successful
378 | 	function jsonpSuccess(requestSettings, callbackContext, mockHandler) {
379 | 		// If a local callback was specified, fire it and pass it the data
380 | 		if ( requestSettings.success ) {
381 | 			requestSettings.success.call( callbackContext, mockHandler.responseText || "", status, {} );
382 | 		}
383 | 
384 | 		// Fire the global callback
385 | 		if ( requestSettings.global ) {
386 | 			trigger(requestSettings, "ajaxSuccess", [{}, requestSettings] );
387 | 		}
388 | 	}
389 | 
390 | 	// The JSONP request was completed
391 | 	function jsonpComplete(requestSettings, callbackContext) {
392 | 		// Process result
393 | 		if ( requestSettings.complete ) {
394 | 			requestSettings.complete.call( callbackContext, {} , status );
395 | 		}
396 | 
397 | 		// The request was completed
398 | 		if ( requestSettings.global ) {
399 | 			trigger( "ajaxComplete", [{}, requestSettings] );
400 | 		}
401 | 
402 | 		// Handle the global AJAX counter
403 | 		if ( requestSettings.global && ! --$.active ) {
404 | 			$.event.trigger( "ajaxStop" );
405 | 		}
406 | 	}
407 | 
408 | 
409 | 	// The core $.ajax replacement.
410 | 	function handleAjax( url, origSettings ) {
411 | 		var mockRequest, requestSettings, mockHandler;
412 | 
413 | 		// If url is an object, simulate pre-1.5 signature
414 | 		if ( typeof url === "object" ) {
415 | 			origSettings = url;
416 | 			url = undefined;
417 | 		} else {
418 | 			// work around to support 1.5 signature
419 | 			origSettings.url = url;
420 | 		}
421 | 
422 | 		// Extend the original settings for the request
423 | 		requestSettings = $.extend(true, {}, $.ajaxSettings, origSettings);
424 | 
425 | 		// Iterate over our mock handlers (in registration order) until we find
426 | 		// one that is willing to intercept the request
427 | 		for(var k = 0; k < mockHandlers.length; k++) {
428 | 			if ( !mockHandlers[k] ) {
429 | 				continue;
430 | 			}
431 | 
432 | 			mockHandler = getMockForRequest( mockHandlers[k], requestSettings );
433 | 			if(!mockHandler) {
434 | 				// No valid mock found for this request
435 | 				continue;
436 | 			}
437 | 
438 | 			mockedAjaxCalls.push(requestSettings);
439 | 
440 | 			// If logging is enabled, log the mock to the console
441 | 			$.mockjaxSettings.log( mockHandler, requestSettings );
442 | 
443 | 
444 | 			if ( requestSettings.dataType === "jsonp" ) {
445 | 				if ((mockRequest = processJsonpMock( requestSettings, mockHandler, origSettings ))) {
446 | 					// This mock will handle the JSONP request
447 | 					return mockRequest;
448 | 				}
449 | 			}
450 | 
451 | 
452 | 			// Removed to fix #54 - keep the mocking data object intact
453 | 			//mockHandler.data = requestSettings.data;
454 | 
455 | 			mockHandler.cache = requestSettings.cache;
456 | 			mockHandler.timeout = requestSettings.timeout;
457 | 			mockHandler.global = requestSettings.global;
458 | 
459 | 			copyUrlParameters(mockHandler, origSettings);
460 | 
461 | 			(function(mockHandler, requestSettings, origSettings, origHandler) {
462 | 				mockRequest = _ajax.call($, $.extend(true, {}, origSettings, {
463 | 					// Mock the XHR object
464 | 					xhr: function() { return xhr( mockHandler, requestSettings, origSettings, origHandler ); }
465 | 				}));
466 | 			})(mockHandler, requestSettings, origSettings, mockHandlers[k]);
467 | 
468 | 			return mockRequest;
469 | 		}
470 | 
471 | 		// We don't have a mock request, trigger a normal request
472 | 		return _ajax.apply($, [origSettings]);
473 | 	}
474 | 
475 | 	/**
476 | 	* Copies URL parameter values if they were captured by a regular expression
477 | 	* @param {Object} mockHandler
478 | 	* @param {Object} origSettings
479 | 	*/
480 | 	function copyUrlParameters(mockHandler, origSettings) {
481 | 		//parameters aren't captured if the URL isn't a RegExp
482 | 		if (!(mockHandler.url instanceof RegExp)) {
483 | 			return;
484 | 		}
485 | 		//if no URL params were defined on the handler, don't attempt a capture
486 | 		if (!mockHandler.hasOwnProperty('urlParams')) {
487 | 			return;
488 | 		}
489 | 		var captures = mockHandler.url.exec(origSettings.url);
490 | 		//the whole RegExp match is always the first value in the capture results
491 | 		if (captures.length === 1) {
492 | 			return;
493 | 		}
494 | 		captures.shift();
495 | 		//use handler params as keys and capture resuts as values
496 | 		var i = 0,
497 | 		capturesLength = captures.length,
498 | 		paramsLength = mockHandler.urlParams.length,
499 | 		//in case the number of params specified is less than actual captures
500 | 		maxIterations = Math.min(capturesLength, paramsLength),
501 | 		paramValues = {};
502 | 		for (i; i < maxIterations; i++) {
503 | 			var key = mockHandler.urlParams[i];
504 | 			paramValues[key] = captures[i];
505 | 		}
506 | 		origSettings.urlParams = paramValues;
507 | 	}
508 | 
509 | 
510 | 	// Public
511 | 
512 | 	$.extend({
513 | 		ajax: handleAjax
514 | 	});
515 | 
516 | 	$.mockjaxSettings = {
517 | 		//url:        null,
518 | 		//type:       'GET',
519 | 		log:          function( mockHandler, requestSettings ) {
520 | 			if ( mockHandler.logging === false ||
521 | 				 ( typeof mockHandler.logging === 'undefined' && $.mockjaxSettings.logging === false ) ) {
522 | 				return;
523 | 			}
524 | 			if ( window.console && console.log ) {
525 | 				var message = 'MOCK ' + requestSettings.type.toUpperCase() + ': ' + requestSettings.url;
526 | 				var request = $.extend({}, requestSettings);
527 | 
528 | 				if (typeof console.log === 'function') {
529 | 					console.log(message, request);
530 | 				} else {
531 | 					try {
532 | 						console.log( message + ' ' + JSON.stringify(request) );
533 | 					} catch (e) {
534 | 						console.log(message);
535 | 					}
536 | 				}
537 | 			}
538 | 		},
539 | 		logging:      true,
540 | 		status:       200,
541 | 		statusText:   "OK",
542 | 		responseTime: 500,
543 | 		isTimeout:    false,
544 | 		contentType:  'text/plain',
545 | 		response:     '',
546 | 		responseText: '',
547 | 		responseXML:  '',
548 | 		proxy:        '',
549 | 		proxyType:    'GET',
550 | 
551 | 		lastModified: null,
552 | 		etag:         '',
553 | 		headers: {
554 | 			etag: 'IJF@H#@923uf8023hFO@I#H#',
555 | 			'content-type' : 'text/plain'
556 | 		}
557 | 	};
558 | 
559 | 	$.mockjax = function(settings) {
560 | 		var i = mockHandlers.length;
561 | 		mockHandlers[i] = settings;
562 | 		return i;
563 | 	};
564 | 	$.mockjaxClear = function(i) {
565 | 		if ( arguments.length == 1 ) {
566 | 			mockHandlers[i] = null;
567 | 		} else {
568 | 			mockHandlers = [];
569 | 		}
570 | 		mockedAjaxCalls = [];
571 | 	};
572 | 	$.mockjax.handler = function(i) {
573 | 		if ( arguments.length == 1 ) {
574 | 			return mockHandlers[i];
575 | 		}
576 | 	};
577 | 	$.mockjax.mockedAjaxCalls = function() {
578 | 		return mockedAjaxCalls;
579 | 	};
580 | })(jQuery);
581 | 


--------------------------------------------------------------------------------
/assets/vendor/handlebars.js:
--------------------------------------------------------------------------------
   1 | /*
   2 | 
   3 | Copyright (C) 2011 by Yehuda Katz
   4 | 
   5 | Permission is hereby granted, free of charge, to any person obtaining a copy
   6 | of this software and associated documentation files (the "Software"), to deal
   7 | in the Software without restriction, including without limitation the rights
   8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   9 | copies of the Software, and to permit persons to whom the Software is
  10 | furnished to do so, subject to the following conditions:
  11 | 
  12 | The above copyright notice and this permission notice shall be included in
  13 | all copies or substantial portions of the Software.
  14 | 
  15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  21 | THE SOFTWARE.
  22 | 
  23 | */
  24 | 
  25 | // lib/handlebars/browser-prefix.js
  26 | var Handlebars = {};
  27 | 
  28 | (function(Handlebars, undefined) {
  29 | ;
  30 | // lib/handlebars/base.js
  31 | 
  32 | Handlebars.VERSION = "1.0.0";
  33 | Handlebars.COMPILER_REVISION = 4;
  34 | 
  35 | Handlebars.REVISION_CHANGES = {
  36 |   1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
  37 |   2: '== 1.0.0-rc.3',
  38 |   3: '== 1.0.0-rc.4',
  39 |   4: '>= 1.0.0'
  40 | };
  41 | 
  42 | Handlebars.helpers  = {};
  43 | Handlebars.partials = {};
  44 | 
  45 | var toString = Object.prototype.toString,
  46 |     functionType = '[object Function]',
  47 |     objectType = '[object Object]';
  48 | 
  49 | Handlebars.registerHelper = function(name, fn, inverse) {
  50 |   if (toString.call(name) === objectType) {
  51 |     if (inverse || fn) { throw new Handlebars.Exception('Arg not supported with multiple helpers'); }
  52 |     Handlebars.Utils.extend(this.helpers, name);
  53 |   } else {
  54 |     if (inverse) { fn.not = inverse; }
  55 |     this.helpers[name] = fn;
  56 |   }
  57 | };
  58 | 
  59 | Handlebars.registerPartial = function(name, str) {
  60 |   if (toString.call(name) === objectType) {
  61 |     Handlebars.Utils.extend(this.partials,  name);
  62 |   } else {
  63 |     this.partials[name] = str;
  64 |   }
  65 | };
  66 | 
  67 | Handlebars.registerHelper('helperMissing', function(arg) {
  68 |   if(arguments.length === 2) {
  69 |     return undefined;
  70 |   } else {
  71 |     throw new Error("Missing helper: '" + arg + "'");
  72 |   }
  73 | });
  74 | 
  75 | Handlebars.registerHelper('blockHelperMissing', function(context, options) {
  76 |   var inverse = options.inverse || function() {}, fn = options.fn;
  77 | 
  78 |   var type = toString.call(context);
  79 | 
  80 |   if(type === functionType) { context = context.call(this); }
  81 | 
  82 |   if(context === true) {
  83 |     return fn(this);
  84 |   } else if(context === false || context == null) {
  85 |     return inverse(this);
  86 |   } else if(type === "[object Array]") {
  87 |     if(context.length > 0) {
  88 |       return Handlebars.helpers.each(context, options);
  89 |     } else {
  90 |       return inverse(this);
  91 |     }
  92 |   } else {
  93 |     return fn(context);
  94 |   }
  95 | });
  96 | 
  97 | Handlebars.K = function() {};
  98 | 
  99 | Handlebars.createFrame = Object.create || function(object) {
 100 |   Handlebars.K.prototype = object;
 101 |   var obj = new Handlebars.K();
 102 |   Handlebars.K.prototype = null;
 103 |   return obj;
 104 | };
 105 | 
 106 | Handlebars.logger = {
 107 |   DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
 108 | 
 109 |   methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
 110 | 
 111 |   // can be overridden in the host environment
 112 |   log: function(level, obj) {
 113 |     if (Handlebars.logger.level <= level) {
 114 |       var method = Handlebars.logger.methodMap[level];
 115 |       if (typeof console !== 'undefined' && console[method]) {
 116 |         console[method].call(console, obj);
 117 |       }
 118 |     }
 119 |   }
 120 | };
 121 | 
 122 | Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); };
 123 | 
 124 | Handlebars.registerHelper('each', function(context, options) {
 125 |   var fn = options.fn, inverse = options.inverse;
 126 |   var i = 0, ret = "", data;
 127 | 
 128 |   var type = toString.call(context);
 129 |   if(type === functionType) { context = context.call(this); }
 130 | 
 131 |   if (options.data) {
 132 |     data = Handlebars.createFrame(options.data);
 133 |   }
 134 | 
 135 |   if(context && typeof context === 'object') {
 136 |     if(context instanceof Array){
 137 |       for(var j = context.length; i<j; i++) {
 138 |         if (data) { data.index = i; }
 139 |         ret = ret + fn(context[i], { data: data });
 140 |       }
 141 |     } else {
 142 |       for(var key in context) {
 143 |         if(context.hasOwnProperty(key)) {
 144 |           if(data) { data.key = key; }
 145 |           ret = ret + fn(context[key], {data: data});
 146 |           i++;
 147 |         }
 148 |       }
 149 |     }
 150 |   }
 151 | 
 152 |   if(i === 0){
 153 |     ret = inverse(this);
 154 |   }
 155 | 
 156 |   return ret;
 157 | });
 158 | 
 159 | Handlebars.registerHelper('if', function(conditional, options) {
 160 |   var type = toString.call(conditional);
 161 |   if(type === functionType) { conditional = conditional.call(this); }
 162 | 
 163 |   if(!conditional || Handlebars.Utils.isEmpty(conditional)) {
 164 |     return options.inverse(this);
 165 |   } else {
 166 |     return options.fn(this);
 167 |   }
 168 | });
 169 | 
 170 | Handlebars.registerHelper('unless', function(conditional, options) {
 171 |   return Handlebars.helpers['if'].call(this, conditional, {fn: options.inverse, inverse: options.fn});
 172 | });
 173 | 
 174 | Handlebars.registerHelper('with', function(context, options) {
 175 |   var type = toString.call(context);
 176 |   if(type === functionType) { context = context.call(this); }
 177 | 
 178 |   if (!Handlebars.Utils.isEmpty(context)) return options.fn(context);
 179 | });
 180 | 
 181 | Handlebars.registerHelper('log', function(context, options) {
 182 |   var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
 183 |   Handlebars.log(level, context);
 184 | });
 185 | ;
 186 | // lib/handlebars/compiler/parser.js
 187 | /* Jison generated parser */
 188 | var handlebars = (function(){
 189 | var parser = {trace: function trace() { },
 190 | yy: {},
 191 | symbols_: {"error":2,"root":3,"program":4,"EOF":5,"simpleInverse":6,"statements":7,"statement":8,"openInverse":9,"closeBlock":10,"openBlock":11,"mustache":12,"partial":13,"CONTENT":14,"COMMENT":15,"OPEN_BLOCK":16,"inMustache":17,"CLOSE":18,"OPEN_INVERSE":19,"OPEN_ENDBLOCK":20,"path":21,"OPEN":22,"OPEN_UNESCAPED":23,"CLOSE_UNESCAPED":24,"OPEN_PARTIAL":25,"partialName":26,"params":27,"hash":28,"dataName":29,"param":30,"STRING":31,"INTEGER":32,"BOOLEAN":33,"hashSegments":34,"hashSegment":35,"ID":36,"EQUALS":37,"DATA":38,"pathSegments":39,"SEP":40,"$accept":0,"$end":1},
 192 | terminals_: {2:"error",5:"EOF",14:"CONTENT",15:"COMMENT",16:"OPEN_BLOCK",18:"CLOSE",19:"OPEN_INVERSE",20:"OPEN_ENDBLOCK",22:"OPEN",23:"OPEN_UNESCAPED",24:"CLOSE_UNESCAPED",25:"OPEN_PARTIAL",31:"STRING",32:"INTEGER",33:"BOOLEAN",36:"ID",37:"EQUALS",38:"DATA",40:"SEP"},
 193 | productions_: [0,[3,2],[4,2],[4,3],[4,2],[4,1],[4,1],[4,0],[7,1],[7,2],[8,3],[8,3],[8,1],[8,1],[8,1],[8,1],[11,3],[9,3],[10,3],[12,3],[12,3],[13,3],[13,4],[6,2],[17,3],[17,2],[17,2],[17,1],[17,1],[27,2],[27,1],[30,1],[30,1],[30,1],[30,1],[30,1],[28,1],[34,2],[34,1],[35,3],[35,3],[35,3],[35,3],[35,3],[26,1],[26,1],[26,1],[29,2],[21,1],[39,3],[39,1]],
 194 | performAction: function anonymous(yytext,yyleng,yylineno,yy,yystate,$$,_$) {
 195 | 
 196 | var $0 = $$.length - 1;
 197 | switch (yystate) {
 198 | case 1: return $$[$0-1]; 
 199 | break;
 200 | case 2: this.$ = new yy.ProgramNode([], $$[$0]); 
 201 | break;
 202 | case 3: this.$ = new yy.ProgramNode($$[$0-2], $$[$0]); 
 203 | break;
 204 | case 4: this.$ = new yy.ProgramNode($$[$0-1], []); 
 205 | break;
 206 | case 5: this.$ = new yy.ProgramNode($$[$0]); 
 207 | break;
 208 | case 6: this.$ = new yy.ProgramNode([], []); 
 209 | break;
 210 | case 7: this.$ = new yy.ProgramNode([]); 
 211 | break;
 212 | case 8: this.$ = [$$[$0]]; 
 213 | break;
 214 | case 9: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
 215 | break;
 216 | case 10: this.$ = new yy.BlockNode($$[$0-2], $$[$0-1].inverse, $$[$0-1], $$[$0]); 
 217 | break;
 218 | case 11: this.$ = new yy.BlockNode($$[$0-2], $$[$0-1], $$[$0-1].inverse, $$[$0]); 
 219 | break;
 220 | case 12: this.$ = $$[$0]; 
 221 | break;
 222 | case 13: this.$ = $$[$0]; 
 223 | break;
 224 | case 14: this.$ = new yy.ContentNode($$[$0]); 
 225 | break;
 226 | case 15: this.$ = new yy.CommentNode($$[$0]); 
 227 | break;
 228 | case 16: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); 
 229 | break;
 230 | case 17: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1]); 
 231 | break;
 232 | case 18: this.$ = $$[$0-1]; 
 233 | break;
 234 | case 19:
 235 |     // Parsing out the '&' escape token at this level saves ~500 bytes after min due to the removal of one parser node.
 236 |     this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1], $$[$0-2][2] === '&');
 237 |   
 238 | break;
 239 | case 20: this.$ = new yy.MustacheNode($$[$0-1][0], $$[$0-1][1], true); 
 240 | break;
 241 | case 21: this.$ = new yy.PartialNode($$[$0-1]); 
 242 | break;
 243 | case 22: this.$ = new yy.PartialNode($$[$0-2], $$[$0-1]); 
 244 | break;
 245 | case 23: 
 246 | break;
 247 | case 24: this.$ = [[$$[$0-2]].concat($$[$0-1]), $$[$0]]; 
 248 | break;
 249 | case 25: this.$ = [[$$[$0-1]].concat($$[$0]), null]; 
 250 | break;
 251 | case 26: this.$ = [[$$[$0-1]], $$[$0]]; 
 252 | break;
 253 | case 27: this.$ = [[$$[$0]], null]; 
 254 | break;
 255 | case 28: this.$ = [[$$[$0]], null]; 
 256 | break;
 257 | case 29: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
 258 | break;
 259 | case 30: this.$ = [$$[$0]]; 
 260 | break;
 261 | case 31: this.$ = $$[$0]; 
 262 | break;
 263 | case 32: this.$ = new yy.StringNode($$[$0]); 
 264 | break;
 265 | case 33: this.$ = new yy.IntegerNode($$[$0]); 
 266 | break;
 267 | case 34: this.$ = new yy.BooleanNode($$[$0]); 
 268 | break;
 269 | case 35: this.$ = $$[$0]; 
 270 | break;
 271 | case 36: this.$ = new yy.HashNode($$[$0]); 
 272 | break;
 273 | case 37: $$[$0-1].push($$[$0]); this.$ = $$[$0-1]; 
 274 | break;
 275 | case 38: this.$ = [$$[$0]]; 
 276 | break;
 277 | case 39: this.$ = [$$[$0-2], $$[$0]]; 
 278 | break;
 279 | case 40: this.$ = [$$[$0-2], new yy.StringNode($$[$0])]; 
 280 | break;
 281 | case 41: this.$ = [$$[$0-2], new yy.IntegerNode($$[$0])]; 
 282 | break;
 283 | case 42: this.$ = [$$[$0-2], new yy.BooleanNode($$[$0])]; 
 284 | break;
 285 | case 43: this.$ = [$$[$0-2], $$[$0]]; 
 286 | break;
 287 | case 44: this.$ = new yy.PartialNameNode($$[$0]); 
 288 | break;
 289 | case 45: this.$ = new yy.PartialNameNode(new yy.StringNode($$[$0])); 
 290 | break;
 291 | case 46: this.$ = new yy.PartialNameNode(new yy.IntegerNode($$[$0])); 
 292 | break;
 293 | case 47: this.$ = new yy.DataNode($$[$0]); 
 294 | break;
 295 | case 48: this.$ = new yy.IdNode($$[$0]); 
 296 | break;
 297 | case 49: $$[$0-2].push({part: $$[$0], separator: $$[$0-1]}); this.$ = $$[$0-2]; 
 298 | break;
 299 | case 50: this.$ = [{part: $$[$0]}]; 
 300 | break;
 301 | }
 302 | },
 303 | table: [{3:1,4:2,5:[2,7],6:3,7:4,8:6,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,5],22:[1,14],23:[1,15],25:[1,16]},{1:[3]},{5:[1,17]},{5:[2,6],7:18,8:6,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,19],20:[2,6],22:[1,14],23:[1,15],25:[1,16]},{5:[2,5],6:20,8:21,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,5],20:[2,5],22:[1,14],23:[1,15],25:[1,16]},{17:23,18:[1,22],21:24,29:25,36:[1,28],38:[1,27],39:26},{5:[2,8],14:[2,8],15:[2,8],16:[2,8],19:[2,8],20:[2,8],22:[2,8],23:[2,8],25:[2,8]},{4:29,6:3,7:4,8:6,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,5],20:[2,7],22:[1,14],23:[1,15],25:[1,16]},{4:30,6:3,7:4,8:6,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,5],20:[2,7],22:[1,14],23:[1,15],25:[1,16]},{5:[2,12],14:[2,12],15:[2,12],16:[2,12],19:[2,12],20:[2,12],22:[2,12],23:[2,12],25:[2,12]},{5:[2,13],14:[2,13],15:[2,13],16:[2,13],19:[2,13],20:[2,13],22:[2,13],23:[2,13],25:[2,13]},{5:[2,14],14:[2,14],15:[2,14],16:[2,14],19:[2,14],20:[2,14],22:[2,14],23:[2,14],25:[2,14]},{5:[2,15],14:[2,15],15:[2,15],16:[2,15],19:[2,15],20:[2,15],22:[2,15],23:[2,15],25:[2,15]},{17:31,21:24,29:25,36:[1,28],38:[1,27],39:26},{17:32,21:24,29:25,36:[1,28],38:[1,27],39:26},{17:33,21:24,29:25,36:[1,28],38:[1,27],39:26},{21:35,26:34,31:[1,36],32:[1,37],36:[1,28],39:26},{1:[2,1]},{5:[2,2],8:21,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,19],20:[2,2],22:[1,14],23:[1,15],25:[1,16]},{17:23,21:24,29:25,36:[1,28],38:[1,27],39:26},{5:[2,4],7:38,8:6,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,19],20:[2,4],22:[1,14],23:[1,15],25:[1,16]},{5:[2,9],14:[2,9],15:[2,9],16:[2,9],19:[2,9],20:[2,9],22:[2,9],23:[2,9],25:[2,9]},{5:[2,23],14:[2,23],15:[2,23],16:[2,23],19:[2,23],20:[2,23],22:[2,23],23:[2,23],25:[2,23]},{18:[1,39]},{18:[2,27],21:44,24:[2,27],27:40,28:41,29:48,30:42,31:[1,45],32:[1,46],33:[1,47],34:43,35:49,36:[1,50],38:[1,27],39:26},{18:[2,28],24:[2,28]},{18:[2,48],24:[2,48],31:[2,48],32:[2,48],33:[2,48],36:[2,48],38:[2,48],40:[1,51]},{21:52,36:[1,28],39:26},{18:[2,50],24:[2,50],31:[2,50],32:[2,50],33:[2,50],36:[2,50],38:[2,50],40:[2,50]},{10:53,20:[1,54]},{10:55,20:[1,54]},{18:[1,56]},{18:[1,57]},{24:[1,58]},{18:[1,59],21:60,36:[1,28],39:26},{18:[2,44],36:[2,44]},{18:[2,45],36:[2,45]},{18:[2,46],36:[2,46]},{5:[2,3],8:21,9:7,11:8,12:9,13:10,14:[1,11],15:[1,12],16:[1,13],19:[1,19],20:[2,3],22:[1,14],23:[1,15],25:[1,16]},{14:[2,17],15:[2,17],16:[2,17],19:[2,17],20:[2,17],22:[2,17],23:[2,17],25:[2,17]},{18:[2,25],21:44,24:[2,25],28:61,29:48,30:62,31:[1,45],32:[1,46],33:[1,47],34:43,35:49,36:[1,50],38:[1,27],39:26},{18:[2,26],24:[2,26]},{18:[2,30],24:[2,30],31:[2,30],32:[2,30],33:[2,30],36:[2,30],38:[2,30]},{18:[2,36],24:[2,36],35:63,36:[1,64]},{18:[2,31],24:[2,31],31:[2,31],32:[2,31],33:[2,31],36:[2,31],38:[2,31]},{18:[2,32],24:[2,32],31:[2,32],32:[2,32],33:[2,32],36:[2,32],38:[2,32]},{18:[2,33],24:[2,33],31:[2,33],32:[2,33],33:[2,33],36:[2,33],38:[2,33]},{18:[2,34],24:[2,34],31:[2,34],32:[2,34],33:[2,34],36:[2,34],38:[2,34]},{18:[2,35],24:[2,35],31:[2,35],32:[2,35],33:[2,35],36:[2,35],38:[2,35]},{18:[2,38],24:[2,38],36:[2,38]},{18:[2,50],24:[2,50],31:[2,50],32:[2,50],33:[2,50],36:[2,50],37:[1,65],38:[2,50],40:[2,50]},{36:[1,66]},{18:[2,47],24:[2,47],31:[2,47],32:[2,47],33:[2,47],36:[2,47],38:[2,47]},{5:[2,10],14:[2,10],15:[2,10],16:[2,10],19:[2,10],20:[2,10],22:[2,10],23:[2,10],25:[2,10]},{21:67,36:[1,28],39:26},{5:[2,11],14:[2,11],15:[2,11],16:[2,11],19:[2,11],20:[2,11],22:[2,11],23:[2,11],25:[2,11]},{14:[2,16],15:[2,16],16:[2,16],19:[2,16],20:[2,16],22:[2,16],23:[2,16],25:[2,16]},{5:[2,19],14:[2,19],15:[2,19],16:[2,19],19:[2,19],20:[2,19],22:[2,19],23:[2,19],25:[2,19]},{5:[2,20],14:[2,20],15:[2,20],16:[2,20],19:[2,20],20:[2,20],22:[2,20],23:[2,20],25:[2,20]},{5:[2,21],14:[2,21],15:[2,21],16:[2,21],19:[2,21],20:[2,21],22:[2,21],23:[2,21],25:[2,21]},{18:[1,68]},{18:[2,24],24:[2,24]},{18:[2,29],24:[2,29],31:[2,29],32:[2,29],33:[2,29],36:[2,29],38:[2,29]},{18:[2,37],24:[2,37],36:[2,37]},{37:[1,65]},{21:69,29:73,31:[1,70],32:[1,71],33:[1,72],36:[1,28],38:[1,27],39:26},{18:[2,49],24:[2,49],31:[2,49],32:[2,49],33:[2,49],36:[2,49],38:[2,49],40:[2,49]},{18:[1,74]},{5:[2,22],14:[2,22],15:[2,22],16:[2,22],19:[2,22],20:[2,22],22:[2,22],23:[2,22],25:[2,22]},{18:[2,39],24:[2,39],36:[2,39]},{18:[2,40],24:[2,40],36:[2,40]},{18:[2,41],24:[2,41],36:[2,41]},{18:[2,42],24:[2,42],36:[2,42]},{18:[2,43],24:[2,43],36:[2,43]},{5:[2,18],14:[2,18],15:[2,18],16:[2,18],19:[2,18],20:[2,18],22:[2,18],23:[2,18],25:[2,18]}],
 304 | defaultActions: {17:[2,1]},
 305 | parseError: function parseError(str, hash) {
 306 |     throw new Error(str);
 307 | },
 308 | parse: function parse(input) {
 309 |     var self = this, stack = [0], vstack = [null], lstack = [], table = this.table, yytext = "", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;
 310 |     this.lexer.setInput(input);
 311 |     this.lexer.yy = this.yy;
 312 |     this.yy.lexer = this.lexer;
 313 |     this.yy.parser = this;
 314 |     if (typeof this.lexer.yylloc == "undefined")
 315 |         this.lexer.yylloc = {};
 316 |     var yyloc = this.lexer.yylloc;
 317 |     lstack.push(yyloc);
 318 |     var ranges = this.lexer.options && this.lexer.options.ranges;
 319 |     if (typeof this.yy.parseError === "function")
 320 |         this.parseError = this.yy.parseError;
 321 |     function popStack(n) {
 322 |         stack.length = stack.length - 2 * n;
 323 |         vstack.length = vstack.length - n;
 324 |         lstack.length = lstack.length - n;
 325 |     }
 326 |     function lex() {
 327 |         var token;
 328 |         token = self.lexer.lex() || 1;
 329 |         if (typeof token !== "number") {
 330 |             token = self.symbols_[token] || token;
 331 |         }
 332 |         return token;
 333 |     }
 334 |     var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;
 335 |     while (true) {
 336 |         state = stack[stack.length - 1];
 337 |         if (this.defaultActions[state]) {
 338 |             action = this.defaultActions[state];
 339 |         } else {
 340 |             if (symbol === null || typeof symbol == "undefined") {
 341 |                 symbol = lex();
 342 |             }
 343 |             action = table[state] && table[state][symbol];
 344 |         }
 345 |         if (typeof action === "undefined" || !action.length || !action[0]) {
 346 |             var errStr = "";
 347 |             if (!recovering) {
 348 |                 expected = [];
 349 |                 for (p in table[state])
 350 |                     if (this.terminals_[p] && p > 2) {
 351 |                         expected.push("'" + this.terminals_[p] + "'");
 352 |                     }
 353 |                 if (this.lexer.showPosition) {
 354 |                     errStr = "Parse error on line " + (yylineno + 1) + ":\n" + this.lexer.showPosition() + "\nExpecting " + expected.join(", ") + ", got '" + (this.terminals_[symbol] || symbol) + "'";
 355 |                 } else {
 356 |                     errStr = "Parse error on line " + (yylineno + 1) + ": Unexpected " + (symbol == 1?"end of input":"'" + (this.terminals_[symbol] || symbol) + "'");
 357 |                 }
 358 |                 this.parseError(errStr, {text: this.lexer.match, token: this.terminals_[symbol] || symbol, line: this.lexer.yylineno, loc: yyloc, expected: expected});
 359 |             }
 360 |         }
 361 |         if (action[0] instanceof Array && action.length > 1) {
 362 |             throw new Error("Parse Error: multiple actions possible at state: " + state + ", token: " + symbol);
 363 |         }
 364 |         switch (action[0]) {
 365 |         case 1:
 366 |             stack.push(symbol);
 367 |             vstack.push(this.lexer.yytext);
 368 |             lstack.push(this.lexer.yylloc);
 369 |             stack.push(action[1]);
 370 |             symbol = null;
 371 |             if (!preErrorSymbol) {
 372 |                 yyleng = this.lexer.yyleng;
 373 |                 yytext = this.lexer.yytext;
 374 |                 yylineno = this.lexer.yylineno;
 375 |                 yyloc = this.lexer.yylloc;
 376 |                 if (recovering > 0)
 377 |                     recovering--;
 378 |             } else {
 379 |                 symbol = preErrorSymbol;
 380 |                 preErrorSymbol = null;
 381 |             }
 382 |             break;
 383 |         case 2:
 384 |             len = this.productions_[action[1]][1];
 385 |             yyval.$ = vstack[vstack.length - len];
 386 |             yyval._$ = {first_line: lstack[lstack.length - (len || 1)].first_line, last_line: lstack[lstack.length - 1].last_line, first_column: lstack[lstack.length - (len || 1)].first_column, last_column: lstack[lstack.length - 1].last_column};
 387 |             if (ranges) {
 388 |                 yyval._$.range = [lstack[lstack.length - (len || 1)].range[0], lstack[lstack.length - 1].range[1]];
 389 |             }
 390 |             r = this.performAction.call(yyval, yytext, yyleng, yylineno, this.yy, action[1], vstack, lstack);
 391 |             if (typeof r !== "undefined") {
 392 |                 return r;
 393 |             }
 394 |             if (len) {
 395 |                 stack = stack.slice(0, -1 * len * 2);
 396 |                 vstack = vstack.slice(0, -1 * len);
 397 |                 lstack = lstack.slice(0, -1 * len);
 398 |             }
 399 |             stack.push(this.productions_[action[1]][0]);
 400 |             vstack.push(yyval.$);
 401 |             lstack.push(yyval._$);
 402 |             newState = table[stack[stack.length - 2]][stack[stack.length - 1]];
 403 |             stack.push(newState);
 404 |             break;
 405 |         case 3:
 406 |             return true;
 407 |         }
 408 |     }
 409 |     return true;
 410 | }
 411 | };
 412 | /* Jison generated lexer */
 413 | var lexer = (function(){
 414 | var lexer = ({EOF:1,
 415 | parseError:function parseError(str, hash) {
 416 |         if (this.yy.parser) {
 417 |             this.yy.parser.parseError(str, hash);
 418 |         } else {
 419 |             throw new Error(str);
 420 |         }
 421 |     },
 422 | setInput:function (input) {
 423 |         this._input = input;
 424 |         this._more = this._less = this.done = false;
 425 |         this.yylineno = this.yyleng = 0;
 426 |         this.yytext = this.matched = this.match = '';
 427 |         this.conditionStack = ['INITIAL'];
 428 |         this.yylloc = {first_line:1,first_column:0,last_line:1,last_column:0};
 429 |         if (this.options.ranges) this.yylloc.range = [0,0];
 430 |         this.offset = 0;
 431 |         return this;
 432 |     },
 433 | input:function () {
 434 |         var ch = this._input[0];
 435 |         this.yytext += ch;
 436 |         this.yyleng++;
 437 |         this.offset++;
 438 |         this.match += ch;
 439 |         this.matched += ch;
 440 |         var lines = ch.match(/(?:\r\n?|\n).*/g);
 441 |         if (lines) {
 442 |             this.yylineno++;
 443 |             this.yylloc.last_line++;
 444 |         } else {
 445 |             this.yylloc.last_column++;
 446 |         }
 447 |         if (this.options.ranges) this.yylloc.range[1]++;
 448 | 
 449 |         this._input = this._input.slice(1);
 450 |         return ch;
 451 |     },
 452 | unput:function (ch) {
 453 |         var len = ch.length;
 454 |         var lines = ch.split(/(?:\r\n?|\n)/g);
 455 | 
 456 |         this._input = ch + this._input;
 457 |         this.yytext = this.yytext.substr(0, this.yytext.length-len-1);
 458 |         //this.yyleng -= len;
 459 |         this.offset -= len;
 460 |         var oldLines = this.match.split(/(?:\r\n?|\n)/g);
 461 |         this.match = this.match.substr(0, this.match.length-1);
 462 |         this.matched = this.matched.substr(0, this.matched.length-1);
 463 | 
 464 |         if (lines.length-1) this.yylineno -= lines.length-1;
 465 |         var r = this.yylloc.range;
 466 | 
 467 |         this.yylloc = {first_line: this.yylloc.first_line,
 468 |           last_line: this.yylineno+1,
 469 |           first_column: this.yylloc.first_column,
 470 |           last_column: lines ?
 471 |               (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length:
 472 |               this.yylloc.first_column - len
 473 |           };
 474 | 
 475 |         if (this.options.ranges) {
 476 |             this.yylloc.range = [r[0], r[0] + this.yyleng - len];
 477 |         }
 478 |         return this;
 479 |     },
 480 | more:function () {
 481 |         this._more = true;
 482 |         return this;
 483 |     },
 484 | less:function (n) {
 485 |         this.unput(this.match.slice(n));
 486 |     },
 487 | pastInput:function () {
 488 |         var past = this.matched.substr(0, this.matched.length - this.match.length);
 489 |         return (past.length > 20 ? '...':'') + past.substr(-20).replace(/\n/g, "");
 490 |     },
 491 | upcomingInput:function () {
 492 |         var next = this.match;
 493 |         if (next.length < 20) {
 494 |             next += this._input.substr(0, 20-next.length);
 495 |         }
 496 |         return (next.substr(0,20)+(next.length > 20 ? '...':'')).replace(/\n/g, "");
 497 |     },
 498 | showPosition:function () {
 499 |         var pre = this.pastInput();
 500 |         var c = new Array(pre.length + 1).join("-");
 501 |         return pre + this.upcomingInput() + "\n" + c+"^";
 502 |     },
 503 | next:function () {
 504 |         if (this.done) {
 505 |             return this.EOF;
 506 |         }
 507 |         if (!this._input) this.done = true;
 508 | 
 509 |         var token,
 510 |             match,
 511 |             tempMatch,
 512 |             index,
 513 |             col,
 514 |             lines;
 515 |         if (!this._more) {
 516 |             this.yytext = '';
 517 |             this.match = '';
 518 |         }
 519 |         var rules = this._currentRules();
 520 |         for (var i=0;i < rules.length; i++) {
 521 |             tempMatch = this._input.match(this.rules[rules[i]]);
 522 |             if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {
 523 |                 match = tempMatch;
 524 |                 index = i;
 525 |                 if (!this.options.flex) break;
 526 |             }
 527 |         }
 528 |         if (match) {
 529 |             lines = match[0].match(/(?:\r\n?|\n).*/g);
 530 |             if (lines) this.yylineno += lines.length;
 531 |             this.yylloc = {first_line: this.yylloc.last_line,
 532 |                            last_line: this.yylineno+1,
 533 |                            first_column: this.yylloc.last_column,
 534 |                            last_column: lines ? lines[lines.length-1].length-lines[lines.length-1].match(/\r?\n?/)[0].length : this.yylloc.last_column + match[0].length};
 535 |             this.yytext += match[0];
 536 |             this.match += match[0];
 537 |             this.matches = match;
 538 |             this.yyleng = this.yytext.length;
 539 |             if (this.options.ranges) {
 540 |                 this.yylloc.range = [this.offset, this.offset += this.yyleng];
 541 |             }
 542 |             this._more = false;
 543 |             this._input = this._input.slice(match[0].length);
 544 |             this.matched += match[0];
 545 |             token = this.performAction.call(this, this.yy, this, rules[index],this.conditionStack[this.conditionStack.length-1]);
 546 |             if (this.done && this._input) this.done = false;
 547 |             if (token) return token;
 548 |             else return;
 549 |         }
 550 |         if (this._input === "") {
 551 |             return this.EOF;
 552 |         } else {
 553 |             return this.parseError('Lexical error on line '+(this.yylineno+1)+'. Unrecognized text.\n'+this.showPosition(),
 554 |                     {text: "", token: null, line: this.yylineno});
 555 |         }
 556 |     },
 557 | lex:function lex() {
 558 |         var r = this.next();
 559 |         if (typeof r !== 'undefined') {
 560 |             return r;
 561 |         } else {
 562 |             return this.lex();
 563 |         }
 564 |     },
 565 | begin:function begin(condition) {
 566 |         this.conditionStack.push(condition);
 567 |     },
 568 | popState:function popState() {
 569 |         return this.conditionStack.pop();
 570 |     },
 571 | _currentRules:function _currentRules() {
 572 |         return this.conditions[this.conditionStack[this.conditionStack.length-1]].rules;
 573 |     },
 574 | topState:function () {
 575 |         return this.conditionStack[this.conditionStack.length-2];
 576 |     },
 577 | pushState:function begin(condition) {
 578 |         this.begin(condition);
 579 |     }});
 580 | lexer.options = {};
 581 | lexer.performAction = function anonymous(yy,yy_,$avoiding_name_collisions,YY_START) {
 582 | 
 583 | var YYSTATE=YY_START
 584 | switch($avoiding_name_collisions) {
 585 | case 0: yy_.yytext = "\\"; return 14; 
 586 | break;
 587 | case 1:
 588 |                                    if(yy_.yytext.slice(-1) !== "\\") this.begin("mu");
 589 |                                    if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1), this.begin("emu");
 590 |                                    if(yy_.yytext) return 14;
 591 |                                  
 592 | break;
 593 | case 2: return 14; 
 594 | break;
 595 | case 3:
 596 |                                    if(yy_.yytext.slice(-1) !== "\\") this.popState();
 597 |                                    if(yy_.yytext.slice(-1) === "\\") yy_.yytext = yy_.yytext.substr(0,yy_.yyleng-1);
 598 |                                    return 14;
 599 |                                  
 600 | break;
 601 | case 4: yy_.yytext = yy_.yytext.substr(0, yy_.yyleng-4); this.popState(); return 15; 
 602 | break;
 603 | case 5: return 25; 
 604 | break;
 605 | case 6: return 16; 
 606 | break;
 607 | case 7: return 20; 
 608 | break;
 609 | case 8: return 19; 
 610 | break;
 611 | case 9: return 19; 
 612 | break;
 613 | case 10: return 23; 
 614 | break;
 615 | case 11: return 22; 
 616 | break;
 617 | case 12: this.popState(); this.begin('com'); 
 618 | break;
 619 | case 13: yy_.yytext = yy_.yytext.substr(3,yy_.yyleng-5); this.popState(); return 15; 
 620 | break;
 621 | case 14: return 22; 
 622 | break;
 623 | case 15: return 37; 
 624 | break;
 625 | case 16: return 36; 
 626 | break;
 627 | case 17: return 36; 
 628 | break;
 629 | case 18: return 40; 
 630 | break;
 631 | case 19: /*ignore whitespace*/ 
 632 | break;
 633 | case 20: this.popState(); return 24; 
 634 | break;
 635 | case 21: this.popState(); return 18; 
 636 | break;
 637 | case 22: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\"/g,'"'); return 31; 
 638 | break;
 639 | case 23: yy_.yytext = yy_.yytext.substr(1,yy_.yyleng-2).replace(/\\'/g,"'"); return 31; 
 640 | break;
 641 | case 24: return 38; 
 642 | break;
 643 | case 25: return 33; 
 644 | break;
 645 | case 26: return 33; 
 646 | break;
 647 | case 27: return 32; 
 648 | break;
 649 | case 28: return 36; 
 650 | break;
 651 | case 29: yy_.yytext = yy_.yytext.substr(1, yy_.yyleng-2); return 36; 
 652 | break;
 653 | case 30: return 'INVALID'; 
 654 | break;
 655 | case 31: return 5; 
 656 | break;
 657 | }
 658 | };
 659 | lexer.rules = [/^(?:\\\\(?=(\{\{)))/,/^(?:[^\x00]*?(?=(\{\{)))/,/^(?:[^\x00]+)/,/^(?:[^\x00]{2,}?(?=(\{\{|$)))/,/^(?:[\s\S]*?--\}\})/,/^(?:\{\{>)/,/^(?:\{\{#)/,/^(?:\{\{\/)/,/^(?:\{\{\^)/,/^(?:\{\{\s*else\b)/,/^(?:\{\{\{)/,/^(?:\{\{&)/,/^(?:\{\{!--)/,/^(?:\{\{![\s\S]*?\}\})/,/^(?:\{\{)/,/^(?:=)/,/^(?:\.(?=[}\/ ]))/,/^(?:\.\.)/,/^(?:[\/.])/,/^(?:\s+)/,/^(?:\}\}\})/,/^(?:\}\})/,/^(?:"(\\["]|[^"])*")/,/^(?:'(\\[']|[^'])*')/,/^(?:@)/,/^(?:true(?=[}\s]))/,/^(?:false(?=[}\s]))/,/^(?:-?[0-9]+(?=[}\s]))/,/^(?:[^\s!"#%-,\.\/;->@\[-\^`\{-~]+(?=[=}\s\/.]))/,/^(?:\[[^\]]*\])/,/^(?:.)/,/^(?:$)/];
 660 | lexer.conditions = {"mu":{"rules":[5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31],"inclusive":false},"emu":{"rules":[3],"inclusive":false},"com":{"rules":[4],"inclusive":false},"INITIAL":{"rules":[0,1,2,31],"inclusive":true}};
 661 | return lexer;})()
 662 | parser.lexer = lexer;
 663 | function Parser () { this.yy = {}; }Parser.prototype = parser;parser.Parser = Parser;
 664 | return new Parser;
 665 | })();;
 666 | // lib/handlebars/compiler/base.js
 667 | 
 668 | Handlebars.Parser = handlebars;
 669 | 
 670 | Handlebars.parse = function(input) {
 671 | 
 672 |   // Just return if an already-compile AST was passed in.
 673 |   if(input.constructor === Handlebars.AST.ProgramNode) { return input; }
 674 | 
 675 |   Handlebars.Parser.yy = Handlebars.AST;
 676 |   return Handlebars.Parser.parse(input);
 677 | };
 678 | ;
 679 | // lib/handlebars/compiler/ast.js
 680 | Handlebars.AST = {};
 681 | 
 682 | Handlebars.AST.ProgramNode = function(statements, inverse) {
 683 |   this.type = "program";
 684 |   this.statements = statements;
 685 |   if(inverse) { this.inverse = new Handlebars.AST.ProgramNode(inverse); }
 686 | };
 687 | 
 688 | Handlebars.AST.MustacheNode = function(rawParams, hash, unescaped) {
 689 |   this.type = "mustache";
 690 |   this.escaped = !unescaped;
 691 |   this.hash = hash;
 692 | 
 693 |   var id = this.id = rawParams[0];
 694 |   var params = this.params = rawParams.slice(1);
 695 | 
 696 |   // a mustache is an eligible helper if:
 697 |   // * its id is simple (a single part, not `this` or `..`)
 698 |   var eligibleHelper = this.eligibleHelper = id.isSimple;
 699 | 
 700 |   // a mustache is definitely a helper if:
 701 |   // * it is an eligible helper, and
 702 |   // * it has at least one parameter or hash segment
 703 |   this.isHelper = eligibleHelper && (params.length || hash);
 704 | 
 705 |   // if a mustache is an eligible helper but not a definite
 706 |   // helper, it is ambiguous, and will be resolved in a later
 707 |   // pass or at runtime.
 708 | };
 709 | 
 710 | Handlebars.AST.PartialNode = function(partialName, context) {
 711 |   this.type         = "partial";
 712 |   this.partialName  = partialName;
 713 |   this.context      = context;
 714 | };
 715 | 
 716 | Handlebars.AST.BlockNode = function(mustache, program, inverse, close) {
 717 |   var verifyMatch = function(open, close) {
 718 |     if(open.original !== close.original) {
 719 |       throw new Handlebars.Exception(open.original + " doesn't match " + close.original);
 720 |     }
 721 |   };
 722 | 
 723 |   verifyMatch(mustache.id, close);
 724 |   this.type = "block";
 725 |   this.mustache = mustache;
 726 |   this.program  = program;
 727 |   this.inverse  = inverse;
 728 | 
 729 |   if (this.inverse && !this.program) {
 730 |     this.isInverse = true;
 731 |   }
 732 | };
 733 | 
 734 | Handlebars.AST.ContentNode = function(string) {
 735 |   this.type = "content";
 736 |   this.string = string;
 737 | };
 738 | 
 739 | Handlebars.AST.HashNode = function(pairs) {
 740 |   this.type = "hash";
 741 |   this.pairs = pairs;
 742 | };
 743 | 
 744 | Handlebars.AST.IdNode = function(parts) {
 745 |   this.type = "ID";
 746 | 
 747 |   var original = "",
 748 |       dig = [],
 749 |       depth = 0;
 750 | 
 751 |   for(var i=0,l=parts.length; i<l; i++) {
 752 |     var part = parts[i].part;
 753 |     original += (parts[i].separator || '') + part;
 754 | 
 755 |     if (part === ".." || part === "." || part === "this") {
 756 |       if (dig.length > 0) { throw new Handlebars.Exception("Invalid path: " + original); }
 757 |       else if (part === "..") { depth++; }
 758 |       else { this.isScoped = true; }
 759 |     }
 760 |     else { dig.push(part); }
 761 |   }
 762 | 
 763 |   this.original = original;
 764 |   this.parts    = dig;
 765 |   this.string   = dig.join('.');
 766 |   this.depth    = depth;
 767 | 
 768 |   // an ID is simple if it only has one part, and that part is not
 769 |   // `..` or `this`.
 770 |   this.isSimple = parts.length === 1 && !this.isScoped && depth === 0;
 771 | 
 772 |   this.stringModeValue = this.string;
 773 | };
 774 | 
 775 | Handlebars.AST.PartialNameNode = function(name) {
 776 |   this.type = "PARTIAL_NAME";
 777 |   this.name = name.original;
 778 | };
 779 | 
 780 | Handlebars.AST.DataNode = function(id) {
 781 |   this.type = "DATA";
 782 |   this.id = id;
 783 | };
 784 | 
 785 | Handlebars.AST.StringNode = function(string) {
 786 |   this.type = "STRING";
 787 |   this.original =
 788 |     this.string =
 789 |     this.stringModeValue = string;
 790 | };
 791 | 
 792 | Handlebars.AST.IntegerNode = function(integer) {
 793 |   this.type = "INTEGER";
 794 |   this.original =
 795 |     this.integer = integer;
 796 |   this.stringModeValue = Number(integer);
 797 | };
 798 | 
 799 | Handlebars.AST.BooleanNode = function(bool) {
 800 |   this.type = "BOOLEAN";
 801 |   this.bool = bool;
 802 |   this.stringModeValue = bool === "true";
 803 | };
 804 | 
 805 | Handlebars.AST.CommentNode = function(comment) {
 806 |   this.type = "comment";
 807 |   this.comment = comment;
 808 | };
 809 | ;
 810 | // lib/handlebars/utils.js
 811 | 
 812 | var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
 813 | 
 814 | Handlebars.Exception = function(message) {
 815 |   var tmp = Error.prototype.constructor.apply(this, arguments);
 816 | 
 817 |   // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
 818 |   for (var idx = 0; idx < errorProps.length; idx++) {
 819 |     this[errorProps[idx]] = tmp[errorProps[idx]];
 820 |   }
 821 | };
 822 | Handlebars.Exception.prototype = new Error();
 823 | 
 824 | // Build out our basic SafeString type
 825 | Handlebars.SafeString = function(string) {
 826 |   this.string = string;
 827 | };
 828 | Handlebars.SafeString.prototype.toString = function() {
 829 |   return this.string.toString();
 830 | };
 831 | 
 832 | var escape = {
 833 |   "&": "&amp;",
 834 |   "<": "&lt;",
 835 |   ">": "&gt;",
 836 |   '"': "&quot;",
 837 |   "'": "&#x27;",
 838 |   "`": "&#x60;"
 839 | };
 840 | 
 841 | var badChars = /[&<>"'`]/g;
 842 | var possible = /[&<>"'`]/;
 843 | 
 844 | var escapeChar = function(chr) {
 845 |   return escape[chr] || "&amp;";
 846 | };
 847 | 
 848 | Handlebars.Utils = {
 849 |   extend: function(obj, value) {
 850 |     for(var key in value) {
 851 |       if(value.hasOwnProperty(key)) {
 852 |         obj[key] = value[key];
 853 |       }
 854 |     }
 855 |   },
 856 | 
 857 |   escapeExpression: function(string) {
 858 |     // don't escape SafeStrings, since they're already safe
 859 |     if (string instanceof Handlebars.SafeString) {
 860 |       return string.toString();
 861 |     } else if (string == null || string === false) {
 862 |       return "";
 863 |     }
 864 | 
 865 |     // Force a string conversion as this will be done by the append regardless and
 866 |     // the regex test will do this transparently behind the scenes, causing issues if
 867 |     // an object's to string has escaped characters in it.
 868 |     string = string.toString();
 869 | 
 870 |     if(!possible.test(string)) { return string; }
 871 |     return string.replace(badChars, escapeChar);
 872 |   },
 873 | 
 874 |   isEmpty: function(value) {
 875 |     if (!value && value !== 0) {
 876 |       return true;
 877 |     } else if(toString.call(value) === "[object Array]" && value.length === 0) {
 878 |       return true;
 879 |     } else {
 880 |       return false;
 881 |     }
 882 |   }
 883 | };
 884 | ;
 885 | // lib/handlebars/compiler/compiler.js
 886 | 
 887 | /*jshint eqnull:true*/
 888 | var Compiler = Handlebars.Compiler = function() {};
 889 | var JavaScriptCompiler = Handlebars.JavaScriptCompiler = function() {};
 890 | 
 891 | // the foundHelper register will disambiguate helper lookup from finding a
 892 | // function in a context. This is necessary for mustache compatibility, which
 893 | // requires that context functions in blocks are evaluated by blockHelperMissing,
 894 | // and then proceed as if the resulting value was provided to blockHelperMissing.
 895 | 
 896 | Compiler.prototype = {
 897 |   compiler: Compiler,
 898 | 
 899 |   disassemble: function() {
 900 |     var opcodes = this.opcodes, opcode, out = [], params, param;
 901 | 
 902 |     for (var i=0, l=opcodes.length; i<l; i++) {
 903 |       opcode = opcodes[i];
 904 | 
 905 |       if (opcode.opcode === 'DECLARE') {
 906 |         out.push("DECLARE " + opcode.name + "=" + opcode.value);
 907 |       } else {
 908 |         params = [];
 909 |         for (var j=0; j<opcode.args.length; j++) {
 910 |           param = opcode.args[j];
 911 |           if (typeof param === "string") {
 912 |             param = "\"" + param.replace("\n", "\\n") + "\"";
 913 |           }
 914 |           params.push(param);
 915 |         }
 916 |         out.push(opcode.opcode + " " + params.join(" "));
 917 |       }
 918 |     }
 919 | 
 920 |     return out.join("\n");
 921 |   },
 922 |   equals: function(other) {
 923 |     var len = this.opcodes.length;
 924 |     if (other.opcodes.length !== len) {
 925 |       return false;
 926 |     }
 927 | 
 928 |     for (var i = 0; i < len; i++) {
 929 |       var opcode = this.opcodes[i],
 930 |           otherOpcode = other.opcodes[i];
 931 |       if (opcode.opcode !== otherOpcode.opcode || opcode.args.length !== otherOpcode.args.length) {
 932 |         return false;
 933 |       }
 934 |       for (var j = 0; j < opcode.args.length; j++) {
 935 |         if (opcode.args[j] !== otherOpcode.args[j]) {
 936 |           return false;
 937 |         }
 938 |       }
 939 |     }
 940 | 
 941 |     len = this.children.length;
 942 |     if (other.children.length !== len) {
 943 |       return false;
 944 |     }
 945 |     for (i = 0; i < len; i++) {
 946 |       if (!this.children[i].equals(other.children[i])) {
 947 |         return false;
 948 |       }
 949 |     }
 950 | 
 951 |     return true;
 952 |   },
 953 | 
 954 |   guid: 0,
 955 | 
 956 |   compile: function(program, options) {
 957 |     this.children = [];
 958 |     this.depths = {list: []};
 959 |     this.options = options;
 960 | 
 961 |     // These changes will propagate to the other compiler components
 962 |     var knownHelpers = this.options.knownHelpers;
 963 |     this.options.knownHelpers = {
 964 |       'helperMissing': true,
 965 |       'blockHelperMissing': true,
 966 |       'each': true,
 967 |       'if': true,
 968 |       'unless': true,
 969 |       'with': true,
 970 |       'log': true
 971 |     };
 972 |     if (knownHelpers) {
 973 |       for (var name in knownHelpers) {
 974 |         this.options.knownHelpers[name] = knownHelpers[name];
 975 |       }
 976 |     }
 977 | 
 978 |     return this.program(program);
 979 |   },
 980 | 
 981 |   accept: function(node) {
 982 |     return this[node.type](node);
 983 |   },
 984 | 
 985 |   program: function(program) {
 986 |     var statements = program.statements, statement;
 987 |     this.opcodes = [];
 988 | 
 989 |     for(var i=0, l=statements.length; i<l; i++) {
 990 |       statement = statements[i];
 991 |       this[statement.type](statement);
 992 |     }
 993 |     this.isSimple = l === 1;
 994 | 
 995 |     this.depths.list = this.depths.list.sort(function(a, b) {
 996 |       return a - b;
 997 |     });
 998 | 
 999 |     return this;
1000 |   },
1001 | 
1002 |   compileProgram: function(program) {
1003 |     var result = new this.compiler().compile(program, this.options);
1004 |     var guid = this.guid++, depth;
1005 | 
1006 |     this.usePartial = this.usePartial || result.usePartial;
1007 | 
1008 |     this.children[guid] = result;
1009 | 
1010 |     for(var i=0, l=result.depths.list.length; i<l; i++) {
1011 |       depth = result.depths.list[i];
1012 | 
1013 |       if(depth < 2) { continue; }
1014 |       else { this.addDepth(depth - 1); }
1015 |     }
1016 | 
1017 |     return guid;
1018 |   },
1019 | 
1020 |   block: function(block) {
1021 |     var mustache = block.mustache,
1022 |         program = block.program,
1023 |         inverse = block.inverse;
1024 | 
1025 |     if (program) {
1026 |       program = this.compileProgram(program);
1027 |     }
1028 | 
1029 |     if (inverse) {
1030 |       inverse = this.compileProgram(inverse);
1031 |     }
1032 | 
1033 |     var type = this.classifyMustache(mustache);
1034 | 
1035 |     if (type === "helper") {
1036 |       this.helperMustache(mustache, program, inverse);
1037 |     } else if (type === "simple") {
1038 |       this.simpleMustache(mustache);
1039 | 
1040 |       // now that the simple mustache is resolved, we need to
1041 |       // evaluate it by executing `blockHelperMissing`
1042 |       this.opcode('pushProgram', program);
1043 |       this.opcode('pushProgram', inverse);
1044 |       this.opcode('emptyHash');
1045 |       this.opcode('blockValue');
1046 |     } else {
1047 |       this.ambiguousMustache(mustache, program, inverse);
1048 | 
1049 |       // now that the simple mustache is resolved, we need to
1050 |       // evaluate it by executing `blockHelperMissing`
1051 |       this.opcode('pushProgram', program);
1052 |       this.opcode('pushProgram', inverse);
1053 |       this.opcode('emptyHash');
1054 |       this.opcode('ambiguousBlockValue');
1055 |     }
1056 | 
1057 |     this.opcode('append');
1058 |   },
1059 | 
1060 |   hash: function(hash) {
1061 |     var pairs = hash.pairs, pair, val;
1062 | 
1063 |     this.opcode('pushHash');
1064 | 
1065 |     for(var i=0, l=pairs.length; i<l; i++) {
1066 |       pair = pairs[i];
1067 |       val  = pair[1];
1068 | 
1069 |       if (this.options.stringParams) {
1070 |         if(val.depth) {
1071 |           this.addDepth(val.depth);
1072 |         }
1073 |         this.opcode('getContext', val.depth || 0);
1074 |         this.opcode('pushStringParam', val.stringModeValue, val.type);
1075 |       } else {
1076 |         this.accept(val);
1077 |       }
1078 | 
1079 |       this.opcode('assignToHash', pair[0]);
1080 |     }
1081 |     this.opcode('popHash');
1082 |   },
1083 | 
1084 |   partial: function(partial) {
1085 |     var partialName = partial.partialName;
1086 |     this.usePartial = true;
1087 | 
1088 |     if(partial.context) {
1089 |       this.ID(partial.context);
1090 |     } else {
1091 |       this.opcode('push', 'depth0');
1092 |     }
1093 | 
1094 |     this.opcode('invokePartial', partialName.name);
1095 |     this.opcode('append');
1096 |   },
1097 | 
1098 |   content: function(content) {
1099 |     this.opcode('appendContent', content.string);
1100 |   },
1101 | 
1102 |   mustache: function(mustache) {
1103 |     var options = this.options;
1104 |     var type = this.classifyMustache(mustache);
1105 | 
1106 |     if (type === "simple") {
1107 |       this.simpleMustache(mustache);
1108 |     } else if (type === "helper") {
1109 |       this.helperMustache(mustache);
1110 |     } else {
1111 |       this.ambiguousMustache(mustache);
1112 |     }
1113 | 
1114 |     if(mustache.escaped && !options.noEscape) {
1115 |       this.opcode('appendEscaped');
1116 |     } else {
1117 |       this.opcode('append');
1118 |     }
1119 |   },
1120 | 
1121 |   ambiguousMustache: function(mustache, program, inverse) {
1122 |     var id = mustache.id,
1123 |         name = id.parts[0],
1124 |         isBlock = program != null || inverse != null;
1125 | 
1126 |     this.opcode('getContext', id.depth);
1127 | 
1128 |     this.opcode('pushProgram', program);
1129 |     this.opcode('pushProgram', inverse);
1130 | 
1131 |     this.opcode('invokeAmbiguous', name, isBlock);
1132 |   },
1133 | 
1134 |   simpleMustache: function(mustache) {
1135 |     var id = mustache.id;
1136 | 
1137 |     if (id.type === 'DATA') {
1138 |       this.DATA(id);
1139 |     } else if (id.parts.length) {
1140 |       this.ID(id);
1141 |     } else {
1142 |       // Simplified ID for `this`
1143 |       this.addDepth(id.depth);
1144 |       this.opcode('getContext', id.depth);
1145 |       this.opcode('pushContext');
1146 |     }
1147 | 
1148 |     this.opcode('resolvePossibleLambda');
1149 |   },
1150 | 
1151 |   helperMustache: function(mustache, program, inverse) {
1152 |     var params = this.setupFullMustacheParams(mustache, program, inverse),
1153 |         name = mustache.id.parts[0];
1154 | 
1155 |     if (this.options.knownHelpers[name]) {
1156 |       this.opcode('invokeKnownHelper', params.length, name);
1157 |     } else if (this.options.knownHelpersOnly) {
1158 |       throw new Error("You specified knownHelpersOnly, but used the unknown helper " + name);
1159 |     } else {
1160 |       this.opcode('invokeHelper', params.length, name);
1161 |     }
1162 |   },
1163 | 
1164 |   ID: function(id) {
1165 |     this.addDepth(id.depth);
1166 |     this.opcode('getContext', id.depth);
1167 | 
1168 |     var name = id.parts[0];
1169 |     if (!name) {
1170 |       this.opcode('pushContext');
1171 |     } else {
1172 |       this.opcode('lookupOnContext', id.parts[0]);
1173 |     }
1174 | 
1175 |     for(var i=1, l=id.parts.length; i<l; i++) {
1176 |       this.opcode('lookup', id.parts[i]);
1177 |     }
1178 |   },
1179 | 
1180 |   DATA: function(data) {
1181 |     this.options.data = true;
1182 |     if (data.id.isScoped || data.id.depth) {
1183 |       throw new Handlebars.Exception('Scoped data references are not supported: ' + data.original);
1184 |     }
1185 | 
1186 |     this.opcode('lookupData');
1187 |     var parts = data.id.parts;
1188 |     for(var i=0, l=parts.length; i<l; i++) {
1189 |       this.opcode('lookup', parts[i]);
1190 |     }
1191 |   },
1192 | 
1193 |   STRING: function(string) {
1194 |     this.opcode('pushString', string.string);
1195 |   },
1196 | 
1197 |   INTEGER: function(integer) {
1198 |     this.opcode('pushLiteral', integer.integer);
1199 |   },
1200 | 
1201 |   BOOLEAN: function(bool) {
1202 |     this.opcode('pushLiteral', bool.bool);
1203 |   },
1204 | 
1205 |   comment: function() {},
1206 | 
1207 |   // HELPERS
1208 |   opcode: function(name) {
1209 |     this.opcodes.push({ opcode: name, args: [].slice.call(arguments, 1) });
1210 |   },
1211 | 
1212 |   declare: function(name, value) {
1213 |     this.opcodes.push({ opcode: 'DECLARE', name: name, value: value });
1214 |   },
1215 | 
1216 |   addDepth: function(depth) {
1217 |     if(isNaN(depth)) { throw new Error("EWOT"); }
1218 |     if(depth === 0) { return; }
1219 | 
1220 |     if(!this.depths[depth]) {
1221 |       this.depths[depth] = true;
1222 |       this.depths.list.push(depth);
1223 |     }
1224 |   },
1225 | 
1226 |   classifyMustache: function(mustache) {
1227 |     var isHelper   = mustache.isHelper;
1228 |     var isEligible = mustache.eligibleHelper;
1229 |     var options    = this.options;
1230 | 
1231 |     // if ambiguous, we can possibly resolve the ambiguity now
1232 |     if (isEligible && !isHelper) {
1233 |       var name = mustache.id.parts[0];
1234 | 
1235 |       if (options.knownHelpers[name]) {
1236 |         isHelper = true;
1237 |       } else if (options.knownHelpersOnly) {
1238 |         isEligible = false;
1239 |       }
1240 |     }
1241 | 
1242 |     if (isHelper) { return "helper"; }
1243 |     else if (isEligible) { return "ambiguous"; }
1244 |     else { return "simple"; }
1245 |   },
1246 | 
1247 |   pushParams: function(params) {
1248 |     var i = params.length, param;
1249 | 
1250 |     while(i--) {
1251 |       param = params[i];
1252 | 
1253 |       if(this.options.stringParams) {
1254 |         if(param.depth) {
1255 |           this.addDepth(param.depth);
1256 |         }
1257 | 
1258 |         this.opcode('getContext', param.depth || 0);
1259 |         this.opcode('pushStringParam', param.stringModeValue, param.type);
1260 |       } else {
1261 |         this[param.type](param);
1262 |       }
1263 |     }
1264 |   },
1265 | 
1266 |   setupMustacheParams: function(mustache) {
1267 |     var params = mustache.params;
1268 |     this.pushParams(params);
1269 | 
1270 |     if(mustache.hash) {
1271 |       this.hash(mustache.hash);
1272 |     } else {
1273 |       this.opcode('emptyHash');
1274 |     }
1275 | 
1276 |     return params;
1277 |   },
1278 | 
1279 |   // this will replace setupMustacheParams when we're done
1280 |   setupFullMustacheParams: function(mustache, program, inverse) {
1281 |     var params = mustache.params;
1282 |     this.pushParams(params);
1283 | 
1284 |     this.opcode('pushProgram', program);
1285 |     this.opcode('pushProgram', inverse);
1286 | 
1287 |     if(mustache.hash) {
1288 |       this.hash(mustache.hash);
1289 |     } else {
1290 |       this.opcode('emptyHash');
1291 |     }
1292 | 
1293 |     return params;
1294 |   }
1295 | };
1296 | 
1297 | var Literal = function(value) {
1298 |   this.value = value;
1299 | };
1300 | 
1301 | JavaScriptCompiler.prototype = {
1302 |   // PUBLIC API: You can override these methods in a subclass to provide
1303 |   // alternative compiled forms for name lookup and buffering semantics
1304 |   nameLookup: function(parent, name /* , type*/) {
1305 |     if (/^[0-9]+$/.test(name)) {
1306 |       return parent + "[" + name + "]";
1307 |     } else if (JavaScriptCompiler.isValidJavaScriptVariableName(name)) {
1308 |       return parent + "." + name;
1309 |     }
1310 |     else {
1311 |       return parent + "['" + name + "']";
1312 |     }
1313 |   },
1314 | 
1315 |   appendToBuffer: function(string) {
1316 |     if (this.environment.isSimple) {
1317 |       return "return " + string + ";";
1318 |     } else {
1319 |       return {
1320 |         appendToBuffer: true,
1321 |         content: string,
1322 |         toString: function() { return "buffer += " + string + ";"; }
1323 |       };
1324 |     }
1325 |   },
1326 | 
1327 |   initializeBuffer: function() {
1328 |     return this.quotedString("");
1329 |   },
1330 | 
1331 |   namespace: "Handlebars",
1332 |   // END PUBLIC API
1333 | 
1334 |   compile: function(environment, options, context, asObject) {
1335 |     this.environment = environment;
1336 |     this.options = options || {};
1337 | 
1338 |     Handlebars.log(Handlebars.logger.DEBUG, this.environment.disassemble() + "\n\n");
1339 | 
1340 |     this.name = this.environment.name;
1341 |     this.isChild = !!context;
1342 |     this.context = context || {
1343 |       programs: [],
1344 |       environments: [],
1345 |       aliases: { }
1346 |     };
1347 | 
1348 |     this.preamble();
1349 | 
1350 |     this.stackSlot = 0;
1351 |     this.stackVars = [];
1352 |     this.registers = { list: [] };
1353 |     this.compileStack = [];
1354 |     this.inlineStack = [];
1355 | 
1356 |     this.compileChildren(environment, options);
1357 | 
1358 |     var opcodes = environment.opcodes, opcode;
1359 | 
1360 |     this.i = 0;
1361 | 
1362 |     for(l=opcodes.length; this.i<l; this.i++) {
1363 |       opcode = opcodes[this.i];
1364 | 
1365 |       if(opcode.opcode === 'DECLARE') {
1366 |         this[opcode.name] = opcode.value;
1367 |       } else {
1368 |         this[opcode.opcode].apply(this, opcode.args);
1369 |       }
1370 |     }
1371 | 
1372 |     return this.createFunctionContext(asObject);
1373 |   },
1374 | 
1375 |   nextOpcode: function() {
1376 |     var opcodes = this.environment.opcodes;
1377 |     return opcodes[this.i + 1];
1378 |   },
1379 | 
1380 |   eat: function() {
1381 |     this.i = this.i + 1;
1382 |   },
1383 | 
1384 |   preamble: function() {
1385 |     var out = [];
1386 | 
1387 |     if (!this.isChild) {
1388 |       var namespace = this.namespace;
1389 | 
1390 |       var copies = "helpers = this.merge(helpers, " + namespace + ".helpers);";
1391 |       if (this.environment.usePartial) { copies = copies + " partials = this.merge(partials, " + namespace + ".partials);"; }
1392 |       if (this.options.data) { copies = copies + " data = data || {};"; }
1393 |       out.push(copies);
1394 |     } else {
1395 |       out.push('');
1396 |     }
1397 | 
1398 |     if (!this.environment.isSimple) {
1399 |       out.push(", buffer = " + this.initializeBuffer());
1400 |     } else {
1401 |       out.push("");
1402 |     }
1403 | 
1404 |     // track the last context pushed into place to allow skipping the
1405 |     // getContext opcode when it would be a noop
1406 |     this.lastContext = 0;
1407 |     this.source = out;
1408 |   },
1409 | 
1410 |   createFunctionContext: function(asObject) {
1411 |     var locals = this.stackVars.concat(this.registers.list);
1412 | 
1413 |     if(locals.length > 0) {
1414 |       this.source[1] = this.source[1] + ", " + locals.join(", ");
1415 |     }
1416 | 
1417 |     // Generate minimizer alias mappings
1418 |     if (!this.isChild) {
1419 |       for (var alias in this.context.aliases) {
1420 |         if (this.context.aliases.hasOwnProperty(alias)) {
1421 |           this.source[1] = this.source[1] + ', ' + alias + '=' + this.context.aliases[alias];
1422 |         }
1423 |       }
1424 |     }
1425 | 
1426 |     if (this.source[1]) {
1427 |       this.source[1] = "var " + this.source[1].substring(2) + ";";
1428 |     }
1429 | 
1430 |     // Merge children
1431 |     if (!this.isChild) {
1432 |       this.source[1] += '\n' + this.context.programs.join('\n') + '\n';
1433 |     }
1434 | 
1435 |     if (!this.environment.isSimple) {
1436 |       this.source.push("return buffer;");
1437 |     }
1438 | 
1439 |     var params = this.isChild ? ["depth0", "data"] : ["Handlebars", "depth0", "helpers", "partials", "data"];
1440 | 
1441 |     for(var i=0, l=this.environment.depths.list.length; i<l; i++) {
1442 |       params.push("depth" + this.environment.depths.list[i]);
1443 |     }
1444 | 
1445 |     // Perform a second pass over the output to merge content when possible
1446 |     var source = this.mergeSource();
1447 | 
1448 |     if (!this.isChild) {
1449 |       var revision = Handlebars.COMPILER_REVISION,
1450 |           versions = Handlebars.REVISION_CHANGES[revision];
1451 |       source = "this.compilerInfo = ["+revision+",'"+versions+"'];\n"+source;
1452 |     }
1453 | 
1454 |     if (asObject) {
1455 |       params.push(source);
1456 | 
1457 |       return Function.apply(this, params);
1458 |     } else {
1459 |       var functionSource = 'function ' + (this.name || '') + '(' + params.join(',') + ') {\n  ' + source + '}';
1460 |       Handlebars.log(Handlebars.logger.DEBUG, functionSource + "\n\n");
1461 |       return functionSource;
1462 |     }
1463 |   },
1464 |   mergeSource: function() {
1465 |     // WARN: We are not handling the case where buffer is still populated as the source should
1466 |     // not have buffer append operations as their final action.
1467 |     var source = '',
1468 |         buffer;
1469 |     for (var i = 0, len = this.source.length; i < len; i++) {
1470 |       var line = this.source[i];
1471 |       if (line.appendToBuffer) {
1472 |         if (buffer) {
1473 |           buffer = buffer + '\n    + ' + line.content;
1474 |         } else {
1475 |           buffer = line.content;
1476 |         }
1477 |       } else {
1478 |         if (buffer) {
1479 |           source += 'buffer += ' + buffer + ';\n  ';
1480 |           buffer = undefined;
1481 |         }
1482 |         source += line + '\n  ';
1483 |       }
1484 |     }
1485 |     return source;
1486 |   },
1487 | 
1488 |   // [blockValue]
1489 |   //
1490 |   // On stack, before: hash, inverse, program, value
1491 |   // On stack, after: return value of blockHelperMissing
1492 |   //
1493 |   // The purpose of this opcode is to take a block of the form
1494 |   // `{{#foo}}...{{/foo}}`, resolve the value of `foo`, and
1495 |   // replace it on the stack with the result of properly
1496 |   // invoking blockHelperMissing.
1497 |   blockValue: function() {
1498 |     this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
1499 | 
1500 |     var params = ["depth0"];
1501 |     this.setupParams(0, params);
1502 | 
1503 |     this.replaceStack(function(current) {
1504 |       params.splice(1, 0, current);
1505 |       return "blockHelperMissing.call(" + params.join(", ") + ")";
1506 |     });
1507 |   },
1508 | 
1509 |   // [ambiguousBlockValue]
1510 |   //
1511 |   // On stack, before: hash, inverse, program, value
1512 |   // Compiler value, before: lastHelper=value of last found helper, if any
1513 |   // On stack, after, if no lastHelper: same as [blockValue]
1514 |   // On stack, after, if lastHelper: value
1515 |   ambiguousBlockValue: function() {
1516 |     this.context.aliases.blockHelperMissing = 'helpers.blockHelperMissing';
1517 | 
1518 |     var params = ["depth0"];
1519 |     this.setupParams(0, params);
1520 | 
1521 |     var current = this.topStack();
1522 |     params.splice(1, 0, current);
1523 | 
1524 |     // Use the options value generated from the invocation
1525 |     params[params.length-1] = 'options';
1526 | 
1527 |     this.source.push("if (!" + this.lastHelper + ") { " + current + " = blockHelperMissing.call(" + params.join(", ") + "); }");
1528 |   },
1529 | 
1530 |   // [appendContent]
1531 |   //
1532 |   // On stack, before: ...
1533 |   // On stack, after: ...
1534 |   //
1535 |   // Appends the string value of `content` to the current buffer
1536 |   appendContent: function(content) {
1537 |     this.source.push(this.appendToBuffer(this.quotedString(content)));
1538 |   },
1539 | 
1540 |   // [append]
1541 |   //
1542 |   // On stack, before: value, ...
1543 |   // On stack, after: ...
1544 |   //
1545 |   // Coerces `value` to a String and appends it to the current buffer.
1546 |   //
1547 |   // If `value` is truthy, or 0, it is coerced into a string and appended
1548 |   // Otherwise, the empty string is appended
1549 |   append: function() {
1550 |     // Force anything that is inlined onto the stack so we don't have duplication
1551 |     // when we examine local
1552 |     this.flushInline();
1553 |     var local = this.popStack();
1554 |     this.source.push("if(" + local + " || " + local + " === 0) { " + this.appendToBuffer(local) + " }");
1555 |     if (this.environment.isSimple) {
1556 |       this.source.push("else { " + this.appendToBuffer("''") + " }");
1557 |     }
1558 |   },
1559 | 
1560 |   // [appendEscaped]
1561 |   //
1562 |   // On stack, before: value, ...
1563 |   // On stack, after: ...
1564 |   //
1565 |   // Escape `value` and append it to the buffer
1566 |   appendEscaped: function() {
1567 |     this.context.aliases.escapeExpression = 'this.escapeExpression';
1568 | 
1569 |     this.source.push(this.appendToBuffer("escapeExpression(" + this.popStack() + ")"));
1570 |   },
1571 | 
1572 |   // [getContext]
1573 |   //
1574 |   // On stack, before: ...
1575 |   // On stack, after: ...
1576 |   // Compiler value, after: lastContext=depth
1577 |   //
1578 |   // Set the value of the `lastContext` compiler value to the depth
1579 |   getContext: function(depth) {
1580 |     if(this.lastContext !== depth) {
1581 |       this.lastContext = depth;
1582 |     }
1583 |   },
1584 | 
1585 |   // [lookupOnContext]
1586 |   //
1587 |   // On stack, before: ...
1588 |   // On stack, after: currentContext[name], ...
1589 |   //
1590 |   // Looks up the value of `name` on the current context and pushes
1591 |   // it onto the stack.
1592 |   lookupOnContext: function(name) {
1593 |     this.push(this.nameLookup('depth' + this.lastContext, name, 'context'));
1594 |   },
1595 | 
1596 |   // [pushContext]
1597 |   //
1598 |   // On stack, before: ...
1599 |   // On stack, after: currentContext, ...
1600 |   //
1601 |   // Pushes the value of the current context onto the stack.
1602 |   pushContext: function() {
1603 |     this.pushStackLiteral('depth' + this.lastContext);
1604 |   },
1605 | 
1606 |   // [resolvePossibleLambda]
1607 |   //
1608 |   // On stack, before: value, ...
1609 |   // On stack, after: resolved value, ...
1610 |   //
1611 |   // If the `value` is a lambda, replace it on the stack by
1612 |   // the return value of the lambda
1613 |   resolvePossibleLambda: function() {
1614 |     this.context.aliases.functionType = '"function"';
1615 | 
1616 |     this.replaceStack(function(current) {
1617 |       return "typeof " + current + " === functionType ? " + current + ".apply(depth0) : " + current;
1618 |     });
1619 |   },
1620 | 
1621 |   // [lookup]
1622 |   //
1623 |   // On stack, before: value, ...
1624 |   // On stack, after: value[name], ...
1625 |   //
1626 |   // Replace the value on the stack with the result of looking
1627 |   // up `name` on `value`
1628 |   lookup: function(name) {
1629 |     this.replaceStack(function(current) {
1630 |       return current + " == null || " + current + " === false ? " + current + " : " + this.nameLookup(current, name, 'context');
1631 |     });
1632 |   },
1633 | 
1634 |   // [lookupData]
1635 |   //
1636 |   // On stack, before: ...
1637 |   // On stack, after: data[id], ...
1638 |   //
1639 |   // Push the result of looking up `id` on the current data
1640 |   lookupData: function(id) {
1641 |     this.push('data');
1642 |   },
1643 | 
1644 |   // [pushStringParam]
1645 |   //
1646 |   // On stack, before: ...
1647 |   // On stack, after: string, currentContext, ...
1648 |   //
1649 |   // This opcode is designed for use in string mode, which
1650 |   // provides the string value of a parameter along with its
1651 |   // depth rather than resolving it immediately.
1652 |   pushStringParam: function(string, type) {
1653 |     this.pushStackLiteral('depth' + this.lastContext);
1654 | 
1655 |     this.pushString(type);
1656 | 
1657 |     if (typeof string === 'string') {
1658 |       this.pushString(string);
1659 |     } else {
1660 |       this.pushStackLiteral(string);
1661 |     }
1662 |   },
1663 | 
1664 |   emptyHash: function() {
1665 |     this.pushStackLiteral('{}');
1666 | 
1667 |     if (this.options.stringParams) {
1668 |       this.register('hashTypes', '{}');
1669 |       this.register('hashContexts', '{}');
1670 |     }
1671 |   },
1672 |   pushHash: function() {
1673 |     this.hash = {values: [], types: [], contexts: []};
1674 |   },
1675 |   popHash: function() {
1676 |     var hash = this.hash;
1677 |     this.hash = undefined;
1678 | 
1679 |     if (this.options.stringParams) {
1680 |       this.register('hashContexts', '{' + hash.contexts.join(',') + '}');
1681 |       this.register('hashTypes', '{' + hash.types.join(',') + '}');
1682 |     }
1683 |     this.push('{\n    ' + hash.values.join(',\n    ') + '\n  }');
1684 |   },
1685 | 
1686 |   // [pushString]
1687 |   //
1688 |   // On stack, before: ...
1689 |   // On stack, after: quotedString(string), ...
1690 |   //
1691 |   // Push a quoted version of `string` onto the stack
1692 |   pushString: function(string) {
1693 |     this.pushStackLiteral(this.quotedString(string));
1694 |   },
1695 | 
1696 |   // [push]
1697 |   //
1698 |   // On stack, before: ...
1699 |   // On stack, after: expr, ...
1700 |   //
1701 |   // Push an expression onto the stack
1702 |   push: function(expr) {
1703 |     this.inlineStack.push(expr);
1704 |     return expr;
1705 |   },
1706 | 
1707 |   // [pushLiteral]
1708 |   //
1709 |   // On stack, before: ...
1710 |   // On stack, after: value, ...
1711 |   //
1712 |   // Pushes a value onto the stack. This operation prevents
1713 |   // the compiler from creating a temporary variable to hold
1714 |   // it.
1715 |   pushLiteral: function(value) {
1716 |     this.pushStackLiteral(value);
1717 |   },
1718 | 
1719 |   // [pushProgram]
1720 |   //
1721 |   // On stack, before: ...
1722 |   // On stack, after: program(guid), ...
1723 |   //
1724 |   // Push a program expression onto the stack. This takes
1725 |   // a compile-time guid and converts it into a runtime-accessible
1726 |   // expression.
1727 |   pushProgram: function(guid) {
1728 |     if (guid != null) {
1729 |       this.pushStackLiteral(this.programExpression(guid));
1730 |     } else {
1731 |       this.pushStackLiteral(null);
1732 |     }
1733 |   },
1734 | 
1735 |   // [invokeHelper]
1736 |   //
1737 |   // On stack, before: hash, inverse, program, params..., ...
1738 |   // On stack, after: result of helper invocation
1739 |   //
1740 |   // Pops off the helper's parameters, invokes the helper,
1741 |   // and pushes the helper's return value onto the stack.
1742 |   //
1743 |   // If the helper is not found, `helperMissing` is called.
1744 |   invokeHelper: function(paramSize, name) {
1745 |     this.context.aliases.helperMissing = 'helpers.helperMissing';
1746 | 
1747 |     var helper = this.lastHelper = this.setupHelper(paramSize, name, true);
1748 |     var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
1749 | 
1750 |     this.push(helper.name + ' || ' + nonHelper);
1751 |     this.replaceStack(function(name) {
1752 |       return name + ' ? ' + name + '.call(' +
1753 |           helper.callParams + ") " + ": helperMissing.call(" +
1754 |           helper.helperMissingParams + ")";
1755 |     });
1756 |   },
1757 | 
1758 |   // [invokeKnownHelper]
1759 |   //
1760 |   // On stack, before: hash, inverse, program, params..., ...
1761 |   // On stack, after: result of helper invocation
1762 |   //
1763 |   // This operation is used when the helper is known to exist,
1764 |   // so a `helperMissing` fallback is not required.
1765 |   invokeKnownHelper: function(paramSize, name) {
1766 |     var helper = this.setupHelper(paramSize, name);
1767 |     this.push(helper.name + ".call(" + helper.callParams + ")");
1768 |   },
1769 | 
1770 |   // [invokeAmbiguous]
1771 |   //
1772 |   // On stack, before: hash, inverse, program, params..., ...
1773 |   // On stack, after: result of disambiguation
1774 |   //
1775 |   // This operation is used when an expression like `{{foo}}`
1776 |   // is provided, but we don't know at compile-time whether it
1777 |   // is a helper or a path.
1778 |   //
1779 |   // This operation emits more code than the other options,
1780 |   // and can be avoided by passing the `knownHelpers` and
1781 |   // `knownHelpersOnly` flags at compile-time.
1782 |   invokeAmbiguous: function(name, helperCall) {
1783 |     this.context.aliases.functionType = '"function"';
1784 | 
1785 |     this.pushStackLiteral('{}');    // Hash value
1786 |     var helper = this.setupHelper(0, name, helperCall);
1787 | 
1788 |     var helperName = this.lastHelper = this.nameLookup('helpers', name, 'helper');
1789 | 
1790 |     var nonHelper = this.nameLookup('depth' + this.lastContext, name, 'context');
1791 |     var nextStack = this.nextStack();
1792 | 
1793 |     this.source.push('if (' + nextStack + ' = ' + helperName + ') { ' + nextStack + ' = ' + nextStack + '.call(' + helper.callParams + '); }');
1794 |     this.source.push('else { ' + nextStack + ' = ' + nonHelper + '; ' + nextStack + ' = typeof ' + nextStack + ' === functionType ? ' + nextStack + '.apply(depth0) : ' + nextStack + '; }');
1795 |   },
1796 | 
1797 |   // [invokePartial]
1798 |   //
1799 |   // On stack, before: context, ...
1800 |   // On stack after: result of partial invocation
1801 |   //
1802 |   // This operation pops off a context, invokes a partial with that context,
1803 |   // and pushes the result of the invocation back.
1804 |   invokePartial: function(name) {
1805 |     var params = [this.nameLookup('partials', name, 'partial'), "'" + name + "'", this.popStack(), "helpers", "partials"];
1806 | 
1807 |     if (this.options.data) {
1808 |       params.push("data");
1809 |     }
1810 | 
1811 |     this.context.aliases.self = "this";
1812 |     this.push("self.invokePartial(" + params.join(", ") + ")");
1813 |   },
1814 | 
1815 |   // [assignToHash]
1816 |   //
1817 |   // On stack, before: value, hash, ...
1818 |   // On stack, after: hash, ...
1819 |   //
1820 |   // Pops a value and hash off the stack, assigns `hash[key] = value`
1821 |   // and pushes the hash back onto the stack.
1822 |   assignToHash: function(key) {
1823 |     var value = this.popStack(),
1824 |         context,
1825 |         type;
1826 | 
1827 |     if (this.options.stringParams) {
1828 |       type = this.popStack();
1829 |       context = this.popStack();
1830 |     }
1831 | 
1832 |     var hash = this.hash;
1833 |     if (context) {
1834 |       hash.contexts.push("'" + key + "': " + context);
1835 |     }
1836 |     if (type) {
1837 |       hash.types.push("'" + key + "': " + type);
1838 |     }
1839 |     hash.values.push("'" + key + "': (" + value + ")");
1840 |   },
1841 | 
1842 |   // HELPERS
1843 | 
1844 |   compiler: JavaScriptCompiler,
1845 | 
1846 |   compileChildren: function(environment, options) {
1847 |     var children = environment.children, child, compiler;
1848 | 
1849 |     for(var i=0, l=children.length; i<l; i++) {
1850 |       child = children[i];
1851 |       compiler = new this.compiler();
1852 | 
1853 |       var index = this.matchExistingProgram(child);
1854 | 
1855 |       if (index == null) {
1856 |         this.context.programs.push('');     // Placeholder to prevent name conflicts for nested children
1857 |         index = this.context.programs.length;
1858 |         child.index = index;
1859 |         child.name = 'program' + index;
1860 |         this.context.programs[index] = compiler.compile(child, options, this.context);
1861 |         this.context.environments[index] = child;
1862 |       } else {
1863 |         child.index = index;
1864 |         child.name = 'program' + index;
1865 |       }
1866 |     }
1867 |   },
1868 |   matchExistingProgram: function(child) {
1869 |     for (var i = 0, len = this.context.environments.length; i < len; i++) {
1870 |       var environment = this.context.environments[i];
1871 |       if (environment && environment.equals(child)) {
1872 |         return i;
1873 |       }
1874 |     }
1875 |   },
1876 | 
1877 |   programExpression: function(guid) {
1878 |     this.context.aliases.self = "this";
1879 | 
1880 |     if(guid == null) {
1881 |       return "self.noop";
1882 |     }
1883 | 
1884 |     var child = this.environment.children[guid],
1885 |         depths = child.depths.list, depth;
1886 | 
1887 |     var programParams = [child.index, child.name, "data"];
1888 | 
1889 |     for(var i=0, l = depths.length; i<l; i++) {
1890 |       depth = depths[i];
1891 | 
1892 |       if(depth === 1) { programParams.push("depth0"); }
1893 |       else { programParams.push("depth" + (depth - 1)); }
1894 |     }
1895 | 
1896 |     return (depths.length === 0 ? "self.program(" : "self.programWithDepth(") + programParams.join(", ") + ")";
1897 |   },
1898 | 
1899 |   register: function(name, val) {
1900 |     this.useRegister(name);
1901 |     this.source.push(name + " = " + val + ";");
1902 |   },
1903 | 
1904 |   useRegister: function(name) {
1905 |     if(!this.registers[name]) {
1906 |       this.registers[name] = true;
1907 |       this.registers.list.push(name);
1908 |     }
1909 |   },
1910 | 
1911 |   pushStackLiteral: function(item) {
1912 |     return this.push(new Literal(item));
1913 |   },
1914 | 
1915 |   pushStack: function(item) {
1916 |     this.flushInline();
1917 | 
1918 |     var stack = this.incrStack();
1919 |     if (item) {
1920 |       this.source.push(stack + " = " + item + ";");
1921 |     }
1922 |     this.compileStack.push(stack);
1923 |     return stack;
1924 |   },
1925 | 
1926 |   replaceStack: function(callback) {
1927 |     var prefix = '',
1928 |         inline = this.isInline(),
1929 |         stack;
1930 | 
1931 |     // If we are currently inline then we want to merge the inline statement into the
1932 |     // replacement statement via ','
1933 |     if (inline) {
1934 |       var top = this.popStack(true);
1935 | 
1936 |       if (top instanceof Literal) {
1937 |         // Literals do not need to be inlined
1938 |         stack = top.value;
1939 |       } else {
1940 |         // Get or create the current stack name for use by the inline
1941 |         var name = this.stackSlot ? this.topStackName() : this.incrStack();
1942 | 
1943 |         prefix = '(' + this.push(name) + ' = ' + top + '),';
1944 |         stack = this.topStack();
1945 |       }
1946 |     } else {
1947 |       stack = this.topStack();
1948 |     }
1949 | 
1950 |     var item = callback.call(this, stack);
1951 | 
1952 |     if (inline) {
1953 |       if (this.inlineStack.length || this.compileStack.length) {
1954 |         this.popStack();
1955 |       }
1956 |       this.push('(' + prefix + item + ')');
1957 |     } else {
1958 |       // Prevent modification of the context depth variable. Through replaceStack
1959 |       if (!/^stack/.test(stack)) {
1960 |         stack = this.nextStack();
1961 |       }
1962 | 
1963 |       this.source.push(stack + " = (" + prefix + item + ");");
1964 |     }
1965 |     return stack;
1966 |   },
1967 | 
1968 |   nextStack: function() {
1969 |     return this.pushStack();
1970 |   },
1971 | 
1972 |   incrStack: function() {
1973 |     this.stackSlot++;
1974 |     if(this.stackSlot > this.stackVars.length) { this.stackVars.push("stack" + this.stackSlot); }
1975 |     return this.topStackName();
1976 |   },
1977 |   topStackName: function() {
1978 |     return "stack" + this.stackSlot;
1979 |   },
1980 |   flushInline: function() {
1981 |     var inlineStack = this.inlineStack;
1982 |     if (inlineStack.length) {
1983 |       this.inlineStack = [];
1984 |       for (var i = 0, len = inlineStack.length; i < len; i++) {
1985 |         var entry = inlineStack[i];
1986 |         if (entry instanceof Literal) {
1987 |           this.compileStack.push(entry);
1988 |         } else {
1989 |           this.pushStack(entry);
1990 |         }
1991 |       }
1992 |     }
1993 |   },
1994 |   isInline: function() {
1995 |     return this.inlineStack.length;
1996 |   },
1997 | 
1998 |   popStack: function(wrapped) {
1999 |     var inline = this.isInline(),
2000 |         item = (inline ? this.inlineStack : this.compileStack).pop();
2001 | 
2002 |     if (!wrapped && (item instanceof Literal)) {
2003 |       return item.value;
2004 |     } else {
2005 |       if (!inline) {
2006 |         this.stackSlot--;
2007 |       }
2008 |       return item;
2009 |     }
2010 |   },
2011 | 
2012 |   topStack: function(wrapped) {
2013 |     var stack = (this.isInline() ? this.inlineStack : this.compileStack),
2014 |         item = stack[stack.length - 1];
2015 | 
2016 |     if (!wrapped && (item instanceof Literal)) {
2017 |       return item.value;
2018 |     } else {
2019 |       return item;
2020 |     }
2021 |   },
2022 | 
2023 |   quotedString: function(str) {
2024 |     return '"' + str
2025 |       .replace(/\\/g, '\\\\')
2026 |       .replace(/"/g, '\\"')
2027 |       .replace(/\n/g, '\\n')
2028 |       .replace(/\r/g, '\\r')
2029 |       .replace(/\u2028/g, '\\u2028')   // Per Ecma-262 7.3 + 7.8.4
2030 |       .replace(/\u2029/g, '\\u2029') + '"';
2031 |   },
2032 | 
2033 |   setupHelper: function(paramSize, name, missingParams) {
2034 |     var params = [];
2035 |     this.setupParams(paramSize, params, missingParams);
2036 |     var foundHelper = this.nameLookup('helpers', name, 'helper');
2037 | 
2038 |     return {
2039 |       params: params,
2040 |       name: foundHelper,
2041 |       callParams: ["depth0"].concat(params).join(", "),
2042 |       helperMissingParams: missingParams && ["depth0", this.quotedString(name)].concat(params).join(", ")
2043 |     };
2044 |   },
2045 | 
2046 |   // the params and contexts arguments are passed in arrays
2047 |   // to fill in
2048 |   setupParams: function(paramSize, params, useRegister) {
2049 |     var options = [], contexts = [], types = [], param, inverse, program;
2050 | 
2051 |     options.push("hash:" + this.popStack());
2052 | 
2053 |     inverse = this.popStack();
2054 |     program = this.popStack();
2055 | 
2056 |     // Avoid setting fn and inverse if neither are set. This allows
2057 |     // helpers to do a check for `if (options.fn)`
2058 |     if (program || inverse) {
2059 |       if (!program) {
2060 |         this.context.aliases.self = "this";
2061 |         program = "self.noop";
2062 |       }
2063 | 
2064 |       if (!inverse) {
2065 |        this.context.aliases.self = "this";
2066 |         inverse = "self.noop";
2067 |       }
2068 | 
2069 |       options.push("inverse:" + inverse);
2070 |       options.push("fn:" + program);
2071 |     }
2072 | 
2073 |     for(var i=0; i<paramSize; i++) {
2074 |       param = this.popStack();
2075 |       params.push(param);
2076 | 
2077 |       if(this.options.stringParams) {
2078 |         types.push(this.popStack());
2079 |         contexts.push(this.popStack());
2080 |       }
2081 |     }
2082 | 
2083 |     if (this.options.stringParams) {
2084 |       options.push("contexts:[" + contexts.join(",") + "]");
2085 |       options.push("types:[" + types.join(",") + "]");
2086 |       options.push("hashContexts:hashContexts");
2087 |       options.push("hashTypes:hashTypes");
2088 |     }
2089 | 
2090 |     if(this.options.data) {
2091 |       options.push("data:data");
2092 |     }
2093 | 
2094 |     options = "{" + options.join(",") + "}";
2095 |     if (useRegister) {
2096 |       this.register('options', options);
2097 |       params.push('options');
2098 |     } else {
2099 |       params.push(options);
2100 |     }
2101 |     return params.join(", ");
2102 |   }
2103 | };
2104 | 
2105 | var reservedWords = (
2106 |   "break else new var" +
2107 |   " case finally return void" +
2108 |   " catch for switch while" +
2109 |   " continue function this with" +
2110 |   " default if throw" +
2111 |   " delete in try" +
2112 |   " do instanceof typeof" +
2113 |   " abstract enum int short" +
2114 |   " boolean export interface static" +
2115 |   " byte extends long super" +
2116 |   " char final native synchronized" +
2117 |   " class float package throws" +
2118 |   " const goto private transient" +
2119 |   " debugger implements protected volatile" +
2120 |   " double import public let yield"
2121 | ).split(" ");
2122 | 
2123 | var compilerWords = JavaScriptCompiler.RESERVED_WORDS = {};
2124 | 
2125 | for(var i=0, l=reservedWords.length; i<l; i++) {
2126 |   compilerWords[reservedWords[i]] = true;
2127 | }
2128 | 
2129 | JavaScriptCompiler.isValidJavaScriptVariableName = function(name) {
2130 |   if(!JavaScriptCompiler.RESERVED_WORDS[name] && /^[a-zA-Z_$][0-9a-zA-Z_$]+$/.test(name)) {
2131 |     return true;
2132 |   }
2133 |   return false;
2134 | };
2135 | 
2136 | Handlebars.precompile = function(input, options) {
2137 |   if (input == null || (typeof input !== 'string' && input.constructor !== Handlebars.AST.ProgramNode)) {
2138 |     throw new Handlebars.Exception("You must pass a string or Handlebars AST to Handlebars.precompile. You passed " + input);
2139 |   }
2140 | 
2141 |   options = options || {};
2142 |   if (!('data' in options)) {
2143 |     options.data = true;
2144 |   }
2145 |   var ast = Handlebars.parse(input);
2146 |   var environment = new Compiler().compile(ast, options);
2147 |   return new JavaScriptCompiler().compile(environment, options);
2148 | };
2149 | 
2150 | Handlebars.compile = function(input, options) {
2151 |   if (input == null || (typeof input !== 'string' && input.constructor !== Handlebars.AST.ProgramNode)) {
2152 |     throw new Handlebars.Exception("You must pass a string or Handlebars AST to Handlebars.compile. You passed " + input);
2153 |   }
2154 | 
2155 |   options = options || {};
2156 |   if (!('data' in options)) {
2157 |     options.data = true;
2158 |   }
2159 |   var compiled;
2160 |   function compile() {
2161 |     var ast = Handlebars.parse(input);
2162 |     var environment = new Compiler().compile(ast, options);
2163 |     var templateSpec = new JavaScriptCompiler().compile(environment, options, undefined, true);
2164 |     return Handlebars.template(templateSpec);
2165 |   }
2166 | 
2167 |   // Template is only compiled on first use and cached after that point.
2168 |   return function(context, options) {
2169 |     if (!compiled) {
2170 |       compiled = compile();
2171 |     }
2172 |     return compiled.call(this, context, options);
2173 |   };
2174 | };
2175 | 
2176 | ;
2177 | // lib/handlebars/runtime.js
2178 | 
2179 | Handlebars.VM = {
2180 |   template: function(templateSpec) {
2181 |     // Just add water
2182 |     var container = {
2183 |       escapeExpression: Handlebars.Utils.escapeExpression,
2184 |       invokePartial: Handlebars.VM.invokePartial,
2185 |       programs: [],
2186 |       program: function(i, fn, data) {
2187 |         var programWrapper = this.programs[i];
2188 |         if(data) {
2189 |           programWrapper = Handlebars.VM.program(i, fn, data);
2190 |         } else if (!programWrapper) {
2191 |           programWrapper = this.programs[i] = Handlebars.VM.program(i, fn);
2192 |         }
2193 |         return programWrapper;
2194 |       },
2195 |       merge: function(param, common) {
2196 |         var ret = param || common;
2197 | 
2198 |         if (param && common) {
2199 |           ret = {};
2200 |           Handlebars.Utils.extend(ret, common);
2201 |           Handlebars.Utils.extend(ret, param);
2202 |         }
2203 |         return ret;
2204 |       },
2205 |       programWithDepth: Handlebars.VM.programWithDepth,
2206 |       noop: Handlebars.VM.noop,
2207 |       compilerInfo: null
2208 |     };
2209 | 
2210 |     return function(context, options) {
2211 |       options = options || {};
2212 |       var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
2213 | 
2214 |       var compilerInfo = container.compilerInfo || [],
2215 |           compilerRevision = compilerInfo[0] || 1,
2216 |           currentRevision = Handlebars.COMPILER_REVISION;
2217 | 
2218 |       if (compilerRevision !== currentRevision) {
2219 |         if (compilerRevision < currentRevision) {
2220 |           var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
2221 |               compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
2222 |           throw "Template was precompiled with an older version of Handlebars than the current runtime. "+
2223 |                 "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").";
2224 |         } else {
2225 |           // Use the embedded version info since the runtime doesn't know about this revision yet
2226 |           throw "Template was precompiled with a newer version of Handlebars than the current runtime. "+
2227 |                 "Please update your runtime to a newer version ("+compilerInfo[1]+").";
2228 |         }
2229 |       }
2230 | 
2231 |       return result;
2232 |     };
2233 |   },
2234 | 
2235 |   programWithDepth: function(i, fn, data /*, $depth */) {
2236 |     var args = Array.prototype.slice.call(arguments, 3);
2237 | 
2238 |     var program = function(context, options) {
2239 |       options = options || {};
2240 | 
2241 |       return fn.apply(this, [context, options.data || data].concat(args));
2242 |     };
2243 |     program.program = i;
2244 |     program.depth = args.length;
2245 |     return program;
2246 |   },
2247 |   program: function(i, fn, data) {
2248 |     var program = function(context, options) {
2249 |       options = options || {};
2250 | 
2251 |       return fn(context, options.data || data);
2252 |     };
2253 |     program.program = i;
2254 |     program.depth = 0;
2255 |     return program;
2256 |   },
2257 |   noop: function() { return ""; },
2258 |   invokePartial: function(partial, name, context, helpers, partials, data) {
2259 |     var options = { helpers: helpers, partials: partials, data: data };
2260 | 
2261 |     if(partial === undefined) {
2262 |       throw new Handlebars.Exception("The partial " + name + " could not be found");
2263 |     } else if(partial instanceof Function) {
2264 |       return partial(context, options);
2265 |     } else if (!Handlebars.compile) {
2266 |       throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
2267 |     } else {
2268 |       partials[name] = Handlebars.compile(partial, {data: data !== undefined});
2269 |       return partials[name](context, options);
2270 |     }
2271 |   }
2272 | };
2273 | 
2274 | Handlebars.template = Handlebars.VM.template;
2275 | ;
2276 | // lib/handlebars/browser-suffix.js
2277 | })(Handlebars);
2278 | ;
2279 | 


--------------------------------------------------------------------------------