refactoring of functional tests

[pmachines.git] / lib / build / build.py

'''Tools for making the builds.'''
from os import walk, chdir, getcwd
from os.path import join, getsize, exists, dirname, getmtime, sep
from subprocess import Popen, PIPE, run
from logging import debug
from time import strftime
from pathlib import Path
from hashlib import md5


#TODO refactor: make class BuilderTools


def exec_cmd(cmd):
    '''Synchronously executes a command and returns its output.'''
    #ret = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=True).communicate()
    #return ret[0].decode('utf-8').strip()
    proc = run(cmd, shell=True, stdout=PIPE, stderr=PIPE, universal_newlines=True)
    return proc.stdout.strip() + proc.stderr.strip()


def _branch():
    '''Returns the current branch.'''
    git_branch = exec_cmd('git symbolic-ref HEAD').split('/')[-1].strip()
    print('git_branch result: %s' % git_branch)
    branches = ['master', 'rc', 'stable']
    if git_branch in branches:
        print('git_branch: %s' % git_branch)
        return git_branch
    root = str(Path(dirname(dirname(__file__))).parent) + '/'
    if 'itch' in __file__.split(sep):
        root = str(Path(dirname(__file__))) + '/'
    if __file__ == '/app/bin/pmachines':  # flatpak
        root = '/app/bin/'
    for branch in branches:
        try:
            print('try: %s' % root + 'assets/bld_version.txt')
            with open(root + 'assets/bld_version.txt') as fver:
                ver = fver.read()
                print('ver: %s' % ver)
            #if branch in ver:
            b2c = {'master': 'a', 'rc': 'r', 'stable': '.'}
            if ver[1] == b2c[branch]:
                return branch
        except FileNotFoundError:
            print('file not found: %s' % root + 'assets/bld_version.txt')


def _commit():
    '''Returns the current branch.'''
    git_commit = exec_cmd('git rev-parse HEAD')[:7]
    print('git_commit result: %s' % git_commit)
    if not git_commit.startswith("Can't r"):
        return git_commit
    root = str(Path(dirname(dirname(__file__))).parent) + '/'
    if 'itch' in __file__.split(sep):
        root = str(Path(dirname(__file__))) + '/'
    if __file__ == '/app/bin/pmachines':  # flatpak
        root = '/app/bin/'
    try:
        print('try: %s' % root + 'assets/bld_version.txt')
        with open(root + 'assets/bld_version.txt') as fver:
            ver = fver.read()
            print('ver: %s' % ver)
            return ver.split('-')[1]
    except FileNotFoundError:
        print('file not found: %s' % root + 'assets/bld_version.txt')


def _version():
    '''Computes the version of the current build.'''
    day = strftime('%y%m%d')
    root = str(Path(dirname(dirname(__file__))).parent) + '/'
    if __file__ == '/app/bin/pmachines':  # flatpak
        root = '/app/bin/'
    if _branch() == 'stable':
        pref, _ver = '', ''
        if exists(root + 'assets/version.txt'):
            with open(root + 'assets/version.txt') as fver:
                pref = fver.read().strip() + '-'  # + _branch() + '-'
                _ver = fver.read().strip()
        ret_ver = _ver or ('0.' + day)
    else:
        #try:  we want an error!
        pref = {'master': 'a', 'rc': 'rc', '': 'runtime'}[_branch()]
        #except KeyError:
        #    pref = 'notfound'
        ret_ver = '0%s%s' % (pref, day)
        pref = ret_ver
    bld_ver = pref + '-' + _commit()
    try:
        with open(root + 'assets/bld_version.txt', 'w') as fver:
            fver.write(bld_ver)
    except OSError:
        print("we can't write inside flatpaks, but we don't need it")
    return ret_ver


def files(_extensions, excl_dirs=None, excl_ends_with=None, root_path='.'):
    '''Retrieves filenames in root_path with _extensions, with filters.'''
    return [join(root, fname)
            for root, _, fnames in walk(root_path)
            for fname in __files_ext(fnames, _extensions)
            if not any(e_d in root.split('/') for e_d in excl_dirs or []) and
            not any(fname.endswith(e_e) for e_e in excl_ends_with or [])]


def __files_ext(fnames, _extensions):
    return [fname for fname in fnames
            if any(fname.endswith('.' + ext) for ext in _extensions)]


def __to_be_built_single(src, tgt):
    if getmtime(tgt) > getmtime(src):
        print('%s is newer than %s: do not build' % (tgt, src))
        return False
    with open(src, 'rb') as f:
        src_content = f.read()
    with open(tgt, 'rb') as f:
        tgt_content = f.read()
    hash_src = md5(src_content).hexdigest()
    hash_tgt = md5(tgt_content).hexdigest()
    cache = {}
    lines = []
    if exists('hash_cache.txt'):
        with open('hash_cache.txt') as f:
            lines = f.readlines()
    for line in lines:
        line_spl = line.split()
        hash = line_spl[-1]
        fname = ' '.join(line_spl[:-1])
        cache[fname] = hash
    if src in cache and tgt in cache:
        if hash_src == cache[src] and \
           hash_tgt == cache[tgt]:
            print('%s and %s are in the cache: do not build' % (tgt, src))
            return False
    print('%s and %s are not up-to-date: building...' % (src, tgt))
    return True


def to_be_built(tgt, srcs):
    '''Should tgt be built (i.e. is it older?) from sources srcs?'''
    if not exists(tgt):
        print(tgt + ' does not exist: building...')
        return True
    return any(__to_be_built_single(src, tgt) for src in srcs)


class InsideDir:
    '''Context manager for working inside a directory.'''

    def __init__(self, dir_):
        self.dir = dir_
        self.old_dir = getcwd()

    def __enter__(self):
        chdir(self.dir)

    def __exit__(self, exc_type, exc_val, exc_tb):
        chdir(self.old_dir)


bld_dpath = 'build/'
branch = _branch()
ver = _version()
win_fpath = '{dst_dir}{appname}-%s-windows.exe' % branch
#osx_fpath = '{dst_dir}{appname}-%s-osx.zip' % branch
#flatpak_fpath = '{dst_dir}{appname}-%s-flatpak' % branch
appimage_fpath = '{dst_dir}{appname}-%s-appimage' % branch
docs_fpath = '{dst_dir}{appname}-%s-docs.tar.gz' % branch