Switch to new library syntax.

tools/copy_dart.py

 #!/usr/bin/env python
 # Copyright (c) 2011, 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.
 """Used to merge and copy dart source files for deployment to AppEngine"""
 
 import fileinput
 import sys
 import shutil
 import os
 import re
 from os.path import abspath, basename, dirname, exists, isabs, join
 from glob import glob
 
 re_directive = re.compile(
-    r'^#(library|import|source|native|resource)\([\'"]([^\'"]*)[\'"](.*)\);$')
+    r'^(library|import|part|native|resource)\s+(.*);$')
 
 class Library(object):
   def __init__(self, name, imports, sources, natives, code):
     self.name = name
     self.imports = imports
     self.sources = sources
     self.natives = natives
     self.code = code
 
 def parseLibrary(library):
   """ Parses a .dart source file that is the root of a library, and returns
       information about it: the name, the imports, included sources, and any
       code in the file.
   """
   libraryname = None
   imports = []
   sources = []
   natives = []
   inlinecode = []
   if exists(library):
     # TODO(sigmund): stop parsing when import/source
     for line in fileinput.input(library):
       match = re_directive.match(line)
       if match:
         directive = match.group(1)
         if directive == 'library':
           assert libraryname is None
           libraryname = match.group(2)
-        elif directive == 'source':
-          sources.append(match.group(2))
+        elif directive == 'part':
+          suffix = match.group(2)
+          if not suffix.startswith('of '):
+            sources.append(match.group(2).strip('"\''))
         elif directive == 'import':
-          imports.append((match.group(2), match.group(3)))
-        elif directive == 'native':
-          natives.append(match.group(2))
-        elif directive == 'resource':
-          # currently ignored
-          pass
+          imports.append(match.group(2))
         else:
-          raise 'unknown directive %s' % directive
+          raise Exception('unknown directive %s in %s' % (directive, line))
       else:
         inlinecode.append(line)
     fileinput.close()
   return Library(libraryname, imports, sources, natives, inlinecode)
 
 def normjoin(*args):
   return os.path.normpath(os.path.join(*args))
 
 def mergefiles(srcs, dstfile):
   for src in srcs:
     with open(src, 'r') as s:
-      dstfile.write(s.read())
+      for line in s:
+        if not line.startswith('part of '):
+          dstfile.write(line)
 
 def copyfile(src, dst):
   if not exists(dirname(dst)):
     os.makedirs(dirname(dst))
   with open(src, 'r') as s:
     with open(dst, 'w') as d:
       d.write(s.read())
 
 def main(outdir = None, *inputs):
   if not outdir or not inputs:
@@ skipping 40 matching lines @@
       # Ensure output directory exists
       outpath = join(outdir, lib[1:] if isabs(lib) else lib)
       dstpath = dirname(outpath)
       if not exists(dstpath):
         os.makedirs(dstpath)
 
 
       # Create file containing all imports, and inlining all sources
       with open(outpath, 'w') as f:
         if library.name:
-          f.write("#library('%s');\n\n" % library.name)
+          f.write("library %s;\n\n" % library.name)
         else:
-          f.write("#library('%s');\n\n" % basename(lib))
-        for (importfile, optional_prefix) in library.imports:
-          f.write("#import('%s'%s);\n" % (importfile, optional_prefix))
-        for native in library.natives:
-          if isabs(native):
-            npath = native[1:]
-          else:
-            npath = native
-          f.write("#native('%s');\n" % npath)
-          copyfile(normjoin(dirname(lib), native),
-              join(dirname(outpath), npath))
+          f.write("library %s;\n\n" % basename(lib))
+        for importfile in library.imports:
+          f.write("import %s;\n" % (importfile))
         f.write('%s' % (''.join(library.code)))
         mergefiles([normjoin(dirname(lib), s) for s in library.sources], f)
 
-      for (i, prefix) in library.imports:
-        if not i.startswith('dart:'):
-          worklist.append(normjoin(dirname(lib), i));
+      for suffix in library.imports:
+        m = re.match(r'[\'"]([^\'"]+)[\'"](\s+as\s+\w+)?$', suffix)
+        uri = m.group(0)
+        if not uri.startswith('dart:'):
+          worklist.append(normjoin(dirname(lib), uri));
 
   return 0
 
 if __name__ == '__main__':
   sys.exit(main(*sys.argv[1:]))