packaging: stage installed files for Inno

Previously, the Inno installer maintained its own mapping of
source files to install location. (We have to maintain a
similar mapping in the WiX installer.)

Managing the explicit file layout for Windows packages is
cumbersome and redundant. Every time you want to change the
layout you need to change N locations. We frequently forget
to do this and we only find out when people install Mercurial
from our packages at release time.

This commit starts the process of consolidating and simplifying
the logic for managing the install layout on Windows.

We introduce a list of install layout rules. These are simply
source filenames (which can contain wildcards) and destination
paths.

The Inno packaging code has been updated to assemble all
files into a staging directory that mirrors the final install
layout. The list of files to add to the installer is derived
by walking this staging directory and dynamically emitting
the proper entries for the Inno Setup script.

I diffed the file layout before and after this commit and
there is no difference.

Another benefit of this change is that it facilitates easier
testing of the Windows install layout. Before, in order to
test the final install layout, you needed to build an installer
and run it. Now, you can stage files into the final layout
and test from there, without running the installer. This
should cut down on overhead when changing Windows code.

Differential Revision: https://phab.mercurial-scm.org/D7159

contrib/packaging/hgpackaging/inno.py

@@ -1,112 +1,159 b''
 # inno.py - Inno Setup functionality.
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import os
 import pathlib
 import shutil
 import subprocess
 
 import jinja2
 
-from .py2exe import build_py2exe
+from .py2exe import (
+    build_py2exe,
+    stage_install,
+)
 from .util import find_vc_runtime_files
 
 EXTRA_PACKAGES = {
     'dulwich',
     'keyring',
     'pygments',
     'win32ctypes',
 }
 
+PACKAGE_FILES_METADATA = {
+    'ReadMe.html': 'Flags: isreadme',
+    'hg.exe': "AfterInstall: Touch('{app}\\hg.exe.local')",
+}
+
 
 def build(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     python_exe: pathlib.Path,
     iscc_exe: pathlib.Path,
     version=None,
 ):
     """Build the Inno installer.
 
     Build files will be placed in ``build_dir``.
 
     py2exe's setup.py doesn't use setuptools. It doesn't have modern logic
     for finding the Python 2.7 toolchain. So, we require the environment
     to already be configured with an active toolchain.
     """
     if not iscc_exe.exists():
         raise Exception('%s does not exist' % iscc_exe)
 
     vc_x64 = r'\x64' in os.environ.get('LIB', '')
     arch = 'x64' if vc_x64 else 'x86'
     inno_source_dir = source_dir / 'contrib' / 'packaging' / 'inno'
     inno_build_dir = build_dir / ('inno-%s' % arch)
+    staging_dir = inno_build_dir / 'stage'
 
     requirements_txt = (
         source_dir / 'contrib' / 'packaging' / 'inno' / 'requirements.txt'
     )
 
     inno_build_dir.mkdir(parents=True, exist_ok=True)
 
     build_py2exe(
         source_dir,
         build_dir,
         python_exe,
         'inno',
         requirements_txt,
         extra_packages=EXTRA_PACKAGES,
     )
 
+    # Purge the staging directory for every build so packaging is
+    # pristine.
+    if staging_dir.exists():
+        print('purging %s' % staging_dir)
+        shutil.rmtree(staging_dir)
+
+    # Now assemble all the packaged files into the staging directory.
+    stage_install(source_dir, staging_dir)
+
     # hg.exe depends on VC9 runtime DLLs. Copy those into place.
     for f in find_vc_runtime_files(vc_x64):
         if f.name.endswith('.manifest'):
             basename = 'Microsoft.VC90.CRT.manifest'
         else:
             basename = f.name
 
-        dest_path = source_dir / 'dist' / basename
+        dest_path = staging_dir / basename
 
         print('copying %s to %s' % (f, dest_path))
         shutil.copyfile(f, dest_path)
 
+    # The final package layout is simply a mirror of the staging directory.
+    package_files = []
+    for root, dirs, files in os.walk(staging_dir):
+        dirs.sort()
+
+        root = pathlib.Path(root)
+
+        for f in sorted(files):
+            full = root / f
+            rel = full.relative_to(staging_dir)
+            if str(rel.parent) == '.':
+                dest_dir = '{app}'
+            else:
+                dest_dir = '{app}\\%s' % rel.parent
+
+            package_files.append(
+                {
+                    'source': rel,
+                    'dest_dir': dest_dir,
+                    'metadata': PACKAGE_FILES_METADATA.get(str(rel), None),
+                }
+            )
+
     print('creating installer')
 
     # Install Inno files by rendering a template.
     jinja_env = jinja2.Environment(
         loader=jinja2.FileSystemLoader(str(inno_source_dir)),
         # Need to change these to prevent conflict with Inno Setup.
         comment_start_string='{##',
         comment_end_string='##}',
     )
 
     try:
         template = jinja_env.get_template('mercurial.iss')
     except jinja2.TemplateSyntaxError as e:
         raise Exception(
             'template syntax error at %s:%d: %s'
             % (e.name, e.lineno, e.message,)
         )
 
