updated comments and usage string in frogpad

tools/testing/frogpad/frogpad.py

 #!/usr/bin/python
 
 # Copyright (c) 2012, 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.
 #
 
 """
-Generates an html file (frogpad.html) that can be used to execute the frog
-compiler in a web browser or DumpRenderTree,
+Frogpad is used to compile .dart files to javascript.
 
-The generated frogpad.html will contain:
+This is accomplished by first creating an html file (usually called
+<something>.frogpad.html) that can be used to execute the frog compiler in
+a web browser (or DumpRenderTree).
+
+The generated frogpad.html contains:
 
   1. all the dart files that compose a dart program
   2. all the dart files of dart:core and other standard dart libraries
   3. frogpad.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 frog compiler will be invoked
-and the user's dart program will be compiled to javascript.  The generated
-javascript will be placed in the <pre> element with id "output".
+When the html page is loaded by a browser, the frog compiler is invoked
+and the dart program is compiled to javascript.  The generated javascript is
+placed in a <pre> element with id "output".
 
-If using DumpRenderTree, the output javascript can be obtained by dumping
-the page as text and looking for the contents of the output textarea.
+When the html page is passed to DumpRenderTree, the dumped output will
+have the generated javascript.
 """
 
 import logging
 import optparse
 import os.path
 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):
@@ skipping 46 matching lines @@
   <pre id="timing"></pre>
   <div class="label">Output:</div>
   <pre id="output"></pre>
   <script type="text/javascript">
     {{FROGPAD_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:(.*)#EOF", re.DOTALL)

[Siggi Cherem (dart-lang), 2012/02/23 20:57:23]

possibly add a '\n' after ':' also?

+
 # We use "application/inert" here to make the browser ignore the
 # these script tags.  (frogpad.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"
@@ skipping 14 matching lines @@
 }
 
 
 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()
+    parser = optparse.OptionParser(usage=
+      "%prog [options] file_to_compile.dart"
+    )
     parser.add_option("-r", "--rebuild",  action="store_true",
-        help="forces rebuild of frogpad_js")
+        help="forces rebuild of the frogpad javascript")
     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:
-      usage()
+      parser.print_help()
+      sys.exit(1)
 
     self.main_file = os.path.abspath(args[1])
 
     # directory of this script
     self.frogpad_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.frogpad_dir)))
 
@@ skipping 34 matching lines @@
     if options.rebuild:
       self.build_frogpad_js()
 
     self.load_libraries()
     self.load_file(self.main_file)
 
     html = self.generate_html()
     write_file(self.html_file, html)
 
     js = self.generate_js()
-    logging.debug("found javascript in drt output (%d lines)",
-        len(js.splitlines()))
     write_file(self.js_file, js)
-    logging.info("generated '%s'", self.js_file)
+
+    line_count = len(js.splitlines())
+    logging.info("generated '%s' (%d lines)", self.js_file, line_count)
 
   def build_frogpad_js(self):
     dart_vm = os.path.join(self.dart_dir, "out/Release_ia32/dart")
     check_exists(dart_vm)
 
     frogc_dart = os.path.join(self.frog_dir, "frogc.dart")
     frogpad_dart = os.path.join(self.frogpad_dir, "frogpad.dart")
     check_exists(frogc_dart)
     check_exists(frogpad_dart)
 
@@ skipping 34 matching lines @@
     return html
 
   def generate_js(self):
     drt = os.path.join(self.dart_dir, "client/tests/drt/DumpRenderTree")
     check_exists(drt)
     args = []
     args.append(drt)
     args.append(self.html_file)
 
     stdout = run_command(args)
-    match = re.match("(?s).*Output:(.*)#EOF", stdout)
+    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.frog_dir, path)
 
   def load_libraries(self):
@@ skipping 92 matching lines @@
     logging.info(level, '%s: %s', args[0], line)
   exitcode = child.wait()
   if exitcode:
     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 usage():
-  print("""
-    Usage:
-    frogpad.py --out hello.js hello.dart
-  """)
-  sys.exit(1)
-
-
 def main(argv):
-  logging.basicConfig(level=logging.INFO)
   Pad(argv)
 
 if __name__ == "__main__":
   sys.exit(main(sys.argv))