Add pub (and by extension YAML) to the SDK.

tools/create_sdk.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.
 #
 # A script which will be invoked from gyp to create an SDK.
 #
 # Usage: create_sdk.py sdk_directory
 #
 # The SDK will be used either from the command-line or from the editor.
 # Top structure is
 #
 # ..dart-sdk/
 # ....bin/
 # ......dart or dart.exe (executable)
 # ......dart.lib (import library for VM native extensions on Windows)
 # ......frogc.dart
+# ......pub
 # ....include/
 # ......dart_api.h
 # ......dart_debugger_api.h
 # ....lib/
 # ......builtin/
 # ........builtin_runtime.dart
 # ......io/
 # ........io_runtime.dart
 # ........runtime/
 # ......core/
@@ skipping 14 matching lines @@
 # ........html_dartium.dart
 # ......json/
 # ........json_frog.dart
 #.........json.dart
 # ........{frog}/
 # ......uri/
 # ........uri.dart
 # ......utf/
 # ......(more will come here)
 # ....util/
+# ......pub/
 # ......(more will come here)
 
 
 
 import os
 import re
 import sys
 import tempfile
 import utils
 
 # TODO(dgrove): Only import modules following Google style guide.
-from os.path import dirname, join, realpath, exists, isdir
+from os.path import basename, dirname, join, realpath, exists, isdir
 
 # TODO(dgrove): Only import modules following Google style guide.
 from shutil import copyfile, copymode, copytree, ignore_patterns, rmtree, move
 
 def ReplaceInFiles(paths, subs):
   '''Reads a series of files, applies a series of substitutions to each, and
      saves them back out. subs should by a list of (pattern, replace) tuples.'''
   for path in paths:
     contents = open(path).read()
     for pattern, replace in subs:
       contents = re.sub(pattern, replace, contents)
 
     dest = open(path, 'w')
     dest.write(contents)
     dest.close()
 
 
 def Copy(src, dest):
   copyfile(src, dest)
   copymode(src, dest)
 
 
