update

node_modules/hamljs/test/test.js

@@ -0,0 +1,366 @@
+'use strict';
+
+var fs = require('fs');
+var haml = require('../lib/haml');
+
+describe('haml', function () {
+  describe('.version', function () {
+    it('should be a triplet', function () {
+      haml.version.should.match(/^\d+\.\d+\.\d+$/);
+    });
+  });
+
+  describe('.compile()', function () {
+    it('should return a function', function () {
+      var fn = haml.compile('%foo= bar');
+      fn({ bar: 'baz' }).should.equal('\n<foo>baz</foo>');
+    });
+  });
+
+  describe('Parser', function () {
+    it('should be available for extension', function () {
+      haml.Parser.should.not.equal(undefined);
+    });
+  });
+
+  describe('.renderFile()', function () {
+    it('should render the given file', function (done) {
+      haml.renderFile(__dirname + '/fixtures/class.haml', 'utf8', {}, function (err, html) {
+        html = html.trim()
+        var expected = fs.readFileSync(__dirname + '/fixtures/class.html').toString()
+
+        console.log(JSON.stringify(html), JSON.stringify(expected))
+        html.should.equal(expected)
+
+        done()
+      });
+    });
+  });
+
+  describe('.render()', function () {
+    var assertAs, assert, assertXML;
+
+    // Prepare helper functions
+    before(function () {
+      assertAs = function(name, type, options) {
+        var str = fs.readFileSync(__dirname + '/fixtures/' + name + '.haml').toString();
+        try {
+          var html = haml.render(str, options).trim();
+          var expected = fs.readFileSync(__dirname + '/fixtures/' + name + '.' + type).toString().trim();
+          html.should.equal(expected);
+        } catch (err) {
+          throw err;
+        }
+      };
+      assert = function(name, options) {
+        assertAs(name, 'html', options, 'CRLF', '\r\n');
+      };
+      assertXML = function(name, options) {
+        assertAs(name, 'xml', options, 'CRLF', '\r\n');
+      };
+    });
+
+    it('should allow passing of a context object', function () {
+      assert('context', { context: 'yay' });
+    });
+
+    it('should allow passing of literals', function () {
+      assert('literals', { locals: { user: 'tj' }});
+    });
+
+    it('should not fail on trailing indents', function () {
+      assert('trailing-indent');
+    });
+
+    it('should add xml support via the "xml" option', function () {
+      assertXML('feed', { xml: true });
+    });
+
+    it('should support xml namespaces', function () {
+      assertXML('namespace');
+    });
+
+    it('should utilize "filename" option when an error is thrown', function () {
+      try { assert('error', { filename: 'error.haml' }); }
+      catch (err) {
+        err.message.should.eql('(error.haml):3 invalid indentation; got 3, when previous was 1');
+      }
+    });
+
+    it('should default filename to "Haml" when an error is thrown', function () {
+      try { assert('error'); }
+      catch (err) {
+        err.message.should.eql('(Haml):3 invalid indentation; got 3, when previous was 1');
+      }
+    });
+
+    it('should bitch when "cache" is true without a filename given', function () {
+      // -{ assert('tag.simple', { cache: true }) }.should.throw_error
+    });
+
+    it('should pre-compiled and cache when "cache" is true', function () {
+      assert('tag.simple', { cache: true, filename: 'tag.simple.haml' });
+      assert('tag.simple', { cache: true, filename: 'tag.simple.haml' });
+    });
+
+    describe('\\n', function () {
+      it('should support blank lines', function () {
+        assert('newlines');
+      });
+
+      it('should support blank lines within tags', function () {
+        assert('newlines.within-tags');
+      });
+    });
+
+    describe('.class', function () {
+      it('should output a div with the given class', function () {
+        assert('class');
+      });
+
+      it('should work with several classes', function () {
+        assert('classes');
+      });
+    });
+
+    describe('#id', function () {
+      it('should output a div with the given id', function () {
+        assert('id');
+      });
+    });
+
+    describe('%tag', function () {
+      it('should work with no text or block', function () {
+        assert('tag.simple');
+      });
+
+      it('should work with text', function () {
+        assert('tag.text');
+      });
+
+      it('should work with block text', function () {
+        assert('tag.text.block');
+      });
+
+      it('should work with blocks of text and tags', function () {
+        assert('tag.text.block.complex');
+      });
+
+      it('should work with many classes / ids / attrs', function () {
+        assert('tag.complex');
+      });
+
+      it('should allow empty tags', function () {
+        assert('tag.empty');
+      });
+    });
+
+    describe('%tag.class', function () {
+      it('should output tag with a class', function () {
+        assert('tag.class');
+      });
+
+      it('should work with several classes', function () {
+        assert('tag.classes');
+      });
+
+      it('should work with both .class and class=\'another-class\'', function () {
+        assert('tag.class.attribute');
+      });
+
+      it('should support self-closing tags', function () {
+        assert('tag.self-close');
+      });
+    });
+
+    describe('%tag!=', function () {
+      it('should output the evaluated code', function () {
+        assert('tag.code');
+      });
+
+      it('should not escape output', function () {
+        assert('tag.code.no-escape');
+      });
+    });
+
+    describe('%tag=', function () {
+      it('should escape the evaluated code', function () {
+        assert('tag.escape');
+      });
+    });
+
+    describe('%namespace:tag', function () {
+      it('should output a tag with a namespace prefix', function () {
+        assert('namespace.tag');
+      });
+    });
+
+    describe('{...}', function () {
+      it('should be mapped as html attributes', function () {
+        assert('tag.attrs');
+      });
+
+      it('should escape values', function () {
+        assert('tag.attrs.escape');
+      });
+
+      it('should allow booleans', function () {
+        assert('tag.attrs.bools');
+      });
+    });
+
+    describe('!!!', function () {
+      it('should default the doctype to 1.0 transitional', function () {
+        assert('doctype');
+      });
+    });
+
+    describe('!!! NAME', function () {
+      it('should output a specific doctype', function () {
+        assert('doctype.xml');
+      });
+
+      it('should be case-insensitive', function () {
+        assert('doctype.xml.case');
+      });
+    });
+
+    describe('nesting', function () {
+      it('should work when nested downwards', function () {
+        assert('nesting.simple');
+      });
+
+      it('should work when blocks outdent', function () {
+        assert('nesting.complex');
+      });
+    });
+
+    describe('- code', function () {
+      it('should work with if statements', function () {
+        assert('code.if');
+      });
+
+      it('should work with if / else statements', function () {
+        assert('code.if.else');
+      });
+
+      it('should work when nested', function () {
+        assert('code.nested');
+      });
+    });
+
+    describe('- each', function () {
+      it('should iterate', function () {
+        assert('code.each', { locals: { items: ['one', 'two', 'three'] }});
+        assert('code.each.non-enumerable', { locals: { items: null }});
+      });
+
+      it('should iterate objects', function () {
+        assert('code.each', { locals: { items: { 0: 'one', 1: 'two', 2: 'three' }}});
+        assert('code.each.index', { locals: { items: { 0: 'one', 1: 'two', 2: 'three' }}});
+      });
+
+      it('should iterate with index', function () {
+        assert('code.each.index', { locals: { items: ['one', 'two', 'three'] }});
+      });
+    });
+
+    describe('= code', function () {
+      it('should output evaluation', function () {
+        assert('code');
+      });
+    });
+
+    describe('&= code', function () {
+      it('should output evaluation while escaping html entities', function () {
+        assert('code.escape');
+      });
+    });
+
+    describe('<literal></html>', function () {
+      it('should remain intact', function () {
+        assert('html');
+      });
+    });
+
+    describe('\\char', function () {
+      it('should escape the character', function () {
+        assert('escape');
+      });
+    });
+
+    describe('#{}', function () {
+      it('should interpolate strings', function () {
+        assert('string.interpolation', { locals: { message: 'it works!' } });
+      });
+
+      it('should interpolate strings (complex)', function () {
+        assert('string.complex-interpolation', { locals: { message: 'it works!' } });
+      });
+    });
+
+    describe('-#', function () {
+      it('should become a silent comment', function () {
+        assert('comment');
+      });
+    });
+
+    describe('/', function () {
+      it('should comment out tags', function () {
+        assert('comment.tag');
+      });
+
+      it('should comment out blocks', function () {
+        assert('comment.block');
+      });
+
+      it('should comment out text', function () {
+        assert('comment.text');
+      });
+
+      it('should work in blocks', function () {
+        assert('comment.text.complex');
+      });
+    });
+
+    describe('/[]', function () {
+      it('should insert conditional comment blocks', function () {
+        assert('comment.block.conditional');
+      });
+    });
+
+    describe(':filter', function () {
+      describe('plain', function () {
+        it('should ignore haml specific characters', function () {
+          assert('filter.plain');
+        });
+      });
+
+      describe('cdata', function () {
+        it('should wrap with CDATA tags', function () {
+          assert('filter.cdata');
+        });
+
+        it('should retain whitespace', function () {
+          assert('filter.cdata.whitespace');
+        });
+      });
+
+      describe('javascript', function () {
+        it('should wrap with <script> and CDATA tags', function () {
+          assert('filter.javascript');
+        });
+      });
+    });
+
+    describe('bug fixes', function () {
+      it('#8 code block', function () {
+        assert('issue.#8', { locals: { items: ['foo', 'bar', 'baz'] }});
+      });
+
+      it('#10 Attributes should not need quotes', function () {
+        assert('issue.#10');
+      });
+    });
+  });
+});