tools/testing/legpad/legpad.py - Issue 16123006: Remove unused files.

Unified Diff: tools/testing/legpad/legpad.py

Issue 16123006: Remove unused files. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart

Patch Set: Created 7 years, 7 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Index: tools/testing/legpad/legpad.py

diff --git a/tools/testing/legpad/legpad.py b/tools/testing/legpad/legpad.py

deleted file mode 100644

index 1a4aa558a5736b6c43b3dab9302782866292791a..0000000000000000000000000000000000000000

--- a/tools/testing/legpad/legpad.py

+++ /dev/null

@@ -1,367 +0,0 @@

-#!/usr/bin/env python

-# BSD-style license that can be found in the LICENSE file.

-"""

-Legpad is used to compile .dart files to javascript, using the dart2js compiler.

-This is accomplished by creating an html file (usually called

-<something>.legpad.html) that executes the dart2js compiler when the page

-is loaded by a web browser (or DumpRenderTree).

-The <something>.legpad.html file contains:

- 1. all the dart files that compose a user's dart program

- 2. all the dart files of dart:core and other standard dart libraries

- (or any other symbol that can follow "dart:" in an import statement

- 3. legpad.dart (compiled to javascript)

-The contents of each dart file is placed in a separate <script> tag.

-When the html page is loaded by a browser, the leg compiler is invoked

-and the dart program is compiled to javascript. The generated javascript is

-placed in a <pre> element with id "output".

-When the html page is passed to DumpRenderTree, the dumped output will

-have the generated javascript.

-See 'example.sh' for an example of how to run legpad.

-"""

-import logging

-import optparse

-import os.path

-import platform

-import re

-import subprocess

-import sys

-class FileNotFoundException(Exception):

- def __init__(self, file_name):

- self._name = file_name

- def __str__(self):

- return self._name

-class CommandFailedException(Exception):

- def __init__(self, message):

- self._message = message

- def GetMessage(self):

- return self._message

-# Template for the legpad.html page we're going to generate.

-HTML = """<!DOCTYPE html>

-<html>

-<head>

- <style type="text/css">

- textarea {

- width: 100%;

- height: 200px;

- }

- .label {

- margin-top: 5px;

- }

- pre {

- border: 2px solid black;

- }

- </style>

- {{script_tags}}

- <script type="text/javascript">

- if (window.layoutTestController) {

- layoutTestController.dumpAsText();

- }

- </script>

-</head>

-<body>

- <h1>Legpad</h1>

- <div class="label">Input:</div>

- <textarea id="input"></textarea>

- <div class="label">Compiler Messages:</div>

- <pre id="warnings"></pre>

- <div class="label">Timing:</div>

- <pre id="timing"></pre>

- <div class="label">Output:</div>

- <pre id="output"></pre>

- <script type="text/javascript">

- {{LEGPAD_JS}}

- </script>

-</body>

-</html>

-"""

-# This finds everything after the word "Output:" in the html page.

-# (Note, because the javascript we're fishing out spans multiple lines

-# we need to use the DOTALL switch here.)

-OUTPUT_JAVASCRIPT_REGEX = re.compile(".*\nOutput:\n(.*)\n#EOF", re.DOTALL)

-# If the legpad.dart encounters a compilation error, the generated

-# javascript will contains the words "dart2js compilation error".

-COMPILATION_ERROR_REGEX = re.compile(".*dart2js compilation error.*", re.DOTALL)

-# We use "application/inert" here to make the browser ignore the

-# these script tags. (legpad.dart will fish out the contents as needed.)

-SCRIPT_TAG = """<script type="application/inert" id="{{id}}">

-{{contents}}

-</script>

-"""

-# Regex that finds #import, #source and #native directives in .dart files.

-# match.group(1) = "import", "source" or "native"

-# match.group(2) = url of file being imported

-DIRECTIVE_RE = re.compile(r"^#(import|source|native)\([\"']([^\"']*)[\"']")

-# id of script tag that holds name of the top dart file to be compiled,

-# (This file name passed will be passed to the leg compiler by legpad.dart.)

-MAIN_ID = "main_id"

-# TODO(mattsh): read this from some config file once ahe/zundel create it

