fyn 1.1.17 → 1.1.21

package/gyp/tools/graphviz.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2011 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Using the JSON dumped by the dump-dependency-json generator,
+generate input suitable for graphviz to render a dependency graph of
+targets."""
+
+
+import collections
+import json
+import sys
+
+
+def ParseTarget(target):
+    target, _, suffix = target.partition("#")
+    filename, _, target = target.partition(":")
+    return filename, target, suffix
+
+
+def LoadEdges(filename, targets):
+    """Load the edges map from the dump file, and filter it to only
+  show targets in |targets| and their depedendents."""
+
+    file = open("dump.json")
+    edges = json.load(file)
+    file.close()
+
+    # Copy out only the edges we're interested in from the full edge list.
+    target_edges = {}
+    to_visit = targets[:]
+    while to_visit:
+        src = to_visit.pop()
+        if src in target_edges:
+            continue
+        target_edges[src] = edges[src]
+        to_visit.extend(edges[src])
+
+    return target_edges
+
+
+def WriteGraph(edges):
+    """Print a graphviz graph to stdout.
+  |edges| is a map of target to a list of other targets it depends on."""
+
+    # Bucket targets by file.
+    files = collections.defaultdict(list)
+    for src, dst in edges.items():
+        build_file, target_name, toolset = ParseTarget(src)
+        files[build_file].append(src)
+
+    print("digraph D {")
+    print("  fontsize=8")  # Used by subgraphs.
+    print("  node [fontsize=8]")
+
+    # Output nodes by file.  We must first write out each node within
+    # its file grouping before writing out any edges that may refer
+    # to those nodes.
+    for filename, targets in files.items():
+        if len(targets) == 1:
+            # If there's only one node for this file, simplify
+            # the display by making it a box without an internal node.
+            target = targets[0]
+            build_file, target_name, toolset = ParseTarget(target)
+            print(
+                f'  "{target}" [shape=box, label="{filename}\\n{target_name}"]'
+            )
+        else:
+            # Group multiple nodes together in a subgraph.
+            print('  subgraph "cluster_%s" {' % filename)
+            print('    label = "%s"' % filename)
+            for target in targets:
+                build_file, target_name, toolset = ParseTarget(target)
+                print(f'    "{target}" [label="{target_name}"]')
+            print("  }")
+
+    # Now that we've placed all the nodes within subgraphs, output all
+    # the edges between nodes.
+    for src, dsts in edges.items():
+        for dst in dsts:
+            print(f'  "{src}" -> "{dst}"')
+
+    print("}")
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(__doc__, file=sys.stderr)
+        print(file=sys.stderr)
+        print("usage: %s target1 target2..." % (sys.argv[0]), file=sys.stderr)
+        return 1
+
+    edges = LoadEdges("dump.json", sys.argv[1:])
+
+    WriteGraph(edges)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/gyp/tools/pretty_gyp.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Pretty-prints the contents of a GYP file."""
+
+
+import sys
+import re
+
+
+# Regex to remove comments when we're counting braces.
+COMMENT_RE = re.compile(r"\s*#.*")
+
+# Regex to remove quoted strings when we're counting braces.
+# It takes into account quoted quotes, and makes sure that the quotes match.
+# NOTE: It does not handle quotes that span more than one line, or
+# cases where an escaped quote is preceded by an escaped backslash.
+QUOTE_RE_STR = r'(?P<q>[\'"])(.*?)(?<![^\\][\\])(?P=q)'
+QUOTE_RE = re.compile(QUOTE_RE_STR)
+
+
+def comment_replace(matchobj):
+    return matchobj.group(1) + matchobj.group(2) + "#" * len(matchobj.group(3))
+
+
+def mask_comments(input):
+    """Mask the quoted strings so we skip braces inside quoted strings."""
+    search_re = re.compile(r"(.*?)(#)(.*)")
+    return [search_re.sub(comment_replace, line) for line in input]
+
+
+def quote_replace(matchobj):
+    return "{}{}{}{}".format(
+        matchobj.group(1),
+        matchobj.group(2),
+        "x" * len(matchobj.group(3)),
+        matchobj.group(2),
+    )
+
+
+def mask_quotes(input):
+    """Mask the quoted strings so we skip braces inside quoted strings."""
+    search_re = re.compile(r"(.*?)" + QUOTE_RE_STR)
+    return [search_re.sub(quote_replace, line) for line in input]
+
+
+def do_split(input, masked_input, search_re):
+    output = []
+    mask_output = []
+    for (line, masked_line) in zip(input, masked_input):
+        m = search_re.match(masked_line)
+        while m:
+            split = len(m.group(1))
+            line = line[:split] + r"\n" + line[split:]
+            masked_line = masked_line[:split] + r"\n" + masked_line[split:]
+            m = search_re.match(masked_line)
+        output.extend(line.split(r"\n"))
+        mask_output.extend(masked_line.split(r"\n"))
+    return (output, mask_output)
+
+
+def split_double_braces(input):
+    """Masks out the quotes and comments, and then splits appropriate
+  lines (lines that matche the double_*_brace re's above) before
+  indenting them below.
+
+  These are used to split lines which have multiple braces on them, so
+  that the indentation looks prettier when all laid out (e.g. closing
+  braces make a nice diagonal line).
+  """
+    double_open_brace_re = re.compile(r"(.*?[\[\{\(,])(\s*)([\[\{\(])")
+    double_close_brace_re = re.compile(r"(.*?[\]\}\)],?)(\s*)([\]\}\)])")
+
+    masked_input = mask_quotes(input)
+    masked_input = mask_comments(masked_input)
+
+    (output, mask_output) = do_split(input, masked_input, double_open_brace_re)
+    (output, mask_output) = do_split(output, mask_output, double_close_brace_re)
+
+    return output
+
+
+def count_braces(line):
+    """keeps track of the number of braces on a given line and returns the result.
+
+  It starts at zero and subtracts for closed braces, and adds for open braces.
+  """
+    open_braces = ["[", "(", "{"]
+    close_braces = ["]", ")", "}"]
+    closing_prefix_re = re.compile(r"(.*?[^\s\]\}\)]+.*?)([\]\}\)],?)\s*$")
+    cnt = 0
+    stripline = COMMENT_RE.sub(r"", line)
+    stripline = QUOTE_RE.sub(r"''", stripline)
+    for char in stripline:
+        for brace in open_braces:
+            if char == brace:
+                cnt += 1
+        for brace in close_braces:
+            if char == brace:
+                cnt -= 1
+
+    after = False
+    if cnt > 0:
+        after = True
+
+    # This catches the special case of a closing brace having something
+    # other than just whitespace ahead of it -- we don't want to
+    # unindent that until after this line is printed so it stays with
+    # the previous indentation level.
+    if cnt < 0 and closing_prefix_re.match(stripline):
+        after = True
+    return (cnt, after)
+
+
+def prettyprint_input(lines):
+    """Does the main work of indenting the input based on the brace counts."""
+    indent = 0
+    basic_offset = 2
+    for line in lines:
+        if COMMENT_RE.match(line):
+            print(line)
+        else:
+            line = line.strip("\r\n\t ")  # Otherwise doesn't strip \r on Unix.
+            if len(line) > 0:
+                (brace_diff, after) = count_braces(line)
+                if brace_diff != 0:
+                    if after:
+                        print(" " * (basic_offset * indent) + line)
+                        indent += brace_diff
+                    else:
+                        indent += brace_diff
+                        print(" " * (basic_offset * indent) + line)
+                else:
+                    print(" " * (basic_offset * indent) + line)
+            else:
+                print("")
+
+
+def main():
+    if len(sys.argv) > 1:
+        data = open(sys.argv[1]).read().splitlines()
+    else:
+        data = sys.stdin.read().splitlines()
+    # Split up the double braces.
+    lines = split_double_braces(data)
+
+    # Indent and print the output.
+    prettyprint_input(lines)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/gyp/tools/pretty_sln.py

