How to use the git-rev-sync.branch function in git-rev-sync

import routes from './routes'
import bodyParser from 'body-parser'
import morgan from 'morgan'
import mongo from './libs/mongo'
import { connect as redis_connect } from './libs/redis'
import { connect as resque_connect } from './libs/queue'
import notifications from './libs/notifications'
import git from 'git-rev-sync'
import aws from './libs/aws'
// import events lib to instantiate CRN Emitter
import events from './libs/events'

// configuration ---------------------------------------------------
const ravenConfig = {
  release: git.long(),
  tags: { branch: git.branch() },
  environment: config.sentry.ENVIRONMENT,
  autoBreadcrumbs: true,
}
Raven.config(config.sentry.DSN, ravenConfig).install()

mongo.connect(config.mongo.url)

const redisConnect = async () => {
  try {
    const redis = await redis_connect(config.redis)
    await resque_connect(redis)
    console.log('Resque connected')
    // start background tasks
    notifications.initCron()
    aws.batch.initCron()
    aws.cloudwatch.initEvents().then(aws.batch.initQueue)

var res = Q.fcall(function(db) {
  server.start({
    development: process.env["NODE_ENV"] !== "production",
    baseUrl: process.env["BASE_URL"],
    logURL: process.env["LOG_URL"],
    gitRev:    process.env["GIT_REV"]    || git.short(),
    gitBranch: process.env["GIT_BRANCH"] || git.branch(),
    port: process.env["PORT"],
    sessionSecret: process.env["SESSION_SECRET"],
    db: storage.makeStorage(client),
    google: {
      apiKey: process.env["GOOGLE_API_KEY"],
      clientId: process.env["GOOGLE_CLIENT_ID"],
      clientSecret: process.env["GOOGLE_CLIENT_SECRET"],
      redirect: "/oauth2callback"
    },
    version: process.env["CURRENT_PYRET_RELEASE"],
    pyret: process.env["PYRET"]
  }, function(app) {
    console.log("Server ready.");
  });
});
res.fail(function(err) {

forEach(answer.moduleEntryKeys, (entryKey) => {
        console.log(
          chalk.black.bold(`Clean folder "${chalk.cyan(entryKey)}"`)
        );
        emptyDirSync(join(BUILD_PATH, entryKey));
        try {
          outputJsonSync(join(BUILD_PATH, entryKey, 'version.txt'), {
            head: gitRev.long(),
            branch: gitRev.branch()
          });
        } catch (e) {
          console.log(
            chalk.yellow('current project is not a git repository!')
          );
        }
      });
      console.log();

export function getVersion() {
    if (fs.existsSync('node_modules')) {
        try {
            let path = Path.resolve(fs.realpathSync('node_modules'), '../');
            let version = gitVer.branch(path) + '#' + gitVer.short(path);
            return `(Development Build) ${version}`;
        } catch (e) {
            Logger.trace(e);
        }
    }
    return Package.version;
}

export function defaultVersionGetter(
  absolutePackageDir: string,
  {globalEnv = WEBEXT_BUILD_ENV}: VersionGetterOptions = {}
): string {
  if (globalEnv === 'production') {
    log.debug('Getting the version from package.json');
    const packageData: any = readFileSync(
      path.join(absolutePackageDir, 'package.json'));
    return JSON.parse(packageData).version;
  } else {
    log.debug('Getting version from the git revision');
    return `${git.branch(absolutePackageDir)}-${git.long(absolutePackageDir)}`;
  }
}

const configureBanner = () => {
    return {
        banner: [
            '/*!',
            ' * @project        ' + settings.name,
            ' * @name           ' + '[filebase]',
            ' * @author         ' + pkg.author.name,
            ' * @build          ' + moment().format('llll') + ' ET',
            ' * @release        ' + git.long() + ' [' + git.branch() + ']',
            ' * @copyright      Copyright (c) ' + moment().format('YYYY') + ' ' + settings.copyright,
            ' *',
            ' */',
            ''
        ].join('\n'),
        raw: true
    };
};

.pipe(jeditor(function (json) {
            json.version = packageJson.version;
            json.revision = git.long();
            json.revisionShort = git.short();
            json.branch = git.branch();
            return json;
        }))
        .pipe(gulp.dest("./src"));

gulp.task('build-branch', ['build'], function() {
  var branch = git.branch();
  if (branch != 'master') {
    return gulp.src('dist/**/*').pipe(gulp.dest('dist/event/' + branch));
  }
});

let throwIfNotOnMaster = () => {
  const branch = git.branch();
  if (branch !== 'master') {
    throw new Error(`Must be on branch master (current branch is ${branch})`);
  }
};

function getReleaseFilename(platform, ext) {
  return (
    pkg.name +
    "_" +
    pkg.version +
    "-" +
    git.branch() +
    "_" +
    git.short() +
    "-" +
    platform +
    "." +
    ext
  );
}