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