closurebuilder.py (9626B)
1 #!/usr/bin/env python 2 # 3 # Copyright 2009 The Closure Library Authors. All Rights Reserved. 4 # 5 # Licensed under the Apache License, Version 2.0 (the "License"); 6 # you may not use this file except in compliance with the License. 7 # You may obtain a copy of the License at 8 # 9 # http://www.apache.org/licenses/LICENSE-2.0 10 # 11 # Unless required by applicable law or agreed to in writing, software 12 # distributed under the License is distributed on an "AS-IS" BASIS, 13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 # See the License for the specific language governing permissions and 15 # limitations under the License. 16 17 """Utility for Closure Library dependency calculation. 18 19 ClosureBuilder scans source files to build dependency info. From the 20 dependencies, the script can produce a manifest in dependency order, 21 a concatenated script, or compiled output from the Closure Compiler. 22 23 Paths to files can be expressed as individual arguments to the tool (intended 24 for use with find and xargs). As a convenience, --root can be used to specify 25 all JS files below a directory. 26 27 usage: %prog [options] [file1.js file2.js ...] 28 """ 29 30 __author__ = 'nnaze@google.com (Nathan Naze)' 31 32 33 import logging 34 import optparse 35 import os 36 import sys 37 38 import depstree 39 import jscompiler 40 import source 41 import treescan 42 43 44 def _GetOptionsParser(): 45 """Get the options parser.""" 46 47 parser = optparse.OptionParser(__doc__) 48 parser.add_option('-i', 49 '--input', 50 dest='inputs', 51 action='append', 52 default=[], 53 help='One or more input files to calculate dependencies ' 54 'for. The namespaces in this file will be combined with ' 55 'those given with the -n flag to form the set of ' 56 'namespaces to find dependencies for.') 57 parser.add_option('-n', 58 '--namespace', 59 dest='namespaces', 60 action='append', 61 default=[], 62 help='One or more namespaces to calculate dependencies ' 63 'for. These namespaces will be combined with those given ' 64 'with the -i flag to form the set of namespaces to find ' 65 'dependencies for. A Closure namespace is a ' 66 'dot-delimited path expression declared with a call to ' 67 'goog.provide() (e.g. "goog.array" or "foo.bar").') 68 parser.add_option('--root', 69 dest='roots', 70 action='append', 71 default=[], 72 help='The paths that should be traversed to build the ' 73 'dependencies.') 74 parser.add_option('-o', 75 '--output_mode', 76 dest='output_mode', 77 type='choice', 78 action='store', 79 choices=['list', 'script', 'compiled'], 80 default='list', 81 help='The type of output to generate from this script. ' 82 'Options are "list" for a list of filenames, "script" ' 83 'for a single script containing the contents of all the ' 84 'files, or "compiled" to produce compiled output with ' 85 'the Closure Compiler. Default is "list".') 86 parser.add_option('-c', 87 '--compiler_jar', 88 dest='compiler_jar', 89 action='store', 90 help='The location of the Closure compiler .jar file.') 91 parser.add_option('-f', 92 '--compiler_flags', 93 dest='compiler_flags', 94 default=[], 95 action='append', 96 help='Additional flags to pass to the Closure compiler. ' 97 'To pass multiple flags, --compiler_flags has to be ' 98 'specified multiple times.') 99 parser.add_option('-j', 100 '--jvm_flags', 101 dest='jvm_flags', 102 default=[], 103 action='append', 104 help='Additional flags to pass to the JVM compiler. ' 105 'To pass multiple flags, --jvm_flags has to be ' 106 'specified multiple times.') 107 parser.add_option('--output_file', 108 dest='output_file', 109 action='store', 110 help=('If specified, write output to this path instead of ' 111 'writing to standard output.')) 112 113 return parser 114 115 116 def _GetInputByPath(path, sources): 117 """Get the source identified by a path. 118 119 Args: 120 path: str, A path to a file that identifies a source. 121 sources: An iterable collection of source objects. 122 123 Returns: 124 The source from sources identified by path, if found. Converts to 125 real paths for comparison. 126 """ 127 for js_source in sources: 128 # Convert both to real paths for comparison. 129 if os.path.realpath(path) == os.path.realpath(js_source.GetPath()): 130 return js_source 131 132 133 def _GetClosureBaseFile(sources): 134 """Given a set of sources, returns the one base.js file. 135 136 Note that if zero or two or more base.js files are found, an error message 137 will be written and the program will be exited. 138 139 Args: 140 sources: An iterable of _PathSource objects. 141 142 Returns: 143 The _PathSource representing the base Closure file. 144 """ 145 base_files = [ 146 js_source for js_source in sources if _IsClosureBaseFile(js_source)] 147 148 if not base_files: 149 logging.error('No Closure base.js file found.') 150 sys.exit(1) 151 if len(base_files) > 1: 152 logging.error('More than one Closure base.js files found at these paths:') 153 for base_file in base_files: 154 logging.error(base_file.GetPath()) 155 sys.exit(1) 156 return base_files[0] 157 158 159 def _IsClosureBaseFile(js_source): 160 """Returns true if the given _PathSource is the Closure base.js source.""" 161 return (os.path.basename(js_source.GetPath()) == 'base.js' and 162 js_source.provides == set(['goog'])) 163 164 165 class _PathSource(source.Source): 166 """Source file subclass that remembers its file path.""" 167 168 def __init__(self, path): 169 """Initialize a source. 170 171 Args: 172 path: str, Path to a JavaScript file. The source string will be read 173 from this file. 174 """ 175 super(_PathSource, self).__init__(source.GetFileContents(path)) 176 177 self._path = path 178 179 def __str__(self): 180 return 'PathSource %s' % self._path 181 182 def GetPath(self): 183 """Returns the path.""" 184 return self._path 185 186 187 def _WrapGoogModuleSource(src): 188 return ('goog.loadModule(function(exports) {{' 189 '"use strict";' 190 '{0}' 191 '\n' # terminate any trailing single line comment. 192 ';return exports' 193 '}});\n').format(src) 194 195 196 def main(): 197 logging.basicConfig(format=(sys.argv[0] + ': %(message)s'), 198 level=logging.INFO) 199 options, args = _GetOptionsParser().parse_args() 200 201 # Make our output pipe. 202 if options.output_file: 203 out = open(options.output_file, 'w') 204 else: 205 out = sys.stdout 206 207 sources = set() 208 209 logging.info('Scanning paths...') 210 for path in options.roots: 211 for js_path in treescan.ScanTreeForJsFiles(path): 212 sources.add(_PathSource(js_path)) 213 214 # Add scripts specified on the command line. 215 for js_path in args: 216 sources.add(_PathSource(js_path)) 217 218 logging.info('%s sources scanned.', len(sources)) 219 220 # Though deps output doesn't need to query the tree, we still build it 221 # to validate dependencies. 222 logging.info('Building dependency tree..') 223 tree = depstree.DepsTree(sources) 224 225 input_namespaces = set() 226 inputs = options.inputs or [] 227 for input_path in inputs: 228 js_input = _GetInputByPath(input_path, sources) 229 if not js_input: 230 logging.error('No source matched input %s', input_path) 231 sys.exit(1) 232 input_namespaces.update(js_input.provides) 233 234 input_namespaces.update(options.namespaces) 235 236 if not input_namespaces: 237 logging.error('No namespaces found. At least one namespace must be ' 238 'specified with the --namespace or --input flags.') 239 sys.exit(2) 240 241 # The Closure Library base file must go first. 242 base = _GetClosureBaseFile(sources) 243 deps = [base] + tree.GetDependencies(input_namespaces) 244 245 output_mode = options.output_mode 246 if output_mode == 'list': 247 out.writelines([js_source.GetPath() + '\n' for js_source in deps]) 248 elif output_mode == 'script': 249 for js_source in deps: 250 src = js_source.GetSource() 251 if js_source.is_goog_module: 252 src = _WrapGoogModuleSource(src) 253 out.write(src + '\n') 254 elif output_mode == 'compiled': 255 logging.warning("""\ 256 Closure Compiler now natively understands and orders Closure dependencies and 257 is prefererred over using this script for performing JavaScript compilation. 258 259 Please migrate your codebase. 260 261 See: 262 https://github.com/google/closure-compiler/wiki/Manage-Closure-Dependencies 263 """) 264 265 # Make sure a .jar is specified. 266 if not options.compiler_jar: 267 logging.error('--compiler_jar flag must be specified if --output is ' 268 '"compiled"') 269 sys.exit(2) 270 271 # Will throw an error if the compilation fails. 272 compiled_source = jscompiler.Compile( 273 options.compiler_jar, 274 [js_source.GetPath() for js_source in deps], 275 jvm_flags=options.jvm_flags, 276 compiler_flags=options.compiler_flags) 277 278 logging.info('JavaScript compilation succeeded.') 279 out.write(compiled_source) 280 281 else: 282 logging.error('Invalid value for --output flag.') 283 sys.exit(2) 284 285 286 if __name__ == '__main__': 287 main()