Merge pull request #2307 from elemoine/build

Build-related clean-ups
2014-07-06 09:16:11 +02:00
parent 489096e40b f18dbcdb97
commit 76584c3291
6 changed files with 1 additions and 540 deletions
@@ -1,202 +0,0 @@
 #!/usr/bin/env python
 #
 # Copyright 2009 The Closure Library Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS-IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Generates out a Closure deps.js file given a list of JavaScript sources.
 Paths can be specified as arguments or (more commonly) specifying trees
 with the flags (call with --help for descriptions).
 Usage: depswriter.py [path/to/js1.js [path/to/js2.js] ...]
 """
 import logging
 import optparse
 import os
 import posixpath
 import shlex
 import sys
 import source
 import treescan
 __author__ = 'nnaze@google.com (Nathan Naze)'
 def MakeDepsFile(source_map):
  """Make a generated deps file.
  Args:
    source_map: A dict map of the source path to source.Source object.
  Returns:
    str, A generated deps file source.
  """
  # Write in path alphabetical order
  paths = sorted(source_map.keys())
  lines = []
  for path in paths:
    js_source = source_map[path]
    # We don't need to add entries that don't provide anything.
    if js_source.provides:
      lines.append(_GetDepsLine(path, js_source))
  return ''.join(lines)
 def _GetDepsLine(path, js_source):
  """Get a deps.js file string for a source."""
  provides = sorted(js_source.provides)
  requires = sorted(js_source.requires)
  return 'goog.addDependency(\'%s\', %s, %s);\n' % (path, provides, requires)
 def _GetOptionsParser():
  """Get the options parser."""
  parser = optparse.OptionParser(__doc__)
  parser.add_option('--output_file',
                    dest='output_file',
                    action='store',
                    help=('If specified, write output to this path instead of '
                          'writing to standard output.'))
  parser.add_option('--root',
                    dest='roots',
                    default=[],
                    action='append',
                    help='A root directory to scan for JS source files. '
                    'Paths of JS files in generated deps file will be '
                    'relative to this path.  This flag may be specified '
                    'multiple times.')
  parser.add_option('--root_with_prefix',
                    dest='roots_with_prefix',
                    default=[],
                    action='append',
                    help='A root directory to scan for JS source files, plus '
                    'a prefix (if either contains a space, surround with '
                    'quotes).  Paths in generated deps file will be relative '
                    'to the root, but preceded by the prefix.  This flag '
                    'may be specified multiple times.')
  parser.add_option('--path_with_depspath',
                    dest='paths_with_depspath',
                    default=[],
                    action='append',
                    help='A path to a source file and an alternate path to '
                    'the file in the generated deps file (if either contains '
                    'a space, surround with whitespace). This flag may be '
                    'specified multiple times.')
  return parser
 def _NormalizePathSeparators(path):
  """Replaces OS-specific path separators with POSIX-style slashes.
  Args:
    path: str, A file path.
  Returns:
    str, The path with any OS-specific path separators (such as backslash on
      Windows) replaced with URL-compatible forward slashes. A no-op on systems
      that use POSIX paths.
  """
  return path.replace(os.sep, posixpath.sep)
 def _GetRelativePathToSourceDict(root, prefix=''):
  """Scans a top root directory for .js sources.
  Args:
    root: str, Root directory.
    prefix: str, Prefix for returned paths.
  Returns:
    dict, A map of relative paths (with prefix, if given), to source.Source
      objects.
  """
  # Remember and restore the cwd when we're done. We work from the root so
  # that paths are relative from the root.
  start_wd = os.getcwd()
  os.chdir(root)
  path_to_source = {}
  for path in treescan.ScanTreeForJsFiles('.'):
    prefixed_path = _NormalizePathSeparators(os.path.join(prefix, path))
    path_to_source[prefixed_path] = source.Source(source.GetFileContents(path))
  os.chdir(start_wd)
  return path_to_source
 def _GetPair(s):
  """Return a string as a shell-parsed tuple.  Two values expected."""
  try:
    # shlex uses '\' as an escape character, so they must be escaped.
    s = s.replace('\\', '\\\\')
    first, second = shlex.split(s)
    return (first, second)
  except:
    raise Exception('Unable to parse input line as a pair: %s' % s)
 def main():
  """CLI frontend to MakeDepsFile."""
  logging.basicConfig(format=(sys.argv[0] + ': %(message)s'),
                      level=logging.INFO)
  options, args = _GetOptionsParser().parse_args()
  path_to_source = {}
  # Roots without prefixes
  for root in options.roots:
    path_to_source.update(_GetRelativePathToSourceDict(root))
  # Roots with prefixes
  for root_and_prefix in options.roots_with_prefix:
    root, prefix = _GetPair(root_and_prefix)
    path_to_source.update(_GetRelativePathToSourceDict(root, prefix=prefix))
  # Source paths
  for path in args:
    path_to_source[path] = source.Source(source.GetFileContents(path))
  # Source paths with alternate deps paths
  for path_with_depspath in options.paths_with_depspath:
    srcpath, depspath = _GetPair(path_with_depspath)
    path_to_source[depspath] = source.Source(source.GetFileContents(srcpath))
  # Make our output pipe.
  if options.output_file:
    out = open(options.output_file, 'w')
  else:
    out = sys.stdout
  out.write('// This file was autogenerated by %s.\n' % sys.argv[0])
  out.write('// Please do not edit.\n')
  out.write(MakeDepsFile(path_to_source))
 if __name__ == '__main__':
  main()
@@ -1,114 +0,0 @@
 # Copyright 2009 The Closure Library Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS-IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Scans a source JS file for its provided and required namespaces.
 Simple class to scan a JavaScript file and express its dependencies.
 """
 __author__ = 'nnaze@google.com'
 import re
 _BASE_REGEX_STRING = '^\s*goog\.%s\(\s*[\'"](.+)[\'"]\s*\)'
 _PROVIDE_REGEX = re.compile(_BASE_REGEX_STRING % 'provide')
 _REQUIRES_REGEX = re.compile(_BASE_REGEX_STRING % 'require')
 # This line identifies base.js and should match the line in that file.
 _GOOG_BASE_LINE = (
    'var goog = goog || {}; // Identifies this file as the Closure base.')
 class Source(object):
  """Scans a JavaScript source for its provided and required namespaces."""
  # Matches a "/* ... */" comment.
  # Note: We can't definitively distinguish a "/*" in a string literal without a
  # state machine tokenizer. We'll assume that a line starting with whitespace
  # and "/*" is a comment.
  _COMMENT_REGEX = re.compile(
      r"""
      ^\s*   # Start of a new line and whitespace
      /\*    # Opening "/*"
      .*?    # Non greedy match of any characters (including newlines)
      \*/    # Closing "*/""",
      re.MULTILINE | re.DOTALL | re.VERBOSE)
  def __init__(self, source):
    """Initialize a source.
    Args:
      source: str, The JavaScript source.
    """
    self.provides = set()
    self.requires = set()
    self._source = source
    self._ScanSource()
  def __str__(self):
    return 'Source %s' % self._path
  def GetSource(self):
    """Get the source as a string."""
    return self._source
  @classmethod
  def _StripComments(cls, source):
    return cls._COMMENT_REGEX.sub('', source)
  def _ScanSource(self):
    """Fill in provides and requires by scanning the source."""
    source = self._StripComments(self.GetSource())
    source_lines = source.splitlines()
    for line in source_lines:
      match = _PROVIDE_REGEX.match(line)
      if match:
        self.provides.add(match.group(1))
      match = _REQUIRES_REGEX.match(line)
      if match:
        self.requires.add(match.group(1))
    # Closure's base file implicitly provides 'goog'.
    for line in source_lines:
      if line == _GOOG_BASE_LINE:
        if len(self.provides) or len(self.requires):
          raise Exception(
              'Base files should not provide or require namespaces.')
        self.provides.add('goog')
 def GetFileContents(path):
  """Get a file's contents as a string.
  Args:
    path: str, Path to file.
  Returns:
    str, Contents of file.
  Raises:
    IOError: An error occurred opening or reading the file.
  """
  fileobj = open(path)
  try:
    return fileobj.read()
  finally:
    fileobj.close()