-    content = template.render()
+    content = template.render(package_files=package_files)
 
     with (inno_build_dir / 'mercurial.iss').open('w', encoding='utf-8') as fh:
         fh.write(content)
 
+    # Copy additional files used by Inno.
+    for p in ('mercurial.ico', 'postinstall.txt'):
+        shutil.copyfile(
+            source_dir / 'contrib' / 'win32' / p, inno_build_dir / p
+        )
+
     args = [str(iscc_exe)]
 
     if vc_x64:
         args.append('/dARCH=x64')
 
     if version:
         args.append('/dVERSION=%s' % version)
 
     args.append('/Odist')
     args.append(str(inno_build_dir / 'mercurial.iss'))
 
     subprocess.run(args, cwd=str(source_dir), check=True)

contrib/packaging/hgpackaging/py2exe.py

@@ -1,171 +1,213 b''
 # py2exe.py - Functionality for performing py2exe builds.
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import os
 import pathlib
 import subprocess
 
 from .downloads import download_entry
 from .util import (
     extract_tar_to_directory,
     extract_zip_to_directory,
+    process_install_rules,
     python_exe_info,
 )
 
 
+STAGING_RULES = [
+    ('contrib/bash_completion', 'Contrib/'),
+    ('contrib/hgk', 'Contrib/hgk.tcl'),
+    ('contrib/hgweb.fcgi', 'Contrib/'),
+    ('contrib/hgweb.wsgi', 'Contrib/'),
+    ('contrib/mercurial.el', 'Contrib/'),
+    ('contrib/mq.el', 'Contrib/'),
+    ('contrib/tcsh_completion', 'Contrib/'),
+    ('contrib/tcsh_completion_build.sh', 'Contrib/'),
+    ('contrib/vim/*', 'Contrib/Vim/'),
+    ('contrib/win32/postinstall.txt', 'ReleaseNotes.txt'),
+    ('contrib/win32/ReadMe.html', 'ReadMe.html'),
+    ('contrib/xml.rnc', 'Contrib/'),
+    ('contrib/zsh_completion', 'Contrib/'),
+    ('dist/hg.exe', './'),
+    ('dist/lib/*.dll', 'lib/'),
+    ('dist/lib/*.pyd', 'lib/'),
+    ('dist/lib/library.zip', 'lib/'),
+    ('dist/Microsoft.VC*.CRT.manifest', './'),
+    ('dist/msvc*.dll', './'),
+    ('dist/python*.dll', './'),
+    ('doc/*.html', 'Docs/'),
+    ('doc/style.css', 'Docs/'),
+    ('mercurial/help/**/*.txt', 'help/'),
+    ('mercurial/default.d/*.rc', 'default.d/'),
+    ('mercurial/locale/**/*', 'locale/'),
+    ('mercurial/templates/**/*', 'Templates/'),
+    ('CONTRIBUTORS', 'Contributors.txt'),
+    ('COPYING', 'Copying.txt'),
+]
+
+
 def build_py2exe(
     source_dir: pathlib.Path,
     build_dir: pathlib.Path,
     python_exe: pathlib.Path,
     build_name: str,
     venv_requirements_txt: pathlib.Path,
     extra_packages=None,
     extra_excludes=None,
     extra_dll_excludes=None,
     extra_packages_script=None,
 ):
     """Build Mercurial with py2exe.
 
     Build files will be placed in ``build_dir``.
 
     py2exe's setup.py doesn't use setuptools. It doesn't have modern logic
     for finding the Python 2.7 toolchain. So, we require the environment
     to already be configured with an active toolchain.
     """
     if 'VCINSTALLDIR' not in os.environ:
         raise Exception(
             'not running from a Visual C++ build environment; '
             'execute the "Visual C++ <version> Command Prompt" '
             'application shortcut or a vcsvarsall.bat file'
         )
 
     # Identity x86/x64 and validate the environment matches the Python
     # architecture.
     vc_x64 = r'\x64' in os.environ['LIB']
 
     py_info = python_exe_info(python_exe)
 
     if vc_x64:
         if py_info['arch'] != '64bit':
             raise Exception(
                 'architecture mismatch: Visual C++ environment '
                 'is configured for 64-bit but Python is 32-bit'
             )
     else:
         if py_info['arch'] != '32bit':
             raise Exception(
                 'architecture mismatch: Visual C++ environment '
                 'is configured for 32-bit but Python is 64-bit'
             )
 
     if py_info['py3']:
         raise Exception('Only Python 2 is currently supported')
 
     build_dir.mkdir(exist_ok=True)
 
     gettext_pkg, gettext_entry = download_entry('gettext', build_dir)
     gettext_dep_pkg = download_entry('gettext-dep', build_dir)[0]
     virtualenv_pkg, virtualenv_entry = download_entry('virtualenv', build_dir)
     py2exe_pkg, py2exe_entry = download_entry('py2exe', build_dir)
 
     venv_path = build_dir / (
         'venv-%s-%s' % (build_name, 'x64' if vc_x64 else 'x86')
     )
 
     gettext_root = build_dir / ('gettext-win-%s' % gettext_entry['version'])
 
     if not gettext_root.exists():
         extract_zip_to_directory(gettext_pkg, gettext_root)
         extract_zip_to_directory(gettext_dep_pkg, gettext_root)
 
     # This assumes Python 2. We don't need virtualenv on Python 3.
     virtualenv_src_path = build_dir / (
         'virtualenv-%s' % virtualenv_entry['version']
     )
     virtualenv_py = virtualenv_src_path / 'virtualenv.py'
 
     if not virtualenv_src_path.exists():
         extract_tar_to_directory(virtualenv_pkg, build_dir)
 
     py2exe_source_path = build_dir / ('py2exe-%s' % py2exe_entry['version'])
 
     if not py2exe_source_path.exists():
         extract_zip_to_directory(py2exe_pkg, build_dir)
 
     if not venv_path.exists():
         print('creating virtualenv with dependencies')
         subprocess.run(
             [str(python_exe), str(virtualenv_py), str(venv_path)], check=True
         )
 
     venv_python = venv_path / 'Scripts' / 'python.exe'
     venv_pip = venv_path / 'Scripts' / 'pip.exe'
 
     subprocess.run(
         [str(venv_pip), 'install', '-r', str(venv_requirements_txt)], check=True
     )
 
     # Force distutils to use VC++ settings from environment, which was
     # validated above.
     env = dict(os.environ)
     env['DISTUTILS_USE_SDK'] = '1'
     env['MSSdk'] = '1'
 
     if extra_packages_script:
         more_packages = set(
             subprocess.check_output(extra_packages_script, cwd=build_dir)
             .split(b'\0')[-1]
             .strip()
             .decode('utf-8')
             .splitlines()
         )
         if more_packages:
             if not extra_packages:
                 extra_packages = more_packages
             else:
                 extra_packages |= more_packages
 
     if extra_packages:
         env['HG_PY2EXE_EXTRA_PACKAGES'] = ' '.join(sorted(extra_packages))
         hgext3rd_extras = sorted(
             e for e in extra_packages if e.startswith('hgext3rd.')
         )
         if hgext3rd_extras:
             env['HG_PY2EXE_EXTRA_INSTALL_PACKAGES'] = ' '.join(hgext3rd_extras)
     if extra_excludes:
         env['HG_PY2EXE_EXTRA_EXCLUDES'] = ' '.join(sorted(extra_excludes))
     if extra_dll_excludes:
         env['HG_PY2EXE_EXTRA_DLL_EXCLUDES'] = ' '.join(
             sorted(extra_dll_excludes)
         )
 
     py2exe_py_path = venv_path / 'Lib' / 'site-packages' / 'py2exe'
     if not py2exe_py_path.exists():
         print('building py2exe')
         subprocess.run(
             [str(venv_python), 'setup.py', 'install'],
             cwd=py2exe_source_path,
             env=env,
             check=True,
         )
 
     # Register location of msgfmt and other binaries.
     env['PATH'] = '%s%s%s' % (
         env['PATH'],
         os.pathsep,
         str(gettext_root / 'bin'),
     )
 
     print('building Mercurial')
     subprocess.run(
         [str(venv_python), 'setup.py', 'py2exe', 'build_doc', '--html'],
         cwd=str(source_dir),
         env=env,
         check=True,
     )
