def _calculate_deps(js_entrypoint_file_path):
js_sources = set()
source_files = set()
logging.info("Scanning paths for Javascript files...")
for js_path in loader.locate("*.js"):
if not js_path.startswith(coverage.INSTRUMENTED_CODE_PATH):
source_files.add(js_path)
for js_path in source_files:
js_sources.add(closurebuilder._PathSource(js_path))
logging.info("Done")
logging.info("Building dependency tree..")
tree = depstree.DepsTree(js_sources)
# find the namespace of entrypoint
entrypoint_source = closurebuilder._PathSource(js_entrypoint_file_path)
if entrypoint_source.provides:
namespace = entrypoint_source.provides
else:
namespace = entrypoint_source.requires
# namespace = [closurebuilder._PathSource(js_entrypoint_file_path).provides.pop()]
# The Closure Library base file must go first.
base = closurebuilder._GetClosureBaseFile(js_sources)
deps = [base] + tree.GetDependencies(namespace)
logging.info("Done")
return deps
def build_minified(self):
from distutils import log
import closurebuilder
import treescan
import depstree
log.info('Building minified script "%s", mode: %s',
self.minified, self.output_mode)
log.info('Scanning paths...')
sources = set(
(closurebuilder._PathSource(js_path)
for path in (self.root, self.project,)
for js_path in treescan.ScanTreeForJsFiles(path)
))
log.info('%s sources scanned.', len(sources))
log.info('Building dependency tree..')
tree = depstree.DepsTree(sources)
input_namespaces = set(self.namespaces)
for input_path in self.inputs:
js_input = closurebuilder._GetInputByPath(input_path, sources)
if not js_input:
msg = 'No source matched input %s' % input_path
log.error(msg)
raise DistutilsError, msg
input_namespaces.update(js_input.provides)
if not input_namespaces:
msg = ('No namespaces found. At least one namespace must be '
'specified with the --namespaces or --inputs flags.')
log.error(msg)
raise DistutilsError, msg
base = closurebuilder._GetClosureBaseFile(sources)
deps = [base] + tree.GetDependencies(input_namespaces)
if self.output_mode == 'list':
log.info('Listing files:')
log.info('\n'.join([js_source.GetPath() for js_source in deps]))
log.info('Build successful!')
return
out = open(self.minified, 'w')
if self.output_mode == 'script':
out.writelines([js_source.GetSource() for js_source in deps])
out.close()
log.info('Build successful!')
return
import jscompiler
compiled_source = jscompiler.Compile(
self.compiler_jar,
[js_source.GetPath() for js_source in deps],
self.compiler_flags)
if compiled_source is None:
msg = 'JavaScript compilation failed.'
log.error(msg)
raise DistutilsError, msg
else:
log.info('JavaScript compilation succeeded.')
out.write(compiled_source)
log.info('Build successful!')
out.close()
def main():
logging.basicConfig(format=(sys.argv[0] + ': %(message)s'),
level=logging.INFO)
options, args = _GetOptionsParser().parse_args()
if not options.modules:
logging.error('No modules specified')
sys.exit(1)
# Make our output pipe.
global out
if options.output_file:
out = open(options.output_file, 'w')
else:
out = sys.stdout
options.keep_dep_tags = ParseBoolean(options.keep_dep_tags)
options.keep_base_separate = ParseBoolean(options.keep_base_separate)
sources = set()
logging.info('Scanning paths...')
for path in options.roots:
for js_path in treescan.ScanTreeForJsFiles(path):
sources.add(closurebuilder._PathSource(js_path))
logging.info('%s sources scanned.', len(sources))
# Add scripts specified on the command line.
for path in args:
sources.add(source.Source(closurebuilder._PathSource(path)))
moduleBlocks = []
for modcmd in options.modules:
modSpec = modcmd.split(':')
if len(modSpec) != 2:
logging.error('Incorrect module specification: %s', modcmd)
sys.exit(1)
name = modSpec[0]
namespaces = _ExtractNamespaces(modSpec[1], sources, allowWildCards=True)
moduleBlocks.append(( name, namespaces ))
modules = _generateModules(sources, moduleBlocks, keepBaseSeparate=options.keep_base_separate)
output_mode = options.output_mode
if output_mode == 'cmdline':
out.writelines(_generateCommandLine(modules, keepDeps=options.keep_dep_tags))
elif output_mode == 'compiled':
# Make sure a .jar is specified.
if not options.compiler_jar:
logging.error('--compiler_jar flag must be specified if --output is '
'"compiled"')
sys.exit(1)
paths = []
for name, deps, moddeps in modules:
paths += [src.GetPath() for src in deps]
compiler_flags = _getModuleFlags(modules, keepDeps=options.keep_dep_tags)
if options.compiler_flags:
compiler_flags += options.compiler_flags.split()
compiled_source = jscompiler.Compile(options.compiler_jar,
paths,
compiler_flags
)
if compiled_source is None:
logging.error('JavaScript compilation failed.')
sys.exit(1)
else:
logging.info('JavaScript compilation succeeded.')
out.write(compiled_source)
else:
logging.error('Invalid value for --output flag.')
sys.exit(1)
options.list_unused_files = ParseBoolean(options.list_unused_files)
# todo: this overlapping could be used to generate _two_ deps files!
# one with all files, and one with the compiled modules (merged with others).
if options.list_unused_files:
# could output contained modules also?
all_src = set([src.GetPath() for src in sources])
mod_src = set()
for mod in modules:
mod_src.update([src.GetPath() for src in mod[1]])
orphans = all_src - mod_src
if len(orphans) > 0:
out.write('Orphan files in the input tree:\n' + '\n'.join(sorted(orphans, key=str.lower)))