@@ -1,78 +0,0 @@
 #!/usr/bin/env python
 #
 # Copyright 2010 The Closure Library Authors. All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS-IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Shared utility functions for scanning directory trees."""
 import os
 import re
 __author__ = 'nnaze@google.com (Nathan Naze)'
 # Matches a .js file path.
 _JS_FILE_REGEX = re.compile(r'^.+\.js$')
 def ScanTreeForJsFiles(root):
  """Scans a directory tree for JavaScript files.
  Args:
    root: str, Path to a root directory.
  Returns:
    An iterable of paths to JS files, relative to cwd.
  """
  return ScanTree(root, path_filter=_JS_FILE_REGEX)
 def ScanTree(root, path_filter=None, ignore_hidden=True):
  """Scans a directory tree for files.
  Args:
    root: str, Path to a root directory.
    path_filter: A regular expression filter.  If set, only paths matching
      the path_filter are returned.
    ignore_hidden: If True, do not follow or return hidden directories or files
      (those starting with a '.' character).
  Yields:
    A string path to files, relative to cwd.
  """
  def OnError(os_error):
    raise os_error
  for dirpath, dirnames, filenames in os.walk(root, onerror=OnError):
    # os.walk allows us to modify dirnames to prevent decent into particular
    # directories.  Avoid hidden directories.
    for dirname in dirnames:
      if ignore_hidden and dirname.startswith('.'):
        dirnames.remove(dirname)
    for filename in filenames:
      # nothing that starts with '.'
      if ignore_hidden and filename.startswith('.'):
        continue
      fullpath = os.path.join(dirpath, filename)
      if path_filter and not path_filter.match(fullpath):
        continue
      yield os.path.normpath(fullpath)