+
+
+def stage_install(source_dir: pathlib.Path, staging_dir: pathlib.Path):
+    """Copy all files to be installed to a directory.
+
+    This allows packaging to simply walk a directory tree to find source
+    files.
+    """
+    process_install_rules(STAGING_RULES, source_dir, staging_dir)

contrib/packaging/hgpackaging/util.py

@@ -1,166 +1,212 b''
 # util.py - Common packaging utility code.
 #
 # Copyright 2019 Gregory Szorc <[e-mail]>
 #
 # This software may be used and distributed according to the terms of the
 # GNU General Public License version 2 or any later version.
 
 # no-check-code because Python 3 native.
 
 import distutils.version
 import getpass
+import glob
 import os
 import pathlib
+import shutil
 import subprocess
 import tarfile
 import zipfile
 
 
 def extract_tar_to_directory(source: pathlib.Path, dest: pathlib.Path):
     with tarfile.open(source, 'r') as tf:
         tf.extractall(dest)
 
 
 def extract_zip_to_directory(source: pathlib.Path, dest: pathlib.Path):
     with zipfile.ZipFile(source, 'r') as zf:
         zf.extractall(dest)
 
 
 def find_vc_runtime_files(x64=False):
     """Finds Visual C++ Runtime DLLs to include in distribution."""
     winsxs = pathlib.Path(os.environ['SYSTEMROOT']) / 'WinSxS'
 
     prefix = 'amd64' if x64 else 'x86'
 
     candidates = sorted(
         p
         for p in os.listdir(winsxs)
         if p.lower().startswith('%s_microsoft.vc90.crt_' % prefix)
     )
 
     for p in candidates:
         print('found candidate VC runtime: %s' % p)
 
     # Take the newest version.
     version = candidates[-1]
 
     d = winsxs / version
 
     return [
         d / 'msvcm90.dll',
         d / 'msvcp90.dll',
         d / 'msvcr90.dll',
         winsxs / 'Manifests' / ('%s.manifest' % version),
     ]
 
 
 def windows_10_sdk_info():
     """Resolves information about the Windows 10 SDK."""
 
     base = pathlib.Path(os.environ['ProgramFiles(x86)']) / 'Windows Kits' / '10'
 
     if not base.is_dir():
         raise Exception('unable to find Windows 10 SDK at %s' % base)
 
     # Find the latest version.
     bin_base = base / 'bin'
 
     versions = [v for v in os.listdir(bin_base) if v.startswith('10.')]
     version = sorted(versions, reverse=True)[0]
 
     bin_version = bin_base / version
 
     return {
         'root': base,
         'version': version,
         'bin_root': bin_version,
         'bin_x86': bin_version / 'x86',
         'bin_x64': bin_version / 'x64',
     }
 
 
 def find_signtool():
     """Find signtool.exe from the Windows SDK."""
     sdk = windows_10_sdk_info()
 
     for key in ('bin_x64', 'bin_x86'):
         p = sdk[key] / 'signtool.exe'
 
         if p.exists():
             return p
 
     raise Exception('could not find signtool.exe in Windows 10 SDK')
 
 
 def sign_with_signtool(
     file_path,
     description,
     subject_name=None,
     cert_path=None,
     cert_password=None,
     timestamp_url=None,
 ):
     """Digitally sign a file with signtool.exe.
 
     ``file_path`` is file to sign.
     ``description`` is text that goes in the signature.
 
     The signing certificate can be specified by ``cert_path`` or
     ``subject_name``. These correspond to the ``/f`` and ``/n`` arguments
     to signtool.exe, respectively.
 
     The certificate password can be specified via ``cert_password``. If
     not provided, you will be prompted for the password.
 
     ``timestamp_url`` is the URL of a RFC 3161 timestamp server (``/tr``
     argument to signtool.exe).
     """
     if cert_path and subject_name:
         raise ValueError('cannot specify both cert_path and subject_name')
 
     while cert_path and not cert_password:
         cert_password = getpass.getpass('password for %s: ' % cert_path)
 
     args = [
         str(find_signtool()),
         'sign',
         '/v',
         '/fd',
         'sha256',
         '/d',
         description,
     ]
 
     if cert_path:
         args.extend(['/f', str(cert_path), '/p', cert_password])
     elif subject_name:
         args.extend(['/n', subject_name])
 
     if timestamp_url:
         args.extend(['/tr', timestamp_url, '/td', 'sha256'])
 
     args.append(str(file_path))
 
     print('signing %s' % file_path)
     subprocess.run(args, check=True)
 
 
 PRINT_PYTHON_INFO = '''
 import platform; print("%s:%s" % (platform.architecture()[0], platform.python_version()))
 '''.strip()
 
 
 def python_exe_info(python_exe: pathlib.Path):
     """Obtain information about a Python executable."""
 
     res = subprocess.check_output([str(python_exe), '-c', PRINT_PYTHON_INFO])
 
     arch, version = res.decode('utf-8').split(':')
 
     version = distutils.version.LooseVersion(version)
 
     return {
         'arch': arch,
         'version': version,
         'py3': version >= distutils.version.LooseVersion('3'),
     }
