jest-bdd-generator/dist/es/commands/adapter.js

Jest code generator empowered with Gherkin and BDD

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
  try {
    var info = gen[key](arg);
    var value = info.value;
  } catch (error) {
    reject(error);
    return;
  }
  if (info.done) {
    resolve(value);
  } else {
    Promise.resolve(value).then(_next, _throw);
  }
}
function _async_to_generator(fn) {
  return function() {
    var self = this, args = arguments;
    return new Promise(function(resolve, reject) {
      var gen = fn.apply(self, args);
      function _next(value) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
      }
      function _throw(err) {
        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
      }
      _next(void 0);
    });
  };
}
function _define_property(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }
  return obj;
}
function _object_spread(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};
    var ownKeys2 = Object.keys(source);
    if (typeof Object.getOwnPropertySymbols === "function") {
      ownKeys2 = ownKeys2.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
        return Object.getOwnPropertyDescriptor(source, sym).enumerable;
      }));
    }
    ownKeys2.forEach(function(key) {
      _define_property(target, key, source[key]);
    });
  }
  return target;
}
function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);
  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) {
      symbols = symbols.filter(function(sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
    }
    keys.push.apply(keys, symbols);
  }
  return keys;
}
function _object_spread_props(target, source) {
  source = source != null ? source : {};
  if (Object.getOwnPropertyDescriptors) {
    Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
  } else {
    ownKeys(Object(source)).forEach(function(key) {
      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
    });
  }
  return target;
}
import * as process from "process";
import * as path from "path";
import * as fs from "fs";
const OUTPUT_PARAM = "pathOutput";
function fetchArgV(name) {
  return (arg) => {
    const match = arg.match(new RegExp(`^${name}=(.+)`, "i"));
    return match === null || match === void 0 ? void 0 : match[1];
  };
}
function run(execute, defaultOption, pathlikeFromArgV) {
  return _run.apply(this, arguments);
}
function _run() {
  _run = _async_to_generator(function* (execute, defaultOption, pathlikeFromArgV) {
    const [_execPath, ...args] = process.argv;
    const options = _object_spread({}, defaultOption);
    const argsNames = [
      OUTPUT_PARAM,
      ...defaultOption ? Object.keys(defaultOption) : [],
      ...pathlikeFromArgV !== null && pathlikeFromArgV !== void 0 ? pathlikeFromArgV : []
    ];
    args.forEach((arg) => {
      argsNames.forEach((key) => {
        const opt = fetchArgV(key)(arg);
        if (opt === null || opt === void 0 ? void 0 : opt.match(/^\.\/|^\.\.\//)) {
          options[key] = path.join(process.cwd(), opt);
        }
      });
    });
    const executables = [];
    Object.keys(options).forEach((argName) => {
      if (argName === OUTPUT_PARAM || !(pathlikeFromArgV === null || pathlikeFromArgV === void 0 ? void 0 : pathlikeFromArgV.includes(argName))) {
        return;
      }
      const optionValue = options[argName];
      if (typeof optionValue === "string" && fs.statSync(optionValue).isDirectory()) {
        fs.readdirSync(optionValue).forEach((fileinfo) => {
          const _option = _object_spread_props(_object_spread({}, options), {
            [argName]: path.join(optionValue, fileinfo)
          });
          const baseName = path.basename(fileinfo, path.extname(fileinfo));
          if (options[OUTPUT_PARAM]) {
            const outputExt = path.extname(options[OUTPUT_PARAM]);
            const outputPath = path.dirname(options[OUTPUT_PARAM]);
            _option[OUTPUT_PARAM] = path.join(outputPath, `${baseName}${outputExt}`);
          }
          executables.push(_option);
        });
      }
    });
    if (executables.length === 0) {
      executables.push(options);
    }
    const ret = yield Promise.all(executables.map(function() {
      var _ref = _async_to_generator(function* (_option) {
        const res = yield execute(_option);
        if (typeof _option[OUTPUT_PARAM] === "string") {
          const outputPath = path.dirname(_option[OUTPUT_PARAM]);
          if (!fs.existsSync(outputPath)) {
            fs.mkdirSync(outputPath);
          }
          fs.writeFileSync(_option[OUTPUT_PARAM], res);
        } else {
          console.log(res);
        }
        return res;
      });
      return function(_option) {
        return _ref.apply(this, arguments);
      };
    }()));
    return ret;
  });
  return _run.apply(this, arguments);
}
export {
  run
};

//# sourceMappingURL=adapter.js.map