@catladder/pipeline/dist/bash/BashExpression.js

Panter workflow for cloud CI/CD and DevOps

"use strict";

var __read = this && this.__read || function (o, n) {
  var m = typeof Symbol === "function" && o[Symbol.iterator];
  if (!m) return o;
  var i = m.call(o),
    r,
    ar = [],
    e;
  try {
    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
  } catch (error) {
    e = {
      error: error
    };
  } finally {
    try {
      if (r && !r.done && (m = i["return"])) m.call(i);
    } finally {
      if (e) throw e.error;
    }
  }
  return ar;
};
var __spreadArray = this && this.__spreadArray || function (to, from, pack) {
  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
    if (ar || !(i in from)) {
      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
      ar[i] = from[i];
    }
  }
  return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.joinBashExpressions = exports.getBashVariable = exports.BashExpression = void 0;
/**
 * this class represents a string that can be evaluated in bash scripts.
 *
 * you can do basic transforms like lowercase, but that does not return you a lowercase string, but instead an experssion represeting a lowercase string
 */
var BashExpression = /** @class */function () {
  function BashExpression(value) {
    this.value = value;
  }
  BashExpression.prototype.toJSON = function () {
    return this.toString();
  };
  BashExpression.prototype.toString = function () {
    return this.value.toString();
  };
  BashExpression.prototype.replace = function (searchValue, replacer) {
    return new BashExpression(this.value.toString().replace(searchValue, replacer));
  };
  /**
   *
   * @returns a bash expression to lowercase the string
   */
  BashExpression.prototype.toLowerCase = function () {
    return this.transformWithCommand("awk '{print tolower($0)}'");
  };
  /**
   * concats a value to this one and returns a new BashExpression
   * @param value
   * @returns
   */
  BashExpression.prototype.concat = function () {
    var _a;
    var values = [];
    for (var _i = 0; _i < arguments.length; _i++) {
      values[_i] = arguments[_i];
    }
    return new BashExpression((_a = this.toString()).concat.apply(_a, __spreadArray([], __read(values.map(function (v) {
      return v.toString();
    })), false)));
  };
  BashExpression.prototype.transformWithCommand = function (command) {
    return new BashExpression(
    // see https://stackoverflow.com/a/2264537
    "$(printf %s \"".concat(this.toString(), "\" | ").concat(command, ")"));
  };
  return BashExpression;
}();
exports.BashExpression = BashExpression;
var getBashVariable = function (name) {
  return new BashExpression("$".concat(name));
};
exports.getBashVariable = getBashVariable;
/**
 * joins bash expressions together with a joiner
 * returns a bash expression if any of the parts is a bash expression
 * returns a string otherwise
 *
 * @param parts
 * @param joiner
 * @returns
 */
var joinBashExpressions = function (parts, joiner) {
  if (joiner === void 0) {
    joiner = "";
  }
  var anyIsBashExpression = parts.some(function (p) {
    return p instanceof BashExpression;
  });
  if (anyIsBashExpression) {
    return new BashExpression(parts.map(function (p) {
      return p instanceof BashExpression ? p.toString() : p;
    }).join(joiner));
  } else {
    return parts.join(joiner);
  }
};
exports.joinBashExpressions = joinBashExpressions;