+
+
+def process_install_rules(
+    rules: list, source_dir: pathlib.Path, dest_dir: pathlib.Path
+):
+    for source, dest in rules:
+        if '*' in source:
+            if not dest.endswith('/'):
+                raise ValueError('destination must end in / when globbing')
+
+            # We strip off the source path component before the first glob
+            # character to construct the relative install path.
+            prefix_end_index = source[: source.index('*')].rindex('/')
+            relative_prefix = source_dir / source[0:prefix_end_index]
+
+            for res in glob.glob(str(source_dir / source), recursive=True):
+                source_path = pathlib.Path(res)
+
+                if source_path.is_dir():
+                    continue
+
+                rel_path = source_path.relative_to(relative_prefix)
+
+                dest_path = dest_dir / dest[:-1] / rel_path
+
+                dest_path.parent.mkdir(parents=True, exist_ok=True)
+                print('copying %s to %s' % (source_path, dest_path))
+                shutil.copy(source_path, dest_path)
+
+        # Simple file case.
+        else:
+            source_path = pathlib.Path(source)
+
+            if dest.endswith('/'):
+                dest_path = pathlib.Path(dest) / source_path.name
+            else:
+                dest_path = pathlib.Path(dest)
+
+            full_source_path = source_dir / source_path
+            full_dest_path = dest_dir / dest_path
+
+            full_dest_path.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(full_source_path, full_dest_path)
+            print('copying %s to %s' % (full_source_path, full_dest_path))