-DART_LIBRARIES = {

- "core": "lib/compiler/implementation/lib/core.dart",

- "_js_helper": "lib/compiler/implementation/lib/js_helper.dart",

- "_interceptors": "lib/compiler/implementation/lib/interceptors.dart",

- "dom": "lib/dom/frog/dom_frog.dart",

- "html": "lib/html/frog/html_frog.dart",

- "io": "lib/compiler/implementation/lib/io.dart",

- "isolate": "lib/isolate/isolate_leg.dart",

- "json": "lib/json/json.dart",

- "uri": "lib/uri/uri.dart",

- "utf": "lib/utf/utf.dart",

-class Pad(object):

- """

- Accumulates all source files that are needed to compile a dart program,

- and places them in <script> tags on an html page.

- """

- def __init__(self, argv):

- parser = optparse.OptionParser(usage=

- "%prog [options] file_to_compile.dart"

- )

- parser.add_option("-o", "--out",

- help="name of javascript output file")

- parser.add_option("-v", "--verbose", action="store_true",

- help="more verbose logging")

- (options, args) = parser.parse_args(argv)

- log_level = logging.INFO

- if options.verbose:

- log_level = logging.DEBUG

- logging.basicConfig(level=log_level)

- if len(args) < 2:

- parser.print_help()

- sys.exit(1)

- self.main_file = os.path.abspath(args[1])

- # directory of this script

- self.legpad_dir = os.path.abspath(os.path.dirname(argv[0]))

- # root of dart source repo

- self.dart_dir = os.path.dirname(os.path.dirname(os.path.dirname(

- self.legpad_dir)))

- logging.debug("dart_dir: '%s'" % self.dart_dir)

- if options.out:

- # user has specified an output file name

- self.js_file = os.path.abspath(options.out)

- else:

- # User didn't specify an output file, so use the input

- # file name as the base of the output file name.

- self.js_file = self.main_file + ".legpad.js"

- logging.debug("js_file: '%s" % self.js_file)

- # this is the html file that we pass to DumpRenderTree

- self.html_file = self.main_file + ".legpad.html"

- logging.debug("html_file: '%s'" % self.html_file)

- # map from file name to File object (contains entries for all corelib

- # and all other dart files needed to compile main_file)

- self.name_to_file = {}

- # map from script tag id to File object

- self.id_to_file = {}

- self.load_libraries()

- self.load_file(self.main_file)

- html = self.generate_html()

- write_file(self.html_file, html)

- js = self.generate_js()

- write_file(self.js_file, js)

- line_count = len(js.splitlines())

- logging.debug("generated '%s' (%d lines)", self.js_file, line_count)

- match = COMPILATION_ERROR_REGEX.match(js)

- if match:

- sys.exit(1)

- def generate_html(self):

- tags = []

- for f in self.id_to_file.values():

- tags.append(self._create_tag(f.id, f.contents))

- tags.append(self._create_tag(MAIN_ID, self.shorten(self.main_file)))

- html = HTML.replace("{{script_tags}}", "".join(tags))

- legpad_js = os.path.join(self.legpad_dir, "legpad.dart.js")

- check_exists(legpad_js)

- html = html.replace("{{LEGPAD_JS}}", read_file(legpad_js))

- return html

- def generate_js(self):

- drt = os.path.join(self.dart_dir, "client/tests/drt/DumpRenderTree")

- if platform.system() == 'Darwin':

- drt += ".app"

- elif platform.system() == 'Windows':

- raise Exception("legpad does not run on Windows")

- check_exists(drt)

- args = []

- args.append(drt)

- args.append(self.html_file)

- stdout = run_command(args)

- match = OUTPUT_JAVASCRIPT_REGEX.match(stdout)

- if not match:

- raise Exception("can't find regex in DumpRenderTree output")

- return match.group(1)

- @staticmethod

- def _create_tag(id, contents):

- s = SCRIPT_TAG

- s = s.replace("{{id}}", id)

- # TODO(mattsh) - need to html escape here

- s = s.replace("{{contents}}", contents)

- return s

- def dart_library(self, name):

- path = DART_LIBRARIES[name]

- if not path:

- raise Exception("unrecognized 'dart:%s'", name)

- return os.path.join(self.dart_dir, path)

- def load_libraries(self):

- for name in DART_LIBRARIES:

- self.load_file(self.dart_library(name))

- def load_file(self, name):

- name = os.path.abspath(name)

- if name in self.name_to_file:

- return

- f = File(self, name)

- self.name_to_file[f.name] = f

- if f.id in self.id_to_file:

- raise Exception("ambiguous id '%s'" % f.id)

- self.id_to_file[f.id] = f

- f.directives()

- def shorten(self, name):

- """

- Change that full path of the dart svn repo to simply "dartdir"

- """

- return name.replace(self.dart_dir, "dartdir")

- def make_id(self, name):

- """

- Generates an id (based on the file name) for the <script> tag that will

- hold the contents of this file.

- """

- return self.shorten(name).replace("/", "_").replace(".", "_")

-class File(object):

- def __init__(self, pad, name):

- self.pad = pad

- self.name = name

- self.id = pad.make_id(name)

- self.contents = read_file(name)

- def directives(self):

- """Load files referenced by #source, #import and #native directives."""

- lines = self.contents.split("\n")

- self.line_number = 0

- for line in lines:

- self.line_number += 1

- self._directive(line)

- def _directive(self, line):

- match = DIRECTIVE_RE.match(line)

- if not match:

- return

- url = match.group(2)

- if url.startswith("dart:"):

- path = self.pad.dart_library(url[len("dart:"):])

- else:

- path = os.path.join(os.path.dirname(self.name), url)

- self.pad.load_file(path)

-def read_file(file_name):

- check_exists(file_name)

- with open(file_name, "r") as input:

- contents = input.read()

- logging.debug("read_file '%s' (%d bytes)" % (file_name, len(contents)))

- return contents

-def write_file(file_name, contents):

- with open(file_name, "w") as output:

- output.write(contents)

- check_exists(file_name)

- logging.debug("write_file '%s' (%d bytes)" % (file_name, len(contents)))

-def check_exists(file_name):

- if not os.path.exists(file_name):

- raise FileNotFoundException(file_name)

-def format_command(args):

- return ' '.join(args)

-def run_command(args):

- """

- Args:

- command: comamnd with arguments to exec

- Returns:

- all output that this command sent to stdout

- """

- command = format_command(args)

- logging.info("RUNNING: '%s'" % command)

- child = subprocess.Popen(args,

- stdout=subprocess.PIPE,

- stderr=subprocess.PIPE,

- close_fds=True)

- (stdout, stderr) = child.communicate()

- exit_code = child.wait()

- if exit_code:

- for line in stderr.splitlines():

- logging.info(line)

- msg = "FAILURE (exit_code=%d): '%s'" % (exit_code, command)

- logging.error(msg)

- raise CommandFailedException(msg)

- logging.debug("SUCCEEDED (%d bytes)" % len(stdout))

- return stdout

-def main(argv):

- Pad(argv)

-if __name__ == "__main__":

- sys.exit(main(sys.argv))

« no previous file with comments | « tools/testing/legpad/legpad.dart ('k') | no next file » | no next file with comments »