@@ -100,7 +100,6 @@ EXAMPLES_SRC = [path
                if not path.startswith('examples/bootstrap')
                if path != 'examples/Jugl.js'
                if path != 'examples/jquery.min.js'
                if path != 'examples/loader.js'
                if path != 'examples/example-list.js']
 EXAMPLES_JSON = ['build/' + example.replace('.html', '.json')
@@ -653,7 +652,7 @@ def host_examples(t):
    t.rm_rf('build/hosted/%(BRANCH)s/ol')
    t.makedirs('build/hosted/%(BRANCH)s/ol')
    t.cp_r('src/ol', 'build/hosted/%(BRANCH)s/ol/ol')
-    t.run('%(PYTHON)s', 'bin/closure/depswriter.py',
+    t.run('%(PYTHON)s', closure_lib_path + '/closure/bin/build/depswriter.py',
          '--root_with_prefix', 'src ../../../ol',
          '--root', 'build/hosted/%(BRANCH)s/closure-library/closure/goog',
          '--root_with_prefix', 'build/hosted/%(BRANCH)s/closure-library/'
@@ -1,64 +0,0 @@
 /**
 * Loader to add the plovr generated script to the document.
 *
 * The following default values may be overridden with query string
 * parameters:
 *
 *     * hostname - the current hostname (window.location.hostname)
 *     * port - 9810
 *     * mode - RAW
 *     * id - id param in loader.js query string; defaults to 'ol' if not set
 *
 * Usage:
 *
 *     <script src="loader.js?id=myexample"></script>
 */
 (function() {
  var scripts = document.getElementsByTagName('script');
  var params = {
    hostname: window.location.hostname,
    port: '9810',
    mode: 'RAW',
    id: 'ol'
  };
  if (window.location.protocol === 'file:' && !params.hostname) {
    params.hostname = 'localhost';
  }
  var chunks, search, pair;
  var src, index, id, i;
  for (i = scripts.length - 1; i >= 0; --i) {
    src = scripts[i].getAttribute('src');
    if (~(index = src.indexOf('loader.js?'))) {
      // script params
      search = src.substr(index + 10);
      chunks = search ? search.split('&') : [];
      for (i = chunks.length - 1; i >= 0; --i) {
        pair = chunks[i].split('=');
        params[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
      }
      break;
    }
  }
  // url params
  search = window.location.search.substring(1);
  chunks = search ? search.split('&') : [];
  for (i = chunks.length - 1; i >= 0; --i) {
    pair = chunks[i].split('=');
    params[decodeURIComponent(pair[0])] = decodeURIComponent(pair[1]);
  }
  var host = params.hostname + ':' + params.port;
  delete params.hostname;
  delete params.port;
  var pairs = [];
  for (var key in params) {
    pairs.push(encodeURIComponent(key) + '=' + encodeURIComponent(params[key]));
  }
  var url = 'http://' + host + '/compile?' + pairs.join('&');
  document.write('<script type="text/javascript" src="' + url + '"></script>');
 }());
@@ -1,80 +0,0 @@
 <!DOCTYPE html>
 <!--
 Note: we assume that Plovr is available at <hostname>:9810, where
 <hostname> is the name of the host used for loading that page. This
 can be overriden by setting plovr_host in the query string. E.g.
     http://localhost/ol3/test/ol.html?plovr_host=192.168.1.2:9810
 -->
 <html>
 <head>
  <title>OL Spec Runner</title>
  <meta charset="utf-8">
  <link rel="stylesheet" type="text/css" href="mocha-1.8.1/mocha.css">
 </head>
 <body>
  <div id="mocha"></div>
  <script type="text/javascript" src="jquery-1.9.1/jquery.min.js"></script>
  <!-- Extended expect.js w/ various methods, see #374 for the differences to 0.2.0 -->
  <script type="text/javascript" src="expect-0.2.0-ol3/expect.js"></script>
  <script type="text/javascript" src="sinon-1.6.0/sinon.js"></script>
  <script type="text/javascript" src="mocha-1.8.1/mocha.js"></script>
  <script type="text/javascript" src="test-extensions.js"></script>
  <script>
    mocha.setup({
      ui: 'bdd',
      bail: false
    });
  </script>
  <script type="text/javascript" src="../build/proj4js/lib/proj4js-combined.js"></script>
  <script type="text/javascript">
    (function(doc, l) {
        var regexResult = /[\\?&]plovr_host=([^&#]*)/.exec(l.href);
        var plovrHost = (regexResult && regexResult[1]) ?
            decodeURIComponent(regexResult[1]) : l.hostname ?
                l.hostname + ':9810' : 'localhost:9810';
        // Create the script tag which includes the derived variables from above
        var script = '<sc' + 'ript type="text/javascript" '
            + 'src="http://' + plovrHost + '/compile?id=test&mode=RAW">'
            + '</scr' + 'ipt>';
        // write out the script-tag to load the compiled result
        doc.write(script);
    })(document, location);
  </script>
  <script type="text/javascript">
    /**
     * The goog.dom.ViewportSizeMonitor (used in map.js) creates a global leak
     * by setting goog.UID_PROPERTY_ on the monitored window.  In order to test
     * that we don't have other global leaks, we preemptively set the property
     * so Mocha can compare the global before and after our tests.
     */
    goog.getUid(this);
    if (window.mochaPhantomJS) {
      mochaPhantomJS.run();
    } else {
      mocha.run();
    }
  </script>
  <!--
    Tests should not depend on any specific markup and should instead create
    whatever elements are needed (cleaning up when done).
  -->
 </body>
 </html>