1#@!#!123s

: / opt / alt / alt-nodejs9 / root / lib / node_modules / npm / node_modules.bundled / cli-table2 / src /
Filename : cell.js
back
var _ = require('lodash');
var utils = require('./utils');

/**
 * A representation of a cell within the table.
 * Implementations must have `init` and `draw` methods,
 * as well as `colSpan`, `rowSpan`, `desiredHeight` and `desiredWidth` properties.
 * @param options
 * @constructor
 */
function Cell(options){
  this.setOptions(options);
}

Cell.prototype.setOptions = function(options){
  if(_.isString(options) || _.isNumber(options) || _.isBoolean(options)){
    options = {content:''+options};
  }
  options = options || {};
  this.options = options;
  var content = options.content;
  if (_.isString(content) || _.isNumber(content) || _.isBoolean(content)) {
    this.content = String(content);
  } else if (!content) {
    this.content = '';
  } else {
    throw new Error('Content needs to be a primitive, got: ' + (typeof  content));
  }
  this.colSpan = options.colSpan || 1;
  this.rowSpan = options.rowSpan || 1;
};

Cell.prototype.mergeTableOptions = function(tableOptions,cells){
  this.cells = cells;

  var optionsChars = this.options.chars || {};
  var tableChars = tableOptions.chars;
  var chars = this.chars = {};
  _.forEach(CHAR_NAMES,function(name){
     setOption(optionsChars,tableChars,name,chars);
  });

  this.truncate = this.options.truncate || tableOptions.truncate;

  var style = this.options.style = this.options.style || {};
  var tableStyle = tableOptions.style;
  setOption(style, tableStyle, 'padding-left', this);
  setOption(style, tableStyle, 'padding-right', this);
  this.head = style.head || tableStyle.head;
  this.border = style.border || tableStyle.border;

  var fixedWidth = tableOptions.colWidths[this.x];
  if(tableOptions.wordWrap && fixedWidth){
    fixedWidth -= this.paddingLeft + this.paddingRight;
    this.lines = utils.colorizeLines(utils.wordWrap(fixedWidth,this.content));
  }
  else {
    this.lines = utils.colorizeLines(this.content.split('\n'));
  }

  this.desiredWidth = utils.strlen(this.content) + this.paddingLeft + this.paddingRight;
  this.desiredHeight = this.lines.length;
};

/**
 * Each cell will have it's `x` and `y` values set by the `layout-manager` prior to
 * `init` being called;
 * @type {Number}
 */

Cell.prototype.x = null;
Cell.prototype.y = null;

/**
 * Initializes the Cells data structure.
 *
 * @param tableOptions - A fully populated set of tableOptions.
 * In addition to the standard default values, tableOptions must have fully populated the
 * `colWidths` and `rowWidths` arrays. Those arrays must have lengths equal to the number
 * of columns or rows (respectively) in this table, and each array item must be a Number.
 *
 */
Cell.prototype.init = function(tableOptions){
  var x = this.x;
  var y = this.y;
  this.widths = tableOptions.colWidths.slice(x, x + this.colSpan);
  this.heights = tableOptions.rowHeights.slice(y, y + this.rowSpan);
  this.width = _.reduce(this.widths,sumPlusOne);
  this.height = _.reduce(this.heights,sumPlusOne);

  this.hAlign = this.options.hAlign || tableOptions.colAligns[x];
  this.vAlign = this.options.vAlign || tableOptions.rowAligns[y];

  this.drawRight = x + this.colSpan == tableOptions.colWidths.length;
};

/**
 * Draws the given line of the cell.
 * This default implementation defers to methods `drawTop`, `drawBottom`, `drawLine` and `drawEmpty`.
 * @param lineNum - can be `top`, `bottom` or a numerical line number.
 * @param spanningCell - will be a number if being called from a RowSpanCell, and will represent how
 * many rows below it's being called from. Otherwise it's undefined.
 * @returns {String} The representation of this line.
 */
