postcss/test/node.test.js

import CssSyntaxError from '../lib/css-syntax-error';
import Declaration    from '../lib/declaration';
import postcss        from '../lib/postcss';
import AtRule         from '../lib/at-rule';
import parse          from '../lib/parse';
import Root           from '../lib/root';
import Rule           from '../lib/rule';

import path from 'path';

let stringify  = (node, builder) => builder(node.selector);

it('shows error on wrong constructor types', () => {
    expect(() => {
        new Rule('a');
    }).toThrowError('PostCSS nodes constructor accepts object, not "a"');
});

it('error() generates custom error', () => {
    let file  = path.resolve('a.css');
    let css   = parse('a{}', { from: file });
    let error = css.first.error('Test');
    expect(error instanceof CssSyntaxError).toBeTruthy();
    expect(error.message).toEqual(file + ':1:1: Test');
});

it('error() generates custom error for nodes without source', () => {
    let rule  = new Rule({ selector: 'a' });
    let error = rule.error('Test');
    expect(error.message).toEqual('<css input>: Test');
});

it('error() highlights index', () => {
    let root  = parse('a { b: c }');
    let error = root.first.first.error('Bad semicolon', { index: 1 });
    expect(error.showSourceCode(false)).toEqual('> 1 | a { b: c }\n' +
                                             '    |      ^');
});

it('error() highlights word', () => {
    let root  = parse('a { color: x red }');
    let error = root.first.first.error('Wrong color', { word: 'x' });
    expect(error.showSourceCode(false)).toEqual('> 1 | a { color: x red }\n' +
                                             '    |            ^');
});

it('error() highlights word in multiline string', () => {
    let root  = parse('a { color: red\n           x }');
    let error = root.first.first.error('Wrong color', { word: 'x' });
    expect(error.showSourceCode(false)).toEqual('  1 | a { color: red\n' +
                                             '> 2 |            x }\n' +
                                             '    |            ^');
});

it('warn() attaches a warning to the result object', () => {
    let warning;
    let warner = postcss.plugin('warner', () => {
        return (css, result) => {
            warning = css.first.warn(result, 'FIRST!');
        };
    });

    return postcss([warner]).process('a{}').then(result => {
        expect(warning.type).toEqual('warning');
        expect(warning.text).toEqual('FIRST!');
        expect(warning.plugin).toEqual('warner');
        expect(result.warnings()).toEqual([warning]);
    });
});

it('warn() accepts options', () => {
    let warner = postcss.plugin('warner', () => {
        return (css, result) => {
            css.first.warn(result, 'FIRST!', { index: 1 });
        };
    });

    let result = postcss([ warner() ]).process('a{}');
    expect(result.warnings().length).toEqual(1);
    expect(result.warnings()[0].index).toEqual(1);
});

it('remove() removes node from parent', () => {
    let rule = new Rule({ selector: 'a' });
    let decl = new Declaration({ prop: 'color', value: 'black' });
    rule.append(decl);

    decl.remove();
    expect(rule.nodes.length).toEqual(0);
    expect(decl.parent).not.toBeDefined();
});

it('replaceWith() inserts new node', () => {
    let rule = new Rule({ selector: 'a' });
    rule.append({ prop: 'color', value: 'black' });
    rule.append({ prop: 'width', value: '1px' });
    rule.append({ prop: 'height', value: '1px' });

    let node   = new Declaration({ prop: 'min-width', value: '1px' });
    let width  = rule.nodes[1];
    let result = width.replaceWith(node);

    expect(result).toEqual(width);
    expect(rule.toString()).toEqual('a {\n' +
                                 '    color: black;\n' +
                                 '    min-width: 1px;\n' +
                                 '    height: 1px\n' +
                                 '}');
});

it('replaceWith() inserts new root', () => {
    let root = new Root();
    root.append( new AtRule({ name: 'import', params: '"a.css"' }) );

    let a = new Root();
    a.append( new Rule({ selector: 'a' }) );
    a.append( new Rule({ selector: 'b' }) );

    root.first.replaceWith(a);
    expect(root.toString()).toEqual('a {}\nb {}');
});

it('replaceWith() replaces node', () => {
    let css    = parse('a{one:1;two:2}');
    let decl   = { prop: 'fix', value: 'fixed' };
    let result = css.first.first.replaceWith(decl);

    expect(result.prop).toEqual('one');
    expect(result.parent).not.toBeDefined();
    expect(css.toString()).toEqual('a{fix:fixed;two:2}');
});

it('toString() accepts custom stringifier', () => {
    expect(new Rule({ selector: 'a' }).toString(stringify)).toEqual('a');
});

it('toString() accepts custom syntax', () => {
    expect(new Rule({ selector: 'a' }).toString({ stringify })).toEqual('a');
});

it('clone() clones nodes', () => {
    let rule = new Rule({ selector: 'a' });
    rule.append({ prop: 'color', value: '/**/black' });

    let clone = rule.clone();

    expect(clone.parent).not.toBeDefined();

    expect(rule.first.parent).toBe(rule);
    expect(clone.first.parent).toBe(clone);

    clone.append({ prop: 'z-index', value: '1' });
    expect(rule.nodes.length).toEqual(1);
});

it('clone() overrides properties', () => {
    let rule  = new Rule({ selector: 'a' });
    let clone = rule.clone({ selector: 'b' });
    expect(clone.selector).toEqual('b');
});

it('clone() keeps code style', () => {
    let css = parse('@page 1{a{color:black;}}');
    expect(css.clone().toString()).toEqual('@page 1{a{color:black;}}');
});

