docs: def install_templates(srcroot, destroot, prefix='', excludes=None,
                        includes=None, path_prefix=None):
      #pylint:disable=too-many-arguments,too-many-statements
      """
      Expand link to compiled assets all templates in *srcroot*
      and its subdirectories.
      """
      #pylint: disable=too-many-locals
      if excludes is None:
          excludes = []
      if includes is None:
          includes = []
      if not os.path.exists(os.path.join(prefix, destroot)):
          os.makedirs(os.path.join(prefix, destroot))
      for pathname in os.listdir(os.path.join(srcroot, prefix)):
          pathname = os.path.join(prefix, pathname)
          excluded = False
          for pat in excludes:
              if re.match(pat, pathname):
                  excluded = True
                  break
          if excluded:
              for pat in includes:
                  if re.match(pat, pathname):
                      excluded = False
                      break
          if excluded:
              LOGGER.debug("skip %s", pathname)
              continue
          source_name = os.path.join(srcroot, pathname)
          dest_name = os.path.join(destroot, pathname)
          if os.path.isfile(source_name) and not os.path.exists(dest_name):
              # We don't want to overwrite specific theme files by generic ones.
              with open(source_name) as source:
                  template_string = source.read()
              try:
                  template_string = force_text(template_string)
                  lexer = DebugLexer(template_string)
                  tokens = lexer.tokenize()
                  if not os.path.isdir(os.path.dirname(dest_name)):
                      os.makedirs(os.path.dirname(dest_name))
                  engine, libraries, builtins = get_html_engine()
                  if isinstance(engine, DjangoTemplates):
                      with open(dest_name, 'w') as dest:
                          parser = AssetsParser(tokens,
                              URLRewriteWrapper(dest, path_prefix),
                              libraries=libraries,
                              builtins=builtins,
                              origin=None)
                          parser.parse_through()
                  else:
                      template_name = None
                      tokens = Lexer(engine.env).tokeniter(template_string,
                          template_name, filename=source_name)
                      buffered_tokens = []
                      state = None
                      with open(dest_name, 'w') as dest:
                          for token in tokens:
                              if state is None:
                                  if token[1] == 'block_begin':
                                      state = STATE_BLOCK_BEGIN
                              elif state == STATE_BLOCK_BEGIN:
                                  if token[1] == 'name':
                                      if token[2] == 'assets':
                                          state = STATE_ASSETS_BEGIN
                                      else:
                                          buffered_tokens += [token]
                                          state = None
                              elif state == STATE_ASSETS_BEGIN:
                                  if (token[1] == 'name'
                                      and token[2] == 'endassets'):
                                      state = STATE_ASSETS_END
                              elif state == STATE_ASSETS_END:
                                  if token[1] == 'block_end':
                                      buffered_tokens += [token]
                                      state = None
                              if state is None:
                                  if buffered_tokens:
                                      for tok in buffered_tokens:
                                          if (tok[1] == 'name' and
                                              tok[2] == 'assets'):
                                              dest.write(_render_assets(
                                                  buffered_tokens,
                                                  engine.env.assets_environment))
                                              buffered_tokens = []
                                              break
                                      if buffered_tokens:
                                          dest.write("%s" % ''.join([token[2]
                                              for token in buffered_tokens]))
                                      buffered_tokens = []
                                  else:
                                      dest.write("%s" % str(token[2]))
                              else:
                                  buffered_tokens += [token]
                          if buffered_tokens:
                              dest.write("%s" % ''.join([
                                  token[2] for token in buffered_tokens]))
                              buffered_tokens = []
                          dest.write("\n")
  
                  cmdline = ['diff', '-u', source_name, dest_name]
                  cmd = subprocess.Popen(cmdline, stdout=subprocess.PIPE)
                  lines = cmd.stdout.readlines()
                  cmd.wait()
                  # Non-zero error codes are ok here. That's how diff
                  # indicates the files are different.
                  if lines:
                      verb = 'compile'
                  else:
                      verb = 'install'
                  dest_multitier_name = dest_name.replace(destroot,
                          '*MULTITIER_TEMPLATES_ROOT*')
                  LOGGER.debug("%s %s to %s", verb,
                      source_name.replace(
                          django_settings.BASE_DIR, '*APP_ROOT*'),
                      dest_multitier_name)
              except UnicodeDecodeError:
                  LOGGER.warning("%s: Templates can only be constructed "
                      "from unicode or UTF-8 strings.", source_name)
          elif os.path.isdir(source_name):
              install_templates(srcroot, destroot, prefix=pathname,
                  excludes=excludes, includes=includes, path_prefix=path_prefix)