@dot-event/git/dist/git.js

dot-event spawn git operation

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

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

var _argv = require("@dot-event/argv");

var _log = _interopRequireDefault(require("@dot-event/log"));

var _spawn = _interopRequireDefault(require("@dot-event/spawn"));

var _status = _interopRequireDefault(require("@dot-event/status"));

var _output = require("./git/output");

// Packages
// Helpers
// Composer
function _default(options) {
  const {
    events
  } = options;

  if (events.ops.has("git")) {
    return options;
  }

  (0, _log.default)({
    events
  });
  (0, _spawn.default)({
    events
  });
  (0, _status.default)({
    events
  });
  events.withOptions({
    cwd: process.cwd()
  }).onAny({
    git: _argv.argvRelay,
    gitAdd: async options => {
      const {
        cwd,
        path = ".",
        props
      } = options;
      const command = "git";
      await events.spawn([...props, "gitAdd", "add"], {
        args: ["add", path],
        command,
        cwd
      });
      await events.spawn([...props, "gitAdd", "addUpdate"], {
        args: ["add", path, "-u"],
        command,
        cwd
      });
    },
    gitCommit: async options => {
      const {
        cwd,
        events,
        message,
        props
      } = options;

      if (!message) {
        throw new Error("No message specified");
      }

      const {
        behind,
        dirty
      } = await events.gitStatus(props, options);
      const command = "git";

      if (!behind && dirty) {
        await events.gitAdd(props, options);
        await events.spawn([...props, "gitCommit", "commit"], {
          args: ["commit", "-a", "-m", message],
          command,
          cwd
        });
        await events.spawn([...props, "gitCommit", "push"], {
          args: ["push", "origin", "master"],
          command,
          cwd
        });
      }
    },
    gitSetupOnce: () => events.argv({
      alias: {
        c: ["commit"],
        d: ["dry"],
        m: ["message"],
        s: ["status"]
      }
    }),
    gitStatus: async options => {
      const {
        cwd,
        event,
        events,
        props
      } = options;
      const {
        operations
      } = events.get(props);
      const command = "git";
      await Promise.all([events.spawn([...props, "gitStatus", "log"], {
        args: ["log", "-1", "--pretty=%B"],
        command,
        cwd,
        lax: true,
        quiet: true
      }), events.spawn([...props, "gitStatus", "status"], {
        args: ["status", "-uno"],
        command,
        cwd,
        lax: true,
        quiet: true
      })]);
      const {
        log,
        status
      } = events.get([...props, "gitStatus"]);
      const results = {
        behind: !!status.out.match(/(ahead|behind)/),
        dirty: !status.out.match(/nothing to commit/),
        needsPublish: !log.out.match(/Version bump/) && operations.version && operations.version.publish !== false
      };
      await events.set([...props, "gitStatus", "results"], results);
      event.signal.returnValue = results;
    },
    set: _output.output
  });
  return options;
}
//# sourceMappingURL=git.js.map