def compile_demo(force, is_debug):
"""Compile the demo application.
Args:
force: True to rebuild, False to ignore if no changes are detected.
is_debug: True to compile for debugging, false for release.
Returns:
True on success, False on failure.
"""
logging.info('Compiling the demo app (%s)...',
'debug' if is_debug else 'release')
base = shakaBuildHelpers.get_source_base()
closure_base_js = shakaBuildHelpers.get_closure_base_js_path()
get = shakaBuildHelpers.get_all_js_files
cast_receiver = set(get('demo', 'cast_receiver'))
files = set(
get('demo') + get('externs') + get('ui', 'externs') +
[closure_base_js]) - cast_receiver
# Make sure we don't compile in load.js, which will be used to bootstrap
# everything else. If we build that into the output, we will get an
# infinite loop of scripts adding themselves.
files.remove(os.path.join(base, 'demo', 'load.js'))
# Remove service_worker.js as well. This executes in a different context.
files.remove(os.path.join(base, 'demo', 'service_worker.js'))
# Don't compile in the uncompiled require file.
files.remove(os.path.join(base, 'demo', 'demo_uncompiled.js'))
# Add lib/debug/asserts.js, which is required for goog.assert.
files.add(os.path.join(base, 'lib', 'debug', 'asserts.js'))
# Add in the generated externs, so that the demo compilation knows the
# definitions of the library APIs.
externs = ('shaka-player.ui.debug.externs.js'
if is_debug else 'shaka-player.ui.externs.js')
files.add(os.path.join(base, 'dist', externs))
name = 'demo.compiled' + ('.debug' if is_debug else '')
# TODO: Why do we always use debug_closure_opts? Nobody remembers.
closure_opts = build.common_closure_opts + build.debug_closure_opts
closure_opts += [
# Ignore missing goog.require since we assume the whole library is
# already included.
'--jscomp_off=missingRequire',
'--jscomp_off=strictMissingRequire',
'-D',
'COMPILED=true',
]
closure = compiler.ClosureCompiler(files, name)
# The output wrapper is only designed for the library. It can't be used
# for apps. TODO: Should we add a simple function wrapper for apps?
closure.add_wrapper = False
if not closure.compile(closure_opts, force):
return False
return True
def build_library(self, name, locales, force, is_debug):
"""Builds Shaka Player using the files in |self.include|.
Args:
name: The name of the build.
locales: A list of strings of locale identifiers.
force: True to rebuild, False to ignore if no changes are detected.
is_debug: True to compile for debugging, false for release.
Returns:
True on success; False on failure.
"""
self.add_closure()
if not self.add_core():
return False
if self.has_ui():
self.generate_localizations(locales, force)
if is_debug:
name += '.debug'
build_name = 'shaka-player.' + name
closure = compiler.ClosureCompiler(self.include, build_name)
closure_opts = common_closure_opts + common_closure_defines
if is_debug:
closure_opts += debug_closure_opts + debug_closure_defines
else:
closure_opts += release_closure_opts + release_closure_defines
if not closure.compile(closure_opts, force):
return False
# Don't pass local node modules to the extern generator. But don't simply
# exclude the string 'node_modules', either, since Shaka Player could be
# rebuilt after installing it as a node module.
node_modules_path = os.path.join(shakaBuildHelpers.get_source_base(),
'node_modules')
local_include = set(
[f for f in self.include if node_modules_path not in f])
extern_generator = compiler.ExternGenerator(local_include, build_name)
if not extern_generator.generate(force):
return False
generated_externs = [extern_generator.output]
shaka_externs = shakaBuildHelpers.get_all_js_files('externs')
if self.has_ui():
shaka_externs += shakaBuildHelpers.get_all_js_files('ui/externs')
ts_def_generator = compiler.TsDefGenerator(
generated_externs + shaka_externs, build_name)
if not ts_def_generator.generate(force):
return False
return True
def compile_receiver(force, is_debug):
"""Compile the cast receiver application.
Args:
force: True to rebuild, False to ignore if no changes are detected.
is_debug: True to compile for debugging, false for release.
Returns:
True on success, False on failure.
"""
logging.info('Compiling the receiver app (%s)...',
'debug' if is_debug else 'release')
match = re.compile(r'.*\.js$')
base = shakaBuildHelpers.get_source_base()
def get(*path_components):
return shakaBuildHelpers.get_all_files(
os.path.join(base, *path_components), match)
files = set(
get('demo', 'common') + get('demo', 'cast_receiver') + get('externs') +
get('ui', 'externs') + get('lib', 'debug') +
get('third_party', 'closure'))
# Add in the generated externs, so that the receiver compilation knows the
# definitions of the library APIs.
externs = ('shaka-player.ui.debug.externs.js'
if is_debug else 'shaka-player.ui.externs.js')
files.add(os.path.join(base, 'dist', externs))
name = 'receiver.compiled' + ('.debug' if is_debug else '')
# TODO: Why do we always use debug_closure_opts? Nobody remembers.
closure_opts = build.common_closure_opts + build.debug_closure_opts
closure_opts += [
# Ignore missing goog.require since we assume the whole library is
# already included.
'--jscomp_off=missingRequire',
'--jscomp_off=strictMissingRequire',
'-D',
'COMPILED=true',
]
closure = compiler.ClosureCompiler(files, name)
# The output wrapper is only designed for the library. It can't be used
# for apps. TODO: Should we add a simple function wrapper for apps?
closure.add_wrapper = False
if not closure.compile(closure_opts, force):
return False
return True
def check_tests(args):
"""Runs an extra compile pass over the test code to check for type errors.
Returns:
True on success, False on failure.
"""
logging.info('Checking the tests for type errors...')
complete_build = complete_build_files()
if not complete_build:
return False
match = re.compile(r'.*\.js$')
base = shakaBuildHelpers.get_source_base()
def get(*path_components):
return shakaBuildHelpers.get_all_files(
os.path.join(base, *path_components), match)
files = complete_build
files.update(
set(get('externs') + get('test') + get('third_party', 'closure')))
files.add(os.path.join(base, 'demo', 'common', 'asset.js'))
files.add(os.path.join(base, 'demo', 'common', 'assets.js'))
files.add(os.path.join(base, 'demo', 'common', 'message_ids.js'))
localizations = compiler.GenerateLocalizations(None)
localizations.generate(args.force)
files.add(localizations.output)
closure_opts = build.common_closure_opts + build.common_closure_defines
closure_opts += build.debug_closure_opts + build.debug_closure_defines
# Ignore missing goog.require since we assume the whole library is
# already included.
closure_opts += [
'--jscomp_off=missingRequire', '--jscomp_off=strictMissingRequire',
'--checks-only', '-O', 'SIMPLE'
]
# Set up a build with the build name of "dummy". With output_compiled_bundle
# set to False, the build name is irrelevant, since we won't generate any
# compiled output.
closure = compiler.ClosureCompiler(files, 'dummy')
closure.output_compiled_bundle = False
# Instead of creating a compiled bundle, we will touch a timestamp file to
# keep track of how recently we've run this check.
closure.timestamp_file = os.path.join(base, 'dist', '.testcheckstamp')
return closure.compile(closure_opts, args.force)
def build_library(self, name, locales, force, is_debug):
"""Builds Shaka Player using the files in |self.include|.
Args:
name: The name of the build.
locales: A list of strings of locale identifiers.
force: True to rebuild, False to ignore if no changes are detected.
is_debug: True to compile for debugging, false for release.
Returns:
True on success; False on failure.
"""
self.add_closure()
if not self.add_core():
return False
if self.has_ui():
self.generate_localizations(locales, force)
if is_debug:
name += '.debug'
build_name = 'shaka-player.' + name
closure = compiler.ClosureCompiler(self.include, build_name)
# Don't pass node modules to the extern generator.
local_include = set([f for f in self.include if 'node_modules' not in f])
generator = compiler.ExternGenerator(local_include, build_name)
closure_opts = common_closure_opts + common_closure_defines
if is_debug:
closure_opts += debug_closure_opts + debug_closure_defines
# The output wrapper is only used in the release build.
closure.add_wrapper = False
else:
closure_opts += release_closure_opts + release_closure_defines
if not closure.compile(closure_opts, force):
return False
if not generator.generate(force):
return False
return True
def build_library(self, name, force, is_debug):
"""Builds Shaka Player using the files in |self.include|.
Args:
name: The name of the build.
force: True to rebuild, False to ignore if no changes are detected.
is_debug: True to compile for debugging, false for release.
Returns:
True on success; False on failure.
"""
self.add_closure()
self.add_core()
if is_debug:
name += '.debug'
build_name = 'shaka-player.' + name
closure = compiler.ClosureCompiler(self.include, build_name)
generator = compiler.ExternGenerator(self.include, build_name)
closure_opts = common_closure_opts + common_closure_defines
if is_debug:
closure_opts += debug_closure_opts + debug_closure_defines
# The output wrapper is only used in the release build.
closure.add_wrapper = False
else:
closure_opts += release_closure_opts + release_closure_defines
if not closure.compile(closure_opts, force):
return False
if not generator.generate(force):
return False
return True