+def CopyShellScript(src_file, dest_dir):
+  '''Copies a shell/batch script to the given destination directory. Handles
+     using the appropriate platform-specific file extension.'''
+  file_extension = ''
+  if utils.GuessOS() == 'win32':
+    file_extension = '.bat'
+
+  src = src_file + file_extension
+  dest = join(dest_dir, basename(src_file) + file_extension)
+  Copy(src, dest)
+
+
 def CopyDart2Js(build_dir, sdk_root):
   '''
   Install dart2js in SDK/lib/dart2js.
 
   Currently, we copy too much stuff to this location, but the SDK's
   layout matches the the layout of the part of the repository we're
   dealing with here which frees us from rewriting files. The long term
   plan is to align the layout of the repository and the SDK, at which
   point we should be able to simplify Main below and share the dart
   files between the various components to minimize SDK download size.
@@ skipping 16 matching lines @@
                    [(r'%SCRIPTPATH%\.\.\\lib',
                      r'%SCRIPTPATH%..\lib\dart2js\lib')])
   else:
     dart2js = os.path.join(sdk_root, 'bin', 'dart2js')
     Copy(os.path.join(build_dir, 'dart2js'), dart2js)
     ReplaceInFiles([dart2js],
                    [(r'\$BIN_DIR/\.\./\.\./lib',
                      r'$BIN_DIR/../lib/dart2js/lib')])
 
 
-
 def Main(argv):
   # Pull in all of the gpyi files which will be munged into the sdk.
   builtin_runtime_sources = \
     (eval(open("runtime/bin/builtin_sources.gypi").read()))['sources']
   io_runtime_sources = \
     (eval(open("runtime/bin/io_sources.gypi").read()))['sources']
   corelib_sources = \
     (eval(open("corelib/src/corelib_sources.gypi").read()))['sources']
   corelib_frog_sources = \
     (eval(open("frog/lib/frog_corelib_sources.gypi").read()))['sources']
@@ skipping 19 matching lines @@
 
   # Create and populate sdk/bin.
   BIN = join(SDK_tmp, 'bin')
   os.makedirs(BIN)
 
   # Copy the Dart VM binary, frogc and Windows dart VM link library
   # into sdk/bin.
   #
   # TODO(dgrove) - deal with architectures that are not ia32.
   build_dir = os.path.dirname(argv[1])
-  frogc_file_extension = ''
   dart_file_extension = ''
   if utils.GuessOS() == 'win32':
     dart_file_extension = '.exe'
-    frogc_file_extension = '.bat'
     dart_import_lib_src = join(HOME, build_dir, 'dart.lib')
     dart_import_lib_dest = join(BIN, 'dart.lib')
     copyfile(dart_import_lib_src, dart_import_lib_dest)
   dart_src_binary = join(HOME, build_dir, 'dart' + dart_file_extension)
   dart_dest_binary = join(BIN, 'dart' + dart_file_extension)
-  frogc_src_binary = join(HOME, 'frog', 'scripts', 'bootstrap',
-      'frogc' + frogc_file_extension)
-  frogc_dest_binary = join(BIN, 'frogc' + frogc_file_extension)
   copyfile(dart_src_binary, dart_dest_binary)
   copymode(dart_src_binary, dart_dest_binary)
-  copyfile(frogc_src_binary, frogc_dest_binary)
-  copymode(frogc_src_binary, frogc_dest_binary)
+
+  frogc_src_binary = join(HOME, 'frog', 'scripts', 'bootstrap', 'frogc')
+  CopyShellScript(frogc_src_binary, BIN)
 
   # Create sdk/bin/frogc.dart, and hack as needed.
   frog_src_dir = join(HOME, 'frog')
 
   # Convert frogc.dart's imports from import('*') -> import('frog/*').
   frogc_contents = open(join(frog_src_dir, 'frogc.dart')).read()
   frogc_dest = open(join(BIN, 'frogc.dart'), 'w')
   frogc_dest.write(
     re.sub(r"#import\('([^.])", r"#import('../lib/frog/\1", frogc_contents))
   frogc_dest.close()
 
+  # Create pub shell script.
+  pub_src_script = join(HOME, 'utils', 'pub', 'sdk', 'pub')
+  CopyShellScript(pub_src_script, BIN)
+
   # TODO(dgrove): copy and fix up frog.dart, minfrogc.dart.
 
   #
   # Create and populate sdk/include.
   #
   INCLUDE = join(SDK_tmp, 'include')
   os.makedirs(INCLUDE)
   copyfile(join(HOME, 'runtime', 'include', 'dart_api.h'),
            join(INCLUDE, 'dart_api.h'))
   copyfile(join(HOME, 'runtime', 'include', 'dart_debugger_api.h'),
@@ skipping 167 matching lines @@
       join(LIB, 'dartdoc', 'classify.dart'),
       join(LIB, 'dartdoc', 'client-live-nav.dart'),
       join(LIB, 'dartdoc', 'client-static.dart')
     ], [
       ("#import\('../../frog", "#import('../frog")
     ])
 
   # Create and populate lib/isolate
   copytree(join(HOME, 'lib', 'isolate'), join(LIB, 'isolate'),
            ignore=ignore_patterns('.svn'))
-  
+
   isolate_runtime_dir = join(LIB, 'isolate', 'runtime')
   # path seems to exist when run locally, but not on builder
   if not exists(isolate_runtime_dir):
     os.makedirs(isolate_runtime_dir)
 
   isolate_runtime_src = join(HOME, 'runtime', 'lib', 'isolate.dart')
   isolate_runtime_dest = join(LIB, 'isolate', 'runtime', 'isolate.dart')
   copyfile(isolate_runtime_src, isolate_runtime_dest)
 
   #
@@ skipping 81 matching lines @@
   for filename in coreimpl_runtime_sources:
     if filename.endswith('.dart'):
       dest_file.write('#source("runtime/' + filename + '");\n')
   dest_file.close()
 
   # Create and copy tools.
 
   UTIL = join(SDK_tmp, 'util')
   os.makedirs(UTIL)
 
+  # Create and populate util/pub
+  pub_src_dir = join(HOME, 'utils', 'pub')
+  pub_dst_dir = join(UTIL, 'pub')
+  copytree(pub_src_dir, pub_dst_dir,
+           ignore=ignore_patterns('.svn', 'sdk'))
 
   # Copy import maps
   PLATFORMS = ['any', 'vm', 'dartium', 'dart2js', 'frog' ]
   os.makedirs(join(LIB, 'config'))
   for platform in PLATFORMS:
     import_src = join(HOME, 'lib', 'config', 'import_' + platform + '.config')
     import_dst = join(LIB, 'config', 'import_' + platform + '.config')
     copyfile(import_src, import_dst);
 
   CopyDart2Js(build_dir, SDK_tmp)
 
   # Write the 'revision' file
   revision = utils.GetSVNRevision()
   if revision is not None:
     with open(os.path.join(SDK_tmp, 'revision'), 'w') as f:
       f.write(revision + '\n')
       f.close()
 
   move(SDK_tmp, SDK)
   utils.Touch(os.path.join(SDK, 'create.stamp'))
 
 if __name__ == '__main__':
   sys.exit(Main(sys.argv))