premake

#!/usr/bin/env python

# Copyright 2015 Ben Vanik. All Rights Reserved.

"""Premake trampoline script.
"""

__author__ = 'ben.vanik@gmail.com (Ben Vanik)'


import os
import subprocess
import sys


self_path = os.path.dirname(os.path.abspath(__file__))
premake_path = os.path.join(self_path, 'third_party', 'premake-core')


def main():
  # First try the freshly-built premake.
  premake5_bin = os.path.join(premake_path, 'bin', 'release', 'premake5')
  if not has_bin(premake5_bin):
    # No fresh build, so fallback to checked in copy (which we may not have).
    premake5_bin = os.path.join('bin', 'premake5')
  if not has_bin(premake5_bin):
    # Still no valid binary, so build it.
    print('premake5 executable not found, attempting build...')
    build_premake()
    premake5_bin = os.path.join(premake_path, 'bin', 'release', 'premake5')
  if not has_bin(premake5_bin):
    # Nope, boned.
    print('ERROR: cannot build premake5 executable.')
    sys.exit(1)

  # Ensure the submodule has been checked out.
  if not os.path.exists(os.path.join(premake_path, 'scripts', 'package.lua')):
    print('third_party/premake-core was not present; fetching...')
    git_submodule_update()

  return_code = shell_call([
      premake5_bin,
      '--scripts=%s' % (premake_path),
      ] + sys.argv[1:],
      throw_on_error=False)

  sys.exit(return_code)


def build_premake():
  """Builds premake from source.
  """
  cwd = os.getcwd()
  try:
    os.chdir(premake_path)
    if sys.platform == 'darwin':
      shell_call([
          'make',
          '-f', 'Bootstrap.mak',
          'osx',
          ])
    elif sys.platform == 'win32':
      # TODO(benvanik): import VS environment.
      shell_call([
          'nmake',
          '-f', 'Bootstrap.mak',
          'windows',
          ])
    else:
      shell_call([
          'make',
          '-f', 'Bootstrap.mak',
          'linux',
          ])
  finally:
    os.chdir(cwd)
  pass


def has_bin(bin):
  """Checks whether the given binary is present.
  """
  for path in os.environ["PATH"].split(os.pathsep):
    path = path.strip('"')
    exe_file = os.path.join(path, bin)
    if os.path.isfile(exe_file) and os.access(exe_file, os.X_OK):
      return True
    exe_file = exe_file + '.exe'
    if os.path.isfile(exe_file) and os.access(exe_file, os.X_OK):
      return True
  return None


def shell_call(command, throw_on_error=True, stdout_path=None):
  """Executes a shell command.

  Args:
    command: Command to execute, as a list of parameters.
    throw_on_error: Whether to throw an error or return the status code.
    stdout_path: File path to write stdout output to.

  Returns:
    If throw_on_error is False the status code of the call will be returned.
  """
  stdout_file = None
  if stdout_path:
    stdout_file = open(stdout_path, 'w')
  result = 0
  try:
    if throw_on_error:
      result = 1
      subprocess.check_call(command, shell=False, stdout=stdout_file)
      result = 0
    else:
      result = subprocess.call(command, shell=False, stdout=stdout_file)
  finally:
    if stdout_file:
      stdout_file.close()
  return result


def git_submodule_update():
  """Runs a full recursive git submodule init and update.

  Older versions of git do not support 'update --init --recursive'. We could
  check and run it on versions that do support it and speed things up a bit.
  """
  if True:
    shell_call([
        'git',
        'submodule',
        'update',
        '--init',
        '--recursive',
        ])
  else:
    shell_call([
        'git',
        'submodule',
        'init',
        ])
    shell_call([
        'git',
        'submodule',
        'foreach',
        '--recursive',
        'git',
        'submodule',
        'init',
        ])
    shell_call([
        'git',
        'submodule',
        'update',
        '--recursive',
        ])


if __name__ == '__main__':
  main()