humpty/dist/getExportsAndCommits.js

Makes sure your changelogs mention your breaking changes

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

let showFile = (() => {
  var _ref = _asyncToGenerator(function* (repo, apiRef, filePath) {
    return new Promise(function (resolve, reject) {
      repo.show([`${apiRef}:${filePath}`], function (err, results) {
        if (err) {
          reject(err);
          return;
        }
        resolve(results);
      });
    });
  });

  return function showFile(_x, _x2, _x3) {
    return _ref.apply(this, arguments);
  };
})();

let loadFile = (() => {
  var _ref2 = _asyncToGenerator(function* (repo, apiRef, filePath, extensionsToTry = ["", ".js", ".jsx"]) {
    for (let i = 0; i < extensionsToTry.length; i++) {
      const ext = extensionsToTry[i];
      try {
        const contents = yield showFile(repo, apiRef, `${filePath}${ext}`);
        return contents;
      } catch (error) {
        // trying next extension
      }
    }
  });

  return function loadFile(_x4, _x5, _x6) {
    return _ref2.apply(this, arguments);
  };
})();

let getPropsOfDeepestFile = (() => {
  var _ref3 = _asyncToGenerator(function* ({
    repo,
    apiRef,
    sourceFile,
    currentDir = ""
  }) {
    const fullFilePath = _path2.default.join(currentDir, sourceFile);
    const source = yield loadFile(repo, apiRef, fullFilePath);
    if (!source) {
      throw new Error(`Could not load file for named export ${sourceFile}`);
    }
    const indexAst = getAST(source);
    const nextSourceFile = getDefaultExportSourceFilePath(indexAst);
    if (nextSourceFile) {
      return yield getPropsOfDeepestFile({
        repo,
        apiRef,
        sourceFile: nextSourceFile,
        currentDir: _path2.default.dirname(fullFilePath)
      });
    }
    return yield detectProps(source);
  });

  return function getPropsOfDeepestFile(_x7) {
    return _ref3.apply(this, arguments);
  };
})();

let detectNamedExports = (() => {
  var _ref4 = _asyncToGenerator(function* ({ repo, apiRef, source: indexSource }) {
    const indexAst = getAST(indexSource);
    if (!indexAst) {
      throw new Error("Could not parse entry file");
    }
    const exportsThatNeedLookup = indexAst.filter(function ({ type }) {
      return ["ExportNamedDeclaration"].includes(type);
    }
    // "ExportDefaultDeclaration"
    ).filter(function ({ source }) {
      return Boolean(source);
    });

    const results = yield Promise.all(exportsThatNeedLookup.map((() => {
      var _ref5 = _asyncToGenerator(function* (toImport) {
        const publicExportName = toImport.specifiers[0].exported.name;
        const sourceFile = toImport.source.value;
        const foundProps = yield getPropsOfDeepestFile({
          repo,
          apiRef,
          sourceFile
        });
        return generateExportDefinition({
          isDefaultExport: false,
          name: publicExportName,
          api: { props: foundProps }
        });
      });

      return function (_x9) {
        return _ref5.apply(this, arguments);
      };
    })()));

    return results;
  });

  return function detectNamedExports(_x8) {
    return _ref4.apply(this, arguments);
  };
})();

let detectProps = (() => {
  var _ref6 = _asyncToGenerator(function* (sourceToParse) {
    const defaultExportApi = reactDocs.parse(sourceToParse);
    return (0, _lodash2.default)(defaultExportApi.props).mapValues(function (value, name) {
      return _lodash2.default.merge({}, value, { name });
    }).values().value();
  });

  return function detectProps(_x10) {
    return _ref6.apply(this, arguments);
  };
})();

let loadExport = (() => {
  var _ref7 = _asyncToGenerator(function* (repo, apiRef) {
    const source = yield loadFile(repo, apiRef, "index.js");
    const namedExports = yield detectNamedExports({ repo, apiRef, source });
    const results = [generateExportDefinition({
      isDefaultExport: true,
      sourceContents: source,
      api: {
        props: yield detectProps(source)
      }
    }), ...namedExports];
    return results;
  });

  return function loadExport(_x11, _x12) {
    return _ref7.apply(this, arguments);
  };
})();

var _lodash = require("lodash");

var _lodash2 = _interopRequireDefault(_lodash);

var _path = require("path");

var _path2 = _interopRequireDefault(_path);

var _simpleGit = require("simple-git");

var _simpleGit2 = _interopRequireDefault(_simpleGit);

var _babylonOptions = require("./util/babylonOptions");

var _babylonOptions2 = _interopRequireDefault(_babylonOptions);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; } // @flow

const babylon = require("babylon");
const reactDocs = require("react-docgen");


function getDefaultExportSourceFilePath(ast) {
  const defaultExportAsNamed = ast.find(node => node.type === "ExportNamedDeclaration" && node.specifiers[0].exported.name === "default");

  if (defaultExportAsNamed) {
    return defaultExportAsNamed.source.value;
  }
}

function generateExportDefinition({
  isDefaultExport,
  name,
  sourceContents,
  api
}) {
  return {
    isDefaultExport,
    sourceContents,
    name,
    api
  };
}

function getGitLog(repo, oldApi, newApi) {
  return new Promise((resolve, reject) => {
    repo.log({
      from: oldApi,
      to: newApi
    }, (err, results) => {
      if (err) {
        reject(err);
        return;
      }
      resolve(results.all.map(log => log.message));
    });
  });
}

function getAST(source) {
  const ast = babylon.parse(source, _babylonOptions2.default);
  return ast ? ast.program.body : null;
}

exports.default = (() => {
  var _ref8 = _asyncToGenerator(function* ({
    oldApi,
    newApi,
    gitRepo
  }) {
    const repo = (0, _simpleGit2.default)(gitRepo).silent(true);
    return {
      commitMessages: yield getGitLog(repo, oldApi, newApi),
      newExports: yield loadExport(repo, newApi),
      oldExports: yield loadExport(repo, oldApi)
    };
  });

  function getExportsAndCommits(_x13) {
    return _ref8.apply(this, arguments);
  }

  return getExportsAndCommits;
})();