suyu/externals/vcpkg/packages/boost-build_x64-windows/tools/boost-build/test/tree.py
2024-03-05 16:42:40 +08:00

245 lines
8 KiB
Python
Executable file

# Copyright 2003 Dave Abrahams
# Copyright 2001, 2002 Vladimir Prus
# Copyright 2012 Jurko Gospodnetic
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE.txt or copy at
# https://www.bfgroup.xyz/b2/LICENSE.txt)
###############################################################################
#
# Based in part on an old Subversion tree.py source file (tools for comparing
# directory trees). See http://subversion.tigris.org for more information.
#
# Copyright (c) 2001 Sam Tobin-Hochstadt. All rights reserved.
#
# This software is licensed as described in the file COPYING, which you should
# have received as part of this distribution. The terms are also available at
# http://subversion.tigris.org/license-1.html. If newer versions of this
# license are posted there, you may use a newer version instead, at your
# option.
#
###############################################################################
from __future__ import print_function
import os
import os.path
import stat
import sys
class TreeNode:
"""
Fundamental data type used to build file system tree structures.
If CHILDREN is None, then the node represents a file. Otherwise, CHILDREN
is a list of the nodes representing that directory's children.
NAME is simply the name of the file or directory. CONTENTS is a string
holding the file's contents (if a file).
"""
def __init__(self, name, children=None, contents=None):
assert children is None or contents is None
self.name = name
self.mtime = 0
self.children = children
self.contents = contents
self.path = name
def add_child(self, newchild):
assert not self.is_file()
for a in self.children:
if a.name == newchild.name:
if newchild.is_file():
a.contents = newchild.contents
a.path = os.path.join(self.path, newchild.name)
else:
for i in newchild.children:
a.add_child(i)
break
else:
self.children.append(newchild)
newchild.path = os.path.join(self.path, newchild.name)
def get_child(self, name):
"""
If the given TreeNode directory NODE contains a child named NAME,
return the child; else, return None.
"""
for n in self.children:
if n.name == name:
return n
def is_file(self):
return self.children is None
def pprint(self):
print(" * Node name: %s" % self.name)
print(" Path: %s" % self.path)
print(" Contents: %s" % self.contents)
if self.is_file():
print(" Children: is a file.")
else:
print(" Children: %d" % len(self.children))
class TreeDifference:
def __init__(self):
self.added_files = []
self.removed_files = []
self.modified_files = []
self.touched_files = []
def append(self, other):
self.added_files.extend(other.added_files)
self.removed_files.extend(other.removed_files)
self.modified_files.extend(other.modified_files)
self.touched_files.extend(other.touched_files)
def ignore_directories(self):
"""Removes directories from our lists of found differences."""
not_dir = lambda x : x[-1] != "/"
self.added_files = list(filter(not_dir, self.added_files))
self.removed_files = list(filter(not_dir, self.removed_files))
self.modified_files = list(filter(not_dir, self.modified_files))
self.touched_files = list(filter(not_dir, self.touched_files))
def pprint(self, file=sys.stdout):
file.write("Added files : %s\n" % self.added_files)
file.write("Removed files : %s\n" % self.removed_files)
file.write("Modified files: %s\n" % self.modified_files)
file.write("Touched files : %s\n" % self.touched_files)
def empty(self):
return not (self.added_files or self.removed_files or
self.modified_files or self.touched_files)
def build_tree(path):
"""
Takes PATH as the folder path, walks the file system below that path, and
creates a tree structure based on any files and folders found there.
Returns the prepared tree structure plus the maximum file modification
timestamp under the given folder.
"""
return _handle_dir(os.path.normpath(path))
def tree_difference(a, b):
"""Compare TreeNodes A and B, and create a TreeDifference instance."""
return _do_tree_difference(a, b, "", True)
def _do_tree_difference(a, b, parent_path, root=False):
"""Internal recursive worker function for tree_difference()."""
# We do not want to list root node names.
if root:
assert not parent_path
assert not a.is_file()
assert not b.is_file()
full_path = ""
else:
assert a.name == b.name
full_path = parent_path + a.name
result = TreeDifference()
# A and B are both files.
if a.is_file() and b.is_file():
if a.contents != b.contents:
result.modified_files.append(full_path)
elif a.mtime != b.mtime:
result.touched_files.append(full_path)
return result
# Directory converted to file.
if not a.is_file() and b.is_file():
result.removed_files.extend(_traverse_tree(a, parent_path))
result.added_files.append(full_path)
# File converted to directory.
elif a.is_file() and not b.is_file():
result.removed_files.append(full_path)
result.added_files.extend(_traverse_tree(b, parent_path))
# A and B are both directories.
else:
if full_path:
full_path += "/"
accounted_for = [] # Children present in both trees.
for a_child in a.children:
b_child = b.get_child(a_child.name)
if b_child:
accounted_for.append(b_child)
result.append(_do_tree_difference(a_child, b_child, full_path))
else:
result.removed_files.append(full_path + a_child.name)
for b_child in b.children:
if b_child not in accounted_for:
result.added_files.extend(_traverse_tree(b_child, full_path))
return result
def _traverse_tree(t, parent_path):
"""Returns a list of all names in a tree."""
assert not parent_path or parent_path[-1] == "/"
full_node_name = parent_path + t.name
if t.is_file():
result = [full_node_name]
else:
name_prefix = full_node_name + "/"
result = [name_prefix]
for i in t.children:
result.extend(_traverse_tree(i, name_prefix))
return result
def _get_text(path):
"""Return a string with the textual contents of a file at PATH."""
fp = open(path, 'rb')
try:
return fp.read()
finally:
fp.close()
def _handle_dir(path):
"""
Main recursive worker function for build_tree(). Returns a newly created
tree node representing the given normalized folder path as well as the
maximum file/folder modification time detected under the same path.
"""
files = []
dirs = []
node = TreeNode(os.path.basename(path), children=[])
max_mtime = node.mtime = os.stat(path).st_mtime
# List files & folders.
for f in os.listdir(path):
f = os.path.join(path, f)
if os.path.isdir(f):
dirs.append(f)
elif os.path.isfile(f):
files.append(f)
# Add a child node for each file.
for f in files:
fcontents = _get_text(f)
new_file_node = TreeNode(os.path.basename(f), contents=fcontents)
new_file_node.mtime = os.stat(f).st_mtime
max_mtime = max(max_mtime, new_file_node.mtime)
node.add_child(new_file_node)
# For each subdir, create a node, walk its tree, add it as a child.
for d in dirs:
new_dir_node, new_max_mtime = _handle_dir(d)
max_mtime = max(max_mtime, new_max_mtime)
node.add_child(new_dir_node)
return node, max_mtime