handlebars.js/spec/visitor.js

describe('Visitor', function() {
  if (!Handlebars.Visitor || !Handlebars.print) {
    return;
  }

  it('should provide coverage', function() {
    // Simply run the thing and make sure it does not fail and that all of the
    // stub methods are executed
    var visitor = new Handlebars.Visitor();
    visitor.accept(Handlebars.parse('{{foo}}{{#foo (bar 1 "1" true undefined null) foo=@data}}{{!comment}}{{> bar }} {{/foo}}'));
    visitor.accept(Handlebars.parse('{{#> bar }} {{/bar}}'));
    visitor.accept(Handlebars.parse('{{#* bar }} {{/bar}}'));
    visitor.accept(Handlebars.parse('{{* bar }}'));
  });

  it('should traverse to stubs', function() {
    var visitor = new Handlebars.Visitor();

    visitor.StringLiteral = function(string) {
      equal(string.value, '2');
    };
    visitor.NumberLiteral = function(number) {
      equal(number.value, 1);
    };
    visitor.BooleanLiteral = function(bool) {
      equal(bool.value, true);

      equal(this.parents.length, 3);
      equal(this.parents[0].type, 'SubExpression');
      equal(this.parents[1].type, 'BlockStatement');
      equal(this.parents[2].type, 'Program');
    };
    visitor.PathExpression = function(id) {
      equal(/(foo\.)?bar$/.test(id.original), true);
    };
    visitor.ContentStatement = function(content) {
      equal(content.value, ' ');
    };
    visitor.CommentStatement = function(comment) {
      equal(comment.value, 'comment');
    };

    visitor.accept(Handlebars.parse('{{#foo.bar (foo.bar 1 "2" true) foo=@foo.bar}}{{!comment}}{{> bar }} {{/foo.bar}}'));
  });

  describe('mutating', function() {
    describe('fields', function() {
      it('should replace value', function() {
        var visitor = new Handlebars.Visitor();

        visitor.mutating = true;
        visitor.StringLiteral = function(string) {
          return {type: 'NumberLiteral', value: 42, loc: string.loc};
        };

        var ast = Handlebars.parse('{{foo foo="foo"}}');
        visitor.accept(ast);
        equals(Handlebars.print(ast), '{{ PATH:foo [] HASH{foo=NUMBER{42}} }}\n');
      });
      it('should treat undefined resonse as identity', function() {
        var visitor = new Handlebars.Visitor();
        visitor.mutating = true;

        var ast = Handlebars.parse('{{foo foo=42}}');
        visitor.accept(ast);
        equals(Handlebars.print(ast), '{{ PATH:foo [] HASH{foo=NUMBER{42}} }}\n');
      });
      it('should remove false responses', function() {
        var visitor = new Handlebars.Visitor();

        visitor.mutating = true;
        visitor.Hash = function() {
          return false;
        };

        var ast = Handlebars.parse('{{foo foo=42}}');
        visitor.accept(ast);
        equals(Handlebars.print(ast), '{{ PATH:foo [] }}\n');
      });
      it('should throw when removing required values', function() {
        shouldThrow(function() {
          var visitor = new Handlebars.Visitor();

          visitor.mutating = true;
          visitor.PathExpression = function() {
            return false;
          };

          var ast = Handlebars.parse('{{foo 42}}');
          visitor.accept(ast);
        }, Handlebars.Exception, 'MustacheStatement requires path');
      });
      it('should throw when returning non-node responses', function() {
        shouldThrow(function() {
          var visitor = new Handlebars.Visitor();

          visitor.mutating = true;
          visitor.PathExpression = function() {
            return {};
          };

          var ast = Handlebars.parse('{{foo 42}}');
          visitor.accept(ast);
        }, Handlebars.Exception, 'Unexpected node type "undefined" found when accepting path on MustacheStatement');
      });
    });
    describe('arrays', function() {
      it('should replace value', function() {
        var visitor = new Handlebars.Visitor();

        visitor.mutating = true;
        visitor.StringLiteral = function(string) {
          return {type: 'NumberLiteral', value: 42, loc: string.locInfo};
        };

        var ast = Handlebars.parse('{{foo "foo"}}');
        visitor.accept(ast);
        equals(Handlebars.print(ast), '{{ PATH:foo [NUMBER{42}] }}\n');
      });
      it('should treat undefined resonse as identity', function() {
        var visitor = new Handlebars.Visitor();
        visitor.mutating = true;

        var ast = Handlebars.parse('{{foo 42}}');
        visitor.accept(ast);
        equals(Handlebars.print(ast), '{{ PATH:foo [NUMBER{42}] }}\n');
      });
      it('should remove false responses', function() {
        var visitor = new Handlebars.Visitor();

        visitor.mutating = true;
        visitor.NumberLiteral = function() {
          return false;
        };

        var ast = Handlebars.parse('{{foo 42}}');
        visitor.accept(ast);
        equals(Handlebars.print(ast), '{{ PATH:foo [] }}\n');
      });
    });
  });
});