it('clone() works with null in raws', () => {
    let decl = new Declaration({
        prop:  'color',
        value: 'black',
        raws:  { value: null }
    });
    let clone = decl.clone();
    expect(Object.keys(clone.raws)).toEqual(['value']);
});

it('cloneBefore() clones and insert before current node', () => {
    let rule = new Rule({ selector: 'a', raws: { after: '' } });
    rule.append({ prop: 'z-index', value: '1', raws: { before: '' } });

    let result = rule.first.cloneBefore({ value: '2' });

    expect(result).toBe(rule.first);
    expect(rule.toString()).toEqual('a {z-index: 2;z-index: 1}');
});

it('cloneAfter() clones and insert after current node', () => {
    let rule = new Rule({ selector: 'a', raws: { after: '' } });
    rule.append({ prop: 'z-index', value: '1', raws: { before: '' } });

    let result = rule.first.cloneAfter({ value: '2' });

    expect(result).toBe(rule.last);
    expect(rule.toString()).toEqual('a {z-index: 1;z-index: 2}');
});

it('before() insert before current node', () => {
    let rule = new Rule({ selector: 'a', raws: { after: '' } });
    rule.append({ prop: 'z-index', value: '1', raws: { before: '' } });

    let result = rule.first.before('color: black');

    expect(result).toBe(rule.last);
    expect(rule.toString()).toEqual('a {color: black;z-index: 1}');
});

it('after() insert after current node', () => {
    let rule = new Rule({ selector: 'a', raws: { after: '' } });
    rule.append({ prop: 'z-index', value: '1', raws: { before: '' } });

    let result = rule.first.after('color: black');

    expect(result).toBe(rule.first);
    expect(rule.toString()).toEqual('a {z-index: 1;color: black}');
});

it('next() returns next node', () => {
    let css = parse('a{one:1;two:2}');
    expect(css.first.first.next()).toBe(css.first.last);
    expect(css.first.last.next()).not.toBeDefined();
});

it('prev() returns previous node', () => {
    let css = parse('a{one:1;two:2}');
    expect(css.first.last.prev()).toBe(css.first.first);
    expect(css.first.first.prev()).not.toBeDefined();
});

it('toJSON() cleans parents inside', () => {
    let rule = new Rule({ selector: 'a' });
    rule.append({ prop: 'color', value: 'b' });

    let json = rule.toJSON();
    expect(json.parent).not.toBeDefined();
    expect(json.nodes[0].parent).not.toBeDefined();

    expect(JSON.stringify(rule))
        .toEqual('{"raws":{},"selector":"a","type":"rule","nodes":[' +
            '{"raws":{},"prop":"color","value":"b","type":"decl"}' +
        ']}');
});

it('toJSON() converts custom properties', () => {
    let root = new Root();
    root._cache = [1];
    root._hack = {
        toJSON() {
            return 'hack';
        }
    };

    expect(root.toJSON()).toEqual({
        type:   'root',
        nodes:  [],
        raws:   { },
        _hack:  'hack',
        _cache: [1]
    });
});

it('raw() has shortcut to stringifier', () => {
    let rule = new Rule({ selector: 'a' });
    expect(rule.raw('before')).toEqual('');
});

it('root() returns root', () => {
    let css = parse('@page{a{color:black}}');
    expect(css.first.first.first.root()).toBe(css);
});

it('root() returns parent of parents', () => {
    let rule = new Rule({ selector: 'a' });
    rule.append({ prop: 'color', value: 'black' });
    expect(rule.first.root()).toBe(rule);
});

it('root() returns self on root', () => {
    let rule = new Rule({ selector: 'a' });
    expect(rule.root()).toBe(rule);
});

it('cleanRaws() cleans style recursivelly', () => {
    let css = parse('@page{a{color:black}}');
    css.cleanRaws();

    expect(css.toString())
        .toEqual('@page {\n    a {\n        color: black\n    }\n}');
    expect(css.first.raws.before).not.toBeDefined();
    expect(css.first.first.first.raws.before).not.toBeDefined();
    expect(css.first.raws.between).not.toBeDefined();
    expect(css.first.first.first.raws.between).not.toBeDefined();
    expect(css.first.raws.after).not.toBeDefined();
});

it('cleanRaws() keeps between on request', () => {
    let css = parse('@page{a{color:black}}');
    css.cleanRaws(true);

    expect(css.toString())
        .toEqual('@page{\n    a{\n        color:black\n    }\n}');
    expect(css.first.raws.between).toBeDefined();
    expect(css.first.first.first.raws.between).toBeDefined();
    expect(css.first.raws.before).not.toBeDefined();
    expect(css.first.first.first.raws.before).not.toBeDefined();
    expect(css.first.raws.after).not.toBeDefined();
});

it('positionInside() returns position when node starts mid-line', () => {
    let css = parse('a {  one: X  }');
    let one = css.first.first;
    expect(one.positionInside(6)).toEqual({ line: 1, column: 12 });
});

it('positionInside() returns position when before contains newline', () => {
    let css = parse('a {\n  one: X}');
    let one = css.first.first;
    expect(one.positionInside(6)).toEqual({ line: 2, column: 9 });
});

it('positionInside() returns position when node contains newlines', () => {
    let css = parse('a {\n\tone: 1\n\t\tX\n3}');
    let one = css.first.first;
    expect(one.positionInside(10)).toEqual({ line: 3, column: 4 });
});