tools/copy_tree.py

#!/usr/bin/env python
# Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
# for details. All rights reserved. Use of this source code is governed by a
# BSD-style license that can be found in the LICENSE file.

import argparse
import gn_helpers
import os
import re
import shutil
import sys


def ParseArgs(args):
    args = args[1:]
    parser = argparse.ArgumentParser(
        description='A script to copy a file tree somewhere')

    parser.add_argument(
        '--exclude_patterns',
        '-e',
        type=str,
        help='Patterns to exclude [passed to shutil.copytree]')
    parser.add_argument(
        '--from', '-f', dest="copy_from", type=str, help='Source directory')
    parser.add_argument(
        '--gn',
        '-g',
        dest='gn',
        default=False,
        action='store_true',
        help='Output for GN for multiple sources, but do not copy anything.')
    parser.add_argument(
        'gn_paths',
        metavar='name path ignore_pattern',
        type=str,
        nargs='*',
        default=None,
        help='When --gn is given, the specification of source paths to list.')
    parser.add_argument('--to', '-t', type=str, help='Destination directory')

    return parser.parse_args(args)


def ValidateArgs(args):
    if args.gn:
        if args.exclude_patterns or args.copy_from or args.to:
            print("--gn mode does not accept other switches")
            return False
        if not args.gn_paths:
            print("--gn mode requires a list of source specifications")
            return False
        return True
    if not args.copy_from or not os.path.isdir(args.copy_from):
        print("--from argument must refer to a directory")
        return False
    if not args.to:
        print("--to is required")
        return False
    return True


def CopyTree(src, dst, ignore=None):
    # Recusive helper method to collect errors but keep processing.
    def copy_tree(src, dst, ignore, errors):
        names = os.listdir(src)
        if ignore is not None:
            ignored_names = ignore(src, names)
        else:
            ignored_names = set()

        if not os.path.exists(dst):
            os.makedirs(dst)
        for name in names:
            if name in ignored_names:
                continue
            srcname = os.path.join(src, name)
            dstname = os.path.join(dst, name)
            try:
                if os.path.isdir(srcname):
                    copy_tree(srcname, dstname, ignore, errors)
                else:
                    shutil.copy(srcname, dstname)
            except (IOError, os.error) as why:
                errors.append((srcname, dstname, str(why)))
        try:
            shutil.copystat(src, dst)
        except WindowsError:
            # Can't copy file access times on Windows.
            pass
        except OSError as why:
            errors.append((src, dst, str(why)))

    # Format errors from file copies.
    def format_error(error):
        if len(error) == 1:
            return "Error: {msg}".format(msg=str(error[0]))
        return "From: {src}\nTo:   {dst}\n{msg}" \
                .format(src=error[0], dst=error[1], msg=error[2])

    errors = []
    copy_tree(src, dst, ignore, errors)
    if errors:
        failures = "\n\n".join(format_error(error) for error in errors)
        parts = ("Some file copies failed:", "=" * 78, failures)
        msg = '\n'.join(parts)
        raise RuntimeError(msg)


def ListTree(src, ignore=None):
    names = os.listdir(src)
    if ignore is not None:
        ignored_names = ignore(src, names)
    else:
        ignored_names = set()

    srcnames = []
    for name in names:
        if name in ignored_names:
            continue
        srcname = os.path.join(src, name)
        if os.path.isdir(srcname):
            srcnames.extend(ListTree(srcname, ignore))
        else:
            srcnames.append(srcname)
    return srcnames


# source_dirs is organized such that sources_dirs[n] is the path for the source
# directory, and source_dirs[n+1] is a list of ignore patterns.
def SourcesToGN(source_dirs):
    if len(source_dirs) % 2 != 0:
        print("--gn list length should be a multiple of 2.")
        return False
    data = []
    for i in range(0, len(source_dirs), 2):
        path = source_dirs[i]
        ignores = source_dirs[i + 1]
        if ignores in ["{}"]:
            sources = ListTree(path)
        else:
            patterns = ignores.split(',')
            sources = ListTree(path, ignore=shutil.ignore_patterns(*patterns))
        data.append(sources)
    scope_data = {"sources": data}
    print(gn_helpers.ToGNString(scope_data))
    return True


def Main(argv):
    args = ParseArgs(argv)
    if not ValidateArgs(args):
        return -1

    if args.gn:
        SourcesToGN(args.gn_paths)
        return 0

    if args.exclude_patterns == None:
        CopyTree(args.copy_from, args.to)
    else:
        patterns = args.exclude_patterns.split(',')
        CopyTree(
            args.copy_from, args.to, ignore=shutil.ignore_patterns(*patterns))
    return 0


if __name__ == '__main__':
    sys.exit(Main(sys.argv))