Cell.prototype.draw = function(lineNum,spanningCell){
  if(lineNum == 'top') return this.drawTop(this.drawRight);
  if(lineNum == 'bottom') return this.drawBottom(this.drawRight);
  var padLen = Math.max(this.height - this.lines.length, 0);
  var padTop;
  switch (this.vAlign){
    case 'center':
      padTop = Math.ceil(padLen / 2);
      break;
    case 'bottom':
      padTop = padLen;
      break;
    default :
      padTop = 0;
  }
  if( (lineNum < padTop) || (lineNum >= (padTop + this.lines.length))){
    return this.drawEmpty(this.drawRight,spanningCell);
  }
  var forceTruncation = (this.lines.length > this.height) && (lineNum + 1 >= this.height);
  return this.drawLine(lineNum - padTop, this.drawRight, forceTruncation,spanningCell);
};

/**
 * Renders the top line of the cell.
 * @param drawRight - true if this method should render the right edge of the cell.
 * @returns {String}
 */
Cell.prototype.drawTop = function(drawRight){
  var content = [];
  if(this.cells){  //TODO: cells should always exist - some tests don't fill it in though
    _.forEach(this.widths,function(width,index){
      content.push(this._topLeftChar(index));
      content.push(
        utils.repeat(this.chars[this.y == 0 ? 'top' : 'mid'],width)
      );
    },this);
  }
  else {
    content.push(this._topLeftChar(0));
    content.push(utils.repeat(this.chars[this.y == 0 ? 'top' : 'mid'],this.width));
  }
  if(drawRight){
    content.push(this.chars[this.y == 0 ? 'topRight' : 'rightMid']);
  }
  return this.wrapWithStyleColors('border',content.join(''));
};

Cell.prototype._topLeftChar = function(offset){
  var x = this.x+offset;
  var leftChar;
  if(this.y == 0){
    leftChar = x == 0 ? 'topLeft' : (offset == 0 ? 'topMid' : 'top');
  } else  {
    if(x == 0){
      leftChar = 'leftMid';
    }
    else {
      leftChar = offset == 0 ? 'midMid' : 'bottomMid';
      if(this.cells){  //TODO: cells should always exist - some tests don't fill it in though
        var spanAbove = this.cells[this.y-1][x] instanceof Cell.ColSpanCell;
        if(spanAbove){
          leftChar = offset == 0 ? 'topMid' : 'mid';
        }
        if(offset == 0){
          var i = 1;
          while(this.cells[this.y][x-i] instanceof Cell.ColSpanCell){
            i++;
          }
          if(this.cells[this.y][x-i] instanceof Cell.RowSpanCell){
            leftChar = 'leftMid';
          }
        }
      }
    }
  }
  return this.chars[leftChar];
};

Cell.prototype.wrapWithStyleColors = function(styleProperty,content){
  if(this[styleProperty] && this[styleProperty].length){
    try {
      var colors = require('colors/safe');
      for(var i = this[styleProperty].length - 1; i >= 0; i--){
        colors = colors[this[styleProperty][i]];
      }
      return colors(content);
    } catch (e) {
      return content;
    }
  }
  else {
    return content;
  }
};

/**
 * Renders a line of text.
 * @param lineNum - Which line of text to render. This is not necessarily the line within the cell.
 * There may be top-padding above the first line of text.
 * @param drawRight - true if this method should render the right edge of the cell.
 * @param forceTruncationSymbol - `true` if the rendered text should end with the truncation symbol even
 * if the text fits. This is used when the cell is vertically truncated. If `false` the text should
 * only include the truncation symbol if the text will not fit horizontally within the cell width.
 * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
 * @returns {String}
 */
Cell.prototype.drawLine = function(lineNum,drawRight,forceTruncationSymbol,spanningCell){
  var left = this.chars[this.x == 0 ? 'left' : 'middle'];
  if(this.x && spanningCell && this.cells){
    var cellLeft = this.cells[this.y+spanningCell][this.x-1];
    while(cellLeft instanceof ColSpanCell){
      cellLeft = this.cells[cellLeft.y][cellLeft.x-1];
    }
    if(!(cellLeft instanceof RowSpanCell)){
      left = this.chars['rightMid'];
    }
  }
  var leftPadding = utils.repeat(' ', this.paddingLeft);
  var right = (drawRight ? this.chars['right'] : '');
  var rightPadding = utils.repeat(' ', this.paddingRight);
  var line = this.lines[lineNum];
  var len = this.width - (this.paddingLeft + this.paddingRight);
  if(forceTruncationSymbol) line += this.truncate || '…';
  var content = utils.truncate(line,len,this.truncate);
  content = utils.pad(content, len, ' ', this.hAlign);
  content = leftPadding + content + rightPadding;
  return this.stylizeLine(left,content,right);
};