@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+
+# Copyright (c) 2012 Google Inc. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+"""Prints the information in a sln file in a diffable way.
+
+   It first outputs each projects in alphabetical order with their
+   dependencies.
+
+   Then it outputs a possible build order.
+"""
+
+
+import os
+import re
+import sys
+import pretty_vcproj
+
+__author__ = "nsylvain (Nicolas Sylvain)"
+
+
+def BuildProject(project, built, projects, deps):
+    # if all dependencies are done, we can build it, otherwise we try to build the
+    # dependency.
+    # This is not infinite-recursion proof.
+    for dep in deps[project]:
+        if dep not in built:
+            BuildProject(dep, built, projects, deps)
+    print(project)
+    built.append(project)
+
+
+def ParseSolution(solution_file):
+    # All projects, their clsid and paths.
+    projects = dict()
+
+    # A list of dependencies associated with a project.
+    dependencies = dict()
+
+    # Regular expressions that matches the SLN format.
+    # The first line of a project definition.
+    begin_project = re.compile(
+        r'^Project\("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942'
+        r'}"\) = "(.*)", "(.*)", "(.*)"$'
+    )
+    # The last line of a project definition.
+    end_project = re.compile("^EndProject$")
+    # The first line of a dependency list.
+    begin_dep = re.compile(r"ProjectSection\(ProjectDependencies\) = postProject$")
+    # The last line of a dependency list.
+    end_dep = re.compile("EndProjectSection$")
+    # A line describing a dependency.
+    dep_line = re.compile(" *({.*}) = ({.*})$")
+
+    in_deps = False
+    solution = open(solution_file)
+    for line in solution:
+        results = begin_project.search(line)
+        if results:
+            # Hack to remove icu because the diff is too different.
+            if results.group(1).find("icu") != -1:
+                continue
+            # We remove "_gyp" from the names because it helps to diff them.
+            current_project = results.group(1).replace("_gyp", "")
+            projects[current_project] = [
+                results.group(2).replace("_gyp", ""),
+                results.group(3),
+                results.group(2),
+            ]
+            dependencies[current_project] = []
+            continue
+
+        results = end_project.search(line)
+        if results:
+            current_project = None
+            continue
+
+        results = begin_dep.search(line)
+        if results:
+            in_deps = True
+            continue
+
+        results = end_dep.search(line)
+        if results:
+            in_deps = False
+            continue
+
+        results = dep_line.search(line)
+        if results and in_deps and current_project:
+            dependencies[current_project].append(results.group(1))
+            continue
+
+    # Change all dependencies clsid to name instead.
+    for project in dependencies:
+        # For each dependencies in this project
+        new_dep_array = []
+        for dep in dependencies[project]:
+            # Look for the project name matching this cldis
+            for project_info in projects:
+                if projects[project_info][1] == dep:
+                    new_dep_array.append(project_info)
+        dependencies[project] = sorted(new_dep_array)
+
+    return (projects, dependencies)
+
+
+def PrintDependencies(projects, deps):
+    print("---------------------------------------")
+    print("Dependencies for all projects")
+    print("---------------------------------------")
+    print("--                                   --")
+
+    for (project, dep_list) in sorted(deps.items()):
+        print("Project : %s" % project)
+        print("Path : %s" % projects[project][0])
+        if dep_list:
+            for dep in dep_list:
+                print("  - %s" % dep)
+        print("")
+
+    print("--                                   --")
+
+
+def PrintBuildOrder(projects, deps):
+    print("---------------------------------------")
+    print("Build order                            ")
+    print("---------------------------------------")
+    print("--                                   --")
+
+    built = []
+    for (project, _) in sorted(deps.items()):
+        if project not in built:
+            BuildProject(project, built, projects, deps)
+
+    print("--                                   --")
+
+
+def PrintVCProj(projects):
+
+    for project in projects:
+        print("-------------------------------------")
+        print("-------------------------------------")
+        print(project)
+        print(project)
+        print(project)
+        print("-------------------------------------")
+        print("-------------------------------------")
+
+        project_path = os.path.abspath(
+            os.path.join(os.path.dirname(sys.argv[1]), projects[project][2])
+        )
+
+        pretty = pretty_vcproj
+        argv = [
+            "",
+            project_path,
+            "$(SolutionDir)=%s\\" % os.path.dirname(sys.argv[1]),
+        ]
+        argv.extend(sys.argv[3:])
+        pretty.main(argv)
+
+
+def main():
+    # check if we have exactly 1 parameter.
+    if len(sys.argv) < 2:
+        print('Usage: %s "c:\\path\\to\\project.sln"' % sys.argv[0])
+        return 1
+
+    (projects, deps) = ParseSolution(sys.argv[1])
+    PrintDependencies(projects, deps)
+    PrintBuildOrder(projects, deps)
+
+    if "--recursive" in sys.argv:
+        PrintVCProj(projects)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())