savvy-js/test/parser.test.js

Savvy - Style sheet documentation tool

(function(){
    'use strict';

    var should = require('chai').should(),
        parser = require('../js/parser');

    describe('parser', function() {
        it('Extract comment blocks out of the document', function(){
            var document =
                '/** \r\n'+
                ' * This is a comment desciption \r\n' +
                ' */ \r\n'+
                ' some lines of document \r\n' +
                '/* \r\n'+
                ' * This is invalid comment with one asterisks instead of two \r\n'+
                ' */ \r\n' +
                ' Some more lines of code \r\n ' +
                '/** \r\n ' +
                ' * Invalid comment with no ending ';

            // only one valid comment
            var result = parser.extractComments(document);

            result.length.should.equal(1);
            result[0].index.should.equal(0);
            result[0].line.should.equal(1);

            // add a comment closing so we will get 2 comments out.
            document += ' */ ';

            result = parser.extractComments(document);

            result.length.should.equal(2);
            result[1].index.should.equal(174);
            result[1].line.should.equal(9);
        });

        it('Parse a statement into an object', function(){
            // module, no description
            parser.parseStatement('@module myModule').should.eql({
                type : 'module',
                name : 'myModule',
                description : []
            });

            // invalid token, treat as description
            // module with at lease 4 spaces after astrix, should be treated as a code sample
            parser.parseStatement('@module2 myModule').should.eql({
                type : 'comment',
                name :null,
                description : [{ type : 'text', text :'@module2 myModule'}]
            });

            // module with astrix and spaces
            parser.parseStatement('* @module myModule').should.eql({
                type : 'module',
                name : 'myModule',
                description : []
            });

            // module with at lease 4 spaces after astrix, should be treated as a code sample
            parser.parseStatement('*    @module myModule').should.eql({
                type : 'comment',
                name :null,
                description : [{ type : 'code', text :'    @module myModule'}]
            });

            // module with one line description
            parser.parseStatement('* @module myModule line 1').should.eql({
                type : 'module',
                name : 'myModule',
                description : [{ type : 'text', text : 'line 1' }]
            });

            // module with multiple lines description
            parser.parseStatement('* @module myModule line 1 \r\n line2').should.eql({
                type : 'module',
                name : 'myModule',
                description : [
                    { type : 'text', text : 'line 1'},
                    { type : 'text', text : 'line2'}
                ]
            });

            // module with multiple lines description and code sample
            parser.parseStatement('* @module myModule line 1 \r\n *     line2').should.eql({
                type : 'module',
                name : 'myModule',
                description : [
                    { type : 'text', text : 'line 1'},
                    { type : 'code', text : '     line2'}]
            });

            // module with multiple lines that the second line start with a token
            parser.parseStatement('* @module myModule line 1 \r\n * class is cool').should.eql({
                type : 'module',
                name : 'myModule',
                description : [
                    { type : 'text', text : 'line 1'},
                    { type : 'text', text : 'class is cool'}]
            });

            //parse statement where the name is dashed
            parser.parseStatement('* @module my-module line 1 \r\n * class is cool').should.eql({
                type : 'module',
                name : 'my-module',
                description : [
                    { type : 'text', text : 'line 1'},
                    { type : 'text', text : 'class is cool'}]
            });

        });

        it('Parse a comment into an object', function(){
            var commentString = '/**\r\n' +
                                  '* This is the first line of the description.\r\n' +
                                  '*\r\n' +
                                  '* This is the second line of the description:\r\n' +
                                  '*\r\n' +
                                  '*      {\r\n' +
                                  '*          sample : number\r\n' +
                                  '*          sample2 : string\r\n' +
                                  '*      }\r\n' +
                                  '*\r\n' +
                                  '* @class myClass\r\n' +
                                  '* @module myModule\r\n' +
                                  '* @submodule mySubmodule\r\n' +
                                  '*/\r\n',
                commentObject = {
                    line : 1,
                    index : 1,
                    comment : commentString
                },
                result;

            result =  parser.parseComment(commentObject);

            result.description.length.should.equal(10);
            result.class.should.eql({ name : 'myClass', description : []});
            result.module.should.eql({ name : 'myModule', description : []});
            result.submodule.should.eql({ name : 'mySubmodule', description : []});
        });
    });
}());