Cell.prototype.stylizeLine = function(left,content,right){
  left = this.wrapWithStyleColors('border',left);
  right = this.wrapWithStyleColors('border',right);
  if(this.y === 0){
    content = this.wrapWithStyleColors('head',content);
  }
  return left + content + right;
};

/**
 * Renders the bottom line of the cell.
 * @param drawRight - true if this method should render the right edge of the cell.
 * @returns {String}
 */
Cell.prototype.drawBottom = function(drawRight){
  var left = this.chars[this.x == 0 ? 'bottomLeft' : 'bottomMid'];
  var content = utils.repeat(this.chars.bottom,this.width);
  var right = drawRight ? this.chars['bottomRight'] : '';
  return this.wrapWithStyleColors('border',left + content + right);
};

/**
 * Renders a blank line of text within the cell. Used for top and/or bottom padding.
 * @param drawRight - true if this method should render the right edge of the cell.
 * @param spanningCell - a number of if being called from a RowSpanCell. (how many rows below). otherwise undefined.
 * @returns {String}
 */
Cell.prototype.drawEmpty = function(drawRight,spanningCell){
  var left = this.chars[this.x == 0 ? 'left' : 'middle'];
  if(this.x && spanningCell && this.cells){
    var cellLeft = this.cells[this.y+spanningCell][this.x-1];
    while(cellLeft instanceof ColSpanCell){
      cellLeft = this.cells[cellLeft.y][cellLeft.x-1];
    }
    if(!(cellLeft instanceof RowSpanCell)){
      left = this.chars['rightMid'];
    }
  }
  var right = (drawRight ? this.chars['right'] : '');
  var content = utils.repeat(' ',this.width);
  return this.stylizeLine(left , content , right);
};

/**
 * A Cell that doesn't do anything. It just draws empty lines.
 * Used as a placeholder in column spanning.
 * @constructor
 */
function ColSpanCell(){}

ColSpanCell.prototype.draw = function(){
  return '';
};

ColSpanCell.prototype.init = function(tableOptions){};


/**
 * A placeholder Cell for a Cell that spans multiple rows.
 * It delegates rendering to the original cell, but adds the appropriate offset.
 * @param originalCell
 * @constructor
 */
function RowSpanCell(originalCell){
  this.originalCell = originalCell;
}

RowSpanCell.prototype.init = function(tableOptions){
  var y = this.y;
  var originalY = this.originalCell.y;
  this.cellOffset = y - originalY;
  this.offset = findDimension(tableOptions.rowHeights,originalY,this.cellOffset);
};

RowSpanCell.prototype.draw = function(lineNum){
  if(lineNum == 'top'){
    return this.originalCell.draw(this.offset,this.cellOffset);
  }
  if(lineNum == 'bottom'){
    return this.originalCell.draw('bottom');
  }
  return this.originalCell.draw(this.offset + 1 + lineNum);
};

ColSpanCell.prototype.mergeTableOptions =
RowSpanCell.prototype.mergeTableOptions = function(){};

// HELPER FUNCTIONS
function setOption(objA,objB,nameB,targetObj){
  var nameA = nameB.split('-');
  if(nameA.length > 1) {
    nameA[1] = nameA[1].charAt(0).toUpperCase() + nameA[1].substr(1);
    nameA = nameA.join('');
    targetObj[nameA] = objA[nameA] || objA[nameB] || objB[nameA] || objB[nameB];
  }
  else {
    targetObj[nameB] = objA[nameB] || objB[nameB];
  }
}

function findDimension(dimensionTable, startingIndex, span){
  var ret = dimensionTable[startingIndex];
  for(var i = 1; i < span; i++){
    ret += 1 + dimensionTable[startingIndex + i];
  }
  return ret;
}

function sumPlusOne(a,b){
  return a+b+1;
}

var CHAR_NAMES = [  'top'
  , 'top-mid'
  , 'top-left'
  , 'top-right'
  , 'bottom'
  , 'bottom-mid'
  , 'bottom-left'
  , 'bottom-right'
  , 'left'
  , 'left-mid'
  , 'mid'
  , 'mid-mid'
  , 'right'
  , 'right-mid'
  , 'middle'
];
module.exports = Cell;
module.exports.ColSpanCell = ColSpanCell;
module.exports.RowSpanCell = RowSpanCell;