node/deps/npm/node_modules/cli-table2/test/table-layout-test.js

describe('tableLayout', function () {
  var Cell = require('../src/cell');
  var layoutManager = require('../src/layout-manager');
  var layoutTable = layoutManager.layoutTable;
  var makeTableLayout = layoutManager.makeTableLayout;
  var addRowSpanCells = layoutManager.addRowSpanCells;
  var maxWidth = layoutManager.maxWidth;
  var fillInTable = layoutManager.fillInTable;
  var computeWidths = layoutManager.computeWidths;
  var computeHeights = layoutManager.computeHeights;
  var chai = require('chai');
  var expect = chai.expect;
  var _ = require('lodash');

  it('simple 2x2 layout',function(){
    var actual = makeTableLayout([
      ['hello','goodbye'],
      ['hola','adios']
    ]);

    var expected = [
      ['hello','goodbye'],
      ['hola','adios']
    ];

    checkLayout(actual,expected);
  });

  it('cross table',function(){
    var actual = makeTableLayout([
      {'1.0':['yes','no']},
      {'2.0':['hello','goodbye']}
    ]);

    var expected = [
      ['1.0','yes','no'],
      ['2.0','hello','goodbye']
    ];

    checkLayout(actual,expected);
  });

  it('vertical table',function(){
    var actual = makeTableLayout([
      {'1.0':'yes'},
      {'2.0':'hello'}
    ]);

    var expected = [
      ['1.0','yes'],
      ['2.0','hello']
    ];

    checkLayout(actual,expected);
  });

  it('colSpan adds RowSpanCells to the right',function(){
    var actual = makeTableLayout([
      [{content:'hello',colSpan:2}],
      ['hola','adios']
    ]);

    var expected = [
      [{content:'hello',colSpan:2},null],
      ['hola','adios']
    ];

    checkLayout(actual,expected);
  });

  it('rowSpan adds RowSpanCell below',function(){
     var actual = makeTableLayout([
       [{content:'hello',rowSpan:2},'goodbye'],
       ['adios']
     ]);

    var expected = [
      ['hello'            , 'goodbye'],
      [{spannerFor:[0,0]} , 'adios']
    ];

    checkLayout(actual,expected);
  });

  it('rowSpan and cellSpan together',function(){
    var actual = makeTableLayout([
      [{content:'hello',rowSpan:2,colSpan:2},'goodbye'],
      ['adios']
    ]);

    var expected = [
      ['hello'            , null, 'goodbye'],
      [{spannerFor:[0,0]} , null, 'adios']
    ];

    checkLayout(actual,expected);
  });

  it('complex layout',function(){
    var actual = makeTableLayout([
      [{content:'hello',rowSpan:2,colSpan:2},{content:'yo',rowSpan:2,colSpan:2},'goodbye'],
      ['adios']
    ]);

    var expected = [
      ['hello'            , null, 'yo'               , null, 'goodbye'],
      [{spannerFor:[0,0]} , null, {spannerFor:[0,2]} , null, 'adios']
    ];

    checkLayout(actual,expected);
  });

  it('complex layout2',function(){
    var actual = makeTableLayout([
      ['a','b',                          {content:'c',rowSpan:3,colSpan:2},'d'],
      [{content:'e',rowSpan:2,colSpan:2}, 'f'],
      ['g']
    ]);

    var expected = [
      ['a',                 'b',   'c',                 null,  'd'],
      ['e',                 null,  {spannerFor:[0,2]},  null,  'f'],
      [{spannerFor:[1,0]},  null,  {spannerFor:[0,2]},  null,  'g']
    ];

    checkLayout(actual,expected);
  });

  it('stairstep spans',function(){
    var actual = makeTableLayout([
      [{content:'',rowSpan:2},''],
      [{content:'',rowSpan:2}],
      ['']
    ]);

    var expected = [
      [{content:'',rowSpan:2}, ''],
      [{spannerFor:[0,0]},{content:'',rowSpan:2}],
      ['',{spannerFor:[1,1]}]
    ];

    checkLayout(actual,expected);
  });

  describe('fillInTable',function(){
    function mc(opts,y,x){
      var cell = new Cell(opts);
      cell.x = x;
      cell.y = y;
      return cell;
    }

    it('will blank out individual cells',function(){
      var cells = [
        [mc('a',0,1)],
        [mc('b',1,0)]
      ];
      fillInTable(cells);

      checkLayout(cells,[
        ['', 'a'],
        ['b', '']
      ]);
    });

    it('will autospan to the right',function(){
      var cells = [
        [],
        [mc('a',1,1)]
      ];
      fillInTable(cells);

      checkLayout(cells,[
        [{content:'',colSpan:2}, null],
        ['', 'a']
      ]);
    });

    it('will autospan down',function(){
      var cells = [
        [ mc('a',0,1)],
        []
      ];
      fillInTable(cells);
      addRowSpanCells(cells);

      checkLayout(cells,[
        [{content:'',rowSpan:2}, 'a'],
        [{spannerFor:[0,0]}, '']
      ]);
    });

    it('will autospan right and down',function(){
      var cells = [
        [               mc('a',0,2)],
        [],
        [  mc('b',2,1)]
      ];
      fillInTable(cells);
      addRowSpanCells(cells);

      checkLayout(cells,[
        [{content:'',colSpan:2, rowSpan:2}, null, 'a'],
        [{spannerFor:[0,0]}, null, {content:'', colSpan:1, rowSpan:2}],
        ['','b',{spannerFor:[1,2]}]
      ]);
    });
  });

  describe('computeWidths',function() {
    function mc(y,x,desiredWidth, colSpan) {
      return {x:x,y:y,desiredWidth:desiredWidth,colSpan:colSpan};
    }

    it('finds the maximum desired width of each column', function () {
      var widths = [];
      var cells = [
        [mc(0,0,7), mc(0,1,3), mc(0,2,5)],
        [mc(1,0,8), mc(1,1,5), mc(1,2,2)],
        [mc(2,0,6), mc(2,1,9), mc(2,2,1)]
      ];

      computeWidths(widths, cells);

      expect(widths).to.eql([8, 9, 5]);
    });

    it('won\'t touch hard coded values', function () {
      var widths = [null, 3];
      var cells = [
        [mc(0,0,7), mc(0,1,3), mc(0,2,5)],
        [mc(1,0,8), mc(1,1,5), mc(1,2,2)],
        [mc(2,0,6), mc(2,1,9), mc(2,2,1)]
      ];

      computeWidths(widths, cells);

      expect(widths).to.eql([8, 3, 5]);
    });

    it('assumes undefined desiredWidth is 1', function () {
      var widths = [];
      var cells = [[{x:0,y:0}], [{x:0,y:1}], [{x:0,y:2}]];
      computeWidths(widths, cells);
      expect(widths).to.eql([1])
    });

    it('takes into account colSpan and wont over expand', function () {
      var widths = [];
      var cells = [
        [mc(0,0,10, 2),        mc(0,2,5)],
        [mc(1,0,5), mc(1,1,5), mc(1,2,2)],
        [mc(2,0,4), mc(2,1,2), mc(2,2,1)]
      ];
      computeWidths(widths, cells);
      expect(widths).to.eql([5, 5, 5]);
    });

    it('will expand rows involved in colSpan in a balanced way', function () {
      var widths = [];
      var cells = [
        [mc(0,0,13,2),          mc(0,2,5)],
        [mc(1,0,5), mc(1,1,5),  mc(1,2,2)],
        [mc(2,0,4), mc(2,1,2),  mc(2,2,1)]
      ];
      computeWidths(widths, cells);
      expect(widths).to.eql([6, 6, 5]);
    });

    it('expands across 3 cols', function () {
      var widths = [];
      var cells = [
        [mc(0,0,25,3)                        ],
        [mc(1,0,5),    mc(1,1,5),  mc(1,2,2) ],
        [mc(2,0,4),    mc(2,1,2),  mc(2,2,1) ]
      ];
      computeWidths(widths, cells);
      expect(widths).to.eql([9, 9, 5]);
    });

    it('multiple spans in same table', function () {
      var widths = [];
      var cells = [
        [mc(0,0,25,3)                        ],
        [mc(1,0,30,3)                        ],
        [mc(2,0,4),    mc(2,1,2),  mc(2,2,1) ]
      ];
      computeWidths(widths, cells);
      expect(widths).to.eql([11, 9, 8]);
    });

    it('spans will only edit uneditable tables',function(){
      var widths = [null, 3];
      var cells = [
        [mc(0,0,20,3)                         ],
        [mc(1,0,4),    mc(1,1,20),  mc(1,2,5) ]
      ];
      computeWidths(widths, cells);
      expect(widths).to.eql([7,3,8])
    });

    it('spans will only edit uneditable tables - first column uneditable',function(){
      var widths = [3];
      var cells = [
        [mc(0,0,20,3)                        ],
        [mc(1,0,4),    mc(1,1,3),  mc(1,2,5) ]
      ];
      computeWidths(widths, cells);
      expect(widths).to.eql([3,7,8])
    });
  });

  describe('computeHeights',function(){
    function mc(y,x,desiredHeight,colSpan){
      return {x:x,y:y,desiredHeight:desiredHeight,rowSpan:colSpan};
    }

    it('finds the maximum desired height of each row',function(){
      var heights = [];
      var cells = [
        [mc(0,0,7),  mc(0,1,3),  mc(0,2,5) ],
        [mc(1,0,8),  mc(1,1,5),  mc(1,2,2) ],
        [mc(2,0,6),  mc(2,1,9),  mc(2,2,1) ]
      ];

      computeHeights(heights,cells);

      expect(heights).to.eql([7,8,9]);
    });

    it('won\'t touch hard coded values',function(){
      var heights = [null,3];
      var cells = [
        [mc(0,0,7),  mc(0,1,3),  mc(0,2,5)],
        [mc(1,0,8),  mc(1,1,5),  mc(1,2,2)],
        [mc(2,0,6),  mc(2,1,9),  mc(2,2,1)]
      ];

      computeHeights(heights,cells);

      expect(heights).to.eql([7,3,9]);
    });

    it('assumes undefined desiredHeight is 1',function(){
      var heights = [];
      var cells = [[{x:0,y:0},{x:1,y:0},{x:2,y:0}]];
      computeHeights(heights,cells);
      expect(heights).to.eql([1])
    });

    it('takes into account rowSpan and wont over expand',function(){
      var heights = [];
      var cells = [
        [mc(0,0,10,2),  mc(0,1,5),  mc(0,2,2)],
        [               mc(1,1,5),  mc(1,2,2)],
        [mc(2,0,4),     mc(2,1,2),  mc(2,2,1)]
      ];
      computeHeights(heights,cells);
      expect(heights).to.eql([5,5,4]);
    });

    it('will expand rows involved in rowSpan in a balanced way',function(){
      var heights = [];
      var cells = [
        [mc(0,0,13,2), mc(0,1,5), mc(0,2,5)],
        [              mc(1,1,5), mc(1,2,2)],
        [mc(2,0,4),    mc(2,1,2), mc(2,2,1)]
      ];
      computeHeights(heights,cells);
      expect(heights).to.eql([6,6,4]);
    });

    it('expands across 3 rows',function(){
      var heights = [];
      var cells = [
        [mc(0,0,25,3), mc(0,1,5), mc(0,2,4)],
        [              mc(1,1,5), mc(1,2,2)],
        [              mc(2,1,2), mc(2,2,1)]
      ];
      computeHeights(heights,cells);
      expect(heights).to.eql([9,9,5]);
    });

    it('multiple spans in same table',function(){
      var heights = [];
      var cells = [
        [mc(0,0,25,3), mc(0,1,30,3), mc(0,2,4)],
        [                            mc(1,2,2)],
        [                            mc(2,2,1)]
      ];
      computeHeights(heights,cells);
      expect(heights).to.eql([11,9,8]);
    });
  });

  /**
   * Provides a shorthand for validating a table of cells.
   * To pass, both arrays must have the same dimensions, and each cell in `actualRows` must
   * satisfy the shorthand assertion of the corresponding location in `expectedRows`.
   *
   * Available Expectations Can Be:
   *
   *    * A `String` -  Must be a normal cell with contents equal to the String value.
   *    * `null` -  Must be a RowSpanCell
   *
   * Or an `Object` with any of the following properties (multiple properties allowed):
   *    * rowSpan:Number - Must be a normal cell with the given rowSpan.
   *    * colSpan:Number - Must be a normal cell with the given colSpan.
   *    * content:String - Must be a normal cell with the given content.
   *    * spannerFor:[row,col] - Must be a RowSpanCell delegating to the cell at the given coordinates.
   *
   * @param actualRows - the table of cells under test.
   * @param expectedRows - a table of shorthand assertions.
   */

  function checkLayout(actualTable,expectedTable){
    _.forEach(expectedTable,function(expectedRow,y){
      _.forEach(expectedRow,function(expectedCell,x){
        if(expectedCell !== null){
          var actualCell = findCell(actualTable,x,y);
          checkExpectation(actualCell,expectedCell,x,y,actualTable);
        }
      });
    });
  }

  function findCell(table,x,y){
    for(var i = 0; i < table.length; i++){
      var row = table[i];
      for(var j = 0; j < row.length; j++){
        var cell = row[j];
        if(cell.x === x && cell.y === y){
          return cell;
        }
      }
    }
  }

  function checkExpectation(actualCell,expectedCell,x,y,actualTable){
    if(_.isString(expectedCell)){
      expectedCell = {content:expectedCell};
    }
    var address = '(' + y + ',' + x + ')';
    if(expectedCell.hasOwnProperty('content')){
      expect(actualCell, address).to.be.instanceOf(Cell);
      expect(actualCell.content,'content of ' + address).to.equal(expectedCell.content);
    }
    if(expectedCell.hasOwnProperty('rowSpan')){
      expect(actualCell, address).to.be.instanceOf(Cell);
      expect(actualCell.rowSpan, 'rowSpan of ' + address).to.equal(expectedCell.rowSpan);
    }
    if(expectedCell.hasOwnProperty('colSpan')){
      expect(actualCell, address).to.be.instanceOf(Cell);
      expect(actualCell.colSpan, 'colSpan of ' + address).to.equal(expectedCell.colSpan);
    }
    if(expectedCell.hasOwnProperty('spannerFor')){
      expect(actualCell, address).to.be.instanceOf(Cell.RowSpanCell);
      expect(actualCell.originalCell,address + 'originalCell should be a cell').to.be.instanceOf(Cell);
      expect(actualCell.originalCell,address + 'originalCell not right').to.equal(findCell(actualTable,
        expectedCell.spannerFor[1],
        expectedCell.spannerFor[0]
      ));
      //TODO: retest here x,y coords
    }
  }
});