contrib/packaging/inno/mercurial.iss

@@ -1,125 +1,99 b''
 ; Script generated by the Inno Setup Script Wizard.
 ; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!
 
 #ifndef VERSION
 #define FileHandle
 #define FileLine
 #define VERSION = "unknown"
 #if FileHandle = FileOpen(SourcePath + "\..\..\mercurial\__version__.py")
   #expr FileLine = FileRead(FileHandle)
   #expr FileLine = FileRead(FileHandle)
   #define VERSION = Copy(FileLine, Pos('"', FileLine)+1, Len(FileLine)-Pos('"', FileLine)-1)
 #endif
 #if FileHandle
   #expr FileClose(FileHandle)
 #endif
 #pragma message "Detected Version: " + VERSION
 #endif
 
 #ifndef ARCH
 #define ARCH = "x86"
 #endif
 
 [Setup]
 AppCopyright=Copyright 2005-2019 Matt Mackall and others
 AppName=Mercurial
 AppVersion={#VERSION}
 #if ARCH == "x64"
 AppVerName=Mercurial {#VERSION} (64-bit)
 OutputBaseFilename=Mercurial-{#VERSION}-x64
 ArchitecturesAllowed=x64
 ArchitecturesInstallIn64BitMode=x64
 #else
 AppVerName=Mercurial {#VERSION}
 OutputBaseFilename=Mercurial-{#VERSION}
 #endif
-InfoAfterFile=contrib/win32/postinstall.txt
-LicenseFile=COPYING
+InfoAfterFile=../postinstall.txt
+LicenseFile=Copying.txt
 ShowLanguageDialog=yes
 AppPublisher=Matt Mackall and others
 AppPublisherURL=https://mercurial-scm.org/
 AppSupportURL=https://mercurial-scm.org/
 AppUpdatesURL=https://mercurial-scm.org/
 {{ 'AppID={{4B95A5F1-EF59-4B08-BED8-C891C46121B3}' }}
 AppContact=[e-mail]
 DefaultDirName={pf}\Mercurial
-SourceDir=..\..
+SourceDir=stage
 VersionInfoDescription=Mercurial distributed SCM (version {#VERSION})
 VersionInfoCopyright=Copyright 2005-2019 Matt Mackall and others
 VersionInfoCompany=Matt Mackall and others
 InternalCompressLevel=max
 SolidCompression=true
-SetupIconFile=contrib\win32\mercurial.ico
+SetupIconFile=../mercurial.ico
 AllowNoIcons=true
 DefaultGroupName=Mercurial
 PrivilegesRequired=none
 ChangesEnvironment=true
 
 [Files]
-Source: contrib\mercurial.el; DestDir: {app}/Contrib
-Source: contrib\vim\*.*; DestDir: {app}/Contrib/Vim
-Source: contrib\zsh_completion; DestDir: {app}/Contrib
-Source: contrib\bash_completion; DestDir: {app}/Contrib
-Source: contrib\tcsh_completion; DestDir: {app}/Contrib
-Source: contrib\tcsh_completion_build.sh; DestDir: {app}/Contrib
-Source: contrib\hgk; DestDir: {app}/Contrib; DestName: hgk.tcl
-Source: contrib\xml.rnc; DestDir: {app}/Contrib
-Source: contrib\mercurial.el; DestDir: {app}/Contrib
-Source: contrib\mq.el; DestDir: {app}/Contrib
-Source: contrib\hgweb.fcgi; DestDir: {app}/Contrib
-Source: contrib\hgweb.wsgi; DestDir: {app}/Contrib
-Source: contrib\win32\ReadMe.html; DestDir: {app}; Flags: isreadme
-Source: contrib\win32\postinstall.txt; DestDir: {app}; DestName: ReleaseNotes.txt
-Source: dist\hg.exe; DestDir: {app}; AfterInstall: Touch('{app}\hg.exe.local')
-Source: dist\lib\*.dll; Destdir: {app}\lib
-Source: dist\lib\*.pyd; Destdir: {app}\lib
-Source: dist\python*.dll; Destdir: {app}; Flags: skipifsourcedoesntexist
-Source: dist\msvc*.dll; DestDir: {app}; Flags: skipifsourcedoesntexist
-Source: dist\Microsoft.VC*.CRT.manifest; DestDir: {app}; Flags: skipifsourcedoesntexist
-Source: dist\lib\library.zip; DestDir: {app}\lib
-Source: doc\*.html; DestDir: {app}\Docs
-Source: doc\style.css; DestDir: {app}\Docs
-Source: mercurial\help\*.txt; DestDir: {app}\help
-Source: mercurial\help\internals\*.txt; DestDir: {app}\help\internals
-Source: mercurial\default.d\*.rc; DestDir: {app}\default.d
-Source: mercurial\locale\*.*; DestDir: {app}\locale; Flags: recursesubdirs createallsubdirs skipifsourcedoesntexist
-Source: mercurial\templates\*.*; DestDir: {app}\Templates; Flags: recursesubdirs createallsubdirs
-Source: CONTRIBUTORS; DestDir: {app}; DestName: Contributors.txt
-Source: COPYING; DestDir: {app}; DestName: Copying.txt
+{% for entry in package_files -%}
+Source: {{ entry.source }}; DestDir: {{ entry.dest_dir }}
+{%- if entry.metadata %}; {{ entry.metadata }}{% endif %}
+{% endfor %}
 
 [INI]
 Filename: {app}\Mercurial.url; Section: InternetShortcut; Key: URL; String: https://mercurial-scm.org/
 Filename: {app}\default.d\editor.rc; Section: ui; Key: editor; String: notepad
 
 [UninstallDelete]
 Type: files; Name: {app}\Mercurial.url
 Type: filesandordirs; Name: {app}\default.d
 Type: files; Name: "{app}\hg.exe.local"
 
 [Icons]
 Name: {group}\Uninstall Mercurial; Filename: {uninstallexe}
 Name: {group}\Mercurial Command Reference; Filename: {app}\Docs\hg.1.html
 Name: {group}\Mercurial Configuration Files; Filename: {app}\Docs\hgrc.5.html
 Name: {group}\Mercurial Ignore Files; Filename: {app}\Docs\hgignore.5.html
 Name: {group}\Mercurial Web Site; Filename: {app}\Mercurial.url
 
 [Tasks]
 Name: modifypath; Description: Add the installation path to the search path; Flags: unchecked
 
 [Code]
 procedure Touch(fn: String);
 begin
   SaveStringToFile(ExpandConstant(fn), '', False);
 end;
 
 const
     ModPathName = 'modifypath';
     ModPathType = 'user';
 
 function ModPathDir(): TArrayOfString;
 begin
     setArrayLength(Result, 1)
     Result[0] := ExpandConstant('{app}');
 end;
 
 {% include 'modpath.iss' %}