Repository: volks73/cargo-wix
Branch: main
Commit: 041cc3c624ab
Files: 45
Total size: 717.4 KB

Directory structure:
gitextract_m7khl9b_/

├── .cargo/
│   └── config.toml
├── .github/
│   ├── dependabot.yml
│   └── workflows/
│       └── ci.yml
├── .gitignore
├── Cargo.toml
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── src/
│   ├── clean.rs
│   ├── create.rs
│   ├── initialize.rs
│   ├── lib.rs
│   ├── licenses.rs
│   ├── main.rs
│   ├── migrate.rs
│   ├── print/
│   │   ├── license.rs
│   │   ├── mod.rs
│   │   └── wxs.rs
│   ├── purge.rs
│   ├── sign.rs
│   ├── stored_path.rs
│   ├── templates/
│   │   ├── Apache-2.0.rtf.mustache
│   │   ├── GPL-3.0.rtf.mustache
│   │   ├── MIT.rtf.mustache
│   │   ├── main.v3.wxs.mustache
│   │   ├── main.v4.wxs.mustache
│   │   └── mod.rs
│   └── toolset/
│       ├── ext.rs
│       ├── includes.rs
│       ├── mod.rs
│       ├── project.rs
│       ├── source.rs
│       └── test.rs
├── tests/
│   ├── common/
│   │   ├── mod.rs
│   │   ├── one.wxs
│   │   ├── post_v4/
│   │   │   ├── fragment.wxs
│   │   │   └── main.wxs
│   │   ├── pre_v4/
│   │   │   └── main.wxs
│   │   ├── three.wxs
│   │   ├── two.wxs
│   │   └── well_known_exts/
│   │       └── main.wxs
│   ├── create.rs
│   └── initialize.rs
└── xtask/
    ├── Cargo.toml
    └── src/
        └── main.rs

================================================
FILE CONTENTS
================================================

================================================
FILE: .cargo/config.toml
================================================
[alias]
xtask = "run --package xtask --"


================================================
FILE: .github/dependabot.yml
================================================
# https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates

version: 2
updates:
  - package-ecosystem: "cargo"
    directory: "/"
    schedule:
      interval: "daily"

  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
      interval: "daily"


================================================
FILE: .github/workflows/ci.yml
================================================
name: CI

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

  workflow_dispatch:

jobs:
  test:
    strategy:
      matrix:
        rust: [stable, 1.88.0]
        os: [windows-latest, ubuntu-latest, macos-latest]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@master
        with:
          toolchain: ${{ matrix.rust }}

      - name: Run tests
        run: cargo test --all-targets

  docs:
    runs-on: windows-latest
    env:
      RUSTDOCFLAGS: -Dwarnings
    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rust-docs

      - name: Generate documentation
        run: cargo doc --workspace --no-deps

  rustfmt:
    runs-on: windows-latest
    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: rustfmt

      - name: Format Rust code
        run: cargo fmt --all -- --check

  clippy:
    runs-on: windows-latest
    steps:
      - name: Checkout source code
        uses: actions/checkout@v6

      - name: Install Rust toolchain
        uses: dtolnay/rust-toolchain@stable
        with:
          components: clippy

      - name: Lint Rust code
        run: cargo clippy --all-targets -- -D warnings


================================================
FILE: .gitignore
================================================
/target/
**/*.rs.bk
/wix/
.lock
.wix/
.test**
wix0/
**.profraw

================================================
FILE: Cargo.toml
================================================
[package]
name = "cargo-wix"
description = "Build Windows installers using the WiX Toolset"
version = "0.3.9"
authors = ["Christopher Field <cfield2@gmail.com>"]
license = "MIT/Apache-2.0"
repository = "https://github.com/volks73/cargo-wix"
documentation = "https://volks73.github.io/cargo-wix"
categories = ["development-tools"]
keywords = ["cargo-subcommand", "installer", "wix-toolset", "wix"]
homepage = "https://github.com/volks73/cargo-wix"
readme = "README.md"
edition = "2024"
exclude = ["/.github"]
rust-version = "1.88.0"

[[bin]]
name = "cargo-wix"

[lib]
name = "wix"

[dependencies]
camino = "1"
chrono = "0.4"
clap = { version = "4", features = ["derive"] }
encoding_rs_io = "0.1"
env_logger = "0.11"
itertools = "0.14"
lazy_static = "1"
log = "0.4"
mustache = "0.9"
regex = "1"
rustc-cfg = "0.5"
semver = "1"
sxd-document = "0.3"
sxd-xpath = "0.4"
termcolor = "1"
uuid = { version = "1", features = ["v4"] }
cargo_metadata = "0.23"
serde_json = "1"

[dev-dependencies]
assert_fs = "1"
maplit = "1"
predicates = "3"
serial_test = "3"
toml = "1"

[workspace]
members = [
    "xtask"
]

[badges]
is-it-maintained-issue-resolution = { repository = "volks73/cargo-wix" }
is-it-maintained-open-issues = { repository = "volks73/cargo-wix" }


================================================
FILE: LICENSE-APACHE
================================================
                              Apache License
                        Version 2.0, January 2004
                     http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

   "License" shall mean the terms and conditions for use, reproduction,
   and distribution as defined by Sections 1 through 9 of this document.

   "Licensor" shall mean the copyright owner or entity authorized by
   the copyright owner that is granting the License.

   "Legal Entity" shall mean the union of the acting entity and all
   other entities that control, are controlled by, or are under common
   control with that entity. For the purposes of this definition,
   "control" means (i) the power, direct or indirect, to cause the
   direction or management of such entity, whether by contract or
   otherwise, or (ii) ownership of fifty percent (50%) or more of the
   outstanding shares, or (iii) beneficial ownership of such entity.

   "You" (or "Your") shall mean an individual or Legal Entity
   exercising permissions granted by this License.

   "Source" form shall mean the preferred form for making modifications,
   including but not limited to software source code, documentation
   source, and configuration files.

   "Object" form shall mean any form resulting from mechanical
   transformation or translation of a Source form, including but
   not limited to compiled object code, generated documentation,
   and conversions to other media types.

   "Work" shall mean the work of authorship, whether in Source or
   Object form, made available under the License, as indicated by a
   copyright notice that is included in or attached to the work
   (an example is provided in the Appendix below).

   "Derivative Works" shall mean any work, whether in Source or Object
   form, that is based on (or derived from) the Work and for which the
   editorial revisions, annotations, elaborations, or other modifications
   represent, as a whole, an original work of authorship. For the purposes
   of this License, Derivative Works shall not include works that remain
   separable from, or merely link (or bind by name) to the interfaces of,
   the Work and Derivative Works thereof.

   "Contribution" shall mean any work of authorship, including
   the original version of the Work and any modifications or additions
   to that Work or Derivative Works thereof, that is intentionally
   submitted to Licensor for inclusion in the Work by the copyright owner
   or by an individual or Legal Entity authorized to submit on behalf of
   the copyright owner. For the purposes of this definition, "submitted"
   means any form of electronic, verbal, or written communication sent
   to the Licensor or its representatives, including but not limited to
   communication on electronic mailing lists, source code control systems,
   and issue tracking systems that are managed by, or on behalf of, the
   Licensor for the purpose of discussing and improving the Work, but
   excluding communication that is conspicuously marked or otherwise
   designated in writing by the copyright owner as "Not a Contribution."

   "Contributor" shall mean Licensor and any individual or Legal Entity
   on behalf of whom a Contribution has been received by Licensor and
   subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   copyright license to reproduce, prepare Derivative Works of,
   publicly display, publicly perform, sublicense, and distribute the
   Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
   this License, each Contributor hereby grants to You a perpetual,
   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
   (except as stated in this section) patent license to make, have made,
   use, offer to sell, sell, import, and otherwise transfer the Work,
   where such license applies only to those patent claims licensable
   by such Contributor that are necessarily infringed by their
   Contribution(s) alone or by combination of their Contribution(s)
   with the Work to which such Contribution(s) was submitted. If You
   institute patent litigation against any entity (including a
   cross-claim or counterclaim in a lawsuit) alleging that the Work
   or a Contribution incorporated within the Work constitutes direct
   or contributory patent infringement, then any patent licenses
   granted to You under this License for that Work shall terminate
   as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
   Work or Derivative Works thereof in any medium, with or without
   modifications, and in Source or Object form, provided that You
   meet the following conditions:

   (a) You must give any other recipients of the Work or
       Derivative Works a copy of this License; and

   (b) You must cause any modified files to carry prominent notices
       stating that You changed the files; and

   (c) You must retain, in the Source form of any Derivative Works
       that You distribute, all copyright, patent, trademark, and
       attribution notices from the Source form of the Work,
       excluding those notices that do not pertain to any part of
       the Derivative Works; and

   (d) If the Work includes a "NOTICE" text file as part of its
       distribution, then any Derivative Works that You distribute must
       include a readable copy of the attribution notices contained
       within such NOTICE file, excluding those notices that do not
       pertain to any part of the Derivative Works, in at least one
       of the following places: within a NOTICE text file distributed
       as part of the Derivative Works; within the Source form or
       documentation, if provided along with the Derivative Works; or,
       within a display generated by the Derivative Works, if and
       wherever such third-party notices normally appear. The contents
       of the NOTICE file are for informational purposes only and
       do not modify the License. You may add Your own attribution
       notices within Derivative Works that You distribute, alongside
       or as an addendum to the NOTICE text from the Work, provided
       that such additional attribution notices cannot be construed
       as modifying the License.

   You may add Your own copyright statement to Your modifications and
   may provide additional or different license terms and conditions
   for use, reproduction, or distribution of Your modifications, or
   for any such Derivative Works as a whole, provided Your use,
   reproduction, and distribution of the Work otherwise complies with
   the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
   any Contribution intentionally submitted for inclusion in the Work
   by You to the Licensor shall be under the terms and conditions of
   this License, without any additional terms or conditions.
   Notwithstanding the above, nothing herein shall supersede or modify
   the terms of any separate license agreement you may have executed
   with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
   names, trademarks, service marks, or product names of the Licensor,
   except as required for reasonable and customary use in describing the
   origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
   agreed to in writing, Licensor provides the Work (and each
   Contributor provides its Contributions) on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
   implied, including, without limitation, any warranties or conditions
   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
   PARTICULAR PURPOSE. You are solely responsible for determining the
   appropriateness of using or redistributing the Work and assume any
   risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
   whether in tort (including negligence), contract, or otherwise,
   unless required by applicable law (such as deliberate and grossly
   negligent acts) or agreed to in writing, shall any Contributor be
   liable to You for damages, including any direct, indirect, special,
   incidental, or consequential damages of any character arising as a
   result of this License or out of the use or inability to use the
   Work (including but not limited to damages for loss of goodwill,
   work stoppage, computer failure or malfunction, or any and all
   other commercial damages or losses), even if such Contributor
   has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
   the Work or Derivative Works thereof, You may choose to offer,
   and charge a fee for, acceptance of support, warranty, indemnity,
   or other liability obligations and/or rights consistent with this
   License. However, in accepting such obligations, You may act only
   on Your own behalf and on Your sole responsibility, not on behalf
   of any other Contributor, and only if You agree to indemnify,
   defend, and hold each Contributor harmless for any liability
   incurred by, or claims asserted against, such Contributor by reason
   of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

   To apply the Apache License to your work, attach the following
   boilerplate notice, with the fields enclosed by brackets "[]"
   replaced with your own identifying information. (Don't include
   the brackets!)  The text should be enclosed in the appropriate
   comment syntax for the file format. We also recommend that a
   file or class name and description of purpose be included on the
   same "printed page" as the copyright notice for easier
   identification within third-party archives.

Copyright 2017 Christopher R. Field

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

	http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.


================================================
FILE: LICENSE-MIT
================================================
Copyright (c) 2017 Christopher R. Field

Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
# cargo-wix: A cargo subcommand to create Windows installers

A subcommand for [Cargo] that builds a Windows installer (MSI) using the [WiX
Toolset] from the build of a [Rust] binary project. It also supports signing the
Windows installer if a code signing certificate is available using the
[SignTool] application available in the [Windows SDK].

[![Crates.io](https://img.shields.io/crates/v/cargo-wix.svg)](https://crates.io/crates/cargo-wix)
[![GitHub release](https://img.shields.io/github/release/volks73/cargo-wix.svg)](https://github.com/volks73/cargo-wix/releases)
[![Crates.io](https://img.shields.io/crates/l/cargo-wix.svg)](https://github.com/volks73/cargo-wix#license)
[![Build Status](https://github.com/volks73/cargo-wix/actions/workflows/ci.yml/badge.svg)](https://github.com/volks73/cargo-wix/actions/workflows/ci.yml)

## Quick Start

Start a command prompt (cmd.exe) and then execute the following commands:

```dos
C:\>cargo install cargo-wix
C:\>cd Path\To\Project
C:\Path\To\Project\>cargo wix init
C:\Path\To\Project\>cargo wix
```

The Windows installer (MSI) for the project will be in the
`C:\Path\To\Project\target\wix` folder. Please see the [Documentation] for more
advanced usage, configuration, and customization.

## Installation

The cargo-wix project can be installed on any platform supported by the Rust
programming language, but the [WiX Toolset] is Windows only; thus, this project is
only useful when installed on a Windows machine. Ensure the following
dependencies are installed before proceeding. 

>[!NOTE]
>Cargo is installed automatically when installing the Rust programming language.
>The `stable-x86_64-pc-windows-msvc` toolchain is recommended.

- [Cargo]
- [Rust v1.88.0 or newer](https://www.rust-lang.org)
- [WiX Toolset] [v3.14.1](https://github.com/wixtoolset/wix3/releases/tag/wix3141rtm) or [newer](https://github.com/wixtoolset/wix/releases)
- [Windows SDK] (Optional), needed for signing the installer

>[!IMPORTANT]
>The [WiX Toolset] is available in two different variants: [Legacy] (v3.14.1) and
>[Modern] (v4+). The Legacy variant uses a two-stage approach with a compiler,
>`candle.exe`, and a linker, `light.exe`. The Modern variant uses a single stage
>approach with a single executable, `wix.exe`, and a new XML schema and
>namespace. The Legacy variant is no longer supported by the WiX Toolset
>developers, [FireGiant]. Both variants are supported by the cargo-wix project
>and the `cargo wix` subcommand, but usage of the Legacy variant is currently the
>default.

>[!WARNING]
>As of April 3rd, 2026, the `windows-latest` GitHub Action image still only
>contains the [Legacy] variant, v3.14.1, of the WiX Toolset. If the [Modern] variant,
>v4+, of the WiX Toolset is desired, then a newer version will needed to be
>explicitly installed as a step in the action _before_ any `cargo wix` commands.

>[!WARNING]
>As of April 3rd, 2026, the GitHub Action Windows 11 ARM64 runner image does not
>have the [WiX Toolset] installed. The [Legacy] or [Modern] variants will have
>to be explicitly installed as a step in the action _before_ any `cargo wix`
>commands. See <https://github.com/actions/partner-runner-images/blob/main/images/arm-windows-11-image.md#omitted-software>.

Once the prerequisites have been installed, execute the following command to
install the `cargo wix` subcommand.

```dos
C:\> cargo install cargo-wix
```

## Usage

Start a command prompt, such as `cmd.exe`, the [Developer Prompt] installed with
the [Build Tools for Visual Studio 2026], [Windows Terminal] with [Powershell],
or [git bash], and navigate to the project's root folder. Run the subcommand:

```dos
C:\Path\to\Project> cargo wix init
```

This will create the `wix` folder in the project's root (along side the
`Cargo.toml` file) and then it will create the `wix\main.wxs` file from the WiX
Source (wxs) embedded within the subcommand. The generated `wix\main.wxs` file
can be used without modification with the following command to create an
installer for the project:

```dos
C:\Path\to\Project> cargo wix
```

The `cargo wix` subcommand without any arguments searches for a `wix\main.wxs`
file, relative to the project's root. It will compile the `wix\main.wxs` file
and then link the object file (`target\wix\build\main.wixobj`) to create the
Windows installer (MSI). The installer will be located in the `target\wix`
folder. All artifacts of the installer compilation and linking process are
placed within the `target\wix` folder. Paths in the `wix\main.wxs` file should
be relative to the project's root, i.e. the same location as the `Cargo.toml`
manifest file. 

A different WiX Source (wxs) file from the `wix\main.wxs` file can be used by
specifying a path to it as an argument to the subcommand as follows:

```dos
C:\Path\to\Project> cargo wix Path\to\WiX\Source\File.wxs
```

You can also automatically run the installer after creating it by specifying the
`--install` argument:

```dos
C:\Path\to\Project> cargo wix --install
```

The `print <template>` subcommand, which prints one of the embedded templates to
stdout, can be used to create the `main.wxs` file. A [WXS template] file
specifically designed to work with this subcommand is embedded within the
`cargo-wix` binary during installation. Use the following commands to create a
WiX Source file and use it to create an installer with this subcommand.

```dos
C:\Path\to\Project> cargo wix print wxs > example.wxs
C:\Path\to\Project> cargo wix example.wxs
```

The WiX source file can be customized using a text editor, but modification of
the XML preprocessor variables should be avoided to ensure the `cargo wix`
command works properly. 

To sign the installer (MSI) as part of the build process, ensure the `signtool`
command is available in the `PATH` system environment variable or use the
[Developer Prompt] that was installed with the Windows SDK, and use the `sign`
sub-subcommand as follows: 

```dos
C:\Path\to\Project> cargo wix sign
```

Use the `-h,--help` flag to display information about additional options and
features.

```dos
C:\Path\to\Project> cargo wix -h
```

## Tests

There are set environment variables that can be used to help debug a failing
test. The `CARGO_WIX_TEST_PERSIST` environment variable can be set to persist
the temporary directories that are created during integration tests. This allows
the developer to inspect the contents of the temporary directory. The
`CARGO_WIX_TEST_PERSIST` environment variable accepts any value. Unsetting the
environment variable will delete the temporary directories after each test. 

The `CARGO_WIX_TEST_LOG` environment variable sets the log level while running
an integration test. It accepts an integer value between 0 and 5, with 0 turning
off logging, and 5 displaying all log statements (ERROR, WARN, INFO, DEBUG, and
TRACE). Log statements are __not__ captured during tests, so this environment
variable should be used only when running an integration test in isolation to
prevent "swampping" the terminal/console with statements. 

Finally, the `CARGO_WIX_TEST_NO_CAPTURE` environment variable accepts any value
and will display the output from the WiX Toolset compiler (candle.exe) and
linker (light.exe) when running an integration test. Similar to the
`CARGO_WIX_TEST_LOG` environment variable, this variable should only be used in
isolation to prevent "swamping" the terminal/console with the output from the
WiX Toolset commands. By default, the output is captured by the _test_ not
cargo's test framework; thus, the `cargo test -- --nocapture` command has no
affect. Example of setting and unsetting all of the environment variables for
running a specific test:

```dos
C:\Path\to\Cargo\Wix> set CARGO_WIX_TEST_PERSIST=1
C:\Path\to\Cargo\Wix> set CARGO_WIX_TEST_LOG=5
C:\Path\to\Cargo\Wix> set CARGO_WIX_TEST_NO_CAPTURE=1
C:\Path\to\Cargo\Wix> cargo test <TEST NAME>
C:\Path\to\Cargo\Wix> set "CARGO_WIX_TEST_NO_CAPTURE="
C:\Path\to\Cargo\Wix> set "CARGO_WIX_TEST_LOG="
C:\Path\to\Cargo\Wix> set "CARGO_WIX_TEST_PERSIST="
```

where `<TEST NAME>` is replaced with the name of an integration test. The last
three lines/commands are optional and unsets the three environment variables to
avoid additional tests from also persisting, logging, and dumping output to the
terminal/console. 

>[!NOTE]
>The `-- --nocapture` option is _not_ needed to display the logging
>statements or the output from the WiX Toolset compiler (candle.exe) and linker
>(light.exe). 

Here is the same example with [Powershell]:

```powershell
PS C:\Path\to\Cargo\Wix> $env:CARGO_WIX_TEST_PERSIST=1; $env:CARGO_WIX_TEST_LOG=5; $env:CARGO_WIX_TEST_NO_CAPTURE=1; 
PS C:\Path\to\Cargo\Wix> cargo test <TEST NAME>
PS C:\Path\to\Cargo\Wix> Remove-Item Env:\CARGO_WIX_TEST_PERSIST; Remove-Item Env:\CARGO_WIX_TEST_LOG; Remove-Item Env:\CARGO_WIX_TEST_NO_CAPTURE
```

## License

The `cargo-wix` project is licensed under either the [MIT license] or [Apache
2.0 license]. See the [LICENSE-MIT] or [LICENSE-APACHE] files for more
information about licensing and copyright.

[apache 2.0 license]: http://www.apache.org/licenses/LICENSE-2.0
[build tools for visual studio 2026]: https://visualstudio.microsoft.com/downloads/
[cargo]: http://doc.crates.io/
[developer prompt]: https://learn.microsoft.com/en-us/visualstudio/ide/reference/command-prompt-powershell
[documentation]: https://volks73.github.io/cargo-wix/cargo_wix/index.html
[firegiant]: https://www.firegiant.com
[git bash]: https://gitforwindows.org/
[legacy]: https://github.com/wixtoolset/wix3/releases/tag/wix3141rtm
[license-apache]: https://github.com/volks73/cargo-wix/blob/main/LICENSE-APACHE
[license-mit]: https://github.com/volks73/cargo-wix/blob/main/LICENSE-MIT
[mit license]: https://opensource.org/licenses/MIT
[modern]: https://github.com/wixtoolset/wix/releases
[powershell]: https://learn.microsoft.com/en-us/powershell/
[rust]: https://www.rust-lang.org
[signtool]: https://learn.microsoft.com/en-us/windows/win32/seccrypto/signtool
[windows sdk]: https://learn.microsoft.com/en-us/windows/apps/windows-sdk/downloads
[windows terminal]: https://learn.microsoft.com/en-us/windows/terminal/install
[wix toolset]: http://wixtoolset.org/
[wxs template]: https://github.com/volks73/cargo-wix/blob/main/src/templates/main.v3.wxs.mustache


================================================
FILE: src/clean.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `clean` command. This command is focused on
//! cleaning up build output, similar to the `cargo clean` subcommand.

use crate::Result;
use crate::WIX;

use log::{debug, info, trace, warn};

use std::fs;
use std::path::{Path, PathBuf};

/// A builder for creating an execution context to clean a package of WiX
/// Toolset-related output.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    input: Option<&'a str>,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder { input: None }
    }

    /// Sets the path to a package's manifest (Cargo.toml) to be cleaned.
    ///
    /// The default is to use the current working directory if a Cargo.toml file
    /// is found.
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Builds an execution context to clean the package of WiX Toolset-related
    /// output.
    pub fn build(&mut self) -> Execution {
        Execution {
            input: self.input.map(PathBuf::from),
        }
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for removing WiX Toolset-related output from a package.
#[derive(Debug)]
pub struct Execution {
    input: Option<PathBuf>,
}

impl Execution {
    /// Removes WiX Toolset-related output from the package's `target` folder.
    ///
    /// This is similar to the `cargo clean` subcommand.
    pub fn run(self) -> Result<()> {
        debug!("input = {:?}", self.input);
        let manifest = super::manifest(self.input.as_ref())?;
        debug!("target_directory = {:?}", manifest.target_directory);
        let target_wix = self.target_wix(manifest.target_directory.as_std_path());
        debug!("target_wix = {:?}", target_wix);
        if target_wix.exists() {
            trace!("The 'target\\wix' folder exists");
            warn!("Removing the 'target\\wix' folder");
            fs::remove_dir_all(target_wix)?;
        } else {
            trace!("The 'target\\wix' folder does not exist");
            info!("Nothing to clean");
        }
        Ok(())
    }

    fn target_wix(&self, target_directory: &Path) -> PathBuf {
        target_directory.join(WIX)
    }
}

impl Default for Execution {
    fn default() -> Self {
        Builder::new().build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    mod builder {
        use super::*;

        #[test]
        fn input_works() {
            const EXPECTED: &str = "C:\\Cargo.toml";
            let mut actual = Builder::default();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }
    }

    mod execution {
        extern crate assert_fs;

        use super::*;
        use std::env;
        use std::fs::File;

        #[test]
        fn target_wix_works() {
            let mut cwd = env::current_dir().expect("Current Working Directory");
            let actual = Execution::default().target_wix(&cwd.join("target"));
            cwd.push("target");
            cwd.push(WIX);
            assert_eq!(actual, cwd);
        }

        #[test]
        fn target_wix_with_existing_cargo_toml_works() {
            let temp_dir = assert_fs::TempDir::new().unwrap();
            let cargo_toml_path = temp_dir.path().join("Cargo.toml");
            let target = temp_dir.path().join("target");
            let expected = target.join(WIX);
            let _non_cargo_toml_handle = File::create(&cargo_toml_path).expect("Create file");
            let actual = Builder::new()
                .input(cargo_toml_path.to_str())
                .build()
                .target_wix(&target);
            assert_eq!(actual, expected);
        }
    }
}


================================================
FILE: src/create.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `create`, or default, command. The default
//! command, `cargo wix`, is focused on creating, or building, the installer
//! using the WiX Toolset.
//!
//! Generally, this involves locating the WiX Source file (wxs) and passing
//! options and flags to the WiX Toolset's compiler (`candle.exe`) and linker
//! (`light.exe`). By default, it looks for a `wix\main.wxs` file relative to
//! the root of the package's manifest (Cargo.toml). A different WiX Source file
//! can be set with the `input` method using the `Builder` struct.
//!
//! When using the modern WiX Toolset (v4+) via `--toolset modern`, the build
//! uses `wix build` instead of the separate compile and link steps. The
//! `--migrate` flag can be used to automatically convert WiX v3 source files
//! and install required extension packages before building.

use crate::BINARY_FOLDER_NAME;
use crate::CARGO;
use crate::Cultures;
use crate::EXE_FILE_EXTENSION;
use crate::Error;
use crate::MSI_FILE_EXTENSION;
use crate::MSIEXEC;
use crate::Result;
use crate::WIX;
use crate::WIX_COMPILER;
use crate::WIX_LINKER;
use crate::WIX_MODERN_TOOLSET;
use crate::WIX_OBJECT_FILE_EXTENSION;
use crate::WIX_PATH_KEY;
use crate::WixArch;
use crate::toolset::Includes;
use crate::toolset::ProjectProvider;
use crate::toolset::Toolset;
use crate::toolset::ToolsetSetupMode;
use itertools::Itertools;
use log::error;
use log::{debug, info, trace, warn};

use semver::Version;

use std::convert::TryFrom;
use std::env;
use std::ffi::OsString;
use std::fmt;
use std::io::{ErrorKind, Read};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::str::FromStr;

use cargo_metadata::Package;

use rustc_cfg::Cfg;

use serde_json::Value;

/// A builder for running the `cargo wix` subcommand.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    bin_path: Option<&'a str>,
    capture_output: bool,
    compiler_args: Option<Vec<&'a str>>,
    culture: Option<&'a str>,
    debug_build: bool,
    profile: Option<&'a str>,
    debug_name: bool,
    includes: Option<Vec<&'a str>>,
    input: Option<&'a str>,
    linker_args: Option<Vec<&'a str>>,
    locale: Option<&'a str>,
    name: Option<&'a str>,
    no_build: bool,
    target_bin_dir: Option<&'a str>,
    install: bool,
    output: Option<&'a str>,
    package: Option<&'a str>,
    target: Option<&'a str>,
    version: Option<&'a str>,
    toolset: Toolset,
    toolset_setup_mode: ToolsetSetupMode,
    // toolset_restore: bool,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder {
            bin_path: None,
            capture_output: true,
            compiler_args: None,
            culture: None,
            debug_build: false,
            profile: None,
            debug_name: false,
            includes: None,
            input: None,
            linker_args: None,
            locale: None,
            name: None,
            no_build: false,
            install: false,
            target_bin_dir: None,
            output: None,
            package: None,
            target: None,
            version: None,
            toolset: Toolset::Legacy,
            toolset_setup_mode: ToolsetSetupMode::None,
        }
    }

    /// Sets the path to the WiX Toolset's `bin` folder.
    ///
    /// The WiX Toolset's `bin` folder should contain the needed `candle.exe`
    /// and `light.exe` applications. The default is to use the WIX system
    /// environment variable that is created during installation of the WiX
    /// Toolset. This will override any value obtained from the environment.
    pub fn bin_path(&mut self, b: Option<&'a str>) -> &mut Self {
        self.bin_path = b;
        self
    }

    /// Enables or disables capturing of the output from the builder (`cargo`),
    /// compiler (`candle`), linker (`light`), and signer (`signtool`).
    ///
    /// The default is to capture all output, i.e. display nothing in the
    /// console but the log statements.
    pub fn capture_output(&mut self, c: bool) -> &mut Self {
        self.capture_output = c;
        self
    }

    /// Adds an argument to the compiler command.
    ///
    /// This "passes" the argument directly to the WiX compiler (candle.exe).
    /// See the help documentation for the WiX compiler for information about
    /// valid options and flags.
    pub fn compiler_args(&mut self, c: Option<Vec<&'a str>>) -> &mut Self {
        self.compiler_args = c;
        self
    }

    /// Sets the culture to use with the linker (light.exe) for building a
    /// localized installer.
    ///
    /// This value will override any defaults and skip looking for a value in
    /// the `[package.metadata.wix]` section of the package's manifest
    /// (Cargo.toml).
    pub fn culture(&mut self, c: Option<&'a str>) -> &mut Self {
        self.culture = c;
        self
    }

    /// Builds the package with the Debug profile instead of the Release profile.
    ///
    /// See the [Cargo book] for more information about release profiles. The
    /// default is to use the Release profile when creating the installer. This
    /// value is ignored if the `no_build` method is set to `true`.
    ///
    /// [Cargo book]: https://doc.rust-lang.org/book/ch14-01-release-profiles.html
    pub fn debug_build(&mut self, d: bool) -> &mut Self {
        self.debug_build = d;
        self
    }

    /// Appends `-debug` to the file stem for the installer (msi).
    ///
    /// If `true`, then `-debug` is added as suffix to the file stem (string
    /// before the dot and file extension) for the installer's file name. For
    /// example, if `true`, then file name would be
    /// `example-0.1.0-x86_64-debug.msi`. The default is to _not_ append the
    /// `-debug` because the Release profile is the default.
    ///
    /// Generally, this should be used in combination with the `debug_build`
    /// method to indicate the installer is for a debugging variant of the
    /// installed binary.
    pub fn debug_name(&mut self, d: bool) -> &mut Self {
        self.debug_name = d;
        self
    }

    /// Adds multiple WiX Source (wxs) files to the creation of an installer.
    ///
    /// By default, any `.wxs` file located in the project's `wix` folder will
    /// be included in the creation of an installer for the project. This method
    /// adds, or appends, to the list of `.wxs` files. The value is a relative
    /// or absolute path.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn includes(&mut self, i: Option<Vec<&'a str>>) -> &mut Self {
        self.includes = i;
        self
    }

    /// Sets the path to a package's manifest (Cargo.toml) file.
    ///
    /// A package's manifest is used to create an installer. If no path is
    /// specified, then the current working directory (CWD) is used. An error
    /// will occur if there is no `Cargo.toml` file in the CWD or at the
    /// specified path. Either an absolute or relative path is valid.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Adds an argument to the linker command.
    ///
    /// This "passes" the argument directly to the WiX linker (light.exe). See
    /// the help documentation for the WiX compiler for information about valid
    /// options and flags.
    pub fn linker_args(&mut self, l: Option<Vec<&'a str>>) -> &mut Self {
        self.linker_args = l;
        self
    }

    /// Sets the path to a WiX localization file, `.wxl`, for the linker
    /// (light.exe).
    ///
    /// The [WiX localization file] is an XML file that contains localization
    /// strings.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    ///
    /// [WiX localization file]: http://wixtoolset.org/documentation/manual/v3/howtos/ui_and_localization/make_installer_localizable.html
    pub fn locale(&mut self, l: Option<&'a str>) -> &mut Self {
        self.locale = l;
        self
    }

    /// Sets the name.
    ///
    /// The default is to use the `name` field under the `[package]` section of
    /// the package's manifest (Cargo.toml). This overrides that value.
    ///
    /// The installer (msi) that is created will be named in the following
    /// format: "name-major.minor.patch-platform.msi", where _name_ is the value
    /// specified with this method or the value from the `name` field under the
    /// `[package]` section, the _major.minor.patch_ is the version number from
    /// the package's manifest `version` field or the value specified at the
    /// command line, and the _platform_ is either "i686" or "x86_64" depending
    /// on the build environment.
    ///
    /// This does __not__ change the name of the executable that is installed.
    /// The name of the executable can be changed by modifying the WiX Source
    /// (wxs) file with a text editor.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn name(&mut self, p: Option<&'a str>) -> &mut Self {
        self.name = p;
        self
    }

    /// Skips the building of the project with the release profile.
    ///
    /// If `true`, the project will _not_ be built using the release profile,
    /// i.e. the `cargo build --release` command will not be executed. The
    /// default is to build the project before each creation. This is useful if
    /// building the project is more involved or is handled in a separate
    /// process.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn no_build(&mut self, n: bool) -> &mut Self {
        self.no_build = n;
        self
    }

    /// Specifies that binaries should be sourced from the given directory.
    ///
    /// Specifically this sets `CargoTargetBinDir` in wxs templates. It is
    /// intended to be combined with `no_build(true)` to let another tool
    /// orchestrate cargo-wix and handle the builds for it.
    pub fn target_bin_dir(&mut self, p: Option<&'a str>) -> &mut Self {
        self.target_bin_dir = p;
        self
    }

    /// Runs the installer after creating it.
    ///
    /// If `true`, the MSI installer will be created and then launched. This will
    /// automatically open the installation wizard for the project and allow the
    /// user to install it.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn install(&mut self, n: bool) -> &mut Self {
        self.install = n;
        self
    }

    /// Sets the output file and destination.
    ///
    /// The default is to create a MSI file with the
    /// `<product-name>-<version>-<arch>.msi` file name and extension in the
    /// `target\wix` folder. Use this method to override the destination and
    /// file name of the Windows installer.
    ///
    /// If the path is to an existing folder or contains a trailing slash
    /// (forward or backward), then the default MSI file name is used, but the
    /// installer will be available at the specified path. When specifying a
    /// file name and path, the `.msi` file is not required. It will be added
    /// automatically.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn output(&mut self, o: Option<&'a str>) -> &mut Self {
        self.output = o;
        self
    }

    /// Sets the package.
    ///
    /// If the project is organized using a workspace, this selects the package
    /// by name to create an installer. If a workspace is not used, then this
    /// has no effect.
    pub fn package(&mut self, p: Option<&'a str>) -> &mut Self {
        self.package = p;
        self
    }

    /// Sets the build target.
    ///
    /// The default is to use the default target for the environment. Use this
    /// method to change the target for the build and installer creation. The
    /// value should be a string from the `rustc --print target-list` command.
    /// This enables "cross-compilation" of installers similar to the
    /// cross-compilation of Rust code, but only for Windows targets.
    pub fn target(&mut self, v: Option<&'a str>) -> &mut Self {
        self.target = v;
        self
    }

    /// Sets the version.
    ///
    /// This overrides the `version` field of the package's manifest
    /// (Cargo.toml). The version should be in the "Major.Minor.Patch" notation.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn version(&mut self, v: Option<&'a str>) -> &mut Self {
        self.version = v;
        self
    }

    /// Sets the wix toolset to use
    pub fn toolset(&mut self, v: Toolset) -> &mut Self {
        self.toolset = v;
        self
    }

    /// Sets the wix toolset migration setup mode
    pub fn toolset_migration(&mut self, setup: ToolsetSetupMode) -> &mut Self {
        self.toolset_setup_mode = setup;
        self
    }

    /// Builds a context for creating, or building, the installer.
    pub fn build(&mut self) -> Execution {
        Execution {
            bin_path: self.bin_path.map(PathBuf::from),
            capture_output: self.capture_output,
            compiler_args: self
                .compiler_args
                .as_ref()
                .map(|c| c.iter().map(|s| (*s).to_string()).collect()),
            culture: self.culture.map(String::from),
            debug_build: self.debug_build,
            profile: self.profile.map(String::from),
            debug_name: self.debug_name,
            includes: self
                .includes
                .as_ref()
                .map(|v| v.iter().map(&PathBuf::from).collect()),
            input: self.input.map(PathBuf::from),
            linker_args: self
                .linker_args
                .as_ref()
                .map(|l| l.iter().map(|s| (*s).to_string()).collect()),
            locale: self.locale.map(PathBuf::from),
            name: self.name.map(String::from),
            no_build: self.no_build,
            toolset: self.toolset.clone(),
            toolset_setup_mode: self.toolset_setup_mode,
            target_bin_dir: self.target_bin_dir.map(PathBuf::from),
            install: self.install,
            output: self.output.map(String::from),
            package: self.package.map(String::from),
            version: self.version.map(String::from),
            target: self.target.map(String::from),
        }
    }

    pub fn profile(&mut self, profile: Option<&'a str>) -> &mut Self {
        self.profile = profile;
        self
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for creating, or building, an installer.
#[derive(Debug)]
pub struct Execution {
    bin_path: Option<PathBuf>,
    capture_output: bool,
    compiler_args: Option<Vec<String>>,
    culture: Option<String>,
    debug_build: bool,
    profile: Option<String>,
    debug_name: bool,
    includes: Option<Vec<PathBuf>>,
    input: Option<PathBuf>,
    target_bin_dir: Option<PathBuf>,
    linker_args: Option<Vec<String>>,
    locale: Option<PathBuf>,
    name: Option<String>,
    no_build: bool,
    pub(crate) toolset: Toolset,
    toolset_setup_mode: ToolsetSetupMode,
    install: bool,
    output: Option<String>,
    package: Option<String>,
    target: Option<String>,
    version: Option<String>,
}

impl Execution {
    /// Creates, or builds, an installer within a built context.
    #[allow(clippy::cognitive_complexity)]
    pub fn run(self) -> Result<()> {
        debug!("self.bin_path = {:?}", self.bin_path);
        debug!("self.capture_output = {:?}", self.capture_output);
        debug!("self.compiler_args = {:?}", self.compiler_args);
        debug!("self.culture = {:?}", self.culture);
        debug!("self.debug_build = {:?}", self.debug_build);
        debug!("self.profile = {:?}", self.profile);
        debug!("self.debug_name = {:?}", self.debug_name);
        debug!("self.includes = {:?}", self.includes);
        debug!("self.input = {:?}", self.input);
        debug!("self.linker_args = {:?}", self.linker_args);
        debug!("self.locale = {:?}", self.locale);
        debug!("self.name = {:?}", self.name);
        debug!("self.no_build = {:?}", self.no_build);
        debug!("self.target_bin_dir = {:?}", self.target_bin_dir);
        debug!("self.install = {:?}", self.install);
        debug!("self.output = {:?}", self.output);
        debug!("self.package = {:?}", self.package);
        debug!("self.target = {:?}", self.target);
        debug!("self.version = {:?}", self.version);
        let manifest_path = super::cargo_toml_file(self.input.as_ref())?;
        debug!("manifest_path = {:?}", manifest_path);
        let manifest = super::manifest(self.input.as_ref())?;
        debug!("target_directory = {:?}", manifest.target_directory);
        let package = super::package(&manifest, self.package.as_deref())?;
        debug!("package = {:?}", package);
        let metadata = package.metadata.clone();
        debug!("metadata = {:?}", metadata);
        let name = self.name(&package);
        debug!("name = {:?}", name);
        let target = self.target()?;
        debug!("target = {:?}", target);
        let version = self.version(&package)?;
        debug!("version = {:?}", version);
        let compiler_args = self.compiler_args(&metadata);
        debug!("compiler_args = {:?}", compiler_args);
        let culture = self.culture(&metadata)?;
        debug!("culture = {:?}", culture);
        let linker_args = self.linker_args(&metadata);
        debug!("linker_args = {:?}", linker_args);
        let locale = self.locale(&metadata)?;
        debug!("locale = {:?}", locale);
        let profile = self.profile(&metadata);
        debug!("profile = {:?}", profile);
        let debug_name = self.debug_name(&metadata);
        debug!("debug_name = {:?}", debug_name);
        let wxs_sources = self.wxs_sources(&package)?;
        debug!("wxs_sources = {:?}", wxs_sources);
        let wixobj_destination = self.wixobj_destination(manifest.target_directory.as_std_path());
        debug!("wixobj_destination = {:?}", wixobj_destination);
        let no_build = self.no_build(&metadata);
        debug!("no_build = {:?}", no_build);
        let target_bin_dir =
            self.target_bin_dir(manifest.target_directory.as_std_path(), &target, &profile);
        debug!("target_bin_dir = {:?}", target_bin_dir);
        let cfg = Cfg::of(&target.triple).map_err(|e| Error::Generic(e.to_string()))?;
        let wix_arch = WixArch::try_from(&cfg)?;
        debug!("wix_arch = {:?}", wix_arch);

        if no_build {
            // Only warn if the user isn't clearly trying to be in charge of builds
            if self.target_bin_dir.is_none() {
                warn!("Skipped building the binary");
            }
        } else {
            // Build the binary, if a binary been built, then this will essentially do nothing.
            info!("Building the binary");
            let mut builder = Command::new(
                env::var("CARGO")
                    .map(PathBuf::from)
                    .ok()
                    .unwrap_or_else(|| PathBuf::from(CARGO)),
            );
            debug!("builder = {:?}", builder);
            if self.capture_output {
                trace!("Capturing the '{}' output", CARGO);
                builder.stdout(Stdio::null());
                builder.stderr(Stdio::null());
            }
            builder.arg("build");
            builder.arg(format!("--profile={}", profile.name));
            if let Some(target) = &target.arg {
                builder.arg(format!("--target={target}"));
            }
            if let Some(ref package) = self.package {
                builder.arg(format!("--package={package}"));
            }
            builder.arg("--manifest-path").arg(&manifest_path);
            debug!("command = {:?}", builder);
            let status = builder.status()?;
            if !status.success() {
                return Err(Error::Command(
                    CARGO,
                    status.code().unwrap_or(100),
                    self.capture_output,
                ));
            }
        }

        // Compile the installer
        info!("Compiling the installer");

        // Legacy toolset uses `candle` and `light` (compile and link)
        // Modern toolset only uses `wix build`
        let mut compiler = if self.toolset.is_legacy() {
            debug!("Using legacy wix build tools");
            self.toolset.compiler(self.bin_path.clone())?
        } else {
            debug!("Using modern wix build tools");
            self.toolset.wix("build")?
        };
        debug!("compiler = {:?}", compiler);

        if self.capture_output {
            trace!("Capturing the '{}' output", WIX_COMPILER);
            compiler.stdout(Stdio::null());
            compiler.stderr(Stdio::null());
        }
        compiler.arg("-arch").arg(wix_arch.to_string());

        if self.toolset.is_legacy() {
            compiler.arg("-ext").arg("WixUtilExtension");

            if let Some(vendor) = &cfg.target_vendor {
                compiler.arg(format!("-dTargetVendor={vendor}"));
            }
            compiler
                .arg(format!("-dVersion={version}"))
                .arg(format!("-dPlatform={wix_arch}"))
                .arg(format!("-dProfile={}", profile.name))
                .arg(format!("-dTargetEnv={}", cfg.target_env))
                .arg(format!("-dTargetTriple={}", target.triple))
                .arg(format!("-dCargoProfile={}", profile.name))
                .arg({
                    let mut s = OsString::from("-dCargoTargetDir=");
                    s.push(&manifest.target_directory);
                    s
                })
                .arg({
                    let mut s = OsString::from("-dCargoTargetBinDir=");
                    s.push(&target_bin_dir);
                    s
                })
                .arg("-o")
                .arg(&wixobj_destination);
        } else {
            let project = self.toolset_setup_mode.setup(&self, &package, None)?;

            // Determine installer type from wxs content before building
            let pkg_count = project.package_count();
            debug!("pkg_count = {:?}", pkg_count);
            if pkg_count == 0 && !project.is_bundle() {
                return Err(Error::Generic(String::from(
                    "No WiX <Package> or <Bundle> definition was found in any of the \
                     source files. There needs to be at least one package or bundle \
                     definition for the installer to be created.",
                )));
            }
            // `wix build` produces a single output file per invocation.
            // Multiple `<Package>` definitions across source files is not supported.
            if pkg_count > 1 {
                return Err(Error::Generic(format!(
                    "Found {pkg_count} WiX package definitions across the source files. \
                     The modern WiX toolset (wix build) can only produce one installer per \
                     invocation. Please separate your WiX sources so that only one source \
                     file defines a <Package> element, or build each package source separately."
                )));
            }

            let installer_kind = project.installer_kind();
            debug!("installer_kind = {:?}", installer_kind);
            let installer_destination = self.installer_destination(
                &name,
                &version,
                &cfg,
                debug_name,
                &installer_kind,
                &package,
                manifest.target_directory.as_std_path(),
            );
            debug!("installer_destination = {:?}", installer_destination);

            // In WiX v4+, `-d` is a separate flag from the key=value pair
            // (two args: `-d Key=Value`). Legacy candle.exe uses a single arg: `-dKey=Value`.
            if let Some(vendor) = &cfg.target_vendor {
                compiler.arg("-d").arg(format!("TargetVendor={vendor}"));
            }
            compiler
                .arg("-d")
                .arg(format!("Version={version}"))
                .arg("-d")
                .arg(format!("Platform={wix_arch}"))
                .arg("-d")
                .arg(format!("Profile={}", profile.name))
                .arg("-d")
                .arg(format!("TargetEnv={}", cfg.target_env))
                .arg("-d")
                .arg(format!("TargetTriple={}", target.triple))
                .arg("-d")
                .arg(format!("CargoProfile={}", profile.name))
                .arg("-d")
                .arg({
                    let mut s = OsString::from("CargoTargetDir=");
                    s.push(&manifest.target_directory);
                    s
                })
                .arg("-d")
                .arg({
                    let mut s = OsString::from("CargoTargetBinDir=");
                    s.push(&target_bin_dir);
                    s
                });

            // "Linker" flags
            // In WiX v4+, `-pdbtype none` replaces the legacy `light.exe -spdb`
            // flag to suppress PDB generation. The `-culture` flag replaces the legacy `-cultures:{v}`
            // colon-delimited syntax.
            compiler
                .args(["-pdbtype", "none"])
                .arg("-culture")
                .arg(culture.to_string());

            // `wix build -o <path>` infers the output type (msi vs exe) from
            // the file extension. This is unlike legacy `light.exe -out` which accepts a directory.
            compiler.arg("-o").arg(&installer_destination);

            // Applies all `-ext` flags
            project.configure_toolset_extensions(&mut compiler)?;

            if let Some(ref l) = locale {
                trace!("Using the a WiX localization file");
                compiler.arg("-loc").arg(l);
            }
        }

        if let Some(args) = &compiler_args {
            trace!("Appending compiler arguments");
            compiler.args(args);
        }
        if self.toolset.is_modern()
            && let Some(args) = &linker_args
        {
            trace!("Appending linker arguments to wix build");
            compiler.args(args);
        }
        compiler.args(&wxs_sources);
        debug!("command = {:?}", compiler);

        let status = compiler.status().map_err(|err| {
            if err.kind() == ErrorKind::NotFound {
                Error::Generic(format!(
                    "The compiler application ({WIX_COMPILER}) could not be found in the PATH environment \
                    variable. Please check the WiX Toolset (http://wixtoolset.org/) is \
                    installed and check the WiX Toolset's '{BINARY_FOLDER_NAME}' folder has been added to the PATH \
                    system environment variable, the {WIX_PATH_KEY} system environment variable exists, or use \
                    the '-b,--bin-path' command line argument."
                ))
            } else {
                err.into()
            }
        })?;
        if !status.success() {
            error!(
                "Could not execute {}",
                compiler
                    .inner
                    .get_args()
                    .filter_map(|a| a.to_str())
                    .join(" ")
            );
            return Err(Error::Command(
                if self.toolset.is_legacy() {
                    WIX_COMPILER
                } else {
                    WIX_MODERN_TOOLSET
                },
                status.code().unwrap_or(100),
                self.capture_output,
            ));
        }

        if self.toolset.is_modern() {
            // Launch the installer (modern path)
            if self.install {
                info!("Launching the installer");
                let project = self.create_project(&package)?;
                let installer_kind = project.installer_kind();
                let dest = self.installer_destination(
                    &name,
                    &version,
                    &cfg,
                    debug_name,
                    &installer_kind,
                    &package,
                    manifest.target_directory.as_std_path(),
                );
                let status = match installer_kind {
                    InstallerKind::Exe => {
                        // Bundles produce .exe files that are launched directly
                        debug!("Launching bundle installer: {:?}", dest);
                        Command::new(&dest).status()?
                    }
                    InstallerKind::Msi => {
                        // MSI packages are installed via msiexec
                        debug!("Launching MSI installer via msiexec: {:?}", dest);
                        let mut installer = Command::new(MSIEXEC);
                        installer.arg("/i").arg(&dest);
                        installer.status()?
                    }
                };
                if !status.success() {
                    return Err(Error::Command(
                        match installer_kind {
                            InstallerKind::Exe => "bundle",
                            InstallerKind::Msi => MSIEXEC,
                        },
                        status.code().unwrap_or(100),
                        self.capture_output,
                    ));
                }
            }
        }

        // Modern wix no longer requires `light`
        if self.toolset.is_legacy() {
            let wixobj_sources = self.wixobj_sources(&wixobj_destination)?;
            debug!("wixobj_sources = {:?}", wixobj_sources);
            let installer_kind = InstallerKind::try_from(
                wixobj_sources
                    .iter()
                    .map(WixObjKind::try_from)
                    .collect::<Result<Vec<WixObjKind>>>()?,
            )?;
            debug!("installer_kind = {:?}", installer_kind);
            let installer_destination = self.installer_destination(
                &name,
                &version,
                &cfg,
                debug_name,
                &installer_kind,
                &package,
                manifest.target_directory.as_std_path(),
            );
            debug!("installer_destination = {:?}", installer_destination);

            // Link the installer
            info!("Linking the installer");
            let mut linker = self.linker()?;
            debug!("linker = {:?}", linker);
            let base_path = manifest_path.parent().ok_or_else(|| {
                Error::Generic(String::from("The base path for the linker is invalid"))
            })?;
            debug!("base_path = {:?}", base_path);
            if self.capture_output {
                trace!("Capturing the '{}' output", WIX_LINKER);
                linker.stdout(Stdio::null());
                linker.stderr(Stdio::null());
            }
            linker
                .arg("-spdb")
                .arg("-ext")
                .arg("WixUIExtension")
                .arg("-ext")
                .arg("WixUtilExtension")
                .arg(format!("-cultures:{culture}"))
                .arg("-out")
                .arg(&installer_destination)
                .arg("-b")
                .arg(base_path);
            if let Some(l) = locale {
                trace!("Using the a WiX localization file");
                linker.arg("-loc").arg(l);
            }
            if let InstallerKind::Exe = installer_kind {
                trace!("Adding the WixBalExtension for the bundle-based installer");
                linker.arg("-ext").arg("WixBalExtension");
            }
            if let Some(args) = &linker_args {
                trace!("Appending linker arguments");
                linker.args(args);
            }
            linker.args(&wixobj_sources);
            debug!("command = {:?}", linker);
            let status = linker.status().map_err(|err| {
                if err.kind() == ErrorKind::NotFound {
                    Error::Generic(format!(
                        "The linker application ({WIX_LINKER}) could not be found in the PATH environment \
                         variable. Please check the WiX Toolset (http://wixtoolset.org/) is \
                         installed and check the WiX Toolset's '{BINARY_FOLDER_NAME}' folder has been added to the PATH \
                         environment variable, the {WIX_PATH_KEY} system environment variable exists, or use the \
                         '-b,--bin-path' command line argument."
                    ))
                } else {
                    err.into()
                }
            })?;
            if !status.success() {
                return Err(Error::Command(
                    WIX_LINKER,
                    status.code().unwrap_or(100),
                    self.capture_output,
                ));
            }

            // Launch the installer
            if self.install {
                info!("Launching the installer");
                let mut installer = Command::new(MSIEXEC);
                installer.arg("/i").arg(&installer_destination);
                let status = installer.status()?;
                if !status.success() {
                    return Err(Error::Command(
                        MSIEXEC,
                        status.code().unwrap_or(100),
                        self.capture_output,
                    ));
                }
            }
        }

        Ok(())
    }

    fn compiler_args(&self, metadata: &Value) -> Option<Vec<String>> {
        self.compiler_args.to_owned().or_else(|| {
            metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("compiler-args"))
                .and_then(|i| i.as_array())
                .map(|a| {
                    a.iter()
                        .map(|s| s.as_str().map(String::from).unwrap())
                        .collect::<Vec<String>>()
                })
        })
    }

    fn culture(&self, metadata: &Value) -> Result<Cultures> {
        if let Some(culture) = &self.culture {
            Cultures::from_str(culture)
        } else if let Some(pkg_meta_wix_culture) = metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("culture"))
            .and_then(|c| c.as_str())
        {
            Cultures::from_str(pkg_meta_wix_culture)
        } else {
            Ok(Cultures::EnUs)
        }
    }

    fn debug_build(&self, metadata: &Value) -> bool {
        if self.debug_build {
            true
        } else {
            metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("dbg-build"))
                .and_then(|c| c.as_bool())
                .unwrap_or_default()
        }
    }

    fn debug_name(&self, metadata: &Value) -> bool {
        if self.debug_name {
            true
        } else {
            metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("dbg-name"))
                .and_then(|c| c.as_bool())
                .unwrap_or_default()
        }
    }

    /// Get the name of the cargo build profile
    ///
    /// If `profile` is set, prefer that.
    /// Otherwise use `debug_build` to choose if we're debug or release.
    fn profile_name(&self, metadata: &Value) -> String {
        if let Some(profile) = self.profile.clone() {
            profile
        } else if let Some(pkg_meta_wix_profile) = metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("profile"))
            .and_then(|c| c.as_str())
        {
            pkg_meta_wix_profile.to_owned()
        } else if self.debug_build(metadata) {
            // The default "debug" build profile is called "dev" for whatever reason
            "dev".to_owned()
        } else {
            "release".to_owned()
        }
    }

    /// Gets the name and dir of the cargo build profile
    fn profile(&self, metadata: &Value) -> Profile {
        let name = self.profile_name(metadata);

        // Figure out what subdir of target will contain our output
        // Cargo specially maps the builtin profile names to "debug" or "release"
        // in the target directory, but custom profiles get forwarded verbatim.
        let dir = match &*name {
            "dev" | "test" => "debug",
            "release" | "bench" => "release",
            p => p,
        }
        .to_owned();

        Profile { name, dir }
    }

    #[allow(clippy::too_many_arguments)]
    fn installer_destination(
        &self,
        name: &str,
        version: &str,
        cfg: &Cfg,
        debug_name: bool,
        installer_kind: &InstallerKind,
        package: &Package,
        target_directory: &Path,
    ) -> PathBuf {
        let filename = if debug_name {
            format!(
                "{}-{}-{}-debug.{}",
                name, version, cfg.target_arch, installer_kind
            )
        } else {
            format!(
                "{}-{}-{}.{}",
                name, version, cfg.target_arch, installer_kind
            )
        };
        if let Some(ref path_str) = self.output {
            trace!("Using the explicitly specified output path for the MSI destination");
            let path = Path::new(path_str);
            if path_str.ends_with('/') || path_str.ends_with('\\') || path.is_dir() {
                path.join(filename)
            } else {
                path.to_owned()
            }
        } else if let Some(pkg_meta_wix_output) = package
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("output"))
            .and_then(|o| o.as_str())
        {
            trace!("Using the output path in the package's metadata for the MSI destination");
            let path = Path::new(pkg_meta_wix_output);
            if pkg_meta_wix_output.ends_with('/')
                || pkg_meta_wix_output.ends_with('\\')
                || path.is_dir()
            {
                path.join(filename)
            } else {
                path.to_owned()
            }
        } else {
            trace!(
                "Using the package's manifest (Cargo.toml) file path to specify the MSI destination"
            );
            target_directory.join(WIX).join(filename)
        }
    }

    fn linker(&self) -> Result<Command> {
        if let Some(mut path) = self.bin_path.as_ref().map(|s| {
            let mut p = PathBuf::from(s);
            trace!(
                "Using the '{}' path to the WiX Toolset '{}' folder for the linker",
                p.display(),
                BINARY_FOLDER_NAME
            );
            p.push(WIX_LINKER);
            p.set_extension(EXE_FILE_EXTENSION);
            p
        }) {
            if !path.exists() {
                path.pop(); // Remove the 'light' application from the path
                Err(Error::Generic(format!(
                    "The linker application ('{}') does not exist at the '{}' path specified via \
                     the '-b,--bin-path' command line argument. Please check the path is correct \
                     and the linker application exists at the path.",
                    WIX_LINKER,
                    path.display()
                )))
            } else {
                Ok(Command::new(path))
            }
        } else if let Some(mut path) = env::var_os(WIX_PATH_KEY).map(|s| {
            let mut p = PathBuf::from(s);
            trace!(
                "Using the '{}' path to the WiX Toolset's '{}' folder for the linker",
                p.display(),
                BINARY_FOLDER_NAME
            );
            p.push(BINARY_FOLDER_NAME);
            p.push(WIX_LINKER);
            p.set_extension(EXE_FILE_EXTENSION);
            p
        }) {
            if !path.exists() {
                path.pop(); // Remove the `candle` application from the path
                Err(Error::Generic(format!(
                    "The linker application ('{}') does not exist at the '{}' path specified \
                     via the {} environment variable. Please check the path is correct and the \
                     linker application exists at the path.",
                    WIX_LINKER,
                    path.display(),
                    WIX_PATH_KEY
                )))
            } else {
                Ok(Command::new(path))
            }
        } else {
            Ok(Command::new(WIX_LINKER))
        }
    }

    fn linker_args(&self, metadata: &Value) -> Option<Vec<String>> {
        self.linker_args.to_owned().or_else(|| {
            metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("linker-args"))
                .and_then(|i| i.as_array())
                .map(|a| {
                    a.iter()
                        .map(|s| s.as_str().map(String::from).unwrap())
                        .collect::<Vec<String>>()
                })
        })
    }

    fn locale(&self, metadata: &Value) -> Result<Option<PathBuf>> {
        if let Some(locale) = self.locale.as_ref().map(PathBuf::from) {
            if locale.exists() {
                Ok(Some(locale))
            } else {
                Err(Error::Generic(format!(
                    "The '{}' WiX localization file could not be found, or it does not exist. \
                     Please check the path is correct and the file exists.",
                    locale.display()
                )))
            }
        } else if let Some(pkg_meta_wix_locale) = metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("locale"))
            .and_then(|l| l.as_str())
            .map(PathBuf::from)
        {
            Ok(Some(pkg_meta_wix_locale))
        } else {
            Ok(None)
        }
    }

    fn name(&self, package: &Package) -> String {
        if let Some(ref p) = self.name {
            p.to_owned()
        } else if let Some(pkg_meta_wix_name) = package
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("name"))
            .and_then(|n| n.as_str())
            .map(String::from)
        {
            pkg_meta_wix_name
        } else {
            package.name.to_string()
        }
    }

    fn no_build(&self, metadata: &Value) -> bool {
        if self.no_build {
            true
        } else {
            metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("no-build"))
                .and_then(|c| c.as_bool())
                .unwrap_or_default()
        }
    }

    /// Get the value of CargoTargetBinDir
    ///
    /// If it's explicitly set, just use that.
    /// Otherwise compute it from the various relevant settings of a build.
    fn target_bin_dir(
        &self,
        target_directory: &Path,
        target: &Target,
        profile: &Profile,
    ) -> PathBuf {
        // Setting this via [package.metadata.wix] explicitly unsupported to avoid footguns
        if let Some(target_bin_dir) = &self.target_bin_dir {
            target_bin_dir.clone()
        } else {
            let mut bin_path = target_directory.to_owned();
            // Cargo only adds the target to the path if it's explicitly passed via --target
            if let Some(target) = &target.arg {
                bin_path.push(target);
            }
            bin_path.push(&profile.dir);
            bin_path
        }
    }

    // TODO: Change to use --unit-graph feature of cargo once stable. See #124.
    //
    // This does not support default-target. Ideally we would use cargo
    // --unit-graph to figure this out without having to second-guess the
    // compiler. Unfortunately, cargo --unit-graph is unstable.
    fn target(&self) -> Result<Target> {
        if let Some(t) = &self.target {
            Ok(Target {
                triple: t.clone(),
                arg: Some(t.clone()),
            })
        } else {
            let output = Command::new("rustc")
                .args(["--version", "--verbose"])
                .output()?;
            for line in output.stdout.split(|b| *b == b'\n') {
                let mut line_elt = line.splitn(2, |b| *b == b':');
                let first = line_elt.next();
                let second = line_elt.next();
                if let (Some(b"host"), Some(host_triple)) = (first, second) {
                    let s = String::from_utf8(host_triple.to_vec()).map_err(|_| {
                        Error::Generic(
                            "Failed to parse output of the 'rustc --verbose \
                            --version' command: invalid UTF8"
                                .to_string(),
                        )
                    });
                    return Ok(Target {
                        triple: s?.trim().to_string(),
                        arg: None,
                    });
                }
            }
            Err(Error::Generic(
                "Failed to parse output of the 'rustc --verbose --version' \
                command"
                    .to_string(),
            ))
        }
    }

    fn wixobj_destination(&self, target_directory: &Path) -> PathBuf {
        // A trailing slash is needed; otherwise, candle tries to dump the
        // object files to a `target\wix` file instead of dumping the object
        // files in the `target\wix\` folder for the `-out` option. The trailing
        // slash must be done "manually" as a string instead of using the
        // PathBuf API because the PathBuf `push` and/or `join` methods treat a
        // single slash (forward or backward) without a prefix as the root `C:\`
        // or `/` and deletes the full path. This is noted in the documentation
        // for PathBuf, but it was unexpected and kind of annoying because I am
        // not sure how to add a trailing slash in a cross-platform way with
        // PathBuf, not that cargo-wix needs to be cross-platform.
        target_directory.join(WIX).join("")
    }

    fn wixobj_sources(&self, wixobj_dst: &Path) -> Result<Vec<PathBuf>> {
        let wixobj_sources: Vec<PathBuf> = std::fs::read_dir(wixobj_dst)?
            .filter(|r| r.is_ok())
            .map(|r| r.unwrap().path())
            .filter(|p| p.extension().and_then(|s| s.to_str()) == Some(WIX_OBJECT_FILE_EXTENSION))
            .collect();
        if wixobj_sources.is_empty() {
            Err(Error::Generic(String::from("No WiX object files found.")))
        } else {
            Ok(wixobj_sources)
        }
    }

    /// Attempts to convert a Rust SemVer version to the format WiX desires.
    ///
    /// WiX only supports numbers in versions, with a format of "x.x.x.x"
    /// WiX itself requires each component to be an integer from 0 to 65534 (inclusive).
    /// However the first 3 parts are forwarded to Windows as a [ProductVersion][0],
    /// which interprets them as "major.minor.build" and states:
    ///
    /// > The major version and has a maximum value of 255.
    /// > The minor version and has a maximum value of 255.
    /// > The build version or the update version and has a maximum value of 65,535.
    ///
    /// So we take the intersection of these requirements, and shove the rust "major.minor.patch"
    /// format into it. This leaves the more freeform "prerelease" and "build" components of a
    /// SemVer Version to get squeezed into the 4th value.
    ///
    /// The 4th value is seemingly just a bonus value that WiX keeps to itself, so it's not
    /// terribly important that we get it perfect. We therefore attempt to heuritistically
    /// parse out a numeric "prerelease version" based on common formats.
    ///
    /// [0]: https://learn.microsoft.com/en-us/windows/win32/msi/productversion
    fn version(&self, package: &Package) -> Result<String> {
        // Select the version
        let version = if let Some(ref v) = self.version {
            Version::parse(v).map_err(Error::from)?
        } else if let Some(pkg_meta_wix_version) = package
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("version"))
            .and_then(|v| v.as_str())
        {
            Version::parse(pkg_meta_wix_version).map_err(Error::from)?
        } else {
            package.version.clone()
        };

        // validate basic parts
        if version.major > 255 {
            return Err(Error::Generic(format!(
                "The app's major version {} can't be greater than 255 for an msi",
                version.major
            )));
        }
        if version.minor > 255 {
            return Err(Error::Generic(format!(
                "The app's minor version {} can't be greater than 255 for an msi",
                version.minor
            )));
        }
        if version.patch > 65534 {
            return Err(Error::Generic(format!(
                "The app's patch version {} can't be greater than 65534 for an msi",
                version.patch
            )));
        }

        // Attempt to validate + convert the prerelease parts
        let needs_prerelease_handling = !version.build.is_empty() || !version.pre.is_empty();
        if needs_prerelease_handling {
            // This mess is trying 3 approaches in sequence:
            //
            // * parse as if it's `1.2.3-4`
            // * parse as if it's `1.2.3-prerelease.4`
            // * parse as if it's `1.2.3-prerelease+4`
            let bonus = version
                .pre
                .parse::<u64>()
                .or_else(|e| {
                    if let Some((_, dotted)) = version.pre.split_once('.') {
                        dotted.parse::<u64>()
                    } else {
                        Err(e)
                    }
                })
                .or_else(|_| version.build.parse::<u64>());

            let bonus = if let Ok(bonus) = bonus {
                bonus
            } else {
                return Err(Error::Generic(format!(
                    "The app's version {} is a prerelease, but we couldn't convert the prerelease \
                     components to an integer. We recommend a format like 1.2.3-prerelease.4, \
                     as we can map it to the 1.2.3.4 format that works for an msi.",
                    version,
                )));
            };
            if bonus > 65534 {
                return Err(Error::Generic(format!(
                    "The app's prerelease version {} can't be greater than 65534 for an msi",
                    bonus
                )));
            }

            Ok(format!(
                "{}.{}.{}.{}",
                version.major, version.minor, version.patch, bonus
            ))
        } else {
            Ok(format!(
                "{}.{}.{}",
                version.major, version.minor, version.patch
            ))
        }
    }
}

impl Includes for Execution {
    fn includes(&self) -> Option<&Vec<PathBuf>> {
        self.includes.as_ref()
    }
}

impl Default for Execution {
    fn default() -> Self {
        Builder::new().build()
    }
}

/// The kind of WiX Object (wixobj) file.
#[derive(Debug, PartialEq, Eq)]
pub enum WixObjKind {
    /// A WiX Object (wixobj) file that ultimately links back to a WiX Source
    /// (wxs) file with a [`bundle`] tag.
    ///
    /// [`bundle`]: https://wixtoolset.org/documentation/manual/v3/xsd/wix/bundle.html
    Bundle,
    /// A WiX Object (wixobj) file that ultimately links back to a WiX Source
    /// (wxs) file with a [`fragment`] tag.
    ///
    /// [`fragment`]: https://wixtoolset.org/documentation/manual/v3/xsd/wix/fragment.html
    Fragment,
    /// A WiX Object (wixobj) file that ultimately links back to a WiX Source
    /// (wxs) file with a [`product`] tag.
    ///
    /// [`product`]: https://wixtoolset.org/documentation/manual/v3/xsd/wix/product.html
    Product,
}

impl WixObjKind {
    /// Determines if the WiX Object (wixobj) file kind is a [`bundle`].
    ///
    /// # Examples
    ///
    /// A WiX Object (wixobj) file identified as a WXS Source (wxs) file
    /// containing a [`bundle`] tag.
    ///
    /// ```
    /// use wix::create::WixObjKind;
    ///
    /// assert!(WixObjKind::Bundle.is_bundle())
    /// ```
    ///
    /// A WiX Object (wixobj) file identified as a WXS Source (wxs) file
    /// containing a [`product`] tag.
    ///
    /// ```
    /// use wix::create::WixObjKind;
    ///
    /// assert!(!WixObjKind::Product.is_bundle())
    /// ```
    ///
    /// [`bundle`]: https://wixtoolset.org/documentation/manual/v3/xsd/wix/bundle.html
    /// [`product`]: https://wixtoolset.org/documentation/manual/v3/xsd/wix/product.html
    pub fn is_bundle(&self) -> bool {
        match *self {
            Self::Bundle => true,
            Self::Fragment => false,
            Self::Product => false,
        }
    }
}

impl FromStr for WixObjKind {
    type Err = crate::Error;

    fn from_str(value: &str) -> Result<Self> {
        match &*value.to_lowercase() {
            "bundle" => Ok(Self::Bundle),
            "fragment" => Ok(Self::Fragment),
            "product" => Ok(Self::Product),
            v => Err(Self::Err::Generic(format!(
                "Unknown '{v}' tag name from a WiX Object (wixobj) file."
            ))),
        }
    }
}

impl TryFrom<&PathBuf> for WixObjKind {
    type Error = crate::Error;

    fn try_from(path: &PathBuf) -> Result<Self> {
        let file = std::fs::File::open(path)?;
        let mut decoder = encoding_rs_io::DecodeReaderBytes::new(file);
        let mut content = String::new();
        decoder.read_to_string(&mut content)?;
        Self::try_from(content.as_str())
    }
}

impl TryFrom<&str> for WixObjKind {
    type Error = crate::Error;

    fn try_from(content: &str) -> Result<Self> {
        let package = sxd_document::parser::parse(content)?;
        let document = package.as_document();
        let mut context = sxd_xpath::Context::new();
        context.set_namespace("wix", "http://schemas.microsoft.com/wix/2006/objects");
        // The assumption is that the following cannot fail because the path is known to be valid at
        // compile-time.
        let xpath = sxd_xpath::Factory::new()
            .build("/wix:wixObject/wix:section/@type")
            .unwrap()
            .unwrap();
        let value = xpath.evaluate(&context, document.root())?.string();
        Self::from_str(&value)
    }
}

/// The kinds of installers that can be created using the WiX compiler
/// (candle.exe) and linker (light.exe).
#[derive(Debug, Default, PartialEq, Eq)]
pub enum InstallerKind {
    /// An executable is used when an [Installation Package Bundle] is created.
    ///
    /// [Installation Package Bundle]: https://wixtoolset.org/documentation/manual/v3/bundle/
    Exe,
    /// A Microsoft installer. This is the more common and typical installer to be created.
    #[default]
    Msi,
}

impl InstallerKind {
    /// Gets the file extension _without_ the dot separator.
    ///
    /// # Examples
    ///
    /// The extension for an installer of an [Installation Package Bundle]. Also
    /// see the [`EXE_FILE_EXTENSION`] constant.
    ///
    /// ```
    /// use wix::create::InstallerKind;
    ///
    /// assert_eq!(InstallerKind::Exe.extension(), "exe")
    /// ```
    ///
    /// The extension for a typical Microsoft installer. Also see the
    /// [`MSI_FILE_EXTENSION`] constant.
    ///
    /// ```
    /// use wix::create::InstallerKind;
    ///
    /// assert_eq!(InstallerKind::Msi.extension(), "msi")
    /// ```
    ///
    /// [Installation Package Bundle]: https://wixtoolset.org/documentation/manual/v3/bundle/
    /// [`EXE_FILE_EXTENSION`]: lib.html#exe-file-extension
    /// [`MSI_FILE_EXTENSION`]: lib.html#msi-file-extension
    pub fn extension(&self) -> &'static str {
        match *self {
            Self::Exe => EXE_FILE_EXTENSION,
            Self::Msi => MSI_FILE_EXTENSION,
        }
    }
}

impl FromStr for InstallerKind {
    type Err = crate::Error;

    fn from_str(value: &str) -> Result<Self> {
        match &*value.to_lowercase() {
            "exe" => Ok(Self::Exe),
            "msi" => Ok(Self::Msi),
            _ => Err(Self::Err::Generic(format!(
                "Unknown '{value}' file extension for an installer"
            ))),
        }
    }
}

impl fmt::Display for InstallerKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.extension())
    }
}

impl TryFrom<Vec<WixObjKind>> for InstallerKind {
    type Error = crate::Error;

    fn try_from(v: Vec<WixObjKind>) -> Result<Self> {
        v.iter()
            .fold(None, |a, v| match v {
                WixObjKind::Bundle => Some(Self::Exe),
                WixObjKind::Product => a.or(Some(Self::Msi)),
                _ => a,
            })
            .ok_or_else(|| {
                Self::Error::Generic(String::from(
                    "Could not determine the installer kind based on the WiX \
                     object files. There needs to be at least one 'product' or \
                     'bundle' tag in the collective WiX source files (wxs).",
                ))
            })
    }
}

/// Details of the cargo build profile
#[derive(Debug, Clone)]
pub struct Profile {
    /// The name of the profile to pass to `--profile=...`
    name: String,
    /// The name of the subdirectory of the cargo target dir that the profile will get
    dir: String,
}

/// Details of the cargo build target
#[derive(Debug, Clone)]
pub struct Target {
    /// The name of the target triple being built
    triple: String,
    /// If an explicit --target flag is being passed to Cargo, this is it
    arg: Option<String>,
}

#[cfg(test)]
mod tests {
    use super::*;

    mod builder {
        use super::*;

        #[test]
        fn defaults_are_correct() {
            let actual = Builder::new();
            assert!(actual.bin_path.is_none());
            assert!(actual.capture_output);
            assert!(actual.compiler_args.is_none());
            assert!(actual.culture.is_none());
            assert!(!actual.debug_build);
            assert!(!actual.debug_name);
            assert!(actual.includes.is_none());
            assert!(actual.input.is_none());
            assert!(actual.linker_args.is_none());
            assert!(actual.locale.is_none());
            assert!(actual.name.is_none());
            assert!(!actual.no_build);
            assert!(actual.output.is_none());
            assert!(actual.version.is_none());
        }

        #[test]
        fn bin_path_works() {
            const EXPECTED: &str = "C:\\Wix Toolset\\bin";
            let mut actual = Builder::new();
            actual.bin_path(Some(EXPECTED));
            assert_eq!(actual.bin_path, Some(EXPECTED));
        }

        #[test]
        fn target_bin_dir_works() {
            const EXPECTED: &str = "target\\special\\build\\";
            let mut actual = Builder::new();
            actual.target_bin_dir(Some(EXPECTED));
            assert_eq!(actual.target_bin_dir, Some(EXPECTED));
        }

        #[test]
        fn capture_output_works() {
            let mut actual = Builder::new();
            actual.capture_output(false);
            assert!(!actual.capture_output);
        }

        #[test]
        fn compiler_args_with_single_value_works() {
            const EXPECTED: &str = "-nologo";
            let mut actual = Builder::new();
            actual.compiler_args(Some(vec![EXPECTED]));
            assert_eq!(actual.compiler_args, Some(vec![EXPECTED]));
        }

        #[test]
        fn compiler_args_with_multiple_values_works() {
            let expected: Vec<&str> = vec!["-arch", "x86"];
            let mut actual = Builder::new();
            actual.compiler_args(Some(expected.clone()));
            assert_eq!(actual.compiler_args, Some(expected));
        }

        #[test]
        fn culture_works() {
            const EXPECTED: &str = "FrFr";
            let mut actual = Builder::new();
            actual.culture(Some(EXPECTED));
            assert_eq!(actual.culture, Some(EXPECTED));
        }

        #[test]
        fn russian_culture_works() {
            const EXPECTED: &str = "RuRu";
            let mut actual = Builder::new();
            actual.culture(Some(EXPECTED));
            assert_eq!(actual.culture, Some(EXPECTED));
        }

        #[test]
        fn debug_build_works() {
            let mut actual = Builder::new();
            actual.debug_build(true);
            assert!(actual.debug_build);
        }

        #[test]
        fn profile_works() {
            const EXPECTED: &str = "dist";
            let mut actual = Builder::new();
            actual.profile(Some(EXPECTED));
            assert_eq!(actual.profile, Some(EXPECTED));
        }

        #[test]
        fn debug_name_works() {
            let mut actual = Builder::new();
            actual.debug_name(true);
            assert!(actual.debug_name);
        }

        #[test]
        fn includes_works() {
            const EXPECTED: &str = "C:\\tmp\\hello_world\\wix\\main.wxs";
            let mut actual = Builder::new();
            actual.includes(Some(vec![EXPECTED]));
            assert_eq!(actual.includes, Some(vec![EXPECTED]));
        }

        #[test]
        fn input_works() {
            const EXPECTED: &str = "C:\\tmp\\hello_world\\Cargo.toml";
            let mut actual = Builder::new();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }

        #[test]
        fn linker_args_with_single_value_works() {
            const EXPECTED: &str = "-nologo";
            let mut actual = Builder::new();
            actual.linker_args(Some(vec![EXPECTED]));
            assert_eq!(actual.linker_args, Some(vec![EXPECTED]));
        }

        #[test]
        fn linker_args_with_multiple_values_works() {
            let expected: Vec<&str> = vec!["-ext", "HelloExtension"];
            let mut actual = Builder::new();
            actual.linker_args(Some(expected.clone()));
            assert_eq!(actual.linker_args, Some(expected));
        }

        #[test]
        fn locale_works() {
            const EXPECTED: &str = "C:\\tmp\\hello_world\\wix\\main.wxl";
            let mut actual = Builder::new();
            actual.locale(Some(EXPECTED));
            assert_eq!(actual.locale, Some(EXPECTED));
        }

        #[test]
        fn name_works() {
            const EXPECTED: &str = "Name";
            let mut actual = Builder::new();
            actual.name(Some(EXPECTED));
            assert_eq!(actual.name, Some(EXPECTED));
        }

        #[test]
        fn no_build_works() {
            let mut actual = Builder::new();
            actual.no_build(true);
            assert!(actual.no_build);
        }

        #[test]
        fn output_works() {
            const EXPECTED: &str = "C:\\tmp\\hello_world\\output";
            let mut actual = Builder::new();
            actual.output(Some(EXPECTED));
            assert_eq!(actual.output, Some(EXPECTED));
        }

        #[test]
        fn version_works() {
            const EXPECTED: &str = "1.2.3";
            let mut actual = Builder::new();
            actual.version(Some(EXPECTED));
            assert_eq!(actual.version, Some(EXPECTED));
        }

        #[test]
        fn build_with_defaults_works() {
            let mut b = Builder::new();
            let default_execution = b.build();
            assert!(default_execution.bin_path.is_none());
            assert!(default_execution.capture_output);
            assert!(default_execution.compiler_args.is_none());
            assert!(default_execution.culture.is_none());
            assert!(!default_execution.debug_build);
            assert!(!default_execution.debug_name);
            assert!(default_execution.includes.is_none());
            assert!(default_execution.input.is_none());
            assert!(default_execution.linker_args.is_none());
            assert!(default_execution.locale.is_none());
            assert!(default_execution.name.is_none());
            assert!(!default_execution.no_build);
            assert!(default_execution.output.is_none());
            assert!(default_execution.version.is_none());
        }

        #[test]
        fn build_with_all_works() {
            const EXPECTED_BIN_PATH: &str = "C:\\Wix Toolset\\bin";
            const EXPECTED_CULTURE: &str = "FrFr";
            const EXPECTED_COMPILER_ARGS: &str = "-nologo";
            const EXPECTED_INCLUDES: &str = "C:\\tmp\\hello_world\\wix\\main.wxs";
            const EXPECTED_INPUT: &str = "C:\\tmp\\hello_world\\Cargo.toml";
            const EXPECTED_LINKER_ARGS: &str = "-nologo";
            const EXPECTED_LOCALE: &str = "C:\\tmp\\hello_world\\wix\\main.wxl";
            const EXPECTED_NAME: &str = "Name";
            const EXPECTED_OUTPUT: &str = "C:\\tmp\\hello_world\\output";
            const EXPECTED_VERSION: &str = "1.2.3";
            let mut b = Builder::new();
            b.bin_path(Some(EXPECTED_BIN_PATH));
            b.capture_output(false);
            b.culture(Some(EXPECTED_CULTURE));
            b.compiler_args(Some(vec![EXPECTED_COMPILER_ARGS]));
            b.debug_build(true);
            b.debug_name(true);
            b.includes(Some(vec![EXPECTED_INCLUDES]));
            b.input(Some(EXPECTED_INPUT));
            b.linker_args(Some(vec![EXPECTED_LINKER_ARGS]));
            b.locale(Some(EXPECTED_LOCALE));
            b.name(Some(EXPECTED_NAME));
            b.no_build(true);
            b.output(Some(EXPECTED_OUTPUT));
            b.version(Some(EXPECTED_VERSION));
            let execution = b.build();
            assert_eq!(execution.bin_path, Some(PathBuf::from(EXPECTED_BIN_PATH)));
            assert!(!execution.capture_output);
            assert_eq!(
                execution.compiler_args,
                Some(vec![String::from(EXPECTED_COMPILER_ARGS)])
            );
            assert_eq!(execution.culture, Some(String::from(EXPECTED_CULTURE)));
            assert!(execution.debug_build);
            assert!(execution.debug_name);
            assert_eq!(
                execution.includes,
                Some(vec![PathBuf::from(EXPECTED_INCLUDES)])
            );
            assert_eq!(execution.input, Some(PathBuf::from(EXPECTED_INPUT)));
            assert_eq!(
                execution.linker_args,
                Some(vec![String::from(EXPECTED_LINKER_ARGS)])
            );
            assert_eq!(execution.locale, Some(PathBuf::from(EXPECTED_LOCALE)));
            assert_eq!(execution.name, Some(String::from(EXPECTED_NAME)));
            assert!(execution.no_build);
            assert_eq!(execution.output, Some(String::from(EXPECTED_OUTPUT)));
            assert_eq!(execution.version, Some(String::from(EXPECTED_VERSION)));
        }
    }

    mod execution {
        use super::*;

        #[test]
        fn default_profile_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": { }
            }"#;
            let execution = Execution::default();
            let profile = execution.profile(&PKG_META_WIX.parse::<Value>().unwrap());
            assert_eq!(profile.name, "release");
            assert_eq!(profile.dir, "release");
        }

        #[test]
        fn debug_build_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "dbg-build": true
                }
            }"#;
            let execution = Execution::default();
            let profile = execution.profile(&PKG_META_WIX.parse::<Value>().unwrap());
            assert_eq!(profile.name, "dev");
            assert_eq!(profile.dir, "debug");
        }

        #[test]
        fn debug_name_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "dbg-name": true
                }
            }"#;
            let execution = Execution::default();
            let debug_name = execution.debug_name(&PKG_META_WIX.parse::<Value>().unwrap());
            assert!(debug_name);
        }

        #[test]
        fn version_metadata_works() {
            const PKG_META_WIX: &str = r#"
            {
                "name": "Example",
                "version": "0.1.0",
                "authors": ["First Last <first.last@example.com>"],
                "license": "Apache-2.0",

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": "",

                "metadata": {
                    "wix": {
                        "version": "2.1.0"
                    }
                }
            }"#;
            let execution = Execution::default();
            let version = execution
                .version(&serde_json::from_str(PKG_META_WIX).unwrap())
                .unwrap();
            assert_eq!(version, "2.1.0");
        }

        #[test]
        fn profile_metadata_works() {
            const PKG_META_WIX: &str = r#" {
                "wix": {
                    "profile": "dist"
                }
            }"#;
            let execution = Execution::default();
            let profile = execution.profile(&serde_json::from_str(PKG_META_WIX).unwrap());
            assert_eq!(profile.name, "dist");
            assert_eq!(profile.dir, "dist");
        }

        #[test]
        fn version_prerelease_parse_works() {
            const PKG_META_WIX: &str = r#"
            {
                "name": "Example",
                "version": "2.1.0-5",
                "authors": ["First Last <first.last@example.com>"],
                "license": "Apache-2.0",

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": ""
            }"#;
            let execution = Execution::default();
            let version = execution
                .version(&serde_json::from_str(PKG_META_WIX).unwrap())
                .unwrap();
            assert_eq!(version, "2.1.0.5");
        }

        #[test]
        fn version_prerelease_dot_parse_works() {
            const PKG_META_WIX: &str = r#"
            {
                "name": "Example",
                "version": "2.1.0-prerelease.5",
                "authors": ["First Last <first.last@example.com>"],
                "license": "Apache-2.0",

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": ""
            }"#;
            let execution = Execution::default();
            let version = execution
                .version(&serde_json::from_str(PKG_META_WIX).unwrap())
                .unwrap();
            assert_eq!(version, "2.1.0.5");
        }

        #[test]
        fn version_build_parse_works() {
            const PKG_META_WIX: &str = r#"
            {
                "name": "Example",
                "version": "2.1.0-prerelease+5",
                "authors": ["First Last <first.last@example.com>"],
                "license": "Apache-2.0",

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": ""
            }"#;
            let execution = Execution::default();
            let version = execution
                .version(&serde_json::from_str(PKG_META_WIX).unwrap())
                .unwrap();
            assert_eq!(version, "2.1.0.5");
        }

        #[test]
        fn name_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "name": "Example",
                "version": "0.1.0",
                "metadata": {
                    "wix": {
                        "name": "Metadata"
                    }
                },

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": ""
            }"#;
            let execution = Execution::default();
            let name = execution.name(&serde_json::from_str(PKG_META_WIX).unwrap());
            assert_eq!(name, "Metadata".to_owned());
        }

        #[test]
        fn no_build_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "no-build": true
                }
            }"#;
            let execution = Execution::default();
            let no_build = execution.no_build(&PKG_META_WIX.parse::<Value>().unwrap());
            assert!(no_build);
        }

        #[test]
        fn culture_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "culture": "Fr-Fr"
                }
            }"#;
            let execution = Execution::default();
            let culture = execution
                .culture(&PKG_META_WIX.parse::<Value>().unwrap())
                .unwrap();
            assert_eq!(culture, Cultures::FrFr);
        }

        #[test]
        fn locale_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "locale": "wix/French.wxl"
                }
            }"#;
            let execution = Execution::default();
            let locale = execution
                .locale(&PKG_META_WIX.parse::<Value>().unwrap())
                .unwrap();
            assert_eq!(locale, Some(PathBuf::from("wix/French.wxl")));
        }

        #[test]
        fn output_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "name": "Example",
                "version": "0.1.0",
                "authors": ["First Last <first.last@example.com>"],
                "license": "XYZ",

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": "",
                "metadata": {
                    "wix": {
                        "output": "target/wix/test.msi"
                    }
                }
            }"#;
            let execution = Execution::default();
            let output = execution.installer_destination(
                "Different",
                "2.1.0",
                &Cfg::of("x86_64-pc-windows-msvc").unwrap(),
                false,
                &InstallerKind::default(),
                &serde_json::from_str(PKG_META_WIX).unwrap(),
                Path::new("target/"),
            );
            assert_eq!(output, PathBuf::from("target/wix/test.msi"));
        }

        #[test]
        fn include_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "name": "Example",
                "version": "0.1.0",
                "authors": ["First Last <first.last@example.com>"],
                "license": "XYZ",

                "id": "",
                "dependencies": [],
                "targets": [],
                "features": {},
                "manifest_path": "C:\\Cargo.toml",
                "metadata": {
                    "wix": {
                        "include": ["Cargo.toml"]
                    }
                }
            }"#;
            let execution = Execution::default();
            let sources = execution
                .wxs_sources(&serde_json::from_str(PKG_META_WIX).unwrap())
                .unwrap();
            assert_eq!(sources, vec![PathBuf::from("Cargo.toml")]);
        }

        #[test]
        fn compiler_args_override_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "compiler-args": ["-nologo"]
                }
            }"#;
            let mut builder = Builder::default();
            builder.compiler_args(Some(vec!["-ws"]));
            let execution = builder.build();
            let args = execution.compiler_args(&PKG_META_WIX.parse::<Value>().unwrap());
            assert_eq!(args, Some(vec![String::from("-ws")]));
        }

        #[test]
        fn compiler_args_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "compiler-args": ["-nologo", "-ws"]
                }
            }"#;
            let execution = Execution::default();
            let args = execution.compiler_args(&PKG_META_WIX.parse::<Value>().unwrap());
            assert_eq!(
                args,
                Some(vec![String::from("-nologo"), String::from("-ws")])
            );
        }

        #[test]
        fn linker_args_override_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "linker-args": ["-nologo"]
                }
            }"#;
            let mut builder = Builder::default();
            builder.linker_args(Some(vec!["-ws"]));
            let execution = builder.build();
            let args = execution.linker_args(&PKG_META_WIX.parse::<Value>().unwrap());
            assert_eq!(args, Some(vec![String::from("-ws")]));
        }

        #[test]
        fn linker_args_metadata_works() {
            const PKG_META_WIX: &str = r#"{
                "wix": {
                    "linker-args": ["-nologo", "-ws"]
                }
            }"#;
            let execution = Execution::default();
            let args = execution.linker_args(&PKG_META_WIX.parse::<Value>().unwrap());
            assert_eq!(
                args,
                Some(vec![String::from("-nologo"), String::from("-ws")])
            );
        }

        const EMPTY_PKG_META_WIX: &str = r#"{"wix": {}}"#;

        #[test]
        fn culture_works() {
            let execution = Execution::default();
            let culture = execution
                .culture(&EMPTY_PKG_META_WIX.parse::<Value>().unwrap())
                .unwrap();
            assert_eq!(culture, Cultures::EnUs);
        }

        #[test]
        fn locale_works() {
            let execution = Execution::default();
            let locale = execution
                .locale(&EMPTY_PKG_META_WIX.parse::<Value>().unwrap())
                .unwrap();
            assert!(locale.is_none());
        }

        #[test]
        fn no_build_works() {
            let execution = Execution::default();
            let no_build = execution.no_build(&EMPTY_PKG_META_WIX.parse::<Value>().unwrap());
            assert!(!no_build);
        }

        #[test]
        fn target_bin_dir_overwrite_works() {
            const EXPECTED: &str = "C:\\my-app\\fancy\\build";
            let mut builder = Builder::new();
            builder.target_bin_dir(Some(EXPECTED));

            let execution = builder.build();
            let target_directory = PathBuf::from("C:\\my-app\\target");
            let target = execution.target().unwrap();
            let profile = execution.profile(&EMPTY_PKG_META_WIX.parse::<Value>().unwrap());

            let target_bin_dir = execution.target_bin_dir(&target_directory, &target, &profile);
            assert_eq!(target_bin_dir, PathBuf::from(EXPECTED));
        }

        #[test]
        #[cfg(windows)]
        fn target_bin_dir_computation_works() {
            const EXPECTED: &str = "C:\\my-app\\target\\i686-pc-windows-msvc\\release";
            let mut builder = Builder::new();
            builder.target(Some("i686-pc-windows-msvc"));
            builder.profile(Some("bench"));
            let target_directory = PathBuf::from("C:\\my-app\\target");

            let execution = builder.build();
            let target = execution.target().unwrap();
            let profile = execution.profile(&EMPTY_PKG_META_WIX.parse::<Value>().unwrap());

            let target_bin_dir = execution.target_bin_dir(&target_directory, &target, &profile);
            assert_eq!(target_bin_dir, PathBuf::from(EXPECTED));
        }

        #[test]
        fn wixobj_destination_works() {
            let execution = Execution::default();
            assert_eq!(
                execution.wixobj_destination(Path::new("target")),
                PathBuf::from("target").join("wix")
            )
        }
    }

    mod wixobj_kind {
        use super::*;

        // I do not know if any of these XML strings are actually valid WiX
        // Object (wixobj) files. These are just snippets to test the XPath
        // evaluation.

        const PRODUCT_WIXOBJ: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
            <wixObject version="3.0.2002.0" xmlns="http://schemas.microsoft.com/wix/2006/objects">
                <section id="*" type="product"></section>
            </wixObject>"#;

        const BUNDLE_WIXOBJ: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
            <wixObject version="3.0.2002.0" xmlns="http://schemas.microsoft.com/wix/2006/objects">
                <section id="*" type="bundle"></section>
            </wixObject>"#;

        const FRAGMENT_WIXOBJ: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
            <wixObject version="3.0.2002.0" xmlns="http://schemas.microsoft.com/wix/2006/objects">
                <section id="*" type="fragment"></section>
            </wixObject>"#;

        const UNKNOWN_WIXOBJ: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
            <wixObject version="3.0.2002.0" xmlns="http://schemas.microsoft.com/wix/2006/objects">
                <section id="*" type="unknown"></section>
            </wixObject>"#;

        const BUNDLE_AND_PRODUCT_WIXOBJ: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
            <wixObject version="3.0.2002.0" xmlns="http://schemas.microsoft.com/wix/2006/objects">
                <section id="*" type="bundle"></section>
                <section id="*" type="product"></section>
            </wixObject>"#;

        const PRODUCT_AND_FRAGMENT_WIXOBJ: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
            <wixObject version="3.0.2002.0" xmlns="http://schemas.microsoft.com/wix/2006/objects">
                <section id="*" type="product"></section>
                <section id="*" type="fragment"></section>
            </wixObject>"#;

        #[test]
        fn try_from_product_object_works() {
            assert_eq!(
                WixObjKind::try_from(PRODUCT_WIXOBJ),
                Ok(WixObjKind::Product)
            );
        }

        #[test]
        fn try_from_bundle_object_works() {
            assert_eq!(WixObjKind::try_from(BUNDLE_WIXOBJ), Ok(WixObjKind::Bundle));
        }

        #[test]
        fn try_from_fragment_object_works() {
            assert_eq!(
                WixObjKind::try_from(FRAGMENT_WIXOBJ),
                Ok(WixObjKind::Fragment)
            );
        }

        #[test]
        fn try_from_bundle_and_product_object_works() {
            assert_eq!(
                WixObjKind::try_from(BUNDLE_AND_PRODUCT_WIXOBJ),
                Ok(WixObjKind::Bundle)
            );
        }

        #[test]
        fn try_from_product_and_fragment_object_works() {
            assert_eq!(
                WixObjKind::try_from(PRODUCT_AND_FRAGMENT_WIXOBJ),
                Ok(WixObjKind::Product)
            );
        }

        #[test]
        #[should_panic]
        fn try_from_unknown_object_fails() {
            WixObjKind::try_from(UNKNOWN_WIXOBJ).unwrap();
        }
    }

    mod installer_kind {
        use super::*;

        #[test]
        fn try_from_wixobj_single_product_works() {
            assert_eq!(
                InstallerKind::try_from(vec![WixObjKind::Product]),
                Ok(InstallerKind::Msi)
            )
        }

        #[test]
        fn try_from_wixobj_single_bundle_works() {
            assert_eq!(
                InstallerKind::try_from(vec![WixObjKind::Bundle]),
                Ok(InstallerKind::Exe)
            )
        }

        #[test]
        #[should_panic]
        fn try_from_wixobj_single_fragment_fails() {
            InstallerKind::try_from(vec![WixObjKind::Fragment]).unwrap();
        }

        #[test]
        #[should_panic]
        fn try_from_wixobj_multiple_fragments_fails() {
            InstallerKind::try_from(vec![
                WixObjKind::Fragment,
                WixObjKind::Fragment,
                WixObjKind::Fragment,
            ])
            .unwrap();
        }

        #[test]
        fn try_from_wixobj_product_and_bundle_works() {
            assert_eq!(
                InstallerKind::try_from(vec![WixObjKind::Product, WixObjKind::Bundle]),
                Ok(InstallerKind::Exe)
            )
        }

        #[test]
        fn try_from_wixobj_multiple_products_and_single_bundle_works() {
            assert_eq!(
                InstallerKind::try_from(vec![
                    WixObjKind::Product,
                    WixObjKind::Product,
                    WixObjKind::Bundle,
                    WixObjKind::Product
                ]),
                Ok(InstallerKind::Exe)
            )
        }

        #[test]
        fn try_from_wixobj_multiple_fragments_and_single_product_works() {
            assert_eq!(
                InstallerKind::try_from(vec![
                    WixObjKind::Fragment,
                    WixObjKind::Fragment,
                    WixObjKind::Product,
                    WixObjKind::Fragment
                ]),
                Ok(InstallerKind::Msi)
            )
        }

        #[test]
        fn try_from_wixobj_multiple_fragments_and_single_bundle_works() {
            assert_eq!(
                InstallerKind::try_from(vec![
                    WixObjKind::Fragment,
                    WixObjKind::Fragment,
                    WixObjKind::Bundle,
                    WixObjKind::Fragment
                ]),
                Ok(InstallerKind::Exe)
            )
        }

        #[test]
        fn try_from_wixobj_multiple_fragments_and_products_works() {
            assert_eq!(
                InstallerKind::try_from(vec![
                    WixObjKind::Fragment,
                    WixObjKind::Fragment,
                    WixObjKind::Product,
                    WixObjKind::Fragment,
                    WixObjKind::Product
                ]),
                Ok(InstallerKind::Msi)
            )
        }

        #[test]
        fn try_from_wixobj_multiple_products_and_bundles_works() {
            assert_eq!(
                InstallerKind::try_from(vec![
                    WixObjKind::Product,
                    WixObjKind::Product,
                    WixObjKind::Bundle,
                    WixObjKind::Product,
                    WixObjKind::Bundle,
                    WixObjKind::Product
                ]),
                Ok(InstallerKind::Exe)
            )
        }

        #[test]
        fn try_from_wixobj_multiple_products_fragments_and_single_bundle_works() {
            assert_eq!(
                InstallerKind::try_from(vec![
                    WixObjKind::Product,
                    WixObjKind::Product,
                    WixObjKind::Bundle,
                    WixObjKind::Fragment,
                    WixObjKind::Fragment,
                    WixObjKind::Product
                ]),
                Ok(InstallerKind::Exe)
            )
        }
    }
}


================================================
FILE: src/initialize.rs
================================================
// Copyright (C) 2018 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `init` command. The `init` command for the `cargo
//! wix` subcommand is focused on creating a WiX Source file (wxs) based on the
//! contents of the Cargo manifest file (Cargo.toml) for the project and any
//! run-time based settings.
//!
//! The `init` command should generally be called before any other commands and
//! it should only be called once per project. Once a WiX Source file (wxs)
//! exists for the project, the `init` command does not need to be executed
//! again.

use camino::Utf8PathBuf;
use cargo_metadata::Package;

use crate::Error;
use crate::Result;
use crate::WIX;
use crate::WIX_SOURCE_FILE_EXTENSION;
use crate::WIX_SOURCE_FILE_NAME;
use crate::print;
use crate::stored_path::StoredPathBuf;
use crate::toolset::project::WxsSchema;

use log::{debug, info, trace};

use std::fs;
use std::path::{Path, PathBuf};

/// A builder for running the `cargo wix init` subcommand.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    banner: Option<&'a str>,
    binaries: Option<Vec<&'a str>>,
    copyright_year: Option<&'a str>,
    copyright_holder: Option<&'a str>,
    description: Option<&'a str>,
    dialog: Option<&'a str>,
    eula: Option<&'a str>,
    force: bool,
    help_url: Option<&'a str>,
    input: Option<&'a str>,
    license: Option<&'a str>,
    manufacturer: Option<&'a str>,
    output: Option<&'a str>,
    package: Option<&'a str>,
    path_guid: Option<&'a str>,
    product_icon: Option<&'a str>,
    product_name: Option<&'a str>,
    upgrade_guid: Option<&'a str>,
    schema: Option<WxsSchema>,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder {
            banner: None,
            binaries: None,
            copyright_year: None,
            copyright_holder: None,
            description: None,
            dialog: None,
            eula: None,
            force: false,
            help_url: None,
            input: None,
            license: None,
            manufacturer: None,
            output: None,
            package: None,
            path_guid: None,
            product_icon: None,
            product_name: None,
            upgrade_guid: None,
            schema: None,
        }
    }

    /// Sets the path to a bitmap (BMP) file to be used as a banner image across
    /// the top of each dialog in the installer.
    ///
    /// The banner image must be 493 x 58 pixels. See the [Wix Toolset
    /// documentation] for details about [customization].
    ///
    /// [Wix Toolset documentation]: http://wixtoolset.org/documentation/
    /// [customization]: http://wixtoolset.org/documentation/manual/v3/wixui/wixui_customizations.html
    pub fn banner(&mut self, b: Option<&'a str>) -> &mut Self {
        self.banner = b;
        self
    }

    /// Sets the path to the binaries.
    ///
    /// The default is to, first, collect all of the `bin` sections and use the
    /// `name` field within each `bin` section of the package's manifest for
    /// each binary's name and create the following source with the `.exe` file
    /// extension: `target\release\<binary-name>.exe`, where `<binary-name>` is
    /// replaced with the name obtained from each `bin` section. All binaries
    /// are included in the installer. If no `bin` sections exist, then the
    /// package's `name` field is used and only one binary is included in the
    /// installer.
    ///
    /// This method skips creating the binary names and sources from the
    /// package's manifest (Cargo.toml) and uses the supplied paths, regardless
    /// of the number of `bin` sections in the package's manifest. The binary
    /// name is extracted from each supplied path as the file stem (file name
    /// without extension).
    ///
    /// This method is useful for including binaries, a.k.a. executables, in the
    /// installer that are necessary for the application to run but are not
    /// necessarily Rust/Cargo built binaries. However, this method overrides
    /// _all_ binaries in the Cargo-based project, so if the installer is to
    /// include a mixture of external and internal binaries, the internal
    /// binaries must be explicitly included in this method.
    pub fn binaries(&mut self, b: Option<Vec<&'a str>>) -> &mut Self {
        self.binaries = b;
        self
    }

    /// Sets the copyright holder for the generated license file and EULA.
    ///
    /// The default is to use the `authors` field of the
    /// package's manifest (Cargo.toml). This method can be used to override the
    /// default and set a different copyright holder if and when a Rich Text
    /// Format (RTF) license and EULA are generated based on the value of the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// This value is ignored and not used if an EULA is set with the [`eula`]
    /// method, if a custom EULA is set using the `license-file` field in the
    /// package's manifest (Cargo.toml), or an EULA is _not_ generated from the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// [`eula`]: https://volks73.github.io/cargo-wix/cargo_wix/initialize.html#eula
    pub fn copyright_holder(&mut self, h: Option<&'a str>) -> &mut Self {
        self.copyright_holder = h;
        self
    }

    /// Sets the copyright year for the generated license file and EULA.
    ///
    /// The default is to use the current year. This method can be used to
    /// override the default and set a specific year if and when a Rich Text
    /// Format (RTF) license and EULA are generated based on the value of the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// This value is ignored and not used if an EULA is set with the [`eula`]
    /// method, if a custom EULA is set using the `license-file` field in the
    /// package's manifest (Cargo.toml), or an EULA is _not_ generated from the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// [`eula`]: https://volks73.github.io/cargo-wix/cargo_wix/initialize.html#eula
    pub fn copyright_year(&mut self, y: Option<&'a str>) -> &mut Self {
        self.copyright_year = y;
        self
    }

    /// Sets the description.
    ///
    /// This overrides the description determined from the `description` field
    /// in the package's manifest (Cargo.toml).
    pub fn description(&mut self, d: Option<&'a str>) -> &mut Self {
        self.description = d;
        self
    }

    /// Sets the path to a bitmap (`.bmp`) file that will be displayed on the
    /// first dialog to the left.
    ///
    /// The image must be 493 x 312 pixels. See the [Wix Toolset
    /// documentation] for details about [customization].
    ///
    /// [Wix Toolset documentation]: http://wixtoolset.org/documentation/
    /// [customization]: http://wixtoolset.org/documentation/manual/v3/wixui/wixui_customizations.html
    pub fn dialog(&mut self, d: Option<&'a str>) -> &mut Self {
        self.dialog = d;
        self
    }

    /// Sets the path to a custom End User License Agreement (EULA).
    ///
    /// The EULA is the text that appears in the license agreement dialog of the
    /// installer, where a checkbox is present for the user to agree to the
    /// terms of the license. Typically, this is the same as the license file
    /// that is included as a [sidecar] file in the installation destination of
    /// the executable.
    ///
    /// The default is to generate an EULA from an embedded template as a RTF
    /// file based on the name of the license specified in the `license` field
    /// of the package's manifest (Cargo.toml). This method can be used to
    /// override the default and specify a custom EULA. A custom EULA must be in
    /// the RTF format and have the `.rtf` file extension.
    ///
    /// If the `license` field is not specified or a template for the license
    /// does not exist but the `license-file` field does specify a path to a
    /// file with the RTF extension, then that RTF file is used as the EULA for
    /// the license agreement dialog in the installer. Finally, if the
    /// `license-file` does not exist or it specifies a file that does not have
    /// the `.rtf` extension, then the license agreement dialog is skipped and
    /// there is no EULA for the installer. This would override the default
    /// behavior and ensure the license agreement dialog is used.
    ///
    /// [sidecar]: https://en.wikipedia.org/wiki/Sidecar_file
    pub fn eula(&mut self, e: Option<&'a str>) -> &mut Self {
        self.eula = e;
        self
    }

    /// Forces the generation of new output even if the various outputs already
    /// exists at the destination.
    pub fn force(&mut self, f: bool) -> &mut Self {
        self.force = f;
        self
    }

    /// Sets the help URL.
    ///
    /// The default is to obtain a URL from one of the following fields in the
    /// package's manifest (Cargo.toml): `documentation`, `homepage`, or
    /// `repository`. If none of these are specified, then the default is to
    /// exclude a help URL from the installer. This will override the default
    /// behavior and provide a help URL for the installer if none of the fields
    /// exist.
    ///
    /// The help URL is the URL that appears in the Add/Remove Program control
    /// panel, a.k.a. `ARPHELPLINK`.
    pub fn help_url(&mut self, h: Option<&'a str>) -> &mut Self {
        self.help_url = h;
        self
    }

    /// Sets the path to a package's manifest (Cargo.toml) to be used to
    /// generate a WiX Source (wxs) file from the embedded template.
    ///
    /// A `wix` and `wix\main.wxs` file will be created in the same directory as
    /// the package's manifest. The default is to use the package's manifest in
    /// the current working directory.
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Sets the path to a file to be used as the [sidecar] license file.
    ///
    /// This will override the `license-file` field in the package's manifest
    /// (Cargo.toml). If the file has the `.rtf` extension, then it will also be
    /// used for the EULA in the license agreement dialog for the installer.
    /// Otherwise, the [`eula`] method can be used to set an RTF file as the
    /// EULA for the license agreement dialog that is independent of the sidecar
    /// license file.
    ///
    /// The default is to use the value specified in the `license-file` field of
    /// the package's manifest or generate a license file and EULA from an
    /// embedded template based on the license ID used in the `license` field
    /// of the package's manifest. If none of these fields are specified or
    /// overridden, then a license file is _not_ included in the installation
    /// directory and the license agreement dialog is skipped in the installer.
    ///
    /// [sidecar]: https://en.wikipedia.org/wiki/Sidecar_file
    /// [`eula`]: #eula
    pub fn license(&mut self, l: Option<&'a str>) -> &mut Self {
        self.license = l;
        self
    }

    /// Sets the manufacturer.
    ///
    /// Default is to use the `authors` field of the
    /// package's manifest (Cargo.toml). This would override the default value.
    pub fn manufacturer(&mut self, m: Option<&'a str>) -> &mut Self {
        self.manufacturer = m;
        self
    }

    /// Sets the destination for creating all of the output from initialization.
    ///
    /// The default is to create all initialization output in the same folder as
    /// the package's manifest (Cargo.toml). Thus, a `wix` folder will be
    /// created within the same folder as the `Cargo.toml` file and all
    /// initialization created files will be placed in the `wix` folder.
    ///
    /// This method can be used to override the default output destination and
    /// have the files related to creating an installer placed in a different
    /// location inside or outside of the package's project folder.
    pub fn output(&mut self, o: Option<&'a str>) -> &mut Self {
        self.output = o;
        self
    }

    /// Sets the path to an image file to be used for product icon.
    ///
    /// The product icon is the icon that appears for an installed application
    /// in the Add/Remove Programs (ARP) control panel. If a product icon is
    /// _not_ defined for an application within the installer, then the Windows
    /// OS assigns a generic one.
    pub fn product_icon(&mut self, p: Option<&'a str>) -> &mut Self {
        self.product_icon = p;
        self
    }

    /// Sets the package within a workspace to initialize an installer.
    ///
    /// Each package within a workspace has its own package manifest, i.e.
    /// `Cargo.toml`. This indicates within package manifest within a workspace
    /// should be used when initializing an installer.
    pub fn package(&mut self, p: Option<&'a str>) -> &mut Self {
        self.package = p;
        self
    }

    /// Sets the GUID for the path component.
    ///
    /// The default automatically generates the GUID needed for the path
    /// component. A GUID is needed so that the path component can be
    /// successfully removed on uninstall.
    ///
    /// Generally, the path component GUID should be generated only once per
    /// project/product and then the same GUID used every time the installer is
    /// created. The GUID is stored in the WiX Source (WXS) file. However,
    /// this allows using an existing GUID, possibly obtained with another tool.
    pub fn path_guid(&mut self, p: Option<&'a str>) -> &mut Self {
        self.path_guid = p;
        self
    }

    /// Sets the product name.
    ///
    /// The default is to use the `name` field under the `package` section of
    /// the package's manifest (Cargo.toml). This overrides that value. An error
    /// occurs if the `name` field is not found in the manifest.
    ///
    /// The product name is also used for the disk prompt during installation
    /// and the name of the default installation destination. For example, a
    /// product anme of `Example` will have an installation destination of
    /// `C:\Program Files\Example` as the default during installation.
    pub fn product_name(&mut self, p: Option<&'a str>) -> &mut Self {
        self.product_name = p;
        self
    }

    /// Sets the Upgrade Code GUID.
    ///
    /// The default automatically generates the need GUID for the `UpgradeCode`
    /// attribute to the `Product` tag. The Upgrade Code uniquely identifies the
    /// installer. It is used to determine if the new installer is the same
    /// product and the current installation should be removed and upgraded to
    /// this version. If the GUIDs of the current product and new product do
    /// _not_ match, then Windows will treat the two installers as separate
    /// products.
    ///
    /// Generally, the upgrade code should be generated only one per
    /// project/product and then the same code used every time the installer is
    /// created and the GUID is stored in the WiX Source (WXS) file. However,
    /// this allows the user to provide an existing GUID for the upgrade code.
    pub fn upgrade_guid(&mut self, u: Option<&'a str>) -> &mut Self {
        self.upgrade_guid = u;
        self
    }

    /// Sets the Wxs Schema
    ///
    /// Wix3 follows the "v3" schema, where as Wix4 and beyond use the "Modern" schema uri.
    pub fn schema(&mut self, schema: Option<WxsSchema>) -> &mut Self {
        self.schema = schema;
        self
    }

    /// Builds a read-only initialization execution.
    pub fn build(&mut self) -> Execution {
        Execution {
            banner: self.banner.map(StoredPathBuf::from),
            binaries: self
                .binaries
                .as_ref()
                .map(|b| b.iter().copied().map(StoredPathBuf::from).collect()),
            copyright_year: self.copyright_year.map(String::from),
            copyright_holder: self.copyright_holder.map(String::from),
            description: self.description.map(String::from),
            dialog: self.dialog.map(StoredPathBuf::from),
            eula: self.eula.map(StoredPathBuf::from),
            force: self.force,
            help_url: self.help_url.map(String::from),
            input: self.input.map(PathBuf::from),
            license: self.license.map(StoredPathBuf::from),
            manufacturer: self.manufacturer.map(String::from),
            output: self.output.map(PathBuf::from),
            package: self.package.map(String::from),
            path_guid: self.path_guid.map(String::from),
            product_icon: self.product_icon.map(StoredPathBuf::from),
            product_name: self.product_name.map(String::from),
            upgrade_guid: self.upgrade_guid.map(String::from),
            schema: self.schema.unwrap_or(WxsSchema::Legacy),
        }
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for creating the necessary files to eventually build an installer.
#[derive(Debug)]
pub struct Execution {
    banner: Option<StoredPathBuf>,
    binaries: Option<Vec<StoredPathBuf>>,
    copyright_holder: Option<String>,
    copyright_year: Option<String>,
    description: Option<String>,
    dialog: Option<StoredPathBuf>,
    eula: Option<StoredPathBuf>,
    force: bool,
    help_url: Option<String>,
    input: Option<PathBuf>,
    license: Option<StoredPathBuf>,
    manufacturer: Option<String>,
    output: Option<PathBuf>,
    package: Option<String>,
    path_guid: Option<String>,
    product_icon: Option<StoredPathBuf>,
    product_name: Option<String>,
    upgrade_guid: Option<String>,
    schema: WxsSchema,
}

impl Execution {
    /// Generates the necessary files to eventually create, or build, an
    /// installer based on a built context.
    pub fn run(self) -> Result<()> {
        debug!("banner = {:?}", self.banner);
        debug!("binaries = {:?}", self.binaries);
        debug!("copyright_holder = {:?}", self.copyright_holder);
        debug!("copyright_year = {:?}", self.copyright_year);
        debug!("description = {:?}", self.description);
        debug!("dialog = {:?}", self.dialog);
        debug!("eula = {:?}", self.eula);
        debug!("force = {:?}", self.force);
        debug!("help_url = {:?}", self.help_url);
        debug!("input = {:?}", self.input);
        debug!("license = {:?}", self.license);
        debug!("manufacturer = {:?}", self.manufacturer);
        debug!("output = {:?}", self.output);
        debug!("package = {:?}", self.package);
        debug!("path_guid = {:?}", self.path_guid);
        debug!("product_icon = {:?}", self.product_icon);
        debug!("product_name = {:?}", self.product_name);
        debug!("upgrade_guid = {:?}", self.upgrade_guid);
        let manifest = super::manifest(self.input.as_ref())?;
        let package = super::package(&manifest, self.package.as_deref())?;
        let mut destination = self.destination(&package);
        debug!("destination = {:?}", destination);
        if !destination.exists() {
            info!("Creating the '{}' directory", destination);
            fs::create_dir(&destination)?;
        }

        destination.push(WIX_SOURCE_FILE_NAME);
        destination.set_extension(WIX_SOURCE_FILE_EXTENSION);
        if destination.exists() && !self.force {
            return Err(Error::already_exists(&destination));
        } else {
            info!("Creating the '{}' file", destination);
            let mut wxs_printer = print::wxs::Builder::new();
            wxs_printer.banner(self.banner.as_ref().map(|s| s.as_str()));
            wxs_printer.binaries(
                self.binaries
                    .as_ref()
                    .map(|b| b.iter().map(|s| s.as_str()).collect()),
            );
            wxs_printer.description(self.description.as_ref().map(String::as_ref));
            wxs_printer.dialog(self.dialog.as_deref().map(|s| s.as_str()));
            wxs_printer.eula(self.eula.as_deref().map(|p| p.as_str()));
            wxs_printer.help_url(self.help_url.as_ref().map(String::as_ref));
            wxs_printer.input(self.input.as_deref().and_then(Path::to_str));
            wxs_printer.license(self.license.as_deref().map(|p| p.as_str()));
            wxs_printer.manufacturer(self.manufacturer.as_ref().map(String::as_ref));
            wxs_printer.output(Some(destination.as_str()));
            wxs_printer.package(self.package.as_deref());
            wxs_printer.path_guid(self.path_guid.as_ref().map(String::as_ref));
            wxs_printer.product_icon(self.product_icon.as_ref().map(|s| s.as_str()));
            wxs_printer.product_name(self.product_name.as_ref().map(String::as_ref));
            wxs_printer.upgrade_guid(self.upgrade_guid.as_ref().map(String::as_ref));
            wxs_printer.schema(Some(self.schema));

            wxs_printer.build().run()?;
        }
        Ok(())
    }

    fn destination(&self, package: &Package) -> Utf8PathBuf {
        if let Some(output) = &self.output {
            trace!("An output path has been explicitly specified");
            Utf8PathBuf::from_path_buf(output.to_owned()).unwrap()
        } else {
            trace!(
                "An output path has NOT been explicitly specified. Implicitly determine output from manifest location."
            );
            package
                .manifest_path
                .parent()
                .map(|p| p.to_path_buf())
                .map(|mut p| {
                    p.push(WIX);
                    p
                })
                .unwrap()
        }
    }
}

impl Default for Execution {
    fn default() -> Self {
        Builder::new().build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    mod builder {
        use super::*;

        const PATH_GUID: &str = "0B5DFC00-1480-4044-AC1A-BEF00E0A91BB";
        const UPGRADE_GUID: &str = "0631BBDF-4079-4C20-823F-7EA8DE40BF08";

        #[test]
        fn defaults_are_correct() {
            let actual = Builder::new();
            assert!(actual.banner.is_none());
            assert!(actual.binaries.is_none());
            assert!(actual.copyright_year.is_none());
            assert!(actual.copyright_holder.is_none());
            assert!(actual.description.is_none());
            assert!(actual.dialog.is_none());
            assert!(actual.eula.is_none());
            assert!(!actual.force);
            assert!(actual.help_url.is_none());
            assert!(actual.input.is_none());
            assert!(actual.license.is_none());
            assert!(actual.manufacturer.is_none());
            assert!(actual.output.is_none());
            assert!(actual.path_guid.is_none());
            assert!(actual.product_icon.is_none());
            assert!(actual.product_name.is_none());
            assert!(actual.upgrade_guid.is_none());
            assert!(actual.schema.is_none());
        }

        #[test]
        fn banner_works() {
            const EXPECTED: &str = "img\\Banner.bmp";
            let mut actual = Builder::new();
            actual.banner(Some(EXPECTED));
            assert_eq!(actual.banner, Some(EXPECTED));
        }

        #[test]
        fn binaries_works() {
            const EXPECTED: &str = "bin\\Example.exe";
            let mut actual = Builder::new();
            actual.binaries(Some(vec![EXPECTED]));
            assert_eq!(actual.binaries, Some(vec![EXPECTED]));
        }

        #[test]
        fn copyright_holder_works() {
            const EXPECTED: &str = "holder";
            let mut actual = Builder::new();
            actual.copyright_holder(Some(EXPECTED));
            assert_eq!(actual.copyright_holder, Some(EXPECTED));
        }

        #[test]
        fn copyright_year_works() {
            const EXPECTED: &str = "2018";
            let mut actual = Builder::new();
            actual.copyright_year(Some(EXPECTED));
            assert_eq!(actual.copyright_year, Some(EXPECTED));
        }

        #[test]
        fn description_works() {
            const EXPECTED: &str = "description";
            let mut actual = Builder::new();
            actual.description(Some(EXPECTED));
            assert_eq!(actual.description, Some(EXPECTED));
        }

        #[test]
        fn dialog_works() {
            const EXPECTED: &str = "img\\Dialog.bmp";
            let mut actual = Builder::new();
            actual.dialog(Some(EXPECTED));
            assert_eq!(actual.dialog, Some(EXPECTED));
        }

        #[test]
        fn eula_works() {
            const EXPECTED: &str = "eula.rtf";
            let mut actual = Builder::new();
            actual.eula(Some(EXPECTED));
            assert_eq!(actual.eula, Some(EXPECTED));
        }

        #[test]
        fn force_works() {
            let mut actual = Builder::new();
            actual.force(true);
            assert!(actual.force);
        }

        #[test]
        fn help_url_works() {
            const EXPECTED: &str = "http://github.com/volks73/cargo-wix";
            let mut actual = Builder::new();
            actual.help_url(Some(EXPECTED));
            assert_eq!(actual.help_url, Some(EXPECTED));
        }

        #[test]
        fn input_works() {
            const EXPECTED: &str = "input.wxs";
            let mut actual = Builder::new();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }

        #[test]
        fn license_works() {
            const EXPECTED: &str = "License.txt";
            let mut actual = Builder::new();
            actual.license(Some(EXPECTED));
            assert_eq!(actual.license, Some(EXPECTED));
        }

        #[test]
        fn manufacturer_works() {
            const EXPECTED: &str = "manufacturer";
            let mut actual = Builder::new();
            actual.manufacturer(Some(EXPECTED));
            assert_eq!(actual.manufacturer, Some(EXPECTED));
        }

        #[test]
        fn output_works() {
            const EXPECTED: &str = "output";
            let mut actual = Builder::new();
            actual.output(Some(EXPECTED));
            assert_eq!(actual.output, Some(EXPECTED));
        }

        #[test]
        fn path_guid_works() {
            let mut actual = Builder::new();
            actual.path_guid(Some(PATH_GUID));
            assert_eq!(actual.path_guid, Some(PATH_GUID));
        }

        #[test]
        fn product_icon_works() {
            const EXPECTED: &str = "img\\Product.ico";
            let mut actual = Builder::new();
            actual.product_icon(Some(EXPECTED));
            assert_eq!(actual.product_icon, Some(EXPECTED));
        }

        #[test]
        fn product_name_works() {
            const EXPECTED: &str = "product name";
            let mut actual = Builder::new();
            actual.product_name(Some(EXPECTED));
            assert_eq!(actual.product_name, Some(EXPECTED));
        }

        #[test]
        fn upgrade_guid_works() {
            let mut actual = Builder::new();
            actual.upgrade_guid(Some(UPGRADE_GUID));
            assert_eq!(actual.upgrade_guid, Some(UPGRADE_GUID));
        }

        #[test]
        fn schema_works() {
            use crate::toolset::project::WxsSchema;
            let mut actual = Builder::new();
            actual.schema(Some(WxsSchema::V4));
            assert_eq!(actual.schema, Some(WxsSchema::V4));
        }

        #[test]
        fn schema_defaults_to_legacy_in_execution() {
            use crate::toolset::project::WxsSchema;
            let mut b = Builder::new();
            let execution = b.build();
            assert!(matches!(execution.schema, WxsSchema::Legacy));
        }

        #[test]
        fn build_with_defaults_works() {
            let mut b = Builder::new();
            let default_execution = b.build();
            assert!(default_execution.binaries.is_none());
            assert!(default_execution.copyright_year.is_none());
            assert!(default_execution.copyright_holder.is_none());
            assert!(default_execution.description.is_none());
            assert!(default_execution.eula.is_none());
            assert!(!default_execution.force);
            assert!(default_execution.help_url.is_none());
            assert!(default_execution.input.is_none());
            assert!(default_execution.license.is_none());
            assert!(default_execution.manufacturer.is_none());
            assert!(default_execution.output.is_none());
            assert!(default_execution.product_icon.is_none());
            assert!(default_execution.product_name.is_none());
            assert!(default_execution.upgrade_guid.is_none());
            assert!(matches!(
                default_execution.schema,
                crate::toolset::project::WxsSchema::Legacy
            ));
        }

        #[test]
        fn build_with_all_works() {
            const EXPECTED_BINARY: &str = "bin\\Example.exe";
            const EXPECTED_COPYRIGHT_HOLDER: &str = "Copyright Holder";
            const EXPECTED_COPYRIGHT_YEAR: &str = "Copyright Year";
            const EXPECTED_DESCRIPTION: &str = "Description";
            const EXPECTED_EULA: &str = "C:\\tmp\\eula.rtf";
            const EXPECTED_URL: &str = "http://github.com/volks73/cargo-wix";
            const EXPECTED_INPUT: &str = "C:\\tmp\\hello_world";
            const EXPECTED_LICENSE: &str = "C:\\tmp\\hello_world\\License.rtf";
            const EXPECTED_MANUFACTURER: &str = "Manufacturer";
            const EXPECTED_OUTPUT: &str = "C:\\tmp\\output";
            const EXPECTED_PRODUCT_ICON: &str = "img\\Product.ico";
            const EXPECTED_PRODUCT_NAME: &str = "Product Name";
            let mut b = Builder::new();
            b.binaries(Some(vec![EXPECTED_BINARY]));
            b.copyright_holder(Some(EXPECTED_COPYRIGHT_HOLDER));
            b.copyright_year(Some(EXPECTED_COPYRIGHT_YEAR));
            b.description(Some(EXPECTED_DESCRIPTION));
            b.eula(Some(EXPECTED_EULA));
            b.force(true);
            b.help_url(Some(EXPECTED_URL));
            b.input(Some(EXPECTED_INPUT));
            b.license(Some(EXPECTED_LICENSE));
            b.manufacturer(Some(EXPECTED_MANUFACTURER));
            b.output(Some(EXPECTED_OUTPUT));
            b.path_guid(Some(PATH_GUID));
            b.product_icon(Some(EXPECTED_PRODUCT_ICON));
            b.product_name(Some(EXPECTED_PRODUCT_NAME));
            b.upgrade_guid(Some(UPGRADE_GUID));
            let execution = b.build();
            assert_eq!(
                execution.binaries,
                Some(vec![EXPECTED_BINARY])
                    .map(|s| s.into_iter().map(StoredPathBuf::from).collect())
            );
            assert_eq!(
                execution.copyright_year,
                Some(String::from(EXPECTED_COPYRIGHT_YEAR))
            );
            assert_eq!(
                execution.copyright_holder,
                Some(String::from(EXPECTED_COPYRIGHT_HOLDER))
            );
            assert_eq!(
                execution.description,
                Some(String::from(EXPECTED_DESCRIPTION))
            );
            assert_eq!(execution.eula, Some(StoredPathBuf::from(EXPECTED_EULA)));
            assert!(execution.force);
            assert_eq!(execution.help_url, Some(String::from(EXPECTED_URL)));
            assert_eq!(execution.input, Some(PathBuf::from(EXPECTED_INPUT)));
            assert_eq!(
                execution.license,
                Some(StoredPathBuf::from(EXPECTED_LICENSE))
            );
            assert_eq!(
                execution.manufacturer,
                Some(String::from(EXPECTED_MANUFACTURER))
            );
            assert_eq!(execution.output, Some(PathBuf::from(EXPECTED_OUTPUT)));
            assert_eq!(execution.path_guid, Some(String::from(PATH_GUID)));
            assert_eq!(
                execution.product_icon,
                Some(StoredPathBuf::from(EXPECTED_PRODUCT_ICON))
            );
            assert_eq!(
                execution.product_name,
                Some(String::from(EXPECTED_PRODUCT_NAME))
            );
            assert_eq!(execution.upgrade_guid, Some(String::from(UPGRADE_GUID)));
        }
    }

    #[cfg(windows)]
    mod execution {
        extern crate assert_fs;

        use super::*;
        use serial_test::serial;
        use std::env;

        const MIN_PACKAGE: &str = r#"[package]
        name = "cargowixtest"
        version = "1.0.0"
        "#;

        #[test]
        #[serial]
        fn destination_is_correct_with_defaults() {
            let original = env::current_dir().unwrap();
            let temp_dir = crate::tests::setup_project(MIN_PACKAGE);
            env::set_current_dir(temp_dir.path()).unwrap();
            let mut expected = env::current_dir().unwrap();
            expected.push(WIX);
            let e = Execution::default();

            let result = crate::manifest(None)
                .and_then(|manifest| crate::package(&manifest, None))
                .map(|package| e.destination(&package));

            env::set_current_dir(original).unwrap();
            let actual = result.unwrap();
            assert_eq!(actual, expected);
        }

        #[test]
        #[serial]
        fn destination_is_correct_with_output() {
            let expected = PathBuf::from("output");
            let temp_dir = crate::tests::setup_project(MIN_PACKAGE);
            let e = Execution {
                output: Some(expected.clone()),
                ..Default::default()
            };
            let actual = crate::manifest(Some(&temp_dir.path().join("Cargo.toml")))
                .and_then(|manifest| crate::package(&manifest, None))
                .map(|package| e.destination(&package))
                .unwrap();

            assert_eq!(actual, expected);
        }
    }
}


================================================
FILE: src/lib.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # `wix` Library
//!
//! The goal of the cargo-wix project and the `wix` library is to make it easy
//! to create a Windows installer (msi) for any Rust project. The cargo-wix
//! project is primarily implemented as a [cargo subcommand], but its core
//! functionality has been organized into a separate library. Documentation for
//! the binary and Command Line Interface (CLI) are provided in the module-level
//! documentation for the [binary] and the `cargo wix --help` command.
//!
//! ## Table of Contents
//!
//! - [Usage](#usage)
//! - [Organization](#organization)
//!
//! ## Usage
//!
//! First, add this to your `Cargo.toml`:
//!
//! ```toml
//! [dependencies]
//! wix = "0.1"
//! ```
//!
//! Next, if not using Rust 2018 edition, then add this to the `lib.rs` or
//! `main.rs` file for your project:
//!
//! ```ignore
//! extern crate wix;
//! ```
//!
//! ## Organization
//!
//! Each subcommand is organized into a separate module. So, there is a
//! `create`, `initialize`, `print`, etc. module within the crate. Some of the
//! modules are in a single Rust source file, while others are organized into
//! sub-folders. Each module follows the [Builder] design pattern, so there is a
//! `Builder` and `Execution` struct for each module/subcommand. The `Builder`
//! struct is used to customize the execution of the subcommand and builds an
//! `Execution` struct. The `Execution` struct is responsible for actually
//! executing the subcommand, which generally involves executing a process with
//! the [`std::process::Command`] struct, but not always. Each method for the
//! `Builder` struct generally corresponds to a CLI option or argument found in
//! the [`cargo wix`] subcommand and binary.
//!
//! [binary]: ../cargo_wix/index.html
//! [Builder]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
//! [cargo subcommand]: https://github.com/rust-lang/cargo/wiki/Third-party-cargo-subcommands
//! [`cargo wix`]: ../cargo_wix/index.html
//! [`std::process::Command`]: https://doc.rust-lang.org/std/process/struct.Command.html

pub use crate::templates::Template;

pub mod clean;
pub mod create;
pub mod initialize;
mod licenses;
pub mod migrate;
pub mod print;
pub mod purge;
pub mod sign;
pub mod stored_path;
mod templates;
pub mod toolset;

use camino::Utf8Path;
use log::debug;

use std::convert::TryFrom;
use std::default::Default;
use std::env;
use std::error::Error as StdError;
use std::ffi::OsStr;
use std::fmt;
use std::fmt::Display;
use std::io::{self, ErrorKind};
use std::path::{Path, PathBuf};
use std::str::FromStr;

use cargo_metadata::{Metadata, MetadataCommand, Package};

use rustc_cfg::Cfg;

/// The name of the folder where binaries are typically stored.
pub const BINARY_FOLDER_NAME: &str = "bin";

/// The file name with extension for a package's manifest.
pub const CARGO_MANIFEST_FILE: &str = "Cargo.toml";

/// The name of the builder application for a Rust project.
pub const CARGO: &str = "cargo";

/// The file extension for an executable.
pub const EXE_FILE_EXTENSION: &str = "exe";

/// The file name without an extension when generating a license.
pub const LICENSE_FILE_NAME: &str = "License";

/// The file extension for a Windows installer.
pub const MSI_FILE_EXTENSION: &str = "msi";

/// The file extension for a Rich Text Format (RTF) file.
pub const RTF_FILE_EXTENSION: &str = "rtf";

/// The name of the signer application from the Windows SDK.
pub const SIGNTOOL: &str = "signtool";

/// The name of the environment variable to specify the path to the signer
/// application.
pub const SIGNTOOL_PATH_KEY: &str = "SIGNTOOL_PATH";

/// The default name of the folder for output from this subcommand.
pub const WIX: &str = "wix";

/// The application name without the file extension of the compiler for the
/// Windows installer.
pub const WIX_COMPILER: &str = "candle";

/// The application name without the file extension of the linker for the
/// Windows installer.
pub const WIX_LINKER: &str = "light";

/// The application name of the modern toolset binary
pub const WIX_MODERN_TOOLSET: &str = "wix";

/// The application name without the file extension of the `msiexec` utility.
pub const MSIEXEC: &str = "msiexec";

/// The file extension for a WiX Toolset object file, which is the output from
/// the WiX compiler.
pub const WIX_OBJECT_FILE_EXTENSION: &str = "wixobj";

/// The name of the environment variable created by the WiX Toolset installer
/// that points to the `bin` folder for the WiX Toolet's compiler (candle.exe)
/// and linker (light.exe).
pub const WIX_PATH_KEY: &str = "WIX";

/// The file extension of the WiX Source file, which is the input to the WiX
/// Toolset compiler.
pub const WIX_SOURCE_FILE_EXTENSION: &str = "wxs";

/// The default file name for the WiX Source file, which is the input to the WiX
/// Toolset compiler.
pub const WIX_SOURCE_FILE_NAME: &str = "main";

/// A specialized [`Result`] type for wix operations.
///
/// [`Result`]: https://doc.rust-lang.org/std/result/
pub type Result<T> = std::result::Result<T, Error>;

fn cargo_toml_file(input: Option<&PathBuf>) -> Result<PathBuf> {
    let i = match input {
        Some(i) => i.to_owned(),
        None => {
            let mut cwd = env::current_dir()?;
            cwd.push(CARGO_MANIFEST_FILE);
            cwd
        }
    };
    if i.exists() {
        if i.is_file() {
            if i.file_name() == Some(OsStr::new(CARGO_MANIFEST_FILE)) {
                Ok(i)
            } else {
                Err(Error::not_a_manifest(&i))
            }
        } else {
            Err(Error::not_a_file(&i))
        }
    } else {
        Err(Error::not_found(&i))
    }
}

fn description(description: Option<String>, manifest: &Package) -> Option<String> {
    description.or_else(|| manifest.description.clone())
}

fn manifest(input: Option<&PathBuf>) -> Result<Metadata> {
    let cargo_file_path = cargo_toml_file(input)?;
    debug!("cargo_file_path = {:?}", cargo_file_path);
    Ok(MetadataCommand::new()
        .no_deps()
        .manifest_path(cargo_file_path)
        .exec()?)
}

fn package(manifest: &Metadata, package: Option<&str>) -> Result<Package> {
    let package_id = if let Some(p) = package {
        manifest
            .workspace_members
            .iter()
            .find(|n| manifest[n].name == p)
            .ok_or_else(|| Error::Generic(format!("No `{p}` package found in the project")))?
    } else if manifest.workspace_members.len() == 1 {
        &manifest.workspace_members[0]
    } else {
        // TODO: Replace error with creating installers for all packages in a
        // workspace. I think this currently means that to create installers for
        // all packages in workspace, a `cargo wix --package <name>` must be
        // executed for each workspace member.
        return Err(Error::Generic(String::from(
            "Workspace detected. Please pass a package name.",
        )));
    };
    Ok(manifest[package_id].clone())
}

fn product_name(product_name: Option<&String>, manifest: &Package) -> String {
    if let Some(p) = product_name {
        p.to_owned()
    } else {
        manifest.name.to_string()
    }
}

/// The error type for wix-related operations and associated traits.
///
/// Errors mostly originate from the dependencies, but custom instances of `Error` can be created
/// with the `Generic` variant and a message.
#[derive(Debug)]
pub enum Error {
    /// Parsing of Cargo metadata failed.
    CargoMetadata(cargo_metadata::Error),
    /// A command operation failed.
    Command(&'static str, i32, bool),
    /// A generic or custom error occurred. The message should contain the detailed information.
    Generic(String),
    /// An I/O operation failed.
    Io(io::Error),
    /// A needed field within the `Cargo.toml` manifest could not be found.
    Manifest(&'static str),
    /// An error occurred with rendering the template using the mustache renderer.
    Mustache(mustache::Error),
    /// UUID generation or parsing failed.
    Uuid(uuid::Error),
    /// Parsing error for a version string or field.
    Version(semver::Error),
    /// Parsing the intermediate WiX Object (wixobj) file, which is XML, failed.
    Xml(sxd_document::parser::Error),
    /// Evaluation of an XPath expression failed.
    XPath(sxd_xpath::Error),
    /// Could not convert bytes to utf8
    Utf8Error(std::string::FromUtf8Error),
}

impl Error {
    /// Gets an error code related to the error.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use wix::Error;
    ///
    /// let err = Error::from("A generic error");
    /// assert_ne!(err.code(), 0)
    /// ```
    ///
    /// This is useful as a return, or exit, code for a command line application, where a non-zero
    /// integer indicates a failure in the application. it can also be used for quickly and easily
    /// testing equality between two errors.
    pub fn code(&self) -> i32 {
        match *self {
            Error::Command(..) => 1,
            Error::Generic(..) => 2,
            Error::Io(..) => 3,
            Error::Manifest(..) => 4,
            Error::Mustache(..) => 5,
            Error::Uuid(..) => 6,
            Error::Version(..) => 7,
            Error::Xml(..) => 8,
            Error::XPath(..) => 9,
            Error::CargoMetadata(..) => 10,
            Error::Utf8Error(..) => 11,
        }
    }

    /// Creates a new `Error` from a [std::io::Error] with the
    /// [std::io::ErrorKind::AlreadyExists] variant.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io;
    /// use camino::Utf8Path;
    /// use wix::Error;
    ///
    /// let path = Utf8Path::new("C:\\");
    /// let expected = Error::Io(io::Error::new(
    ///     io::ErrorKind::AlreadyExists,
    ///     path.to_string()
    /// ));
    /// assert_eq!(expected, Error::already_exists(path));
    /// ```
    ///
    /// [std::io::Error]: https://doc.rust-lang.org/std/io/struct.Error.html
    /// [std::io::ErrorKind::AlreadyExists]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html
    pub fn already_exists(p: &Utf8Path) -> Self {
        io::Error::new(ErrorKind::AlreadyExists, p.to_string()).into()
    }

    /// Creates a new `Error` from a [std::io::Error] with the
    /// [std::io::ErrorKind::NotFound] variant.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io;
    /// use std::path::Path;
    /// use wix::Error;
    ///
    /// let path = Path::new("C:\\Cargo\\Wix\\file.txt");
    /// let expected = Error::Io(io::Error::new(
    ///     io::ErrorKind::NotFound,
    ///     path.display().to_string()
    /// ));
    /// assert_eq!(expected, Error::not_found(path));
    /// ```
    ///
    /// [std::io::Error]: https://doc.rust-lang.org/std/io/struct.Error.html
    /// [std::io::ErrorKind::NotFound]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html
    pub fn not_found(p: &Path) -> Self {
        io::Error::new(ErrorKind::NotFound, p.display().to_string()).into()
    }

    /// Creates a new `Error` from a [std::io::Error] with the
    /// [std::io::ErrorKind::InvalidInput] variant if a path is not a file.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io;
    /// use std::path::Path;
    /// use wix::Error;
    ///
    /// let path = Path::new("C:\\Cargo\\Wix\\file.txt");
    /// let expected = Error::Io(io::Error::new(
    ///     io::ErrorKind::InvalidInput,
    ///     format!("The '{}' path is not a file.", path.display())
    /// ));
    /// assert_eq!(expected, Error::not_a_file(path));
    /// ```
    ///
    /// [std::io::Error]: https://doc.rust-lang.org/std/io/struct.Error.html
    /// [std::io::ErrorKind::InvalidInput]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html
    pub fn not_a_file(p: &Path) -> Self {
        io::Error::new(
            ErrorKind::InvalidInput,
            format!("The '{}' path is not a file.", p.display()),
        )
        .into()
    }

    /// Creates a new `Error` from a [std::io::Error] with the
    /// [std::io::ErrorKind::InvalidInput] variant if a path is not to a
    /// `Cargo.toml` file.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::io;
    /// use std::path::Path;
    /// use wix::Error;
    ///
    /// let path = Path::new("C:\\Cargo\\Wix\\file.txt");
    /// let expected = Error::Io(io::Error::new(
    ///     io::ErrorKind::InvalidInput,
    ///     format!(
    ///         "The '{}' path does not appear to be to a 'Cargo.toml' file.",
    ///         path.display(),
    ///     ),
    /// ));
    /// assert_eq!(expected, Error::not_a_manifest(path));
    /// ```
    ///
    /// [std::io::Error]: https://doc.rust-lang.org/std/io/struct.Error.html
    /// [std::io::ErrorKind::InvalidInput]: https://doc.rust-lang.org/std/io/enum.ErrorKind.html
    pub fn not_a_manifest(p: &Path) -> Self {
        io::Error::new(
            ErrorKind::InvalidInput,
            format!(
                "The '{}' path does not appear to be to a '{}' file.",
                p.display(),
                CARGO_MANIFEST_FILE
            ),
        )
        .into()
    }

    /// Extracts a short, single word representation of the error.
    ///
    /// The `std::error::Error::description` method is "soft-deprecated"
    /// according to the Rust stdlib documentation. It is recommended to use the
    /// `std::fmt::Display` implementation for a "description" string. However,
    /// there is already a `std::fmt::Display` implementation for this error
    /// type, and it is nice to have a short, single word representation for
    /// nicely formatting errors to humans. This method maintains the error
    /// message formatting.
    pub fn as_str(&self) -> &str {
        match *self {
            Error::CargoMetadata(..) => "CargoMetadata",
            Error::Command(..) => "Command",
            Error::Generic(..) => "Generic",
            Error::Io(..) => "Io",
            Error::Manifest(..) => "Manifest",
            Error::Mustache(..) => "Mustache",
            Error::Uuid(..) => "UUID",
            Error::Version(..) => "Version",
            Error::Xml(..) => "XML",
            Error::XPath(..) => "XPath",
            Error::Utf8Error(..) => "Utf8",
        }
    }
}

impl StdError for Error {
    fn description(&self) -> &str {
        self.as_str()
    }

    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match *self {
            Error::CargoMetadata(ref err) => Some(err),
            Error::Io(ref err) => Some(err),
            Error::Mustache(ref err) => Some(err),
            Error::Uuid(ref err) => Some(err),
            Error::Version(ref err) => Some(err),
            Error::Xml(ref err) => Some(err),
            Error::XPath(ref err) => Some(err),
            _ => None,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::CargoMetadata(ref err) => err.fmt(f),
            Error::Command(ref command, ref code, captured_output) => {
                if captured_output {
                    write!(
                        f,
                        "The '{command}' application failed with exit code = {code}. Consider using the \
                         '--nocapture' flag to obtain more information."
                    )
                } else {
                    write!(
                        f,
                        "The '{command}' application failed with exit code = {code}"
                    )
                }
            }
            Error::Generic(ref msg) => msg.fmt(f),
            Error::Io(ref err) => match err.kind() {
                ErrorKind::AlreadyExists => {
                    if let Some(path) = err.get_ref() {
                        write!(
                            f,
                            "The '{path}' file already exists. Use the '--force' flag to overwrite the contents."
                        )
                    } else {
                        err.fmt(f)
                    }
                }
                ErrorKind::NotFound => {
                    if let Some(path) = err.get_ref() {
                        write!(f, "The '{path}' path does not exist")
                    } else {
                        err.fmt(f)
                    }
                }
                _ => err.fmt(f),
            },
            Error::Manifest(ref var) => write!(
                f,
                "No '{var}' field found in the package's manifest (Cargo.toml)"
            ),
            Error::Mustache(ref err) => err.fmt(f),
            Error::Uuid(ref err) => err.fmt(f),
            Error::Version(ref err) => err.fmt(f),
            Error::Xml(ref err) => err.fmt(f),
            Error::XPath(ref err) => err.fmt(f),
            Error::Utf8Error(ref err) => err.fmt(f),
        }
    }
}

impl PartialEq for Error {
    fn eq(&self, other: &Error) -> bool {
        self.code() == other.code()
    }
}

impl From<&str> for Error {
    fn from(s: &str) -> Self {
        Error::Generic(s.to_string())
    }
}

impl From<cargo_metadata::Error> for Error {
    fn from(err: cargo_metadata::Error) -> Self {
        Error::CargoMetadata(err)
    }
}

impl From<io::Error> for Error {
    fn from(err: io::Error) -> Self {
        Error::Io(err)
    }
}

impl From<mustache::Error> for Error {
    fn from(err: mustache::Error) -> Self {
        Error::Mustache(err)
    }
}

impl From<semver::Error> for Error {
    fn from(err: semver::Error) -> Self {
        Error::Version(err)
    }
}

impl From<std::path::StripPrefixError> for Error {
    fn from(err: std::path::StripPrefixError) -> Self {
        Error::Generic(err.to_string())
    }
}

impl From<sxd_document::parser::Error> for Error {
    fn from(err: sxd_document::parser::Error) -> Self {
        Error::Xml(err)
    }
}

impl From<uuid::Error> for Error {
    fn from(err: uuid::Error) -> Self {
        Error::Uuid(err)
    }
}

impl From<sxd_xpath::Error> for Error {
    fn from(value: sxd_xpath::Error) -> Self {
        Error::XPath(value)
    }
}

impl From<sxd_xpath::ExecutionError> for Error {
    fn from(value: sxd_xpath::ExecutionError) -> Self {
        Error::XPath(sxd_xpath::Error::Executing(value))
    }
}

impl From<std::string::FromUtf8Error> for Error {
    fn from(value: std::string::FromUtf8Error) -> Self {
        Error::Utf8Error(value)
    }
}

/// The different architectures supported by the WiX Toolset.
///
/// These are also the valid values for the `-arch` option to the WiX compiler
/// (candle.exe).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WixArch {
    /// The x86 32-bit architecture.
    X86,
    /// The x86_64 or AMD64 64-bit architecture.
    X64,
    /// The ARM 32-bit architecture.
    Arm,
    /// The ARM 64-bit architecture.
    Arm64,
}

impl Display for WixArch {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self {
            Self::X86 => write!(f, "x86"),
            Self::X64 => write!(f, "x64"),
            Self::Arm => write!(f, "arm"),
            Self::Arm64 => write!(f, "arm64"),
        }
    }
}

impl TryFrom<&Cfg> for WixArch {
    type Error = crate::Error;

    fn try_from(c: &Cfg) -> std::result::Result<Self, Self::Error> {
        match &*c.target_arch {
            "x86" => Ok(Self::X86),
            "x86_64" => Ok(Self::X64),
            "aarch64" => Ok(Self::Arm64),
            "thumbv7a" => Ok(Self::Arm),
            a => {
                if a.starts_with("arm") {
                    Ok(Self::Arm)
                } else {
                    Err(Error::Generic(format!(
                        "Unsupported target architecture: {a}"
                    )))
                }
            }
        }
    }
}

impl FromStr for WixArch {
    type Err = crate::Error;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Self::try_from(&Cfg::of(s).map_err(|e| Error::Generic(e.to_string()))?)
    }
}

/// The aliases for the URLs to different Microsoft Authenticode timestamp servers.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TimestampServer {
    /// A URL to a timestamp server.
    Custom(String),
    /// The alias for the Comodo timestamp server.
    Comodo,
    /// The alias for the Verisign timestamp server.
    Verisign,
}

impl TimestampServer {
    /// Gets the URL of the timestamp server for an alias.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use std::str::FromStr;
    /// use wix::TimestampServer;
    ///
    /// assert_eq!(
    ///     TimestampServer::from_str("http://www.example.com").unwrap().url(),
    ///     "http://www.example.com"
    /// );
    /// assert_eq!(
    ///     TimestampServer::Comodo.url(),
    ///     "http://timestamp.comodoca.com/"
    /// );
    /// assert_eq!(
    ///     TimestampServer::Verisign.url(),
    ///     "http://timestamp.verisign.com/scripts/timstamp.dll"
    /// );
    /// ```
    pub fn url(&self) -> &str {
        match *self {
            TimestampServer::Custom(ref url) => url,
            TimestampServer::Comodo => "http://timestamp.comodoca.com/",
            TimestampServer::Verisign => "http://timestamp.verisign.com/scripts/timstamp.dll",
        }
    }
}

impl fmt::Display for TimestampServer {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.url())
    }
}

impl FromStr for TimestampServer {
    type Err = Error;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        match s.to_lowercase().trim() {
            "comodo" => Ok(TimestampServer::Comodo),
            "verisign" => Ok(TimestampServer::Verisign),
            u => Ok(TimestampServer::Custom(String::from(u))),
        }
    }
}

/// The various culture codes for localization.
///
/// These are taken from the table in the [WixUI localization] documentation.
///
/// [WixUI localization]: http://wixtoolset.org/documentation/manual/v3/wixui/wixui_localization.html
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub enum Cultures {
    /// Arabic, Saudi Arabia
    ArSa,
    /// Bulgarian, Bulgaria
    BgBg,
    /// Catalan, Spain
    CaEs,
    /// Croatian, Croatia
    HrHr,
    /// Czech, Czech Republic
    CsCz,
    /// Danish, Denmark
    DaDk,
    /// Dutch, Netherlands
    NlNl,
    /// English, United States
    #[default]
    EnUs,
    /// Estonian, Estonia
    EtEe,
    /// Finnish, Finland
    FiFi,
    /// French, France
    FrFr,
    /// German, Germany
    DeDe,
    /// Greek, Greece
    ElGr,
    /// Hebrew, Israel
    HeIl,
    /// Hindi, India
    HiIn,
    /// Hungarian, Hungary
    HuHu,
    /// Italian, Italy
    ItIt,
    /// Japanese, Japan
    JaJp,
    /// Kazakh, Kazakhstan
    KkKz,
    /// Korean, Korea
    KoKr,
    /// Latvian, Latvia
    LvLv,
    /// Lithuanian, Lithuania
    LtLt,
    /// Norwegian, Norway
    NbNo,
    /// Polish, Poland
    PlPl,
    /// Portuguese, Brazil
    PtBr,
    /// Portuguese, Portugal
    PtPt,
    /// Romanian, Romania
    RoRo,
    /// Russian, Russian
    RuRu,
    /// Serbian, Serbia and Montenegro
    SrLatnCs,
    /// Simplified Chinese, China
    ZhCn,
    /// Slovak, Slovak Republic
    SkSk,
    /// Solvenian, Solvenia
    SlSi,
    /// Spanish, Spain
    EsEs,
    /// Swedish, Sweden
    SvSe,
    /// Thai, Thailand
    ThTh,
    /// Traditional Chinese, Hong Kong SAR
    ZhHk,
    /// Traditional Chinese, Taiwan
    ZhTw,
    /// Turkish, Turkey
    TrTr,
    /// Ukrainian, Ukraine
    UkUa,
}

impl Cultures {
    /// The language of the culture code.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use wix::Cultures;
    ///
    /// assert_eq!(Cultures::ArSa.language(), "Arabic");
    /// assert_eq!(Cultures::BgBg.language(), "Bulgarian");
    /// assert_eq!(Cultures::CaEs.language(), "Catalan");
    /// assert_eq!(Cultures::HrHr.language(), "Croatian");
    /// assert_eq!(Cultures::CsCz.language(), "Czech");
    /// assert_eq!(Cultures::DaDk.language(), "Danish");
    /// assert_eq!(Cultures::NlNl.language(), "Dutch");
    /// assert_eq!(Cultures::EnUs.language(), "English");
    /// assert_eq!(Cultures::EtEe.language(), "Estonian");
    /// assert_eq!(Cultures::FiFi.language(), "Finnish");
    /// assert_eq!(Cultures::FrFr.language(), "French");
    /// assert_eq!(Cultures::DeDe.language(), "German");
    /// assert_eq!(Cultures::ElGr.language(), "Greek");
    /// assert_eq!(Cultures::HeIl.language(), "Hebrew");
    /// assert_eq!(Cultures::HiIn.language(), "Hindi");
    /// assert_eq!(Cultures::HuHu.language(), "Hungarian");
    /// assert_eq!(Cultures::ItIt.language(), "Italian");
    /// assert_eq!(Cultures::JaJp.language(), "Japanese");
    /// assert_eq!(Cultures::KkKz.language(), "Kazakh");
    /// assert_eq!(Cultures::KoKr.language(), "Korean");
    /// assert_eq!(Cultures::LvLv.language(), "Latvian");
    /// assert_eq!(Cultures::LtLt.language(), "Lithuanian");
    /// assert_eq!(Cultures::NbNo.language(), "Norwegian");
    /// assert_eq!(Cultures::PlPl.language(), "Polish");
    /// assert_eq!(Cultures::PtBr.language(), "Portuguese");
    /// assert_eq!(Cultures::PtPt.language(), "Portuguese");
    /// assert_eq!(Cultures::RoRo.language(), "Romanian");
    /// assert_eq!(Cultures::RuRu.language(), "Russian");
    /// assert_eq!(Cultures::SrLatnCs.language(), "Serbian (Latin)");
    /// assert_eq!(Cultures::ZhCn.language(), "Simplified Chinese");
    /// assert_eq!(Cultures::SkSk.language(), "Slovak");
    /// assert_eq!(Cultures::SlSi.language(), "Slovenian");
    /// assert_eq!(Cultures::EsEs.language(), "Spanish");
    /// assert_eq!(Cultures::SvSe.language(), "Swedish");
    /// assert_eq!(Cultures::ThTh.language(), "Thai");
    /// assert_eq!(Cultures::ZhHk.language(), "Traditional Chinese");
    /// assert_eq!(Cultures::ZhTw.language(), "Traditional Chinese");
    /// assert_eq!(Cultures::TrTr.language(), "Turkish");
    /// assert_eq!(Cultures::UkUa.language(), "Ukrainian");
    /// ```
    pub fn language(&self) -> &'static str {
        match *self {
            Cultures::ArSa => "Arabic",
            Cultures::BgBg => "Bulgarian",
            Cultures::CaEs => "Catalan",
            Cultures::HrHr => "Croatian",
            Cultures::CsCz => "Czech",
            Cultures::DaDk => "Danish",
            Cultures::NlNl => "Dutch",
            Cultures::EnUs => "English",
            Cultures::EtEe => "Estonian",
            Cultures::FiFi => "Finnish",
            Cultures::FrFr => "French",
            Cultures::DeDe => "German",
            Cultures::ElGr => "Greek",
            Cultures::HeIl => "Hebrew",
            Cultures::HiIn => "Hindi",
            Cultures::HuHu => "Hungarian",
            Cultures::ItIt => "Italian",
            Cultures::JaJp => "Japanese",
            Cultures::KkKz => "Kazakh",
            Cultures::KoKr => "Korean",
            Cultures::LvLv => "Latvian",
            Cultures::LtLt => "Lithuanian",
            Cultures::NbNo => "Norwegian",
            Cultures::PlPl => "Polish",
            Cultures::PtBr => "Portuguese",
            Cultures::PtPt => "Portuguese",
            Cultures::RoRo => "Romanian",
            Cultures::RuRu => "Russian",
            Cultures::SrLatnCs => "Serbian (Latin)",
            Cultures::ZhCn => "Simplified Chinese",
            Cultures::SkSk => "Slovak",
            Cultures::SlSi => "Slovenian",
            Cultures::EsEs => "Spanish",
            Cultures::SvSe => "Swedish",
            Cultures::ThTh => "Thai",
            Cultures::ZhHk => "Traditional Chinese",
            Cultures::ZhTw => "Traditional Chinese",
            Cultures::TrTr => "Turkish",
            Cultures::UkUa => "Ukrainian",
        }
    }

    /// The location of the culture component, typically the country that speaks the language.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use wix::Cultures;
    ///
    /// assert_eq!(Cultures::ArSa.location(), "Saudi Arabia");
    /// assert_eq!(Cultures::BgBg.location(), "Bulgaria");
    /// assert_eq!(Cultures::CaEs.location(), "Spain");
    /// assert_eq!(Cultures::HrHr.location(), "Croatia");
    /// assert_eq!(Cultures::CsCz.location(), "Czech Republic");
    /// assert_eq!(Cultures::DaDk.location(), "Denmark");
    /// assert_eq!(Cultures::NlNl.location(), "Netherlands");
    /// assert_eq!(Cultures::EnUs.location(), "United States");
    /// assert_eq!(Cultures::EtEe.location(), "Estonia");
    /// assert_eq!(Cultures::FiFi.location(), "Finland");
    /// assert_eq!(Cultures::FrFr.location(), "France");
    /// assert_eq!(Cultures::DeDe.location(), "Germany");
    /// assert_eq!(Cultures::ElGr.location(), "Greece");
    /// assert_eq!(Cultures::HeIl.location(), "Israel");
    /// assert_eq!(Cultures::HiIn.location(), "India");
    /// assert_eq!(Cultures::HuHu.location(), "Hungary");
    /// assert_eq!(Cultures::ItIt.location(), "Italy");
    /// assert_eq!(Cultures::JaJp.location(), "Japan");
    /// assert_eq!(Cultures::KkKz.location(), "Kazakhstan");
    /// assert_eq!(Cultures::KoKr.location(), "Korea");
    /// assert_eq!(Cultures::LvLv.location(), "Latvia");
    /// assert_eq!(Cultures::LtLt.location(), "Lithuania");
    /// assert_eq!(Cultures::NbNo.location(), "Norway");
    /// assert_eq!(Cultures::PlPl.location(), "Poland");
    /// assert_eq!(Cultures::PtBr.location(), "Brazil");
    /// assert_eq!(Cultures::PtPt.location(), "Portugal");
    /// assert_eq!(Cultures::RoRo.location(), "Romania");
    /// assert_eq!(Cultures::RuRu.location(), "Russia");
    /// assert_eq!(Cultures::SrLatnCs.location(), "Serbia and Montenegro");
    /// assert_eq!(Cultures::ZhCn.location(), "China");
    /// assert_eq!(Cultures::SkSk.location(), "Slovak Republic");
    /// assert_eq!(Cultures::SlSi.location(), "Solvenia");
    /// assert_eq!(Cultures::EsEs.location(), "Spain");
    /// assert_eq!(Cultures::SvSe.location(), "Sweden");
    /// assert_eq!(Cultures::ThTh.location(), "Thailand");
    /// assert_eq!(Cultures::ZhHk.location(), "Hong Kong SAR");
    /// assert_eq!(Cultures::ZhTw.location(), "Taiwan");
    /// assert_eq!(Cultures::TrTr.location(), "Turkey");
    /// assert_eq!(Cultures::UkUa.location(), "Ukraine");
    /// ```
    pub fn location(&self) -> &'static str {
        match *self {
            Cultures::ArSa => "Saudi Arabia",
            Cultures::BgBg => "Bulgaria",
            Cultures::CaEs => "Spain",
            Cultures::HrHr => "Croatia",
            Cultures::CsCz => "Czech Republic",
            Cultures::DaDk => "Denmark",
            Cultures::NlNl => "Netherlands",
            Cultures::EnUs => "United States",
            Cultures::EtEe => "Estonia",
            Cultures::FiFi => "Finland",
            Cultures::FrFr => "France",
            Cultures::DeDe => "Germany",
            Cultures::ElGr => "Greece",
            Cultures::HeIl => "Israel",
            Cultures::HiIn => "India",
            Cultures::HuHu => "Hungary",
            Cultures::ItIt => "Italy",
            Cultures::JaJp => "Japan",
            Cultures::KkKz => "Kazakhstan",
            Cultures::KoKr => "Korea",
            Cultures::LvLv => "Latvia",
            Cultures::LtLt => "Lithuania",
            Cultures::NbNo => "Norway",
            Cultures::PlPl => "Poland",
            Cultures::PtBr => "Brazil",
            Cultures::PtPt => "Portugal",
            Cultures::RoRo => "Romania",
            Cultures::RuRu => "Russia",
            Cultures::SrLatnCs => "Serbia and Montenegro",
            Cultures::ZhCn => "China",
            Cultures::SkSk => "Slovak Republic",
            Cultures::SlSi => "Solvenia",
            Cultures::EsEs => "Spain",
            Cultures::SvSe => "Sweden",
            Cultures::ThTh => "Thailand",
            Cultures::ZhHk => "Hong Kong SAR",
            Cultures::ZhTw => "Taiwan",
            Cultures::TrTr => "Turkey",
            Cultures::UkUa => "Ukraine",
        }
    }
}

impl fmt::Display for Cultures {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Cultures::ArSa => write!(f, "ar-SA"),
            Cultures::BgBg => write!(f, "bg-BG"),
            Cultures::CaEs => write!(f, "ca-ES"),
            Cultures::HrHr => write!(f, "hr-HR"),
            Cultures::CsCz => write!(f, "cs-CZ"),
            Cultures::DaDk => write!(f, "da-DK"),
            Cultures::NlNl => write!(f, "nl-NL"),
            Cultures::EnUs => write!(f, "en-US"),
            Cultures::EtEe => write!(f, "et-EE"),
            Cultures::FiFi => write!(f, "fi-FI"),
            Cultures::FrFr => write!(f, "fr-FR"),
            Cultures::DeDe => write!(f, "de-DE"),
            Cultures::ElGr => write!(f, "el-GR"),
            Cultures::HeIl => write!(f, "he-IL"),
            Cultures::HiIn => write!(f, "hi-IN"),
            Cultures::HuHu => write!(f, "hu-HU"),
            Cultures::ItIt => write!(f, "it-IT"),
            Cultures::JaJp => write!(f, "ja-JP"),
            Cultures::KkKz => write!(f, "kk-KZ"),
            Cultures::KoKr => write!(f, "ko-KR"),
            Cultures::LvLv => write!(f, "lv-LV"),
            Cultures::LtLt => write!(f, "lt-LT"),
            Cultures::NbNo => write!(f, "nb-NO"),
            Cultures::PlPl => write!(f, "pl-PL"),
            Cultures::PtBr => write!(f, "pt-BR"),
            Cultures::PtPt => write!(f, "pt-PT"),
            Cultures::RoRo => write!(f, "ro-RO"),
            Cultures::RuRu => write!(f, "ru-RU"),
            Cultures::SrLatnCs => write!(f, "sr-Latn-CS"),
            Cultures::ZhCn => write!(f, "zh-CN"),
            Cultures::SkSk => write!(f, "sk-SK"),
            Cultures::SlSi => write!(f, "sl-SI"),
            Cultures::EsEs => write!(f, "es-ES"),
            Cultures::SvSe => write!(f, "sv-SE"),
            Cultures::ThTh => write!(f, "th-TH"),
            Cultures::ZhHk => write!(f, "zh-HK"),
            Cultures::ZhTw => write!(f, "zh-TW"),
            Cultures::TrTr => write!(f, "tr-TR"),
            Cultures::UkUa => write!(f, "uk-UA"),
        }
    }
}

impl FromStr for Cultures {
    type Err = Error;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        match s.to_lowercase().trim() {
            "ar-sa" => Ok(Cultures::ArSa),
            "bg-bg" => Ok(Cultures::BgBg),
            "ca-es" => Ok(Cultures::CaEs),
            "hr-hr" => Ok(Cultures::HrHr),
            "cs-cz" => Ok(Cultures::CsCz),
            "da-dk" => Ok(Cultures::DaDk),
            "nl-nl" => Ok(Cultures::NlNl),
            "en-us" => Ok(Cultures::EnUs),
            "et-ee" => Ok(Cultures::EtEe),
            "fi-fi" => Ok(Cultures::FiFi),
            "fr-fr" => Ok(Cultures::FrFr),
            "de-de" => Ok(Cultures::DeDe),
            "el-gr" => Ok(Cultures::ElGr),
            "he-il" => Ok(Cultures::HeIl),
            "hi-in" => Ok(Cultures::HiIn),
            "hu-hu" => Ok(Cultures::HuHu),
            "it-it" => Ok(Cultures::ItIt),
            "ja-jp" => Ok(Cultures::JaJp),
            "kk-kz" => Ok(Cultures::KkKz),
            "ko-kr" => Ok(Cultures::KoKr),
            "lv-lv" => Ok(Cultures::LvLv),
            "lt-lt" => Ok(Cultures::LtLt),
            "nb-no" => Ok(Cultures::NbNo),
            "pl-pl" => Ok(Cultures::PlPl),
            "pt-br" => Ok(Cultures::PtBr),
            "pt-pt" => Ok(Cultures::PtPt),
            "ro-ro" => Ok(Cultures::RoRo),
            "ru-ru" => Ok(Cultures::RuRu),
            "sr-latn-cs" => Ok(Cultures::SrLatnCs),
            "zh-cn" => Ok(Cultures::ZhCn),
            "sk-sk" => Ok(Cultures::SkSk),
            "sl-si" => Ok(Cultures::SlSi),
            "es-es" => Ok(Cultures::EsEs),
            "sv-se" => Ok(Cultures::SvSe),
            "th-th" => Ok(Cultures::ThTh),
            "zh-hk" => Ok(Cultures::ZhHk),
            "zh-tw" => Ok(Cultures::ZhTw),
            "tr-tr" => Ok(Cultures::TrTr),
            "uk-ua" => Ok(Cultures::UkUa),
            e => Err(Error::Generic(format!("Unknown '{e}' culture"))),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use assert_fs::TempDir;
    use std::env;
    use std::fs;

    /// Create a simple project with the provided TOML.
    pub fn setup_project(toml: &str) -> TempDir {
        pub const PERSIST_VAR_NAME: &str = "CARGO_WIX_TEST_PERSIST";

        let temp_dir = TempDir::new().unwrap();
        fs::write(temp_dir.path().join("Cargo.toml"), toml).unwrap();
        fs::create_dir(temp_dir.path().join("src")).unwrap();
        fs::write(temp_dir.path().join("src").join("main.rs"), "fn main() {}").unwrap();

        temp_dir.into_persistent_if(env::var(PERSIST_VAR_NAME).is_ok())
    }

    mod culture {
        use super::*;

        #[test]
        fn from_str_is_correct_for_dash_russian() {
            assert_eq!(Cultures::from_str("ru-ru"), Ok(Cultures::RuRu));
        }

        #[test]
        #[should_panic]
        fn from_str_fails_for_underscore_russian() {
            Cultures::from_str("ru_ru").unwrap();
        }

        #[test]
        fn display_is_correct_for_russian() {
            assert_eq!(format!("{}", Cultures::RuRu), String::from("ru-RU"));
        }

        #[test]
        fn from_str_is_correct_for_lowercase_slovak() {
            assert_eq!(Cultures::from_str("sk-sk"), Ok(Cultures::SkSk));
        }

        #[test]
        fn from_str_is_correct_for_uppercase_slovak() {
            assert_eq!(Cultures::from_str("sk-SK"), Ok(Cultures::SkSk));
        }

        #[test]
        #[should_panic]
        fn from_str_fails_for_underscore_slovak() {
            Cultures::from_str("sk_sk").unwrap();
        }

        #[test]
        fn display_is_correct_for_slovak() {
            assert_eq!(format!("{}", Cultures::SkSk), String::from("sk-SK"));
        }
    }

    mod wix_arch {
        use super::*;

        #[test]
        fn try_from_x86_64_pc_windows_msvc_is_correct() {
            let arch = WixArch::try_from(&Cfg::of("x86_64-pc-windows-msvc").expect("Cfg parsing"))
                .unwrap();
            assert_eq!(arch, WixArch::X64);
        }

        #[test]
        fn try_from_x86_64_pc_windows_gnu_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("x86_64-pc-windows-gnu").expect("Cfg parsing")).unwrap();
            assert_eq!(arch, WixArch::X64);
        }

        #[test]
        fn try_from_x86_64_uwp_windows_msvc_is_correct() {
            let arch = WixArch::try_from(&Cfg::of("x86_64-uwp-windows-msvc").expect("Cfg parsing"))
                .unwrap();
            assert_eq!(arch, WixArch::X64);
        }

        #[test]
        fn try_from_x86_64_uwp_windows_gnu_is_correct() {
            let arch = WixArch::try_from(&Cfg::of("x86_64-uwp-windows-gnu").expect("Cfg parsing"))
                .unwrap();
            assert_eq!(arch, WixArch::X64);
        }

        #[test]
        fn try_from_i686_pc_windows_msvc_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("i686-pc-windows-msvc").expect("Cfg parsing")).unwrap();
            assert_eq!(arch, WixArch::X86);
        }

        #[test]
        fn try_from_i686_pc_windows_gnu_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("i686-pc-windows-gnu").expect("Cfg parsing")).unwrap();
            assert_eq!(arch, WixArch::X86);
        }

        #[test]
        fn try_from_i686_uwp_windows_msvc_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("i686-uwp-windows-msvc").expect("Cfg parsing")).unwrap();
            assert_eq!(arch, WixArch::X86);
        }

        #[test]
        fn try_from_i686_uwp_windows_gnu_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("i686-uwp-windows-gnu").expect("Cfg parsing")).unwrap();
            assert_eq!(arch, WixArch::X86);
        }

        #[test]
        fn try_from_aarch64_pc_windows_msvc_is_correct() {
            let arch = WixArch::try_from(&Cfg::of("aarch64-pc-windows-msvc").expect("Cfg parsing"))
                .unwrap();
            assert_eq!(arch, WixArch::Arm64);
        }

        #[test]
        fn try_from_aarch64_uwp_windows_msvc_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("aarch64-uwp-windows-msvc").expect("Cfg parsing"))
                    .unwrap();
            assert_eq!(arch, WixArch::Arm64);
        }

        #[test]
        fn try_from_thumbv7a_pc_windows_msvc_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("thumbv7a-pc-windows-msvc").expect("Cfg parsing"))
                    .unwrap();
            assert_eq!(arch, WixArch::Arm);
        }

        #[test]
        fn try_from_thumbv7a_uwp_windows_msvc_is_correct() {
            let arch =
                WixArch::try_from(&Cfg::of("thumbv7a-uwp-windows-msvc").expect("Cfg parsing"))
                    .unwrap();
            assert_eq!(arch, WixArch::Arm);
        }

        #[test]
        fn from_str_is_correct() {
            let arch = WixArch::from_str("thumbv7a-uwp-windows-msvc").unwrap();
            assert_eq!(arch, WixArch::Arm);
        }
    }
}


================================================
FILE: src/licenses.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::Error;
use crate::LICENSE_FILE_NAME;
use crate::RTF_FILE_EXTENSION;
use crate::Result;
use crate::Template;
use crate::stored_path::{StoredPath, StoredPathBuf};

use camino::Utf8Path;
use camino::Utf8PathBuf;
use log::trace;
use log::warn;

use std::str::FromStr;

use cargo_metadata::Package;

/// License info
#[derive(Clone, Debug)]
pub struct Licenses {
    /// The license for the actual source code
    ///
    /// This likely will become/contain a Vec at some point,
    /// since dual MIT/Apache wants to have two license files!
    pub source: Option<License>,
    /// The end-user license (EULA) that must be agreed to when installing
    pub end_user: Option<License>,
}

/// A license file/item
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct License {
    /// Path to the file, relative to package's root dir.
    ///
    /// So generated files would be "wix\License.rtf"
    /// and the typical LICENSE file would just be "LICENSE-MIT".
    ///
    /// Conveniently this means we don't need to do any special handling
    /// to rewrite/relativize a path we get out of a Cargo.toml.
    ///
    /// It can also be an absolute path if the user passed this via CLI
    /// and doesn't care about persistence/portability.
    pub stored_path: StoredPathBuf,
    /// File name to use for the license when installed to the user's system
    ///
    /// If None, the source file name is used.
    pub name: Option<String>,

    /// This file needs to be generated, write it to the given path
    /// using the given Template.
    pub generate: Option<(Utf8PathBuf, Template)>,
}

impl License {
    /// Create a License entry with just the StoredPath
    fn from_stored_path(path: &StoredPath) -> Self {
        Self {
            name: None,
            stored_path: path.to_owned(),
            generate: None,
        }
    }
}

impl Licenses {
    /// Get license/eula info for a package
    pub fn new(
        dest_dir: Option<&Utf8Path>,
        license_path: Option<&StoredPath>,
        eula_path: Option<&StoredPath>,
        package: &Package,
    ) -> Result<Self> {
        let source_license = Self::find_source_license(dest_dir, license_path, package)?;
        let end_user_license =
            Self::find_end_user_license(eula_path, package, source_license.as_ref())?;

        Ok(Self {
            source: source_license,
            end_user: end_user_license,
        })
    }

    /// Find the source-license for a package
    fn find_source_license(
        dest_dir: Option<&Utf8Path>,
        path: Option<&StoredPath>,
        package: &Package,
    ) -> Result<Option<License>> {
        trace!("finding source license for {}", package.name);
        // If explicitly passed, use that
        if let Some(path) = path {
            trace!("explicit source-license path passed as argument, using that");
            return Ok(Some(License::from_stored_path(path)));
        }

        let package_dir = package.manifest_path.parent().expect("non-root Cargo.toml");
        let dest_dir = dest_dir
            .map(|p| p.to_owned())
            .unwrap_or_else(|| package_dir.join(crate::WIX));

        // If there's [package.manifest.wix].license, respect that
        if let Some(license) = package
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("license"))
        {
            trace!("[package.manifest.wix].license is specified");
            if let Some(license_enabled) = license.as_bool() {
                // If the user sets `eula = false`, disable the eula
                // (= true just falls through to the auto-detection stuff below)
                if !license_enabled {
                    trace!("[package.manifest.wix].license is false, disabling license support");
                    return Ok(None);
                } else {
                    trace!("[package.manifest.wix].license is true, continuing to auto-detect");
                }
            } else if let Some(path) = license.as_str() {
                // If the user sets `license = "path/to/license"`, use that
                trace!("[package.manifest.wix].license is a path, using that");
                if package_dir.join(path).exists() {
                    return Ok(Some(License::from_stored_path(StoredPath::new(path))));
                } else {
                    return Err(Error::Generic(format!(
                        r#"{} specifies package.metadata.wix.license="{}" in its Cargo.toml, but no such file exists."#,
                        package.name, path,
                    )));
                }
            } else {
                // Don't accept anything else
                trace!("[package.manifest.wix].license is an invalid type");
                return Err(Error::Generic(format!(
                    "{}'s [package.metadata.wix].license must be a bool or a path",
                    package.name
                )));
            }
        }

        // First try Cargo's license_file field
        if let Some(path) = &package.license_file {
            trace!("Cargo.toml license_file is specified, using that");
            // NOTE: this join will mishandle an absolute path stored in the Cargo.toml
            // but there's very little justification for such a thing, so it's fine.
            if package_dir.join(path).exists() {
                // This is already a path relative to the Cargo.toml, so it can be used verbatim
                return Ok(Some(License::from_stored_path(
                    &StoredPathBuf::from_utf8_path(path),
                )));
            } else {
                return Err(Error::Generic(format!(
                    r#"{} specifies license-file="{}" in its Cargo.toml, but no such file exists."#,
                    package.name, path,
                )));
            }
        }

        // Next try Cargo's license field
        if let Some(name) = package.license.clone() {
            trace!("Cargo.toml license is specified");
            // If there's a template for this license, generate it
            if let Ok(generate) = Template::from_str(&name) {
                trace!("Found a matching template, generating that");
                let file_name = format!("{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}");
                let dest_file = dest_dir.join(file_name);
                let rel_file = dest_file.strip_prefix(package_dir).unwrap_or(&dest_file);
                let stored_path = StoredPathBuf::from_utf8_path(rel_file);
                return Ok(Some(License {
                    name: None,
                    stored_path,
                    generate: Some((dest_file, generate)),
                }));
            } else {
                trace!("No matching template, ignoring license");
            }
        }

        trace!("No source-license found");
        Ok(None)
    }

    /// Find the eula for a package
    fn find_end_user_license(
        path: Option<&StoredPath>,
        package: &Package,
        source_license: Option<&License>,
    ) -> Result<Option<License>> {
        trace!("finding end-user-license for {}", package.name);

        // If explicitly passed, use that
        if let Some(path) = path {
            trace!("explicit end-user-license path passed as argument, using that");
            return Ok(Some(License::from_stored_path(path)));
        }

        let package_dir = package.manifest_path.parent().expect("non-root Cargo.toml");

        // If there's [package.manifest.wix].eula, respect that
        if let Some(eula) = package
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("eula"))
        {
            trace!("[package.manifest.wix].eula is specified");
            if let Some(eula_enabled) = eula.as_bool() {
                // If the user sets `eula = false`, disable the eula
                // (= true just falls through to the auto-detection stuff below)
                if !eula_enabled {
                    trace!("[package.manifest.wix].eula is false, disabling license support");
                    return Ok(None);
                } else {
                    trace!("[package.manifest.wix].eula is true, continuing to auto-detect");
                }
            } else if let Some(path) = eula.as_str() {
                // If the user sets `eula = "path/to/license"`, use that
                trace!("[package.manifest.wix].eula is a path, using that");
                if package_dir.join(path).exists() {
                    return Ok(Some(License::from_stored_path(StoredPath::new(path))));
                } else {
                    return Err(Error::Generic(format!(
                        r#"{} specifies package.metadata.wix.eula="{}" in its Cargo.toml, but no such file exists."#,
                        package.name, path,
                    )));
                }
            } else {
                // Don't accept anything else
                trace!("[package.manifest.wix].eula is an invalid type");
                return Err(Error::Generic(format!(
                    "{}'s [package.metadata.wix].eula must be a bool or a path",
                    package.name
                )));
            }
        }

        // Try to use the source-license, if it has a path and is RTF,
        if let Some(license) = source_license {
            trace!("source-license is defined");
            let path = &license.stored_path;
            if path.extension() == Some(RTF_FILE_EXTENSION) {
                trace!("using path from license");
                return Ok(Some(License::from_stored_path(path)));
            }
        }

        trace!("No end-user-license found");

        warn!(
            "Could not find your project's EULA. The license agreement dialog will be excluded \
from the installer. You can add one by either:

* Setting 'package.license' to a recognized value (MIT, Apache-2.0, or GPL-3.0)
* Setting 'package.license-file', 'package.metadata.wix.license', or 'package.metadata.wix.eula' \
to point to an RTF file
* Passing an RTF file with --license or --eula to the cargo-wix CLI
* Editing the generated WiX Source (wxs) with a text editor

To supress this warning, set 'package.metadata.wix.eula = false'"
        );
        Ok(None)
    }
}


================================================
FILE: src/main.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # `cargo-wix` Binary and Subcommand
//!
//! The goal of the cargo-wix project and the `cargo wix` subcommand is to make
//! it easy to create a Windows installer (msi) for any Rust project. The
//! project is primarily implemented as a [cargo subcommand], but the core
//! functionality is provided in a library (crate). See the module-level
//! comments for the [library] for more information about usage and
//! organization of the `wix` crate. The remainder of this documentation
//! focuses on the usage and features of the `cargo wix` subcommand.
//!
//! ## Table of Contents
//!
//! - [Quick Start](#quick-start)
//! - [C Runtime](#c-runtime)
//! - [Examples](#examples)
//! - [Features](#features)
//!   - [Signing](#signing)
//!   - [Templates](#templates)
//!   - [Variables](#variables)
//!   - [Extensions](#extensions)
//!   - [Multiple WiX Sources](#multiple-wix-sources)
//!   - [Bundles](#bundles)
//! - [Configuration](#configuration)
//! - [Flags and Options](#flags-and-options)
//!
//! ## Quick Start
//!
//! Ensure the [WiX Toolset] is installed and a `WIX` system environment
//! variable has been created. The installer for the WiX Toolset should create
//! the `WIX` system environment variable automatically. Then, start, or
//! restart, a command prompt (cmd.exe) and execute the following commands:
//!
//! ```dos
//! C:\>cargo install cargo-wix
//! C:\>cd Path\To\Project
//! C:\Path\To\Project\>cargo wix init
//! C:\Path\To\Project\>cargo wix
//! ```
//!
//! The Windows installer (msi) will be in the `C:\Path\To\Project\target\wix`
//! folder. The `cargo wix init` command will create a `wix` folder alongside
//! the `src` folder and the project's manifest (Cargo.toml). The `wix` folder
//! will contain the WiX Source file (`main.wxs`) that was automatically
//! generated for the project based the contents of its manifest. The WiX Source
//! file can be customized using a text editor, and once the file exists, the
//! `cargo wix init` command does not need to be used again.
//!
//! The `cargo wix` command uses the `wix\main.wxs` file generated from the
//! previous `cargo wix init` command as input for the WiX Toolset's "compiler"
//! and "linker", i.e. `candle.exe` and `light.exe`, respectively, to create the
//! Windows installer (msi). A variety of artifact files will be created in the
//! `target\wix` folder. These can be ignored and/or deleted.
//!
//! ### Using WiX Toolset v4 and Newer (Modern Toolset)
//!
//! WiX Toolset v4 and newer use a single `wix.exe` binary instead of the
//! separate `candle.exe` and `light.exe` tools. To use the modern toolset,
//! install WiX v4+ via `dotnet tool install --global wix` and use the
//! `--toolset modern` flag:
//!
//! ```dos
//! C:\Path\To\Project\>cargo wix --toolset modern
//! ```
//!
//! If your project has existing WiX v3 source files (`.wxs`), they must be
//! converted to the v4 format before building. The `--migrate` flag automates
//! this conversion and installs any required WiX extension packages:
//!
//! ```dos
//! C:\Path\To\Project\>cargo wix --toolset modern --migrate global
//! ```
//!
//! The `--migrate` flag accepts two modes:
//!
//! - `global` — Converts `.wxs` files in place and installs extensions to the
//!   global WiX extension cache. Best for simple projects and CI pipelines with
//!   network access.
//! - `vendor` — Converts `.wxs` files in place and installs extensions to a
//!   local `.wix/extensions` folder. Best for offline builds or when tracking
//!   extension packages in version control.
//!
//! Alternatively, migration can be performed as a standalone step using the
//! `migrate` subcommand:
//!
//! ```dos
//! C:\Path\To\Project\>cargo wix migrate
//! ```
//!
//! After migration, the `--migrate` flag is no longer needed for subsequent
//! builds.
//!
//! For new projects starting with WiX v4, use `--schema v4` when initializing
//! to generate a v4-format `.wxs` file directly:
//!
//! ```dos
//! C:\Path\To\Project\>cargo wix init --schema v4
//! ```
//!
//! The created installer will install the executable file in a `bin` folder
//! within the destination selected by the user during installation. It will add
//! a license file to the same folder as the `bin` folder, and it will add the
//! `bin` folder to the `PATH` system environment variable so that the
//! executable can be called from anywhere with a command prompt. Most of these
//! behaviors can be adjusted during the installation process. The default
//! installation destination is `C:\Program Files\<project name>`, where
//! `<project name>` is replaced with the name of the project.
//!
//! ## C Runtime
//!
//! If using the `x86_64-pc-windows-msvc` or the `i686-pc-windows-msvc`
//! toolchain, then an appropriate C RunTime (CRT) must be available on the host
//! system _or_ the CRT must be statically compiled with the Rust binary
//! (executable). By default, the CRT is dynamically linked to a Rust binary if
//! using Microsoft Visual C compiler (MSVC). This may cause issues and errors
//! when running the Rust binary immediately after installation on a clean
//! Windows installation, i.e. the CRT has not already been installed. If the
//! Rust compiler is installed and an `-msvc` toolchain is available, then the
//! Rust binary will execute after installation without an issue.
//!
//! **Note**, the Rust programming language does _not_ need to be installed
//! to run an executable built using Cargo and Rust. Only a Microsoft-provided CRT
//! needs to be installed. These are often referred to as "redistributables". Rust
//! with either of the `-msvc` toolchains will dynamically link against the
//! `vcruntime140.dll`, which is part of the Visual C++ 2015 redistributable and
//! freely provided by Microsoft.
//!
//! For developers using the `cargo wix` subcommand to create an installer, this
//! dependency on the presence of an appropriate C runtime can lead to a sub-optimal
//! user experience. There are three options: (i) statically link the C runtime
//! within the Rust binary (recommended), (ii) add the Visual C++ redistributable to
//! the installer via the [Merge module] method for the WiX Toolset, or (iii)
//! provide the user with instructions for downloading and installing the CRT
//! _before_ running the executable.
//!
//! The current recommended option is to [statically link the CRT] when building
//! the Rust binary. Rust v1.19 or newer is required, and the solution
//! ultimately becomes adding the `-C target-feature=+crt-static` option to the
//! invocation of the Rust compiler (rustc). There are a variety of methods for
//! adding the option to the invocation, including but not limited to: (i)
//! creating a Cargo configuration file for the user or project, i.e.
//! `.cargo/config.toml`, and adding the following:
//!
//! ```
//! [target.x86_64-pc-windows-msvc]
//! rustflags = ["-C", "target-feature=+crt-static"]
//!
//! [target.i686-pc-windows-msvc]
//! rustflags = ["-C", "target-feature=+crt-static"]
//! ```
//!
//! to the `config.toml` file or (ii) creating the `RUSTFLAGS` environment
//! variable and setting its value to `"-C target-feature=+crt-static"`. Please
//! see the Rust compiler documentation on static linking for more information
//! and details.
//!
//! ## Examples
//!
//! All of the following examples use the native Command Prompt (cmd.exe) for
//! the Windows OS; however, the [Developer Prompt] installed with the [VC Build
//! Tools] is recommended. A [git bash], [PowerShell], or [Alacritty] terminal can
//! also be used.
//!
//! Begin each example by starting the appropriate prompt and navigating to the
//! root folder of the Rust project. The `cargo wix` subcommand and binary
//! assumes the current working directory (cwd) is the project, a.k.a. package,
//! root folder, i.e. the same folder as the package's manifest (Cargo.toml).
//!
//! Let's create a basic project with Cargo and then an installer.
//!
//! ```dos
//! C:\Path\to\Project> cargo init --bin --vcs none --name example
//! ```
//!
//! This will create a simple binary package named "example" without any version
//! control. While the `cargo wix` subcommand and binary does work with
//! libraries (crates) in addition to binaries (applications), generally an
//! installer is needed for a binary (application) not a library. Rust libraries
//! are typically distributed via [crates.io] and do not need an installer. The
//! package's manifest should look like the following, but with your name and
//! email address for the `authors` field:
//!
//! ```toml
//! [package]
//! name = "example"
//! version = "0.1.0"
//! authors = ["First Last <first.last@example.com>"]
//!
//! [dependencies]
//! ```
//!
//! The next step is to create the WiX Source (wxs) file, which is needed to
//! create the installer for the project.
//!
//! ```dos
//! C:\Path\to\Project> cargo wix init
//!  WARN: A description was not specified at the command line or in the package's manifest (Cargo.toml). The description can be added manually to the generated WiX Source (wxs) file using a text editor.
//!  WARN: An EULA was not specified at the command line, a RTF license file was not specified in the package manifest's (Cargo.toml) 'license-file' field, or the license ID from the package manifest's 'license' field is not recognized. The license agreement dialog will be excluded from the installer. An EULA can be added manually to the generated WiX Source (wxs) file using a text editor.
//!  WARN: A help URL could not be found and it will be excluded from the installer. A help URL can be added manually to the generated WiX Source (wxs) file using a text editor.
//!  WARN: A license file could not be found and it will be excluded from the installer. A license file can be added manually to the generated WiX Source (wxs) file using a text editor.
//! ```
//!
//! The warnings can be ignored for the time being, and they will be addressed in
//! subsequent examples. The above command will create a `wix` folder with the
//! `main.wxs` file:
//!
//! ```dos
//! C:\Path\to\Project> dir /B
//! Cargo.toml
//! src
//! wix
//! C:\Path\to\Project> dir wix /B
//! main.wxs
//! ```
//!
//! The `wix` folder and the `main.wxs` file now exist, and an installer can be
//! created:
//!
//! ```dos
//! C:\Path\to\Project> cargo wix
//! ```
//!
//! This may take a moment to complete as the `cargo wix` subcommand will build
//! the application with the _Release_ target profile and then build the
//! installer. The installer will be located in the `target\wix` folder.
//!
//! ```dos
//! C:\Path\to\Project> dir target\wix /B
//! example-0.1.0-x86_64.msi
//! main.wixobj
//! ```
//!
//! Great! An installer (msi) exists for the application. The `main.wixobj` file
//! is an artifact of the installer build process and can be ignored and/or
//! deleted.
//!
//! You can also automatically run the installer after creating it by
//! specifying the `--install` argument:
//!
//! ```dos
//! C:\Path\to\Project> cargo wix --install
//!  ```
//!
//! The installer that is created with the above steps and commands will install
//! the `example.exe` file to: `C:\Program Files\example\bin\example.exe`. It
//! will also add the `C:\Program Files\example\bin` path to the `PATH` system
//! environment variable, unless this feature is disabled during the
//! installation process from the Custom Setup dialog. The default welcome
//! screen, banner, and icons from the WiX Toolset's default UI component will
//! be used. A license dialog will _not_ appear for this installer.
//!
//! The installer that is created from the previous example is relatively simple,
//! but so is the application and package. It would be nice to have a license
//! dialog appear in the installer that allows the end-user to review and
//! acknowledge the End User License Agreement (EULA). It would also be nice to
//! have this same license appear in the installation folder for the application
//! so end-users can review it after installation.
//!
//! The license agreement dialog for a WiX Toolset-created installer must be in
//! the [Rich Text Format] (.rtf). The majority of Rust binaries and libraries
//! are developed and distributed with an open source license. We will do the
//! same for the example binary here and use the GPL-3.0 license. Creating a RTF
//! version of the GPL-3.0 requires a third-party tool, such as [WordPad], which
//! is freely available with any Windows distribution, [Microsoft Office],
//! [LibreOffice], or any number of freely available text editors, word
//! processors, or document conversion tools. Luckily, the `cargo wix`
//! subcommand and binary has a RTF version of the GPL-3.0 license available and
//! eliminates the need to install, pay, and/or learn another tool to create the
//! EULA.
//!
//! First, open the package's manifest (Cargo.toml) in a text editor, like
//! [Microsoft Notepad], and add the [`license`] field to the `package`
//! section with the `GPL-3.0` value:
//!
//! ```toml
//! [package]
//! name = "example"
//! version = "0.1.0"
//! authors = ["First Last <first.last@example.com>"]
//! license = "GPL-3.0"
//!
//! [dependencies]
//! ```
//!
//! Save the package's manifest and exit the text editor. Now, we can create a
//! `wix\main.wxs` file that will include the license dialog with a GPL-3.0
//! EULA.
//!
//! ```dos
//! C:\Path\to\Project> cargo wix init --force
//!  WARN: A description was not specified at the command line or in the package's manifest (Cargo.toml). The description can be added manually to the generated WiX Source (wxs) file using a text editor.
//!  WARN: A help URL could not be found and it will be excluded from the installer. A help URL can be added manually to the generated WiX Source (wxs) file using a text editor.
//!
//! C:\Path\to\Project> dir wix /B
//! License.rtf
//! main.wxs
//! C:\Path\to\Project> cargo wix
//! ```
//!
//! The `--force` flag is needed so that the existing `wix\main.wxs` is
//! overwritten with the new EULA-enabled `wix\main.wxs` file. The majority of
//! the warnings have also been addressed. Notice there is now a `License.rtf`
//! file in the `wix` folder. This will be used as the EULA in the license
//! agreement dialog for the installer and be included in the installation
//! folder with the binary.
//!
//! A side note, while version control has been disabled for these examples, it is
//! best practice to include installer-related files in version control; thus,
//! the `wix\main.wxs` and `wix\License.rtf` should be added to version control.
//!
//! Let's fix the remaining warnings. Both of the remaining warnings can be
//! resolved in multiple ways. The first is to use the options available for the
//! `cargo wix init` subcommmand following the previous example project:
//!
//! ```dos
//! C:\Path\to\Project> cargo wix init --force -d "This is a description" -u http://www.example.com
//!
//! C:\Path\to\Project> dir wix /B
//! License.rtf
//! main.wxs
//! C:\Path\to\Project> cargo wix
//! ```
//!
//! The warnings for the description and help URL have disappeared. The
//! `-d,--description` option for the `cargo wix init` command adds a
//! description for the installer. Similarly, the `-u,--url` option adds a help
//! URL. The `--force` flag is still needed to overwrite the previous
//! `wix\main.wxs` file.
//!
//! Another possibility is to add the `description` and `homepage` fields to the
//! package's manifest (Cargo.toml), and then initialize and create the
//! installer. The cargo-wix binary and subcommand will use these fields, among
//! others, to automatically include the values into the installer. The
//! `-d,--description` and `-u,--url` options can still be used to override the
//! values from the package's manifest. This can be useful if the contents of
//! the installer might need to be different or more detailed than the package.
//!
//! Following from the previous example, open the package's manifest
//! (Cargo.toml) in a text editor, like [Microsoft Notepad], and add the
//! [`description`] and [`homepage`] fields to the `package` section:
//!
//! ```toml
//! [package]
//! name = "example"
//! version = "0.1.0"
//! authors = ["First Last <first.last@example.com>"]
//! license = "GPL-3.0"
//! description = "This is a description"
//! homepage = "http://www.example.com"
//!
//! [dependencies]
//! ```
//!
//! Save the package's manifest and exit the text editor. Now, we can create a
//! `wix\main.wxs` file without any warnings and uses the description and
//! homepage from the package's manifest:
//!
//! ```dos
//! C:\Path\to\Project> cargo wix init --force
//! C:\Path\to\Project> dir wix /B
//! License.rtf
//! main.wxs
//! C:\Path\to\Project> cargo wix
//! ```
//!
//! The [`documentation`] and [`repository`] fields can be used instead of the
//! [`homepage`] field for the help URL, too.
//!
//! ## Features
//!
//! The cargo-wix binary, and related `cargo wix` subcommand, use the WiX
//! Toolset and the [SignTool] application available in the [Windows 10 SDK].
//! These are obviously Windows-only applications, so while the crate and binary
//! can be built on any platform supported by the [Rust] programming language
//! and [Cargo], the `cargo wix` subcommand is only really useful in a Windows
//! environment.
//!
//! The WiX Toolset provides a "compiler" (`candle.exe`) and "linker"
//! (`light.exe`). These can be found in the `bin` directory of the installation
//! location for the WiX Toolset. The value of the `WIX` system environment
//! variable that is created during installation of the WiX Toolset is a path to
//! the installation folder that contains the `bin` folder. The `WIX` system
//! environment variable is used by the `cargo wix` subcommand with
//! the [`std::process::Command`] module to create installers.
//!
//! ### Signing
//!
//! The Windows SDK provides a signer (`signtool`) application for signing
//! installers. The application is installed in the `bin` folder of the Windows
//! SDK installation. The location of the `bin` folder varies depending on the
//! version. It is recommended to use the Developer Prompt to ensure the
//! `signtool` application is available. Signing an installer is optional.
//!
//! ### Templates
//!
//! The WiX Toolset requires a WiX Source (WXS) file, which is an [XML] file. A
//! template is provided with this binary that attempts to meet the majority
//! of use cases for developers and avoid requiring extensive knowledge of the
//! WiX Toolset and Windows installer technologies. Modification of the template
//! is encouraged, but please consult the WiX Toolset's extensive
//! [documentation] and [tutorials] for information about writing (authoring),
//! customizing, and using WXS files. This documentation here is only for this
//! binary and subcommand.
//!
//! The [WXS] template is embedded in the binary installation of the subcommand
//! and it can be printed to STDOUT using the `cargo wix print wxs` command from
//! the command prompt (cmd.exe). Note, each time the `cargo wix print wxs`
//! command is invoked, new Globally Unique Identifiers ([GUID]) are generated
//! for fields that require them. Thus, a developer does not need to worry about
//! generating GUIDs and can begin using the template immediately with this
//! subcommand or the WiX Toolset's compiler (`candle.exe`) and linker
//! (`light.exe`) applications.
//!
//! In addition to the WXS template, there are several license templates which
//! are used to generate an End User License Agreement (EULA) during the `cargo
//! wix init` command. Depending on the license ID(s) in the `license` field for
//! a package's manifest (Cargo.toml), a license file in the Rich Text Format
//! (RTF) is generated from a template and placed in the `wix` folder. This RTF
//! file is then displayed in the license agreement dialog of the installer. See
//! the help information on the `carge wix print` subcommand:
//!
//! ```dos
//! C:\Path\to\Project> cargo wix print --help
//! ```
//!
//! for information about supported licenses. If the `license` field is
//! not used, or the license ID is not supported, then the EULA is _not_
//! automatically created during initialization and it will have to be created
//! manually with a text editor or some other authoring tool.
//!
//! The `cargo wix init` subcommand uses a combination of the [`license`] and
//! [`license-file`] fields of the project's manifest (Cargo.toml) to determine
//! if a [sidecar] license file should be included in the installation folder
//! alongside the `bin` folder. The `license` field appears to be the more
//! commonly used field to describe the licensing for a Rust project and
//! package, while the `license-file` field is used to specify a custom, or
//! proprietary, license.
//!
//! The top three most common licenses for Rust projects are supported from the
//! `license` field, i.e. MIT, Apache-2.0, and GPLv3. If any of these three
//! supported open source licenses are used for the `license` field, then a
//! `License.rtf` file is generated from an embedded template and placed in the
//! `wix` folder as part of the `cargo wix init` subcommand. This generated RTF
//! file will be used as a sidecar file and for the End User License Agreement
//! (EULA) that is displayed in the license agreement dialog of the installer.
//! If the `license-file` field is used and it contains a path to a file with
//! the `.rtf` extension, then this file will be used as a sidecar file and for
//! the EULA. If neither of these fields exist or contain valid values, then no
//! sidecar file is included in the installation and no license agreement dialog
//! appears during installation. This default behavior can be overridden with
//! the `-l,--license` and `-e,--eula` options for the `cargo wix init`
//! subcommand.
//!
//! ### Variables
//!
//! The cargo-wix subcommand automatically passes some Cargo and build
//! configuration-related values to the WiX Toolset compiler (candle.exe). These
//! variables can be used within a WiX Source (WXS) file using the
//! `$(var.<VARIABLE>)` notation, where `<VARIABLE>` is replaced with the name
//! of variable passed from the cargo-wix subcommand to the WiX Toolset
//! compiler using the `-DKEY=VALUE` option. Notable usage of these variables
//! are in [WiX preprocessor] directives to dynamically change the installer
//! creation at build time. Below is a current list of variables passed from the
//! cargo-wix subcommand to a WXS file during installer creation.
//!
//! - `TargetTriple` = The rustc target triple name as seen with the `rustc
//!   --print target-list` command
//! - `TargetEnv` = The rustc target environment, as seen with the output from
//!   the `rustc --print cfg` command as `target_env`. On Windows, this typically
//!   either `msvc` or `gnu` depending on the toolchain downloaded and installed.
//! - `TargetVendor` = The rustc target vendor, as seen with the output from the
//!   `rustc --print cfg` command as `target_vendor`. This is typically `pc`, but Rust
//!   does support other vendors, like `uwp`.
//! - `CargoTargetBinDir` = The complete path to the binary (exe). The default
//!   would be `target\release\<BINARY_NAME>.exe` where `<BINARY_NAME>` is replaced
//!   with the name of each binary target defined in the package's manifest
//!   (Cargo.toml). If a different rustc target triple is used than the host, i.e.
//!   cross-compiling, then the default path would be
//!   `target\<CARGO_TARGET>\<CARGO_PROFILE>\<BINARY_NAME>.exe`, where
//!   `<CARGO_TARGET>` is replaced with the `CargoTarget` variable value and
//!   `<CARGO_PROFILE>` is replaced with the value from the `CargoProfile` variable.
//! - `CargoTargetDir` = The path to the directory for the build artifacts, i.e.
//!   `target`.
//! - `CargoProfile` = Either `debug` or `release` depending on the build
//!   profile. The default is `release`.
//! - `Platform` = (Deprecated) Either `x86`, `x64`, `arm`, or `arm64`. See the
//!   documentation for the WiX Toolset compiler (candle.exe) `-arch` option.
//!   Note, this variable is deprecated and will eventually be removed because it is
//!   ultimately redundant to the `$(sys.BUILDARCH)` variable that is already provided
//!   by the WiX Toolset compiler. Existing projects should replace usage of
//!   `$(var.Platform)` with `$(sys.BUILDARCH)`. No action is needed for new projects.
//! - `Profile` = (Deprecated) See `CargoProfile`.
//! - `Version` = The version for the installer. The default is the
//!   `Major.Minor.Fix` semantic versioning number of the Rust package.
//!
//! Additional, user-defined variables for custom WXS files can be passed to the
//! WiX Toolset compiler (candle.exe) using the cargo-wix subcommand
//! `-C,--compiler-arg` option. For example,
//!
//! ```dos
//! C:\Path\To\Project\>cargo wix -C "-DUSER_KEY=USER_VALUE"
//! ```
//!
//! ### Extensions
//!
//! The [WixUIExtension] and [WixUtilExtension] are included in every execution
//! of the default _create_ cargo-wix subcommand, i.e. `cargo wix`. This is the
//! same as calling either the compiler (candle.exe) or the linker (light.exe)
//! with the `-ext WixUIExtension -ext WixUtilExtension` options. These two
//! extensions are commonly used to create installers when using the WiX
//! Toolset, so these are included by default. Additionally, the WixUIExtension
//! is used for the template WXS file.
//!
//! Additionally, the [WixBalExtension] is automatically included if the
//! cargo-wix subcommand detects a bundle (exe) is to be created instead of a
//! MSI package. See the [Bundles](#bundles) section for more information about
//! creating and managing bundles with the cargo-wix subcommand.
//!
//! ### Multiple WiX Sources
//!
//! The cargo-wix subcommand supports including multiple WXS files when creating
//! an installer. A lot of customization is possible through the WXS file and
//! sometimes the installer's source code becomes its own project where
//! organization and formatting are important. Breaking up a single, large WXS
//! file into multiple WXS files can be useful for code readability and project
//! navigation. Thus, cargo-wix will include any file with the `.wxs` file
//! extension found in the default source folder, `wix`, when creating an
//! installer. For example, say you have the following project with three WXS
//! files in the `wix` sub-folder:
//!
//! ```dos
//! C:\Path\to\Project> dir /B
//! Cargo.toml
//! src
//! wix
//! C:\Path\to\Project> dir wix /B
//! first.wxs
//! second.wxs
//! third.wxs
//! ```
//!
//! When the `cargo wix` default _create_ command is executed, all three WXS files
//! will be included and used to create the installer. Generally, this
//! translates to the following set of commands:
//!
//! ```dos
//! C:\Path\to\Project> candle -out target\wix\ wix\first.wxs wix\second.wxs wix\third.wxs
//! C:\Path\to\Project> light -out target\wix\example-0.1.0-x86_64.msi target\wix\first.wixobj target\wix\second.wixobj target\wix\third.wixobj
//! ```
//!
//! Alternatively, multiple WXS files can also be included when creating an
//! installer by including the relative or absolute paths to the WXS files as
//! arguments to the subcommand, but any WXS files in the default, `wix`,
//! sub-folder are ignored and would have to be explicitly included. For
//! example,
//!
//! ```dos
//! C:\Path\To\Project> cargo wix path\to\first\wxs\file\one.wxs path\to\second\wxs\file\two.wxs
//! ```
//!
//! ### Bundles
//!
//! It is possible to create [bundle-based installers] with the WiX Toolset. The
//! cargo-wix subcommand and binary currently offer limited support for creating
//! bundles from Rust projects. This includes automatically detecting if a
//! bundle is to be created by inspecting all WiX Object (wixobj) files before
//! linking and changing the file extension from `msi` to `exe`, as bundles
//! require the executable (exe) file extension. In addition to automatically
//! changing the file extension of the installer, the [WixBalExtension] is
//! included automatically during linking if a bundle is detected because this
//! extension includes a standard bootstrapper application that is commonly used
//! to build and customize bundles.
//!
//! While the cargo-wix subcommand does provide some support for bundles with
//! automatic file extension determination and inclusion of useful
//! bundle-centric extensions, the process for creating a bundle for a Rust
//! project is currently a manual process. Let's assume the following
//! [workspace]-based Rust project layout and structure:
//!
//! ```text
//! |-- C:\Path\to\Rust\Project
//! |-- |-- Cargo.toml
//! |-- |-- client
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- server
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! ```
//!
//! The virtual manifest, Cargo.toml, in the root of the project is a [virtual
//! manifest] that only contains the following:
//!
//! ```toml
//! [workspace]
//! members = ["client", "server"]
//! ```
//!
//! The package manifests for the workspace members, `client\Cargo.toml` and
//! `server\Cargo.toml`, are the typical package manifests content for a binary
//! package.
//!
//! The goal is to create a bundle-based executable that contains and
//! installs both the client and server packages through their respective
//! installers (MSI packages). A combination of manual file manipulation and the
//! cargo-wix subcommand can be used to accomplish this goal, all from the root
//! of the workspace. Begin by creating the WiX Source (wxs) files for the
//! client and server MSI packages:
//!
//! ```dos
//! C:\Path\to\Rust\Workspace> cargo wix init client\Cargo.toml
//! C:\Path\to\Rust\Workspace> cargo wix init server\Cargo.toml
//! ```
//!
//! The following project layout should have been created:
//!
//! ```text
//! |-- C:\Path\to\Rust\Workspace
//! |-- |-- Cargo.toml
//! |-- |-- client
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- |-- wix
//! |-- |-- |-- |-- main.wxs
//! |-- |-- server
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- |-- wix
//! |-- |-- |-- |-- main.wxs
//! ```
//!
//! The WiX Source (wxs) files created for the client and server crates of the
//! Rust workspace using the cargo-wix subcommand will be generated following
//! the normal rules, features, and templates when using the `cargo wix init`
//! within a non-workspace-based project.
//!
//! With the WiX Source (wxs) files created for the two MSI-based installers, a
//! bundle-based WiX Source (wxs) file must be created for the workspace and
//! bundle. Create a new `main.wxs` file and place it in a `wix` sub-folder
//! relative to the workspace root. The following project layout should exist:
//!
//! ```text
//! |-- C:\Path\to\Rust\Workspace
//! |-- |-- Cargo.toml
//! |-- |-- client
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- |-- wix
//! |-- |-- |-- |-- main.wxs
//! |-- |-- server
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- |-- wix
//! |-- |-- |-- |-- main.wxs
//! |-- |-- wix
//! |-- |-- |-- main.wxs
//! ```
//!
//! Open the `wix\main.wxs` file in a suitable text editor and add the following
//! XML to it to define the bundle:
//!
//! ```xml
//! <?xml version="1.0"?>
//! <Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
//!   <Bundle Version="1.0.0" UpgradeCode="[Your GUID Here]">
//!     <BootstrapperApplicationRef Id="WixStandardBootstrapperApplication.RtfLicense"/>
//!     <Chain>
//!       <MsiPackage SourceFile="client\target\wix\client-0.1.0-x86_64.msi" />
//!       <MsiPackage SourceFile="server\target\wix\server-0.1.0-x86_64.msi" />
//!     </Chain>
//!   </Bundle>
//! </Wix>
//! ```
//!
//! A GUID will need to be manually generated for the `UpgradeCode` attribute of
//! the `Bundle` tag and used to replace the `[Your GUID Here]` value. Now, the
//! bundle can be created but first both the client and server MSI packages must
//! be created. Thus, creating the bundle is a multi-step, or multi-command,
//! process:
//!
//! ```dos
//! C:\Path\to\Workspace> cargo wix client\Cargo.toml
//! C:\Path\to\Workspace> cargo wix server\Cargo.toml
//! C:\Path\to\Workspace> cargo wix --name Bundle --install-version 1.0.0
//! ```
//!
//! The following project layout should exist:
//!
//! ```text
//! |-- C:\Path\to\Rust\Workspace
//! |-- |-- Cargo.toml
//! |-- |-- client
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- |-- target
//! |-- |-- |-- |-- wix
//! |-- |-- |-- |-- |-- server-0.1.0-x86_64.msi
//! |-- |-- |-- wix
//! |-- |-- |-- |-- main.wxs
//! |-- |-- server
//! |-- |-- |-- Cargo.toml
//! |-- |-- |-- src
//! |-- |-- |-- |-- main.rs
//! |-- |-- |-- target
//! |-- |-- |-- |-- wix
//! |-- |-- |-- |-- |-- server-0.1.0-x86_64.msi
//! |-- |-- |-- wix
//! |-- |-- |-- |-- main.wxs
//! |-- |-- target
//! |-- |-- |-- Release
//! |-- |-- |-- |-- client.exe
//! |-- |-- |-- |-- server.exe
//! |-- |-- |-- wix
//! |-- |-- |-- |-- Bundle-1.0.0-x86_64.exe
//! |-- |-- wix
//! |-- |-- |-- main.wxs
//! ```
//!
//! Note the built binaries are located in the `target\Release` folder relative
//! to the workspace root as opposed to the `client\target\Release` and
//! `server\target\Release` folders, even though the MSI packages are available
//! in the member's `target\wix` folders. This will fail if the various `cargo
//! wix` commands are _not_ executed from the workspace root.
//!
//! The `name` and `install-version` options can be moved into a
//! [configuration](#configuration) section for the subcommand within the
//! virtual manifest of the workspace, i.e. the Cargo.toml file with the
//! `[workspace]` section to avoid having to retype them each time a bundle is
//! created, but all three `cargo wix` commands must be issued each time.
//!
//! While the above steps will create a bundle installer for the workspace-based
//! Rust project with a default, placeholder EULA, it is very manual and
//! cumbersome. For example, the bundle-based WiX Source (wxs) file will have to
//! be manually updated each time the version numbers of the member MSI packages
//! are changed because the paths to the source files are hard-coded in the XML.
//! Efforts are underway to improve support within the cargo-wix subcommand for
//! both workspaces and bundles ([Issue #74] and [Issue #98]).
//!
//! [Issue #74]: https://github.com/volks73/cargo-wix/issues/74
//! [Issue #98]: https://github.com/volks73/cargo-wix/issues/98
//!
//! ## Configuration
//!
//! The default subcommand, `cargo wix`, which creates a MSI based on the
//! contents of the package's manifest (Cargo.toml) can be configured by adding
//! a `[package.metadata.wix]` section to the manifest. For each CLI option for
//! the default _create_ subcommand, a field can be added to the
//! `[package.metadata.wix]` section. If the corresponding CLI option is used
//! with the default _create_ subcommand, then the CLI option value will
//! override the value in the metadata section.
//!
//! Below is an example `[package.metadata.wix]` section from a package's
//! manifest that configures the default _create_ subcommand:
//!
//! ```toml
//! [package.metadata.wix]
//! banner = "path\to\banner.png"
//! compiler-args = ["-nologo", "-wn"]
//! culture = "Fr-Fr"
//! dbg-build = false
//! dbg-name = false
//! dialog = "path\to\dialog.png"
//! eula = "path\to\eula.rtf"
//! include = ["Path\to\WIX\Source\File\One.wxs", "Path\to\WIX\Source\File\Two.wxs"]
//! license = "path\to\license.txt"
//! linker-args = ["-nologo"]
//! locale = "Path\to\WIX\Localization\File.wxl"
//! name = "example"
//! no-build = false
//! output = "Path\and\file\name\for\installer.msi"
//! path-guid = "BFD25009-65A4-4D1E-97F1-0030465D90D6"
//! product-icon = "path\to\product_icon.ico"
//! upgrade-guid = "B36177BE-EA4D-44FB-B05C-EDDABDAA95CA"
//! version = "2.1.0"
//! ```
//!
//! See the documentation for each CLI option for more information about each
//! field and its purpose. Note, the `name` and `version` fields will be the
//! name and version number of the application as it appears in the Add/Remove
//! Programs control panel, and the version number does _not_ need to match the
//! package's version number. In other words, the installed application can have
//! a different version number from the package, which is useful with multiple
//! binaries, workspaces, or distributing a "suite" of applications, where the
//! version number would be for the suite and not necessarily the individual
//! applications within the suite.
//!
//! Please note that unlike most of the fields, the `include` field is an [TOML
//! array] instead of a string value. This is the same as passing multiple paths
//! to the default _create_ subcommand using multiple `-I,--include` options or
//! including multiple WXS files in the default, `wix`, project source location.
//!
//! The only CLI option, or argument, that is not supported in the
//! `[package.metadata.wix]` section is the `<INPUT>` argument for the default
//! _create_ command, which specifies a relative or absolute path to a package's
//! manifest file. The assumption is that the package manifest (Cargo.toml) to
//! be used for the default _create_ subcommand is the same manifest that
//! contains the `[package.metadata.wix]` section.
//!
//! ## Flags and Options
//!
//! Generally, any value that is obtained from the package's manifest
//! (Cargo.toml) can be overridden at the command line with an appropriate
//! option. For example, the manufacturer, which is displayed as the "Publisher"
//! in the Add/Remove Programs (ARP) control panel is obtained from the first
//! author listed in the `authors` field of a project's manifest, but it can be
//! overridden using the `-m,--manufacturer` option with the `cargo wix init`
//! subcommand.
//!
//! Use the `-h,--help` flag with each subcommand to get a full list of options
//! and flags that are available. The short flag, `-h`, will print a condensed
//! version of each flag and option for the subcommand, while the long flag,
//! `--help`, will print a detailed help for each flag and option. The rest of
//! this section is a list of all flags and options implemented for all
//! subcommands.
//!
//! ### `-b,--banner`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Sets the path to an image file (.png, .bmp, ...) that will be displayed across
//! the top of each dialog in the installer. The banner image dimensions should
//! be 493 x 58 pixels, but the left-most 50% of that image is covered with text,
//! so if you want to leave a blank background for text readability, you only want
//! to color in the right-most ~200 pixels of that image.
//!
//!
//! ### `-b,--bin-path`
//!
//! Available for the default _create_ (`cargo wix`) and _sign_ (`cargo wix
//! sign`) subcommands.
//!
//! The `-b,--bin-path` option can be used to specify a path (relative or
//! absolute) to the WiX Toolset `bin` folder. The `-b,--bin-path` option is
//! useful if a different version of the WiX Toolset needs to be used to create
//! the installer. The descending order of precedence is: (1) `-b,--bin-path`
//! option then (2) `WIX` system environment variable. An error will be
//! displayed if the compiler and/or linker cannot be found.
//!
//! This option is also available for the `cargo wix sign` subcommand and can be
//! used to specify a path to the Windows SDK `bin` folder. This can be used to
//! override default `signtool` application found using the
//! [`std::process::Command::status`] method.
//!
//! ### `-B,--binary`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! A path to a binary, a.k.a. executable, to include in the installer _instead_
//! of any and all binaries defined in the package's manifest (Cargo.toml). By
//! default, all binaries defined with the `[[bin]]` section in the package's
//! manifest are included in the installer. If no `[[bin]]` section is defined,
//! then the package's `name` field is used. This option can be used to
//! override, i.e. _not_ append, the binaries that should be included in the
//! installer.
//!
//! This option can be used multiple times to define multiple binaries to
//! include in the installer. The value is a path to a binary file. The file
//! stem (file name without extension) is used as the binary name within the WXS
//! file. A relative or absolute path is acceptable.
//!
//! ### `-C,--compiler-arg`
//!
//! Available for the default _create (`cargo wix`) subcommand.
//!
//! Appends an argument to the WiX compiler (candle.exe) invocation. This
//! provides a mechanism for "passing" arguments to the compiler. This can be called
//! multiple times to pass multiple arguments (flags or options), but only one
//! value per occurrence is allowed to avoid ambiguity during argument parsing.
//! Note, if it is an option, i.e. argument with an accompanying value, then the
//! value must be passed as a separate usage of this option. For example, adding
//! an user-defined compiler extension would require the following command
//! `cargo wix -C -ext -C UserDefinedExtension` to yield a `candle -ext
//! UserDefinedExtension` invocation.
//!
//! ### `-c,--culture`
//!
//! Available for the default _create_ (`cargo wix`) subcommand.
//!
//! Sets the culture for localization. Use with the `-l,--locale` option. See
//! the [WixUI localization documentation] for more information about acceptable
//! culture codes. The codes are case insensitive.
//!
//! ### `-d,--dbg-build`
//!
//! Available only for the default _create_ (`cargo wix`) subcommmand.
//!
//! Builds the package using the Debug profile instead of the Release profile
//! with Cargo. This flag is ignored if the `--no-build` flag is used. The
//! default is to build the package with the Release profile.
//!
//! ### `-D,--dbg-name`
//!
//! Available only for the default _create_ (`cargo wix`) subcommand.
//!
//! Appends `-debug` to the file stem (portion before the dot and file
//! extension) of the installer's file name. The default is to _not_ include the
//! suffix. Generally, this should be used to indicate an installer contains a
//! binary that was built with debugging information and minimal optimizations
//! as a tradeoff for being able to troubleshoot execution of the application on
//! an end-user's system. A release build generally does not contain any
//! debugging information but includes optimizations. It is typical to use this
//! flag with the `-d,--dbg-build` flag but it is not required. This allows a
//! developer to provide other mechanisms for creating a debugging variant of
//! his or her application and still use the Release profile.
//!
//! ### `-d,--description`
//!
//! Available for the _init_ (`cargo wix init`), _print_ (`cargo wix print`),
//! and _sign_ (`cargo wix sign`) subcommands.
//!
//! The package description is used in multiple places for the installer,
//! including the text that appears in the blue UAC dialog when using a signed
//! installer. This can be overridden using the `-d,--description` option with
//! the `cargo wix init` or `cargo wix sign` subcommands, respectively.
//!
//! ### `-D,--dialog`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Sets the path to an image file (.png, bmp, ...) that will be displayed as
//! the background of the first dialog of the installer. The dialog image dimensions
//! should be 493 x 312 pixels, but the right-most 60% of that area is covered
//! by the actual text of the dialog, so if you want to leave a blank background for text
//! readability, you only want to color in the left-most ~200 pixels of that image.
//!
//! The first dialog is known as the "Welcome" dialog.
//!
//! ### `-e,--eula`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Specifies a Rich Text Format (RTF) file to use as the End User License
//! Agreement (EULA) for the license agreement dialog of the installer. The
//! default is to disable the license agreement dialog unless one of the
//! supported licenses (GPL-3.0, Apache-2.0, or MIT) is generated based on the
//! value of the `license` field in the package's manifest (Cargo.toml). An EULA
//! can be enabled later by directly modifying the WiX Source (WXS) file with a
//! text editor.
//!
//! When specified via `package.metadata.wix.eula` the path is assumed to be relative
//! to the Cargo.toml (directory). This field can also be set to `false` to disable
//! the eula even if we could auto-generate one for you, as described above.
//!
//! ### `--force`
//!
//! Available for the _init_ (`cargo wix init`) subcommand.
//!
//! Forces overwriting of generated files from the _init_ subcommand. Use with
//! caution! This cannot be undone.
//!
//! ### `-h,--help`
//!
//! Available for all subcommands.
//!
//! The short flag, `-h`, will print a condensed version of the help text, while
//! the long flag, `--help`, will print a more detailed version of the help
//! text.
//!
//! ### `-u,--homepage`
//!
//! Available for the _sign_ (`cargo wix sign`) subcommand.
//!
//! This will be displayed in the ACL dialog.
//!
//! ### `--install`
//!
//! Available for the default _create_ (`cargo wix`) subcommand.
//!
//! Automatically runs the installer after creating it.
//!
//! ### `-i,--install-version`
//!
//! Available for the default _create_ (`cargo wix`) subcommand.
//!
//! Overrides the version from the package's manifest (Cargo.toml), which is
//! used for the installer name and appears in the Add/Remove Programs (ARP)
//! control panel.
//!
//! ### `-I,--include`
//!
//! Available only for the default _create_ (`cargo wix`) subcommand.
//!
//! This option can be used multiple times to include multiple WiX Source (WXS)
//! files in the creation of an installer. The option takes a path to a single
//! WXS file as its value. Any WXS files located in the default `wix` folder
//! located within the package's root folder, i.e. same location as the
//! package's manifest (Cargo.toml) are automatically included and used in the
//! creation of the installer. This option allows the inclusion of other WXS
//! files outside of the default `wix` location.
//!
//! ### `-l,--license`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Overrides the `license-file` field or any license generated from the
//! `license` field of the package's manifest (Cargo.toml). If an appropriate
//! license file does not exist, cannot be found, or is not specified, then no
//! license file is included in the installer or in the installation folder
//! along side the `bin` folder. A file containing the license, such as a TXT,
//! PDF, or RTF file, can be added later by directly editing the generated WiX
//! Source file (WXS) in a text editor.
//!
//! When specified via `package.metadata.wix.license` the path is assumed to be relative
//! to the Cargo.toml (directory). This field can also be set to `false` to disable
//! the license auto-generation features described above.
//!
//! ### `-L,--linker-arg`
//!
//! Available for the default _create (`cargo wix`) subcommand.
//!
//! Appends an argument to the WiX linker (light.exe) invocation. This provides
//! a mechanism for "passing" arguments to the linker. This can be called
//! multiple times to pass multiple arguments (flags or options). Only one value
//! per occurrence is allowed to avoid ambiguity during argument parsing. Note,
//! if it is an option, i.e. argument with an accompanying value, then the value
//! must be passed as a separate usage of this option. For example, adding an
//! user-defined linker extension would require the following command `cargo wix
//! -L -ext -L UserDefinedExtension` to yield a `light -ext
//! UserDefinedExtension` invocation.
//!
//! ### `-l,--locale`
//!
//! Available for the default _create_ (`cargo wix`) subcommand.
//!
//! Sets the path to a WiX localization file (wxl) which contains localized
//! strings. Use in conjunction with the `-c,--culture` option.
//!
//! ### `-m,--manufacturer`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Overrides the `authors` field of the package's manifest
//! (Cargo.toml) as the manufacturer within the installer. The manufacturer can
//! be changed after initialization by directly modifying the WiX Source file
//! (WXS) with a text editor.
//!
//! ### `-n,--name`
//!
//! Available for the default _create_ (`cargo wix`) subcommand.
//!
//! Overrides the `name` field in the package's manifest (Cargo.toml), which is
//! used in the file name of the installer (msi). This does not change the name
//! of the executable _within_ the installer.
//!
//! ### `--no-build`
//!
//! Available for the default _create_ (`cargo wix`) subcommand.
//!
//! This skips building the Rust package using Cargo for the Release target.
//!
//! ### `--nocapture`
//!
//! Available for the default _create_ (`cargo wix`) and _sign_ (`cargo wix sign`)
//! subcommands.
//!
//! Displays all output from the builder (Cargo), compiler (candle.exe), linker
//! (light.exe), and signer (signtool.exe) applications.
//!
//! ### `-o,--output`
//!
//! Available for the default _create_ (`cargo wix`), _init_ (`cargo wix init`) and
//! _print_ (`cargo wix print`) subcommands.
//!
//! Sets the destination for _init_ subcommand files, such as the WiX Source
//! file (WXS), an alternative to stdout for _print_ subcommand, and the created
//! installer for the default _create_ subcommand.
//!
//! When used with the default _create_ subcommand to create an installer (MSI),
//! if the path is to an existing directory or the path has a trailing `/` or
//! `\`, then the MSI will be available after creation at the specified path,
//! but the MSI file name will be the default file name based on the package
//! name, version, and platform.
//!
//! ### `-O,--owner`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Sets the copyright owner of the license during initialization or printing.
//! The default is to use the `authors` field of the package's manifest
//! (Cargo.toml). This is only used when generating a license based on the value
//! of the `license` field in the package's manifest.
//!
//! ### `-p,--package`
//!
//! Available for the _create_ (`cargo wix`), _init_ (`cargo wix init`), and
//! _print_ (`cargo wix print`) subcommands.
//!
//! Selects the package within a workspace. This is required if a project
//! organized with a workspace. A workspace can have one or more members, where
//! each member may have a separate installer. This option has no effect if the
//! project does not use a workspace.
//!
//! ### `--path-guid`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Overrides the automatically generated GUID for the path component with an
//! existing GUID in the hyphenated, uppercase format. The path GUID should only
//! be generated once for a product/project. The same GUID should be used for
//! all installer creations to ensure no artifacts are left after uninstalling
//! and proper modification of the `PATH` environment variable.
//!
//! ### `--product-icon`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Sets the path to a 16x16 image file (.ico) that will be display as an icon in the
//! Add/Remove Programs (ARP) control panel for the installed application.
//!
//! ### `--product-name`
//!
//! Available for the _init_ (`cargo wix init`), _print_ (`cargo wix print`),
//! and _sign_ (`cargo wix sign`) subcommands.
//!
//! Overrides the `name` field of the package's manifest (Cargo.toml) as the
//! product name within the installer. The product name can be changed after
//! initialization or printing by directly modifying the WiX Source file (wxs)
//! with a text editor.
//!
//! ### `-t,--timestamp`
//!
//! Available for the _sign_ (`cargo wix sign`) subcommand.
//!
//! An alias or URL to a timestamp server when signing an installer with a
//! certificate. Valid aliases are: `Comodo` and `Versign`, which are case
//! insensitive.
//!
//! ### `--upgrade-guid`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Overrides the automatically generated GUID for the product's upgrade code
//! with an existing GUID in the hyphenated, uppercase format. The upgrade code
//! should only be generated once for a product/project. The same upgrade code
//! should then be used for all installer creations of the same product/project. If
//! a new GUID is used every time an installer is created, then each installer will
//! be installing the same product but as separate installations.
//!
//! ### `-u,--url`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Adds a URL to the installer that will be displayed in the Add/Remove
//! Programs (ARP) control panel for the application. The default is to disable
//! it unless a URL is specified for either the `homepage`, `documentation`, or
//! `repository` fields in the package's manifest (Cargo.toml). The help URL can
//! be enabled after initialization by directly modifying the WiX Source (wxs)
//! file with a text editor.
//!
//! ### `-V,--version`
//!
//! Available for all subcommands.
//!
//! Prints the cargo-wix binary and subcommand version.
//!
//! ### `-v,--verbose`
//!
//! Available for all subcommands.
//!
//! Increases the level of logging statements based on occurrence count of the
//! flag. The more `-v,--verbose` flags used, the more logging statements that
//! will be printed during execution of a subcommand. When combined with the
//! `--nocapture` flag, this is useful for debugging and testing.
//!
//! ### `-i,--installer`
//!
//! Available for the _sign_ (`cargo wix sign`) subcommand.
//!
//! Speicifies path to the installer(msi) to be signed.
//!
//! ### `-y,--year`
//!
//! Available for the _init_ (`cargo wix init`) and _print_ (`cargo wix print`)
//! subcommands.
//!
//! Sets the copyright year for the license during initialization. The default
//! is to use the current year. This is only used if a license is generated from
//! one of the supported licenses based on the value of the `license` field in
//! the package's manifest (Cargo.toml).
//!
//! [Alacritty]: https://github.com/alacritty/alacritty
//! [bundle-based installers]: https://wixtoolset.org/documentation/manual/v3/bundle/
//! [Cargo]: https://crates.io
//! [cargo subcommand]: https://github.com/rust-lang/cargo/wiki/Third-party-cargo-subcommands
//! [crates.io]: https://crates.io
//! [Developer Prompt]: https://msdn.microsoft.com/en-us/library/f35ctcxw.aspx
//! [`description`]: https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata
//! [`documentation`]: https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata
//! [documentation]: http://wixtoolset.org/documentation/
//! [git bash]: https://gitforwindows.org/
//! [GUID]: https://en.wikipedia.org/wiki/Universally_unique_identifier
//! [`homepage`]: https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata
//! [library]: ../wix/index.html
//! [LibreOffice]: https://www.libreoffice.org/
//! [`license`]: https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata
//! [`license-file`]: https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata
//! [Merge module]: https://wixtoolset.org/documentation/manual/v3/howtos/redistributables_and_install_checks/install_vcredist.html
//! [Microsoft Office]: https://products.office.com/en-us/home
//! [Microsoft Notepad]: https://en.wikipedia.org/wiki/Microsoft_Notepad
//! [PowerShell]: https://github.com/PowerShell/PowerShell
//! [`repository`]: https://doc.rust-lang.org/cargo/reference/manifest.html#package-metadata
//! [Rich Text Format]: https://en.wikipedia.org/wiki/Rich_Text_Format
//! [Rust]: https://www.rust-lang.org
//! [sidecar]: https://en.wikipedia.org/wiki/Sidecar_file
//! [SignTool]: https://msdn.microsoft.com/en-us/library/windows/desktop/aa387764(v=vs.85).aspx
//! [statically link the CRT]: https://doc.rust-lang.org/reference/linkage.html#static-and-dynamic-c-runtimes
//! [`std::process::Command`]: https://doc.rust-lang.org/std/process/struct.Command.html
//! [`std::process::Command::status`]: https://doc.rust-lang.org/std/process/struct.Command.html#method.status
//! [TOML array]: https://github.com/toml-lang/toml#user-content-array
//! [tutorials]: https://www.firegiant.com/wix/tutorial/
//! [VC Build Tools]: https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2017
//! [virtual manifest]: https://doc.rust-lang.org/cargo/reference/workspaces.html
//! [Windows 10 SDK]: https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk
//! [WixBalExtension]: https://wixtoolset.org/documentation/manual/v3/bundle/wixstdba/
//! [WixUIExtension]: https://wixtoolset.org//documentation/manual/v3/wixui/wixui_dialog_library.html
//! [WixUtilExtension]: https://wixtoolset.org/documentation/manual/v3/xsd/util/
//! [WixUI localization documentation]: http://wixtoolset.org/documentation/manual/v3/wixui/wixui_localization.html
//! [WiX preprocessor]: https://wixtoolset.org/documentation/manual/v3/overview/preprocessor.html
//! [WiX Toolset]: http://wixtoolset.org
//! [WordPad]: https://en.wikipedia.org/wiki/WordPad
//! [workspace]: https://doc.rust-lang.org/cargo/reference/workspaces.html
//! [WXS]: ../wix/enum.Template.html
//! [XML]: https://en.wikipedia.org/wiki/XML

use clap::builder::EnumValueParser;
use clap::{Arg, ArgAction, Command};

use env_logger::Builder;
use env_logger::fmt::style::{AnsiColor as LogColor, Style};

use log::{Level, LevelFilter};
use std::io::Write;
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
use wix::toolset::project::WxsSchema;
use wix::toolset::{Toolset, ToolsetSetupMode};

use wix::clean;
use wix::create;
use wix::initialize;
use wix::migrate;
use wix::print;
use wix::purge;
use wix::sign;
use wix::{BINARY_FOLDER_NAME, Template, WIX_PATH_KEY};

pub const PKG_DESCRIPTION: &str = env!("CARGO_PKG_DESCRIPTION");
pub const PKG_NAME: &str = env!("CARGO_PKG_NAME");
pub const PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

const SUBCOMMAND_NAME: &str = "wix";

fn main() {
    // The banner option for the `init` and `print` subcommands.
    let banner = Arg::new("banner")
        .help("A path to an image file (.bmp) for the installer's banner")
        .long_help(
            "Sets the path to a bitmap (.bmp) image file that will be \
             displayed across the top of each dialog in the installer. The banner \
             image dimensions should be 493 x 58 pixels.",
        )
        .long("banner")
        .short('b')
        .num_args(1);
    // The binaries option for the `init` and `print` subcommands.
    let binaries = Arg::new("binaries")
        .help("A path to an executable file (.exe) for the application")
        .long_help(
            "Sets the path to an executable file that will override the default \
             binaries included in the installer. The default binaries are the \
             'target\\release\\<package name>.exe' file, where <package-name> is \
             the value from the 'name' field in the '[package]' section of the \
             package's manifest (Cargo.toml) if no '[[bin]]' sections are \
             defined; otherwise, all binaries defined in the package's manifest \
             in each '[[bin]]' section are included. This option overrides any \
             and all binaries defined in the package's manifest. Use this option \
             repeatedly to include multiple binaries.",
        )
        .long("binary")
        .action(ArgAction::Append)
        .short('B')
        .num_args(1);
    // The description option for the `init` and `print` subcommands.
    let description = Arg::new("description")
        .help("A string describing the application in the installer")
        .long_help(
            "Overrides the 'description' field of the package's manifest \
             (Cargo.toml) as the description within the installer. Text with spaces \
             should be surrounded by double quotes.",
        )
        .long("description")
        .short('d')
        .num_args(1);
    // The dialog option for the `init` and `print` subcommands.
    let dialog = Arg::new("dialog")
        .help("A path to an image file (.bmp) for the installer's welcome dialog")
        .long_help(
            "Sets the path to a bitmap (.bmp) image file that will be \
             displayed to the left on the first dialog of the installer. The dialog \
             image dimensions should be 493 x 312 pxiels.",
        )
        .long("dialog")
        .short('D')
        .num_args(1);
    // The eula option for the `init` and `print` subcommands.
    let eula = Arg::new("eula")
        .help("A path to a RTF file (.rtf) for the installer's license agreement dialog")
        .long_help(
            "Specifies a Rich Text Format (RTF) file to use as the End \
             User License Agreement (EULA) for the license agreement dialog of the \
             installer. The default is to disable the license agreement dialog unless \
             one of the supported licenses (GPL-3.0, Apache-2.0, or MIT) is generated \
             based on the value of the 'license' field in the package's manifest \
             (Cargo.toml). An EULA can be enabled later by directly modifying the WiX \
             Source (wxs) file with a text editor.",
        )
        .long("eula")
        .short('e')
        .num_args(1);
    // The license option for the `init` and `print` subcommands.
    let license = Arg::new("license")
        .help("A path to any file (.txt, .pdf, .rtf, etc.) to be used as a license")
        .long_help(
            "Overrides the 'license-file' field or any license generated \
             from the 'license' field of the package's manifest (Cargo.toml). If an \
             appropriate license file does not exist, cannot be found, or is not \
             specified, then no license file is included in the installer or the \
             installation folder along side the binary. A file containing the \
             license, such as a TXT, PDF, or RTF file, can be added later by directly \
             editing the generated WiX Source file (wxs) in a text editor.",
        )
        .long("license")
        .short('l')
        .num_args(1);
    // The url option for the `init` and `print` subcommands
    let url = Arg::new("url")
        .help("A URL for the Add/Remove Programs control panel's Help Link")
        .long_help(
            "Adds a URL to the installer that will be displayed in the \
             Add/Remove Programs control panel for the application. The default is to \
             disable it unless a URL is specified for either the 'homepage', \
             'documentation', or 'repository' fields in the package's manifest \
             (Cargo.toml). The help URL can be enabled after initialization by \
             directly modifying the WiX Source (wxs) file with a text editor.",
        )
        .long("url")
        .short('u')
        .num_args(1);
    // The manufacturer option for the `init` and `print` subcommands
    let manufacturer = Arg::new("manufacturer")
        .help("A string for the Add/Remove Programs control panel's Manufacturer")
        .long_help(
            "Overrides the 'authors' field of the \
             package's manifest (Cargo.toml) as the manufacturer within the \
             installer. The manufacturer can be changed after initialization by \
             directly modifying the WiX Source file (wxs) with a text editor.",
        )
        .long("manufacturer")
        .short('m')
        .num_args(1);
    // The owner option for the `init` and `print` subcommands
    let owner = Arg::new("owner")
        .help("A string for a generated license's copyright holder")
        .long_help(
            "Sets the copyright owner for the license during \
             initialization. The default is to use the `authors` field from the \
             package's manifest (Cargo.toml). This is only used when generating a \
             license based on the value of the 'license' field in the package's \
             manifest.",
        )
        .long("owner")
        .short('O')
        .num_args(1);
    // The package option for `create` or `migrate`
    let include = Arg::new("include")
        .help("Include an additional WiX Source (wxs) file")
        .long_help(
            "Includes a WiX source (wxs) file for a project, \
        where the wxs file is not located in the default location, \
        i.e. 'wix'. Use this option multiple times to include \
        multiple wxs files.",
        )
        .long("include")
        .short('I')
        .num_args(1)
        .action(ArgAction::Append);
    // The package option for the `create`, `init`, and `print` subcommands
    let package = Arg::new("package")
        .help("The name of the package in the current workspace")
        .long_help(
            "Selects the package within a project organized as a workspace. \
             Workspaces have one or more members, where each member is a package. \
             This option selects the package by name.",
        )
        .long("package")
        .short('p')
        .num_args(1);
    // The path guid option for the `init` and `print` subcommands
    let path_guid = Arg::new("path-guid")
        .help("A string formatted as a v4 hyphenated, uppercase UUID for the path component")
        .long_help(
            "Overrides the automatically generated GUID for the path component. \
             The path component needs a constant GUID so that the PATH \
             environment variable can be updated properly during uninstall and \
             upgrading. Generally, the GUID is generated once at the start \
             of a product/project and stored in the WiX Source (WXS) file. Using \
             a different GUID for each installer creation will leave artifacts \
             after uninstallation.",
        )
        .long("path-guid")
        .num_args(1);
    // The product icon option for the `init` and `print` subcommands
    let product_icon = Arg::new("product-icon")
        .help("A path to an image file (.ico) for the Add/Remove Programs control panel")
        .long_help(
            "Sets the path to an image file that will be displayed as an \
             icon in the Add/Remove Programs (ARP) control panel for the installed \
             application.",
        )
        .long("product-icon")
        .num_args(1);

    // The product name option for the `init`, `print`, and `sign` subcommands.
    let product_name = Arg::new("product-name")
        .help("A string for the Add/Remove Programs control panel's Name")
        .long_help(
            "Overrides the 'name' field of the package's manifest \
             (Cargo.toml) as the product name within the installer. The product name \
             can be changed after initialization by directly modifying the WiX Source \
             file (wxs) with a text editor.",
        )
        .long("product-name")
        .num_args(1);
    // The upgrade guid option for the `init` and `print` subcommands.
    let upgrade_guid = Arg::new("upgrade-guid")
        .help("A string formatted as a v4 hyphenated, uppercase UUID for the globally unique upgrade code")
        .long_help(
            "Overrides the automatically generated GUID for the product's \
             upgrade code. The upgrade code is used to determine if the installer \
             is for a different product or the same product but should be \
             upgraded instead of a new install. Generally, the upgrade code is \
             generated once at the start of a product/project and stored in the \
             WiX Source (WXS) file. Using a different GUID for each installer \
             creation will install separate versions of a product."
        )
        .long("upgrade-guid")
        .num_args(1);
    // The "global" verbose flag for all subcommands.
    let verbose = Arg::new("verbose")
        .help("The verbosity level for logging statements")
        .long_help(
            "Sets the level of verbosity. The higher the level of \
             verbosity, the more information that is printed and logged when the \
             application is executed. This flag can be specified multiple times, \
             where each occurrence increases the level and/or details written for \
             each statement.",
        )
        .long("verbose")
        .short('v')
        .action(ArgAction::Count);
    let year = Arg::new("year")
        .help("A string for a generated license's copyright year")
        .long_help(
            "Sets the copyright year for the license during \
             initialization. The default is to use the current year. This is only \
             used if a license is generated from one of the supported licenses based \
             on the value of the 'license' field in the package's manifest \
             (Cargo.toml).",
        )
        .long("year")
        .short('y')
        .num_args(1);
    let matches = Command::new(PKG_NAME)
        .bin_name("cargo")
        .subcommand(
            Command::new(SUBCOMMAND_NAME)
                .version(PKG_VERSION)
                .about(PKG_DESCRIPTION)
                .arg(Arg::new("bin-path")
                     .help(format!(
                         "A path to the WiX Toolset's '{BINARY_FOLDER_NAME}' folder"))
                     .long_help(format!(
                         "Specifies the path to the WiX Toolset's '{BINARY_FOLDER_NAME}' folder, which should contain \
                         the needed 'candle.exe' and 'light.exe' applications. The default is to use \
                         the path specified with the {WIX_PATH_KEY} system environment variable that is created \
                         during the installation of the WiX Toolset. Failing the existence of the \
                         {WIX_PATH_KEY} system environment variable, the path specified in the PATH system \
                         environment variable is used. This is useful when working with multiple \
                         versions of the WiX Toolset."))
                     .long("bin-path")
                     .short('b')
                     .num_args(1))
                .subcommand(Command::new("clean")
                    .version(PKG_VERSION)
                    .about("Deletes the 'target\\wix' folder")
                    .long_about("Deletes the 'target\\wix' folder if it exists.")
                    .arg(verbose.clone())
                    .arg(Arg::new("INPUT")
                         .help("A path to a package's manifest (Cargo.toml)")
                         .long_help("The 'target\\wix' folder that exists \
                            alongside the package's manifest will be removed. This \
                            is optional and the default is to use the current \
                            working directory (cwd).")
                         .index(1)))
                .arg(Arg::new("culture")
                    .help("The culture code for localization")
                    .long_help("Sets the culture for localization. Use with the \
                        '-l,--locale' option. See the WixUI localization \
                        documentation for more information about acceptable culture \
                        codes. The codes are case insensitive.")
                    .long("culture")
                    .short('c')
                    .num_args(1))
                .arg(Arg::new("compiler-arg")
                    .help("Send an argument to the WiX compiler (candle.exe)")
                    .long_help("Appends the argument to the command that is \
                        invoked when compiling an installer. This is the same as \
                        manually typing the option or flag for the compiler at the \
                        command line. If the argument is for an option with a value, \
                        the option's value must be passed as a separate call of this \
                        option. Multiple occurrences are possible, but only one \
                        value per occurrence is allowed to avoid ambiguity in \
                        argument parsing. For example, '-C -ext -C \
                        WixUtilExtension'.")
                    .long("compiler-arg")
                    .short('C')
                    .num_args(1)
                    .action(ArgAction::Append)
                    .allow_hyphen_values(true))
                .arg(Arg::new("target")
                    .help("The cargo target to build the WiX installer for.")
                    .long_help("Tells cargo to build the given target, and instructs \
                        WiX to build an installer targeting the right architecture.")
                    .long("target")
                    .short('t')
                    .num_args(1))
                .arg(Arg::new("debug-build")
                    .help("Builds the package using the Debug profile")
                    .long_help("Uses the Debug profile when building the package \
                        using Cargo. The default is to build the package using the \
                        Release profile.")
                    .long("dbg-build")
                    .short('d')
                    .action(ArgAction::SetTrue))
                .arg(Arg::new("profile")
                    .help("Builds the package using the given profile")
                    .long_help("Uses the given profile when building the package \
                        using Cargo. The default is to build the package using the \
                        Release profile.")
                    .long("profile")
                    .num_args(1))
                .arg(Arg::new("debug-name")
                    .help("Appends '-debug' to the file stem of installer's file name")
                    .long_help("Adds the '-debug' suffix to the file stem \
                        (content before the file extension) for the installer's file \
                        name. This should be used to indicate the binary distributed \
                        within the installer was built using debugging information \
                        and optimizations. Generally, this should be used in \
                        combination with the '-d,--dbg-build' flag to build the \
                        binary with the Debug profile.")
                    .long("dbg-name")
                    .short('D')
                    .action(ArgAction::SetTrue))
                .arg(include.clone())
                .subcommand(Command::new("init")
                    .version(PKG_VERSION)
                    .about("Generates files from a package's manifest (Cargo.toml) to create an installer")
                    .long_about("Uses a package's manifest (Cargo.toml) to generate a WiX Source (wxs) \
                        file that can be used immediately without modification to create an \
                        installer for the package. This will also generate an EULA in the Rich \
                        Text Format (RTF) if the 'license' field is specified with a supported \
                        license (GPL-3.0, Apache-2.0, or MIT). All generated files are placed in \
                        the 'wix' sub-folder by default.")
                        .arg(Arg::new("INPUT")
                        .help("A path to a package's manifest (Cargo.toml)")
                        .long_help("If the '-o,--output' option is not used, \
                            then all output from initialization will be placed in a \
                            'wix' folder created alongside this path.")
                        .index(1))
                    .arg(banner.clone())
                    .arg(binaries.clone())
                    .arg(description.clone())
                    .arg(dialog.clone())
                    .arg(eula.clone())
                    .arg(Arg::new("force")
                        .help("Overwrite existing WiX-related files")
                        .long_help("Overwrites any existing files that are \
                            generated during initialization. Use with caution.")
                        .long("force")
                        .action(ArgAction::SetTrue))
                    .arg(license.clone())
                    .arg(manufacturer.clone())
                    .arg(Arg::new("output")
                        .help("A path to a folder for generated files")
                        .long_help("Sets the destination for all files \
                            generated during initialization. The default is to \
                            create a 'wix' folder within the project then generate \
                            all files in the 'wix' sub-folder.")
                        .long("output")
                        .short('o')
                        .num_args(1))
                    .arg(owner.clone())
                    .arg(package.clone())
                    .arg(path_guid.clone())
                    .arg(product_icon.clone())
                    .arg(product_name.clone())
                    .arg(upgrade_guid.clone())
                    .arg(url.clone())
                    .arg(verbose.clone())
                    .arg(year.clone())
                    .arg(Arg::new("schema")
                        .long("schema")
                        .help("The schema version of wxs source to render")
                        .long_help(
                            "Between Wix3 and Wix4, wxs files have differing schemas.\n\
                            This setting allows initialization to render the corresponding schema \n\
                            The default setting is the legacy format (Supported by Wix3)")
                        .num_args(1)
                        .value_parser(EnumValueParser::<WxsSchema>::new())))
                .arg(Arg::new("INPUT")
                     .help("Path to a package's manifest (Cargo.toml) file.")
                     .long_help("If no value is provided, then the current \
                        working directory (CWD) will be used to locate a package's \
                        manifest. An error will occur if a manifest cannot be \
                        found. A relative or absolute path to a package's manifest \
                        (Cargo.toml) file can be used. Only one manifest is \
                        allowed. The creation of an installer will be relative to \
                        the specified manifest.")
                     .required(false)
                     .index(1))
                .arg(Arg::new("install-version")
                    .help("A string for the Add/Remove Programs control panel's version number")
                    .long_help("Overrides the version from the package's manifest \
                        (Cargo.toml), which is used for the installer name and \
                        appears in the Add/Remove Programs control panel.")
                    .long("install-version")
                    .short('i')
                    .num_args(1))
                .arg(Arg::new("linker-arg")
                    .help("Send an argument to the WiX linker (light.exe)")
                    .long_help("Appends the argument to the command that is \
                        invoked when linking an installer. This is the same as \
                        manually typing the option or flag for the linker at the \
                        command line. If the argument is for an option with a value, \
                        the option's value must be passed as a separate call of this \
                        option. Multiple occurrences are possible, but only one \
                        value per occurrence is allowed to avoid ambiguity in \
                        argument parsing. For example, '-L -ext -L \
                        WixUIExtension'.")
                    .long("linker-arg")
                    .short('L')
                    .num_args(1)
                    .action(ArgAction::Append)
                    .allow_hyphen_values(true))
                .arg(Arg::new("locale")
                    .help("A path to a WiX localization file (.wxl)")
                    .long_help("Sets the path to a WiX localization file (wxl) \
                        which contains localized strings. Use in conjunction with \
                        the '-c,--culture' option.")
                    .long("locale")
                    .short('l')
                    .num_args(1))
                .arg(Arg::new("name")
                    .help("A string for the installer's product name")
                    .long_help("Overrides the 'name' field in the package's \
                        manifest (Cargo.toml), which is used in the file name of the \
                        installer (msi). This does not change the name of the \
                        executable within the installer.")
                    .long("name")
                    .short('n')
                    .num_args(1))
                .arg(Arg::new("no-build")
                    .help("Skips building the release binary")
                    .long_help("The installer is created, but the 'cargo build \
                        --release' is not executed.")
                    .long("no-build")
                    .action(ArgAction::SetTrue))
                .arg(Arg::new("target-bin-dir")
                    .help("A path to the directory of binaries to include in the installer")
                    .long_help("Sets the CargoTargetBinDir variable that will be substituted \
                        into main.wxs. Use in conjunction with --no-build to fully handle builds.")
                    .long("target-bin-dir")
                    .num_args(1))
                .arg(Arg::new("no-capture")
                    .help("Displays all output from the builder, compiler, linker, and signer")
                    .long_help("By default, this subcommand captures, or hides, \
                        all output from the builder, compiler, linker, and signer \
                        for the binary and Windows installer, respectively. Use this \
                        flag to show the output.")
                    .long("nocapture")
                    .action(ArgAction::SetTrue))
                .arg(Arg::new("install")
                    .help("Runs the installer after creating it")
                    .long_help("Creates the installer and runs it after that.")
                    .long("install")
                    .action(ArgAction::SetTrue))
                .arg(Arg::new("output")
                    .help("A path to a destination file or an existing folder")
                    .long_help("Sets the destination file name and path for the \
                        created installer, or the destination folder for the \
                        installer with the default file name. If the path is to \
                        an existing folder or has a trailing slash (forward and \
                        backward), then the default installer file name will be \
                        used and the installer will be available in the folder \
                        after creation. Otherwise, this value overwrites the \
                        default file name and path for the installer. The \
                        default is to create an installer with the \
                        '<product-name>-<version>-<arch>.msi' file name in the \
                        'target\\wix' folder.")
                    .long("output")
                    .short('o')
                    .num_args(1))
                .arg(Arg::new("toolset")
                    .long("toolset")
                    .help("Toolset to use for wix related operations")
                    .long_help(
                        "Before WiX4 the binaries that were used to build the installer were light.exe and candle.exe.\n\
                         The WiX toolset now uses a single binary, wix.exe, that performs all the previous operations.\n\
                         In addition WiX3 did not have a unified package installation method, where-as WiX4 and beyond\n\
                         can be installed via `dotnet install`.\n\
                         \n\
                         This argument can be used to opt-in to the modern toolset, however it is important to note that\n\
                         while WiX4+ are backwards compatible, WiX3 .wxs files are not compatible and must be converted\n\
                         to WiX4 semantics. Luckily the modern wix toolsets contain a convert tool, however there are\n\
                         several key differences after WiX3 that must be addressed before the files may be built.\n\
                         If the `toolset-upgrade` argument is provided in addition to this command, cargo-wix can ensure\n\
                         that the included wix source files are updated to the modern format and that the dependencies used\n\
                         in those source files are installed in the current context. This also provides the benefit between\n\
                         WiX4+ versions, as the wix toolset extensions now depend on the WiX toolset version, `cargo-wix`\n\
                         can ensure that before the build starts all wix extensions are up to date.")
                    .value_parser(EnumValueParser::<Toolset>::new())
                    .required(false)
                    .num_args(1)
                )
                .arg(Arg::new("migrate")
                    .long("migrate")
                    .help("Toolset migration setup mode to use before building the installer")
                    .long_help(
                        "Note: Only applied if `--toolset modern` is present, if no migration setup is required this will have no additional effect\n\
                        When enabled, this will perform checks to ensure that the current wix environment\n\
                        is up to date before attempting to build the installer which includes:\n\
                        \t1) Ensuring that *.wxs files are in the correct format according to the wix toolset setting\n\
                        \t2) Installing extensions that are required to build the installer\n\
                        There are several modes that can be used with inplace being the simplest and sxs being the least destructive")
                        .value_parser(EnumValueParser::<ToolsetSetupMode>::new())
                        .num_args(1))
                .arg(package.clone())
                .subcommand(Command::new("print")
                    .version(PKG_VERSION)
                    .about("Prints a template")
                    .long_about("Prints a template to stdout or a file. In the case \
                        of a license template, the output is in the Rich Text Format \
                        (RTF) and for a WiX Source file (wxs), the output is in XML. \
                        New GUIDs are generated for the 'UpgradeCode' and Path \
                        Component each time the 'WXS' template is printed. [values: \
                        Apache-2.0, GPL-3.0, MIT, WXS]")
                        .arg(Arg::new("TEMPLATE")
                        .help("A name of a template")
                        .long_help("This is required and values are case \
                            insensitive. [values: Apache-2.0, GPL-3.0, MIT, WXS]")
                        .hide_possible_values(true)
                        .value_parser(Template::possible_values().iter().map(String::as_str).collect::<Vec<&str>>())
                        .required(true)
                        .index(1))
                        .arg(Arg::new("INPUT")
                        .help("A path to a package's manifest (Cargo.toml)")
                        .long_help("The selected template will be printed to \
                            stdout or a file based on the field values in this \
                            manifest. The default is to use the manifest in the \
                            current working directory (cwd). An error occurs if a \
                            manifest is not found.")
                        .index(2))
                    .arg(banner)
                    .arg(binaries)
                    .arg(description)
                    .arg(dialog)
                    .arg(eula)
                    .arg(license)
                    .arg(manufacturer)
                    .arg(Arg::new("output")
                        .help("A path to a folder for generated files")
                        .long_help("Sets the destination for printing the \
                            template. The default is to print/write the rendered \
                            template to stdout. If the destination, a.k.a. file, \
                            does not exist, it will be created.")
                        .long("output")
                        .short('o')
                        .num_args(1))
                    .arg(owner)
                    .arg(package.clone())
                    .arg(path_guid)
                    .arg(product_icon)
                    .arg(product_name.clone())
                    .arg(upgrade_guid)
                    .arg(url)
                    .arg(year)
                    .arg(verbose.clone()))
                .subcommand(Command::new("purge")
                    .version(PKG_VERSION)
                    .about("Deletes the 'target\\wix' and 'wix' folders")
                    .long_about("Deletes the 'target\\wix' and 'wix' folders if they \
                        exist. Use with caution!")
                    .arg(Arg::new("INPUT")
                        .help("A path to a package's manifest (Cargo.toml)")
                        .long_help("The 'target\\wix' and 'wix' folders that \
                            exists alongside the package's manifest will be removed. \
                            This is optional and the default is to use the current \
                            working directory (cwd).")
                        .index(1)))
                .subcommand(Command::new("sign")
                    .version(PKG_VERSION)
                    .about("Signs an installer")
                    .long_about("The Windows installer (msi) will be signed using the \
                        SignTool application available in the Windows 10 SDK. The \
                        signtool is invoked with the '/a' flag to automatically \
                        obtain an appropriate certificate from the Windows \
                        certificate manager. The default is to also use the Comodo \
                        timestamp server with the '/t' flag.")
                    .arg(Arg::new("bin-path")
                        .help("A path to the folder containing the 'signtool' application")
                        .long_help("The default is to use the PATH system environment \
                             variable to locate the application.")
                        .long("bin-path")
                        .short('b')
                        .num_args(1))
                    .arg(Arg::new("description")
                        .help("A string for the extended ACL dialog")
                        .long_help("The information for the extended text of \
                            the ACL dialog that appears. This will be appended to \
                            the product name and delimited by a dash, '-'. The \
                            default is to use the description from the package's \
                            manifest (Cargo.toml). This option will override the \
                            default.")
                        .long("description")
                        .short('d')
                        .num_args(1))
                    .arg(Arg::new("homepage")
                        .help("A URL for the product's homepage")
                        .long_help("This will be displayed in the ACL dialog.")
                        .long("homepage")
                        .short('u')
                        .num_args(1))
                    .arg(Arg::new("INPUT")
                        .help("A path to a package's manifest (Cargo.toml)")
                        .long_help("The installer located in the 'target\\wix' \
                            folder alongside this manifest will be signed based on \
                            the metadata within the manifest.")
                        .index(1))
                    .arg(Arg::new("installer")
                        .help("specify the installer to be signed")
                        .long_help("Specify the installer to be signed.")
                        .long("installer")
                        .short('i')
                        .num_args(1))
                    .arg(Arg::new("no-capture")
                        .help("Display output from the signer")
                        .long_help("By default, this subcommand captures, or \
                            hides, all output from the signer. Use this flag to \
                            show the output.")
                        .long("nocapture")
                        .action(ArgAction::SetTrue))
                    .arg(product_name)
                    .arg(package.clone())
                    .arg(Arg::new("timestamp")
                        .help("An alias or URL to a timestamp server")
                        .long_help("Either an alias or URL can be used. Aliases \
                            are case-insensitive. [values: Comodo, Verisign]")
                        .short('t')
                        .long("timestamp")
                        .num_args(1))
                    .arg(verbose.clone()))
                .subcommand(Command::new("migrate")
                        .version(PKG_VERSION)
                        .about("WiX project migration setup utilities")
                        .long_about(
                            "Perform various wix toolset migration setup operations such as:\n\
                            - Converting wxs files to the modern WiX toolset format\n\
                            - Restoring wix extension packages by analyzing extension dependencies found in wxs files.\n\
                            - Enable vendoring of wix extension dependencies for offline builds\n\
                            \n\
                            If no additional flags are passed such as `--vendor`\n\
                            and no mode is set via `-m` or `--mode`\n\
                            Then this will apply the 'global' setup mode, meaning:\n\
                            - all wxs files will be converted in place\n\
                            - all wix extensions will be installed globally")
                        .arg(Arg::new("INPUT")
                            .help("Path to a package's manifest (Cargo.toml) file.")
                            .long_help(
                                "If no value is provided, then the current\n\
                                working directory (CWD) will be used to locate a package's\n\
                                manifest. An error will occur if a manifest cannot be\n\
                                found. A relative or absolute path to a package's manifest\n\
                                (Cargo.toml) file can be used. Only one manifest is\n\
                                allowed. The creation of an installer will be relative to\n\
                                the specified manifest.")
                            .required(false)
                            .index(1))
                        .arg(package)
                        .arg(include)
                        .arg(Arg::new("vendor")
                            .long("vendor")
                            .help("Will enable vendoring when installing WiX extensions")
                            .long_help(
                                "By using vendoring mode, all extension dependencies will be installed in the current directory\n\
                                This is suited for proejcts that must be built in environments without network access and/or\n\
                                If tracking extension packages in SVC is desired\n\
                                \n\
                                Equivalent to `-m vendor` or `--mode vendor`")
                            .action(ArgAction::SetTrue))
                        .arg(Arg::new("mode")
                            .long("mode")
                            .short('m')
                            .help("Will explicitly configure the migration setup mode. Note: Using `none` will not have any effect with the `migrate` command.")
                            .value_parser(EnumValueParser::<ToolsetSetupMode>::new()))
                        .arg(verbose.clone()))
                .arg(verbose)
        ).get_matches();
    let matches = matches.subcommand_matches(SUBCOMMAND_NAME).unwrap();
    let verbosity = match matches.subcommand() {
        Some(("clean", m)) => m,
        Some(("init", m)) => m,
        Some(("print", m)) => m,
        Some(("purge", m)) => m,
        Some(("migrate", m)) => m,
        _ => matches,
    }
    .get_count("verbose");
    // Using the `Builder::new` instead of the `Builder::from_env` or `Builder::from_default_env`
    // skips reading the configuration from any environment variable, i.e. `RUST_LOG`. The log
    // level is later configured with the verbosity using the `filter` method. There are many
    // questions related to implementing support for environment variables:
    //
    // 1. What should the environment variable be called, WIX_LOG, CARGO_WIX_LOG, CARGO_LOG, etc.?
    //    WIX_LOG might conflict with a system variable that is used for the WiX Toolset. CARGO_LOG
    //    is too generic. The only viable one is CARGO_WIX_LOG.
    // 2. How is the environment variable supposed to work with the verbosity without crazy side
    //    effects? What if the level is set to TRACE with the environment variable, but the
    //    verbosity is only one?
    // 3. Should the RUST_LOG environment variable be "obeyed" for a cargo subcommand?
    //
    // For now, implementing environment variable support is held off and only the verbosity is
    // used to set the log level.
    let mut builder = Builder::new();
    builder
        .format(|buf, record| {
            // This implementation for a format is copied from the default format implemented for the
            // `env_logger` crate but modified to use a colon, `:`, to separate the level from the
            // message and change the colors to match the previous colors used by the `loggerv` crate.
            let level = record.level();
            let style = match level {
                // Light Gray, or just Gray, is not a supported color for non-ANSI enabled Windows
                // consoles, so TRACE and DEBUG statements are differentiated by boldness but use the
                // same white color.
                Level::Trace => Style::new().fg_color(Some(LogColor::White.into())),
                Level::Debug => Style::new().fg_color(Some(LogColor::White.into())).bold(),
                Level::Info => Style::new().fg_color(Some(LogColor::Green.into())).bold(),
                Level::Warn => Style::new().fg_color(Some(LogColor::Yellow.into())).bold(),
                Level::Error => Style::new().fg_color(Some(LogColor::Red.into())).bold(),
            };
            let write_level = write!(buf, "{style}{level:>5}{style:#}: ");
            let write_args = writeln!(buf, "{}", record.args());
            write_level.and(write_args)
        })
        .filter(
            Some("wix"),
            match verbosity {
                0 => LevelFilter::Warn,
                1 => LevelFilter::Info,
                2 => LevelFilter::Debug,
                _ => LevelFilter::Trace,
            },
        )
        .init();
    let result = match matches.subcommand() {
        Some(("clean", m)) => {
            let mut clean = clean::Builder::new();
            clean.input(m.get_one("INPUT").map(String::as_str));
            clean.build().run()
        }
        Some(("init", m)) => {
            let mut init = initialize::Builder::new();
            init.banner(m.get_one("banner").map(String::as_str));
            init.binaries(
                m.get_many::<String>("binaries")
                    .map(|v| v.map(String::as_str).collect()),
            );
            init.copyright_holder(m.get_one("owner").map(String::as_str));
            init.copyright_year(m.get_one("year").map(String::as_str));
            init.description(m.get_one("description").map(String::as_str));
            init.dialog(m.get_one("dialog").map(String::as_str));
            init.eula(m.get_one("eula").map(String::as_str));
            init.force(m.get_flag("force"));
            init.help_url(m.get_one("url").map(String::as_str));
            init.input(m.get_one("INPUT").map(String::as_str));
            init.license(m.get_one("license").map(String::as_str));
            init.manufacturer(m.get_one("manufacturer").map(String::as_str));
            init.output(m.get_one("output").map(String::as_str));
            init.package(m.get_one("package").map(String::as_str));
            init.path_guid(m.get_one("path-guid").map(String::as_str));
            init.product_icon(m.get_one("product-icon").map(String::as_str));
            init.product_name(m.get_one("product-name").map(String::as_str));
            init.upgrade_guid(m.get_one("upgrade-guid").map(String::as_str));
            init.schema(m.get_one::<WxsSchema>("schema").copied());
            init.build().run()
        }
        Some(("print", m)) => {
            let template = m
                .get_one::<String>("TEMPLATE")
                .unwrap()
                .parse::<Template>()
                .unwrap();
            match template {
                Template::WxsV3 | Template::WxsV4 => {
                    let mut print = print::wxs::Builder::new();
                    print.banner(m.get_one("banner").map(String::as_str));
                    print.binaries(
                        m.get_many("binaries")
                            .map(|v| v.map(String::as_str).collect()),
                    );
                    print.description(m.get_one("description").map(String::as_str));
                    print.dialog(m.get_one("dialog").map(String::as_str));
                    print.eula(m.get_one("eula").map(String::as_str));
                    print.help_url(m.get_one("url").map(String::as_str));
                    print.input(m.get_one("INPUT").map(String::as_str));
                    print.license(m.get_one("license").map(String::as_str));
                    print.manufacturer(m.get_one("manufacturer").map(String::as_str));
                    print.output(m.get_one("output").map(String::as_str));
                    print.package(m.get_one("package").map(String::as_str));
                    print.path_guid(m.get_one("path-guid").map(String::as_str));
                    print.product_icon(m.get_one("product-icon").map(String::as_str));
                    print.product_name(m.get_one("product-name").map(String::as_str));
                    print.upgrade_guid(m.get_one("upgrade-guid").map(String::as_str));
                    if matches!(template, Template::WxsV4) {
                        print.schema(Some(WxsSchema::V4));
                    }
                    print.build().run()
                }
                t => {
                    let mut print = print::license::Builder::new();
                    print.copyright_holder(m.get_one("owner").map(String::as_str));
                    print.copyright_year(m.get_one("year").map(String::as_str));
                    print.input(m.get_one("INPUT").map(String::as_str));
                    print.output(m.get_one("output").map(String::as_str));
                    print.package(m.get_one("package").map(String::as_str));
                    print.build().run(&t)
                }
            }
        }
        Some(("purge", m)) => {
            let mut purge = purge::Builder::new();
            purge.input(m.get_one("INPUT").map(String::as_str));
            purge.build().run()
        }
        Some(("sign", m)) => {
            let mut sign = sign::Builder::new();
            sign.bin_path(m.get_one("bin-path").map(String::as_str));
            sign.capture_output(!m.get_flag("no-capture"));
            sign.description(m.get_one("description").map(String::as_str));
            sign.homepage(m.get_one("homepage").map(String::as_str));
            sign.input(m.get_one("INPUT").map(String::as_str));
            sign.installer(m.get_one("installer").map(String::as_str));
            sign.package(m.get_one("package").map(String::as_str));
            sign.product_name(m.get_one("product-name").map(String::as_str));
            sign.timestamp(m.get_one("timestamp").map(String::as_str));
            sign.build().run()
        }
        Some(("migrate", m)) => {
            let mut setup = migrate::Builder::new();
            setup.input(
                m.get_one("INPUT")
                    .map(String::as_str)
                    .or(matches.get_one("INPUT").map(String::as_str)),
            );
            setup.package(
                m.get_one("package")
                    .map(String::as_str)
                    .or(matches.get_one("package").map(String::as_str)),
            );
            setup.includes(
                m.get_many("include")
                    .map(|v| v.map(String::as_str).collect())
                    .or(matches
                        .get_many("include")
                        .map(|v| v.map(String::as_str).collect())),
            );
            if let Some(mode) = m.get_one::<ToolsetSetupMode>("mode") {
                match mode {
                    ToolsetSetupMode::None | ToolsetSetupMode::Global => {}
                    ToolsetSetupMode::Vendor => {
                        setup.vendor(true);
                    }
                }
            } else {
                setup.vendor(m.get_flag("vendor"));
            }
            setup.build().run()
        }
        _ => {
            let mut create = create::Builder::new();
            create.bin_path(matches.get_one("bin-path").map(String::as_str));
            create.capture_output(!matches.get_flag("no-capture"));
            create.compiler_args(
                matches
                    .get_many("compiler-arg")
                    .map(|v| v.map(String::as_str).collect()),
            );
            create.culture(matches.get_one("culture").map(String::as_str));
            create.debug_build(matches.get_flag("debug-build"));
            create.profile(matches.get_one("profile").map(String::as_str));
            create.debug_name(matches.get_flag("debug-name"));
            create.includes(
                matches
                    .get_many("include")
                    .map(|v| v.map(String::as_str).collect()),
            );
            create.input(matches.get_one("INPUT").map(String::as_str));
            create.linker_args(
                matches
                    .get_many("linker-arg")
                    .map(|v| v.map(String::as_str).collect()),
            );
            create.locale(matches.get_one("locale").map(String::as_str));
            create.name(matches.get_one("name").map(String::as_str));
            create.no_build(matches.get_flag("no-build"));
            create.target_bin_dir(matches.get_one("target-bin-dir").map(String::as_str));
            create.install(matches.get_flag("install"));
            create.output(matches.get_one("output").map(String::as_str));
            create.version(matches.get_one("install-version").map(String::as_str));
            create.package(matches.get_one("package").map(String::as_str));
            create.target(matches.get_one("target").map(String::as_str));
            create.toolset(
                matches
                    .get_one("toolset")
                    .cloned()
                    .unwrap_or(Toolset::Legacy),
            );
            create.toolset_migration(
                matches
                    .get_one("migrate")
                    .cloned()
                    .unwrap_or(ToolsetSetupMode::None),
            );
            create.build().run()
        }
    };
    match result {
        Ok(_) => std::process::exit(0),
        Err(e) => {
            {
                let mut stderr = StandardStream::stderr(ColorChoice::Auto);
                stderr
                    .set_color(ColorSpec::new().set_fg(Some(Color::Red)).set_bold(true))
                    .expect("Coloring stderr");
                write!(&mut stderr, "Error[{}] ({}): ", e.code(), e.as_str())
                    .expect("Write tag to stderr");
                // This prevents "leaking" the color settings to the console after the
                // sub-command/application has completed and ensures the message is not printed in
                // Red.
                //
                // See:
                //
                // - [Issue #47](https://github.com/volks73/cargo-wix/issues/47)
                // - [Issue #48](https://github.com/volks73/cargo-wix/issues/48).
                stderr
                    .reset()
                    .expect("Revert color settings after printing the tag");
                stderr
                    .set_color(ColorSpec::new().set_fg(Some(Color::White)).set_bold(false))
                    .expect("Coloring stderr");
                writeln!(&mut stderr, "{e}").expect("Write message to stderr");
                // This prevents "leaking" the color settings to the console after the
                // sub-command/application has completed.
                //
                // See:
                //
                // - [Issue #47](https://github.com/volks73/cargo-wix/issues/47)
                // - [Issue #48](https://github.com/volks73/cargo-wix/issues/48).
                stderr
                    .reset()
                    .expect("Revert color settings after printing the message");
            }
            std::process::exit(e.code());
        }
    }
}


================================================
FILE: src/migrate.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `migrate` command. The default behavior will use the
//! "Project" setup mode, which will update any *.wxs source files to the modern format as well
//! as install the extension packages to the global cache.
//!
//! Specific information about the different toolset modes can be found in the documentation for
//! `ToolsetSetupMode`.

use crate::toolset::*;
use log::debug;
use std::path::PathBuf;

/// A builder for running the `cargo wix migrate` subcommand.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    input: Option<&'a str>,
    package: Option<&'a str>,
    includes: Option<Vec<&'a str>>,
    vendor: bool,
}

impl<'a> Builder<'a> {
    /// Creates a new Builder
    pub fn new() -> Self {
        Self {
            input: None,
            package: None,
            includes: None,
            vendor: false,
        }
    }

    /// Sets the path to a package's manifest (Cargo.toml) file.
    ///
    /// A package's manifest is used to create an installer. If no path is
    /// specified, then the current working directory (CWD) is used. An error
    /// will occur if there is no `Cargo.toml` file in the CWD or at the
    /// specified path. Either an absolute or relative path is valid.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Adds multiple WiX Source (wxs) files to the creation of an installer.
    ///
    /// By default, any `.wxs` file located in the project's `wix` folder will
    /// be included in the creation of an installer for the project. This method
    /// adds, or appends, to the list of `.wxs` files. The value is a relative
    /// or absolute path.
    ///
    /// This value will override any default and skip looking for a value in the
    /// `[package.metadata.wix]` section of the package's manifest (Cargo.toml).
    pub fn includes(&mut self, i: Option<Vec<&'a str>>) -> &mut Self {
        self.includes = i;
        self
    }

    /// Sets the package.
    ///
    /// If the project is organized using a workspace, this selects the package
    /// by name to create an installer. If a workspace is not used, then this
    /// has no effect.
    pub fn package(&mut self, p: Option<&'a str>) -> &mut Self {
        self.package = p;
        self
    }

    /// Enables vendored mode when restoring Wix extensions
    pub fn vendor(&mut self, vendored: bool) -> &mut Self {
        self.vendor = vendored;
        self
    }

    /// Consumes the builder and returns the upgrade execution context
    ///
    /// Will resolve toolset migration setup mode from the provided flags
    pub fn build(self) -> Execution {
        Execution {
            input: self.input.map(PathBuf::from),
            package: self.package.map(String::from),
            includes: self
                .includes
                .as_ref()
                .map(|v| v.iter().map(&PathBuf::from).collect()),
            toolset_setup_mode: if self.vendor {
                ToolsetSetupMode::Vendor
            } else {
                ToolsetSetupMode::Global
            },
        }
    }
}

/// A context for setting up a WiX project migration to a new toolset
#[derive(Debug)]
pub struct Execution {
    input: Option<PathBuf>,
    package: Option<String>,
    includes: Option<Vec<PathBuf>>,
    toolset_setup_mode: ToolsetSetupMode,
}

impl Execution {
    /// Consumes the execution context and performs the migration setup
    pub fn run(self) -> crate::Result<()> {
        debug!("self.input = {:?}", self.input);
        debug!("self.package = {:?}", self.package);
        debug!("self.includes = {:?}", self.includes);
        debug!("self.toolset_upgrade = {:?}", self.toolset_setup_mode);

        debug!("Resolving manifest");
        let manifest = crate::manifest(self.input.as_ref())?;
        debug!("{manifest:?}");
        debug!("Resolving package");
        let package = crate::package(&manifest, self.package.as_deref())?;

        debug!("Evaluating project and beginning setup");
        self.toolset_setup_mode.setup(&self, &package, None)?;
        Ok(())
    }
}

impl Includes for Execution {
    fn includes(&self) -> Option<&Vec<PathBuf>> {
        self.includes.as_ref()
    }
}

impl<'a> Default for Builder<'a> {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn builder_defaults() {
        let builder = Builder::new();
        assert!(builder.input.is_none());
        assert!(builder.package.is_none());
        assert!(builder.includes.is_none());
        assert!(!builder.vendor);
    }

    #[test]
    fn builder_input_works() {
        let mut builder = Builder::new();
        builder.input(Some("path/to/Cargo.toml"));
        assert_eq!(builder.input, Some("path/to/Cargo.toml"));
    }

    #[test]
    fn builder_package_works() {
        let mut builder = Builder::new();
        builder.package(Some("my-package"));
        assert_eq!(builder.package, Some("my-package"));
    }

    #[test]
    fn builder_includes_works() {
        let mut builder = Builder::new();
        builder.includes(Some(vec!["a.wxs", "b.wxs"]));
        assert_eq!(builder.includes, Some(vec!["a.wxs", "b.wxs"]));
    }

    #[test]
    fn builder_vendor_works() {
        let mut builder = Builder::new();
        builder.vendor(true);
        assert!(builder.vendor);
    }

    #[test]
    fn build_sets_global_mode_by_default() {
        let execution = Builder::new().build();
        assert!(matches!(
            execution.toolset_setup_mode,
            ToolsetSetupMode::Global
        ));
    }

    #[test]
    fn build_sets_vendor_mode_when_vendor_enabled() {
        let mut builder = Builder::new();
        builder.vendor(true);
        let execution = builder.build();
        assert!(matches!(
            execution.toolset_setup_mode,
            ToolsetSetupMode::Vendor
        ));
    }

    #[test]
    fn build_converts_input_to_pathbuf() {
        let mut builder = Builder::new();
        builder.input(Some("some/path"));
        let execution = builder.build();
        assert_eq!(execution.input, Some(PathBuf::from("some/path")));
    }

    #[test]
    fn build_converts_includes_to_pathbufs() {
        let mut builder = Builder::new();
        builder.includes(Some(vec!["a.wxs", "b.wxs"]));
        let execution = builder.build();
        assert_eq!(
            execution.includes,
            Some(vec![PathBuf::from("a.wxs"), PathBuf::from("b.wxs")])
        );
    }
}


================================================
FILE: src/print/license.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for printing a license.

use chrono::{Datelike, Utc};

use crate::Error;
use crate::Result;
use crate::Template;
use crate::manifest;
use crate::package;

use log::debug;

use mustache::{self, MapBuilder};

use std::path::PathBuf;

use cargo_metadata::Package;

use super::RenderOutput;

/// A builder for creating an execution context to print a license.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    copyright_year: Option<&'a str>,
    copyright_holder: Option<&'a str>,
    input: Option<&'a str>,
    output: Option<&'a str>,
    package: Option<&'a str>,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder {
            copyright_year: None,
            copyright_holder: None,
            input: None,
            output: None,
            package: None,
        }
    }

    /// Sets the copyright holder for the generated license.
    ///
    /// If the license template does not use a copyright holder, then this value
    /// is ignored.
    ///
    /// The default is to use `authors` field of the package's manifest (Cargo.toml).
    pub fn copyright_holder(&mut self, h: Option<&'a str>) -> &mut Self {
        self.copyright_holder = h;
        self
    }

    /// Sets the copyright year for the generated license.
    ///
    /// If the license template does not use a copyright year, then this value
    /// is ignored.
    ///
    /// The default is to use this year when generating the license.
    pub fn copyright_year(&mut self, y: Option<&'a str>) -> &mut Self {
        self.copyright_year = y;
        self
    }

    /// Sets the path to a package's manifest (Cargo.toml) to be used to
    /// generate license in the Rich Text Format (RTF).
    ///
    /// By default, the license will be printed to `STDOUT` unless the
    /// [`output`] method is used.
    ///
    /// [`output`]: #output
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Sets the destination.
    ///
    /// The default is to print all output to `STDOUT`. This method can be used
    /// to specify that the generated license be written, or "printed", to a
    /// file instead of `STDOUT`.
    pub fn output(&mut self, o: Option<&'a str>) -> &mut Self {
        self.output = o;
        self
    }

    /// Sets the package.
    ///
    pub fn package(&mut self, o: Option<&'a str>) -> &mut Self {
        self.package = o;
        self
    }

    /// Builds an execution context based on the configuration.
    pub fn build(&self) -> Execution {
        Execution {
            copyright_holder: self.copyright_holder.map(String::from),
            copyright_year: self.copyright_year.map(String::from),
            input: self.input.map(PathBuf::from),
            output: self.output.map(PathBuf::from),
            package: self.package.map(PathBuf::from),
        }
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for printing a license.
#[derive(Debug)]
pub struct Execution {
    copyright_holder: Option<String>,
    copyright_year: Option<String>,
    input: Option<PathBuf>,
    output: Option<PathBuf>,
    package: Option<PathBuf>,
}

impl Execution {
    /// Prints a license based on the built context.
    pub fn run(self, template: &Template) -> Result<()> {
        let render = self.render(template)?;
        render.write()?;
        Ok(())
    }

    pub fn render(self, template: &Template) -> Result<RenderOutput> {
        debug!("copyright_holder = {:?}", self.copyright_holder);
        debug!("copyright_year = {:?}", self.copyright_year);
        debug!("input = {:?}", self.input);
        debug!("output = {:?}", self.output);
        let manifest = manifest(self.input.as_ref())?;
        let package = package(&manifest, self.package.as_ref().and_then(|p| p.to_str()))?;
        let template = mustache::compile_str(template.to_str())?;
        let data = MapBuilder::new()
            .insert_str("copyright-year", self.copyright_year())
            .insert_str("copyright-holder", self.copyright_holder(&package)?)
            .build();
        let rendered = template.render_data_to_string(&data).map_err(Error::from)?;

        Ok(RenderOutput {
            path: self.output,
            rendered,
        })
    }

    fn copyright_holder(&self, manifest: &Package) -> Result<String> {
        if let Some(ref h) = self.copyright_holder {
            Ok(h.to_owned())
        } else {
            super::authors(manifest)
        }
    }

    fn copyright_year(&self) -> String {
        self.copyright_year
            .clone()
            .unwrap_or_else(|| Utc::now().year().to_string())
    }
}

impl Default for Execution {
    fn default() -> Self {
        Builder::new().build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    mod builder {
        use super::*;

        #[test]
        fn copyright_holder_works() {
            const EXPECTED: &str = "Example";
            let mut actual = Builder::new();
            actual.copyright_holder(Some(EXPECTED));
            assert_eq!(actual.copyright_holder, Some(EXPECTED));
        }

        #[test]
        fn copyright_year_works() {
            const EXPECTED: &str = "1982";
            let mut actual = Builder::new();
            actual.copyright_year(Some(EXPECTED));
            assert_eq!(actual.copyright_year, Some(EXPECTED));
        }

        #[test]
        fn input_works() {
            const EXPECTED: &str = "Example.wxs";
            let mut actual = Builder::new();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }

        #[test]
        fn output_works() {
            const EXPECTED: &str = "C:\\Example\\output";
            let mut actual = Builder::new();
            actual.output(Some(EXPECTED));
            assert_eq!(actual.output, Some(EXPECTED));
        }
    }

    mod execution {
        use super::*;

        const MIN_MANIFEST: &str = r#"{
            "name": "Example",
            "version": "0.1.0",
            "authors": ["First Last <first.last@example.com>"],

            "id": "",
            "dependencies": [],
            "targets": [],
            "features": {},
            "manifest_path": ""
        }"#;

        #[test]
        fn copyright_holder_works() {
            let manifest = serde_json::from_str(MIN_MANIFEST).expect("Parsing TOML");
            let actual = Execution::default().copyright_holder(&manifest).unwrap();
            assert_eq!(actual, String::from("First Last"));
        }

        #[test]
        fn copyright_holder_with_override_works() {
            const EXPECTED: &str = "Dr. Example";
            let manifest = serde_json::from_str(MIN_MANIFEST).expect("Parsing TOML");
            let actual = Builder::new()
                .copyright_holder(Some(EXPECTED))
                .build()
                .copyright_holder(&manifest)
                .unwrap();
            assert_eq!(actual, String::from(EXPECTED));
        }

        #[test]
        fn copyright_year_works() {
            let actual = Execution::default().copyright_year();
            assert_eq!(actual, Utc::now().year().to_string());
        }

        #[test]
        fn copyright_year_with_override_works() {
            const EXPECTED: &str = "1982";
            let actual = Builder::new()
                .copyright_year(Some(EXPECTED))
                .build()
                .copyright_year();
            assert_eq!(actual, String::from(EXPECTED));
        }
    }
}


================================================
FILE: src/print/mod.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `print` command. This command is focused on
//! printing various templates based on a package's manifest (Cargo.toml) or
//! end-user input.

use itertools::Itertools;
use log::warn;
pub mod license;
pub mod wxs;

use crate::Error;
use crate::Result;

use log::trace;

use regex::Regex;

use std::fs::File;
use std::io::{self, Write};
use std::path::PathBuf;

use cargo_metadata::Package;

/// The result of rendering a template (main.wxs, License.rtf, ...)
pub struct RenderOutput {
    /// The path the template should be written to
    /// (we needed to know this at generation time to properly embed relative paths)
    ///
    /// If this is None then the template should be written to stdout
    /// FIMXE: this is kinda busted! You still need to know relative paths!
    pub path: Option<PathBuf>,
    /// The contents of the file
    pub rendered: String,
}

impl RenderOutput {
    /// Write the output to its expected destination.
    ///
    /// See [`RenderOutput::path`][] for details.
    pub fn write(&self) -> Result<()> {
        let mut out = destination(self.path.as_ref())?;
        out.write_all(self.rendered.as_bytes())?;
        out.flush()?;
        Ok(())
    }

    /// Write the output to its expected destination, if that destination is a file.
    ///
    /// This is for "auxiliary files" which also need to be produced somehow, but
    /// which we can't emit when printing the "main file" to stdout. With nowhere
    /// to put them, all we can do is warn.
    ///
    /// See [`RenderOutput::path`][] for details.
    pub fn write_disk_only(&self) -> Result<()> {
        if self.path.is_none() {
            warn!("License.rtf also needs to be generated!");
            return Ok(());
        }
        self.write()
    }
}

fn destination(output: Option<&PathBuf>) -> Result<Box<dyn Write>> {
    if let Some(ref output) = output {
        trace!("An output path has been explicitly specified");
        let f = File::create(output)?;
        Ok(Box::new(f))
    } else {
        trace!(
            "An output path has NOT been explicitly specified. Implicitly \
             determine output."
        );
        Ok(Box::new(io::stdout()))
    }
}

fn authors(package: &Package) -> Result<String> {
    let result = package
        .authors
        .iter()
        .map(|s| {
            // Strip email if it exists.
            let re = Regex::new(r"<(.*?)>").unwrap();
            re.replace_all(s, "")
        })
        .map(|s| String::from(s.trim()))
        // Replace this with intersperse from stdlib when it is stabilized: https://github.com/rust-lang/rust/issues/79524
        .join("; ");

    if result.is_empty() {
        Err(Error::Manifest("authors"))
    } else {
        Ok(result)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    const SINGLE_AUTHOR_MANIFEST: &str = r#"{
            "name": "Example",
            "version": "0.1.0",
            "authors": ["First Last <first.last@example.com>"],

            "id": "",
            "dependencies": [],
            "targets": [],
            "features": {},
            "manifest_path": ""
        }"#;

    const MULTIPLE_AUTHORS_MANIFEST: &str = r#"{
            "name": "Example",
            "version": "0.1.0",
            "authors": ["1 Author <first.last@example.com>", "2 Author <2.author@example.com>", "3 author <3.author@example.com>"],

            "id": "",
            "dependencies": [],
            "targets": [],
            "features": {},
            "manifest_path": ""
        }"#;

    #[test]
    fn authors_with_single_author_works() {
        let manifest = serde_json::from_str(SINGLE_AUTHOR_MANIFEST).expect("Parsing TOML");
        let actual = authors(&manifest).unwrap();
        assert_eq!(actual, String::from("First Last"));
    }

    #[test]
    fn authors_with_multiple_authors_works() {
        let manifest = serde_json::from_str(MULTIPLE_AUTHORS_MANIFEST).expect("Parsing TOML");
        let actual = authors(&manifest).unwrap();
        assert_eq!(actual, String::from("1 Author; 2 Author; 3 author"));
    }
}


================================================
FILE: src/print/wxs.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for printing a WiX Source (wxs) file.

use crate::EXE_FILE_EXTENSION;
use crate::Error;
use crate::Result;
use crate::Template;
use crate::description;
use crate::licenses::{License, Licenses};
use crate::manifest;
use crate::package;
use crate::product_name;
use crate::stored_path::StoredPathBuf;
use crate::toolset::project::WxsSchema;

use camino::Utf8Path;
use log::{debug, trace, warn};

use mustache::{self, MapBuilder};

use std::path::Path;
use std::{collections::HashMap, str::FromStr};

use cargo_metadata::{Package, TargetKind};

use uuid::Uuid;

use super::RenderOutput;

/// A builder for creating an execution context to print a WiX Toolset source file (wxs).
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    banner: Option<&'a str>,
    binaries: Option<Vec<&'a str>>,
    copyright_year: Option<&'a str>,
    copyright_holder: Option<&'a str>,
    description: Option<&'a str>,
    dialog: Option<&'a str>,
    eula: Option<&'a str>,
    help_url: Option<&'a str>,
    input: Option<&'a str>,
    license: Option<&'a str>,
    manufacturer: Option<&'a str>,
    output: Option<&'a str>,
    package: Option<&'a str>,
    path_guid: Option<&'a str>,
    product_icon: Option<&'a str>,
    product_name: Option<&'a str>,
    upgrade_guid: Option<&'a str>,
    schema: Option<WxsSchema>,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder {
            banner: None,
            binaries: None,
            copyright_year: None,
            copyright_holder: None,
            description: None,
            dialog: None,
            eula: None,
            help_url: None,
            input: None,
            license: None,
            manufacturer: None,
            output: None,
            package: None,
            path_guid: None,
            product_icon: None,
            product_name: None,
            upgrade_guid: None,
            schema: None,
        }
    }

    /// Sets the path to a bitmap (BMP) file to be used as a banner image across
    /// the top of each dialog in the installer.
    ///
    /// The banner image must be 493 x 58 pixels. See the [Wix Toolset
    /// documentation] for details about [customization].
    ///
    /// [Wix Toolset documentation]: http://wixtoolset.org/documentation/
    /// [customization]: http://wixtoolset.org/documentation/manual/v3/wixui/wixui_customizations.html
    pub fn banner(&mut self, b: Option<&'a str>) -> &mut Self {
        self.banner = b;
        self
    }

    /// Sets the path to one or more binaries to include in the installer.
    ///
    /// The default is to first find _all_ binaries defined in the `bin`
    /// sections of the package's manifest (Cargo.toml) and include all of them
    /// in the installer. If there are no `bin` sections, then the `name` field
    /// uder the `package` section is used. This overrides either of these
    /// cases, regardless of the existence and number of `bin` sections.
    ///
    /// A path to each binary should be used for the value. The file stem (file
    /// name without the extension) will be used for each binary's name, while
    /// the path will be used for the source. The binary names will _not_ appear
    /// in the Add/Remove Programs control panel. Use the `product_name` method
    /// to change the name that appears in the Add/Remove Programs control
    /// panel.
    pub fn binaries(&mut self, b: Option<Vec<&'a str>>) -> &mut Self {
        self.binaries = b;
        self
    }

    /// Sets the copyright holder for the generated license file and EULA.
    ///
    /// The default is to use the `authors` field of the
    /// package's manifest (Cargo.toml). This method can be used to override the
    /// default and set a different copyright holder if and when a Rich Text
    /// Format (RTF) license and EULA are generated based on the value of the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// This value is ignored and not used if an EULA is set with the [`eula`]
    /// method, if a custom EULA is set using the `license-file` field in the
    /// package's manifest (Cargo.toml), or an EULA is _not_ generated from the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// [`eula`]: https://volks73.github.io/cargo-wix/cargo_wix/initialize.html#eula
    pub fn copyright_holder(&mut self, h: Option<&'a str>) -> &mut Self {
        self.copyright_holder = h;
        self
    }

    /// Sets the copyright year for the generated license file and EULA.
    ///
    /// The default is to use the current year. This method can be used to
    /// override the default and set a specific year if and when a Rich Text
    /// Format (RTF) license and EULA are generated based on the value of the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// This value is ignored and not used if an EULA is set with the [`eula`]
    /// method, if a custom EULA is set using the `license-file` field in the
    /// package's manifest (Cargo.toml), or an EULA is _not_ generated from the
    /// `license` field in the package's manifest (Cargo.toml).
    ///
    /// [`eula`]: https://volks73.github.io/cargo-wix/cargo_wix/initialize.html#eula
    pub fn copyright_year(&mut self, y: Option<&'a str>) -> &mut Self {
        self.copyright_year = y;
        self
    }

    /// Sets the description.
    ///
    /// This overrides the description determined from the `description` field
    /// in the package'
    pub fn description(&mut self, d: Option<&'a str>) -> &mut Self {
        self.description = d;
        self
    }

    /// Sets the path to a bitmap (`.bmp`) file that will be displayed on the
    /// first dialog to the left.
    ///
    /// The image must be 493 x 312 pixels. See the [Wix Toolset
    /// documentation] for details about [customization].
    ///
    /// [Wix Toolset documentation]: http://wixtoolset.org/documentation/
    /// [customization]: http://wixtoolset.org/documentation/manual/v3/wixui/wixui_customizations.html
    pub fn dialog(&mut self, d: Option<&'a str>) -> &mut Self {
        self.dialog = d;
        self
    }

    /// Sets the path to a custom EULA.
    ///
    /// The default is to generate an EULA from an embedded template as a RTF
    /// file based on the name of the license specified in the `license` field
    /// of the package's manifest (Cargo.toml). If the `license` field is not
    /// specified or a template for the license does not exist but the
    /// `license-file` field does specify a path to a file with the RTF
    /// extension, then that RTF file is used as the EULA for the license
    /// agreement dialog in the installer. Finally, if the `license-file` does
    /// not exist or it specifies a file that does not have the `.rtf`
    /// extension, then the license agreement dialog is skipped and there is no
    /// EULA for the installer. This would override the default behavior and
    /// ensure the license agreement dialog is used.
    pub fn eula(&mut self, e: Option<&'a str>) -> &mut Self {
        self.eula = e;
        self
    }

    /// Sets the help URL.
    ///
    /// The default is to obtain a URL from one of the following fields in the
    /// package's manifest (Cargo.toml): `documentation`, `homepage`, or
    /// `repository`. If none of these are specified, then the default is to
    /// exclude a help URL from the installer. This will override the default
    /// behavior and provide a help URL for the installer if none of the fields
    /// exist.
    pub fn help_url(&mut self, h: Option<&'a str>) -> &mut Self {
        self.help_url = h;
        self
    }

    /// Sets the path to a package's manifest (Cargo.toml) to be used to
    /// generate a WiX Source (wxs) file from the embedded template.
    ///
    /// A `wix` and `wix\main.wxs` file will be created in the same directory as
    /// the package's manifest. The default is to use the package's manifest in
    /// the current working directory.
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Sets the path to a file to be used as the license [sidecar] file.
    ///
    /// The default is to use the value specified in the `license-file` field of
    /// the package's manifest (Cargo.toml) or generate a Rich Text Format (RTF)
    /// license file from an embedded template based on the license ID used in
    /// the `license` field of the package's manifest. If none of these fields
    /// are specified or overridden, then a license sidecar file is _not_
    /// included in the installation directory.
    ///
    /// This will override the default behavior and skip using either the
    /// `license` or `license-file` fields in the package's manifest.
    ///
    /// [sidecar]: https://en.wikipedia.org/wiki/Sidecar_file
    pub fn license(&mut self, l: Option<&'a str>) -> &mut Self {
        self.license = l;
        self
    }

    /// Sets the manufacturer.
    ///
    /// Default is to use the `authors` field of the
    /// package's manifest (Cargo.toml). This would override the default value.
    pub fn manufacturer(&mut self, m: Option<&'a str>) -> &mut Self {
        self.manufacturer = m;
        self
    }

    /// Sets the destination for creating all of the output from initialization.
    ///
    /// The default is to create all initialization output in the current
    /// working directory.
    pub fn output(&mut self, o: Option<&'a str>) -> &mut Self {
        self.output = o;
        self
    }

    /// Sets the package within a workspace to print a template.
    ///
    /// Each package within a workspace has its own package manifest, i.e.
    /// `Cargo.toml`. This indicates which package manifest within a workspace
    /// should be used to populate a template.
    pub fn package(&mut self, p: Option<&'a str>) -> &mut Self {
        self.package = p;
        self
    }

    /// Sets the GUID for the path component.
    ///
    /// The default automatically generates the GUID needed for the path
    /// component. A GUID is needed so that the path component can be
    /// successfully removed on uninstall.
    ///
    /// Generally, the path component GUID should be generated only once per
    /// project/product and then the same GUID used every time the installer is
    /// created. The GUID is stored in the WiX Source (WXS) file. However,
    /// this allows using an existing GUID, possibly obtained with another tool.
    pub fn path_guid(&mut self, p: Option<&'a str>) -> &mut Self {
        self.path_guid = p;
        self
    }

    /// Sets the path to an image file to be used for product icon.
    ///
    /// The product icon is the icon that appears for an installed application
    /// in the Add/Remove Programs (ARP) control panel. If a product icon is
    /// _not_ defined for an application within the installer, then the Windows
    /// OS assigns a generic one.
    pub fn product_icon(&mut self, p: Option<&'a str>) -> &mut Self {
        self.product_icon = p;
        self
    }

    /// Sets the product name.
    ///
    /// The default is to use the `name` field under the `package` section of
    /// the package's manifest (Cargo.toml). This overrides that value. An error
    /// occurs if the `name` field is not found in the manifest.
    ///
    /// This is different from the binary name in that it is the name that
    /// appears in the Add/Remove Programs (ARP) control panel, _not_ the name
    /// of the executable. The [`binary_name`] method can be used to change the
    /// executable name. This value can have spaces and special characters,
    /// where the binary name should avoid spaces and special characters.
    ///
    /// [`binary_name`]: #binary_name
    pub fn product_name(&mut self, p: Option<&'a str>) -> &mut Self {
        self.product_name = p;
        self
    }

    /// Sets the Upgrade Code GUID.
    ///
    /// The default automatically generates the GUID needed for the `UpgradeCode`
    /// attribute to the `Product` tag. The Upgrade Code uniquely identifies the
    /// installer. It is used to determine if the new installer is the same
    /// product and the current installation should be removed and upgraded to
    /// this version. If the GUIDs of the current product and new product do
    /// _not_ match, then Windows will treat the two installers as separate
    /// products.
    ///
    /// Generally, the upgrade code should be generated only once per
    /// project/product and then the same code used every time the installer is
    /// created. The GUID is stored in the WiX Source (WXS) file. However,
    /// this allows usage of an existing GUID for the upgrade code.
    pub fn upgrade_guid(&mut self, u: Option<&'a str>) -> &mut Self {
        self.upgrade_guid = u;
        self
    }

    /// Sets the Wxs Schema
    ///
    /// Wix3 follows the "v3" schema, where as Wix4 and beyond use the "Modern" schema uri.
    pub fn schema(&mut self, schema: Option<WxsSchema>) -> &mut Self {
        self.schema = schema;
        self
    }

    /// Builds an execution context for printing a template.
    pub fn build(&self) -> Execution {
        Execution {
            banner: self.banner.map(StoredPathBuf::from),
            binaries: self
                .binaries
                .as_ref()
                .map(|b| b.iter().copied().map(StoredPathBuf::from).collect()),
            copyright_holder: self.copyright_holder.map(String::from),
            copyright_year: self.copyright_year.map(String::from),
            description: self.description.map(String::from),
            dialog: self.dialog.map(StoredPathBuf::from),
            eula: self.eula.map(StoredPathBuf::from),
            help_url: self.help_url.map(String::from),
            input: self.input.map(std::path::PathBuf::from),
            license: self.license.map(StoredPathBuf::from),
            manufacturer: self.manufacturer.map(String::from),
            output: self.output.map(std::path::PathBuf::from),
            package: self.package.map(String::from),
            path_guid: self.path_guid.map(String::from),
            product_icon: self.product_icon.map(StoredPathBuf::from),
            product_name: self.product_name.map(String::from),
            upgrade_guid: self.upgrade_guid.map(String::from),
            schema: self.schema.unwrap_or(WxsSchema::Legacy),
        }
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for printing a WiX Toolset source file (wxs).
#[derive(Debug)]
pub struct Execution {
    banner: Option<StoredPathBuf>,
    binaries: Option<Vec<StoredPathBuf>>,
    copyright_holder: Option<String>,
    copyright_year: Option<String>,
    description: Option<String>,
    dialog: Option<StoredPathBuf>,
    eula: Option<StoredPathBuf>,
    help_url: Option<String>,
    input: Option<std::path::PathBuf>,
    license: Option<StoredPathBuf>,
    manufacturer: Option<String>,
    output: Option<std::path::PathBuf>,
    package: Option<String>,
    path_guid: Option<String>,
    product_icon: Option<StoredPathBuf>,
    product_name: Option<String>,
    upgrade_guid: Option<String>,
    schema: WxsSchema,
}

/// All the possible output files of [`Execution::render`][].
///
/// Although we're only trying to output the "main" output of main.wxs,
/// that file may want to reference other files that also need to be generated,
/// so we need to report them all together.
pub struct WxsRenders {
    /// The main output, typically wix\main.wxs
    pub wxs: RenderOutput,
    /// A potential source-license for the project (MIT, Apache, ...), typically wix\License.rtf
    pub license: Option<RenderOutput>,
    /// A potential eula for the project
    ///
    /// This is currently always None, as the generation of eula texts
    /// is currently always accomplished by generating a source-license,
    /// but you should assume this can be Some so that you don't need to
    /// do anything if we ever start using this.
    pub eula: Option<RenderOutput>,
}

impl Execution {
    /// Prints a WiX Source (wxs) file based on the built context.
    pub fn run(self) -> Result<()> {
        let renders = self.render()?;
        renders.wxs.write()?;
        if let Some(license) = renders.license {
            license.write_disk_only()?;
        }
        if let Some(eula) = renders.eula {
            eula.write_disk_only()?;
        }
        Ok(())
    }

    /// Instead of printing the output like [`Execution::run`][], render the output to Strings.
    ///
    /// See [`WxsRenders`][] for details of the output.
    pub fn render(self) -> Result<WxsRenders> {
        debug!("banner = {:?}", self.banner);
        debug!("binaries = {:?}", self.binaries);
        debug!("copyright_holder = {:?}", self.copyright_holder);
        debug!("copyright_year = {:?}", self.copyright_year);
        debug!("description = {:?}", self.description);
        debug!("dialog = {:?}", self.description);
        debug!("eula = {:?}", self.eula);
        debug!("help_url = {:?}", self.help_url);
        debug!("input = {:?}", self.input);
        debug!("license = {:?}", self.license);
        debug!("manufacturer = {:?}", self.manufacturer);
        debug!("output = {:?}", self.output);
        debug!("package = {:?}", self.package);
        debug!("path_guid = {:?}", self.path_guid);
        debug!("product_icon = {:?}", self.product_icon);
        debug!("product_name = {:?}", self.product_name);
        debug!("upgrade_guid = {:?}", self.upgrade_guid);
        let manifest = manifest(self.input.as_ref())?;
        let package = package(&manifest, self.package.as_deref())?;
        let binaries = self.binaries(&package)?;
        let licenses = self.licenses(&package)?;
        let mut map = MapBuilder::new()
            .insert_vec("binaries", |mut builder| {
                for binary in &binaries {
                    builder = builder.push_map(|builder| {
                        builder
                            .insert_str("binary-index", binary.get("binary-index").unwrap())
                            .insert_str("binary-name", binary.get("binary-name").unwrap())
                            .insert_str("binary-source", binary.get("binary-source").unwrap())
                    });
                }
                builder
            })
            .insert_str(
                "product-name",
                product_name(self.product_name.as_ref(), &package),
            )
            .insert_str("manufacturer", self.manufacturer(&package)?)
            .insert_str("upgrade-code-guid", self.upgrade_guid(&package)?)
            .insert_str("path-component-guid", self.path_guid(&package)?);
        if let Some(banner) = self.banner_image(&package) {
            map = map.insert_str("banner", banner);
        }
        if let Some(description) = description(self.description.clone(), &package) {
            map = map.insert_str("description", description);
        } else {
            warn!(
                "A description was not specified at the command line or in the package's manifest \
                 (Cargo.toml). The description can be added manually to the generated WiX \
                 Source (wxs) file using a text editor."
            );
        }
        if let Some(dialog) = self.dialog_image(&package) {
            map = map.insert_str("dialog", dialog);
        }
        if let Some(eula) = &licenses.end_user {
            map = map.insert_str("eula", &eula.stored_path);
        }
        if let Some(url) = self.help_url(&package) {
            map = map.insert_str("help-url", url);
        } else {
            warn!(
                "A help URL could not be found and it will be excluded from the installer. \
                 A help URL can be added manually to the generated WiX Source (wxs) file \
                 using a text editor."
            );
        }
        if let Some(license) = &licenses.source {
            map = map.insert_str("license-source", &license.stored_path);
            if let Some(name) = &license.name {
                map = map.insert_str("license-name", name);
            }
        }
        if let Some(icon) = self.product_icon(&package) {
            map = map.insert_str("product-icon", icon);
        }

        let wxs = {
            let data = map.build();
            let main_destination = self.output.clone();
            let wxs_template = match self.schema {
                WxsSchema::Legacy => Template::WxsV3.to_str(),
                WxsSchema::V4 => Template::WxsV4.to_str(),
                _ => {
                    unreachable!("should always have one of the above valid schemas set")
                }
            };
            let template = mustache::compile_str(wxs_template)?;
            let rendered = template.render_data_to_string(&data).map_err(Error::from)?;
            RenderOutput {
                path: main_destination,
                rendered,
            }
        };
        let license = self.render_license_string(licenses.source.as_ref())?;
        let eula = self.render_license_string(licenses.end_user.as_ref())?;
        Ok(WxsRenders { wxs, license, eula })
    }

    fn render_license_string(&self, license: Option<&License>) -> Result<Option<RenderOutput>> {
        let Some(license) = license else {
            return Ok(None);
        };
        let Some((output, template)) = &license.generate else {
            return Ok(None);
        };

        let mut printer = crate::print::license::Builder::new();
        printer.copyright_holder(self.copyright_holder.as_ref().map(String::as_ref));
        printer.copyright_year(self.copyright_year.as_ref().map(String::as_ref));
        printer.input(self.input.as_deref().and_then(Path::to_str));
        // Slightly hacky: only respect the template's desire to be written to disk
        // if we're writing the overall wxs to disk! This makes "stdout" mode
        // behave in the desired manner.
        if self.output.is_some() {
            printer.output(Some(output.as_str()));
        }
        printer.package(self.package.as_deref());

        let render = printer.build().render(template)?;
        Ok(Some(render))
    }

    fn binaries(&self, package: &Package) -> Result<Vec<HashMap<&'static str, String>>> {
        let mut binaries = Vec::new();
        if let Some(binary_paths) = &self.binaries {
            let mut map = HashMap::with_capacity(3);
            for (index, binary) in binary_paths.iter().enumerate() {
                let binary_file_stem = binary.file_stem().ok_or_else(|| {
                    Error::Generic(format!(
                        "The '{}' binary path does not have a file name",
                        binary
                    ))
                })?;
                map.insert("binary-index", index.to_string());
                map.insert("binary-name", binary_file_stem.to_owned());
                map.insert("binary-source", binary.to_string());
            }
            binaries.push(map);
        } else {
            // cargo-metadata attempts to sort binaries by name to keep things stable,
            // but for whatever reason it internally uses the platform-specific binary name
            // with ".exe" appended, even though the output doesn't refer to that extension.
            // As such, the ordering ends up being platform-specific, because any time one
            // binary has a name that's a prefix of the other (e.g. "app" and "app-helper")
            // the `.exe` extension changes the ordering of the sort. We sort the list again
            // with the agnostic name to avoid this issue.
            let mut binaries_list = package
                .targets
                .iter()
                .filter(|v| v.kind.iter().any(|v| v == &TargetKind::Bin))
                .collect::<Vec<_>>();
            binaries_list.sort_by_key(|k| &k.name);

            for (index, binary) in binaries_list.into_iter().enumerate() {
                let mut map = HashMap::with_capacity(3);
                map.insert("binary-index", index.to_string());
                map.insert("binary-name", binary.name.clone());
                map.insert(
                    "binary-source",
                    Self::default_binary_path(&binary.name).to_string(),
                );
                binaries.push(map);
            }
        }
        Ok(binaries)
    }

    fn default_binary_path(name: &str) -> StoredPathBuf {
        // Use hardcoded path separator here to avoid platform-specific output
        StoredPathBuf::from(format!(
            "$(var.CargoTargetBinDir)\\{name}.{EXE_FILE_EXTENSION}"
        ))
    }

    fn help_url(&self, manifest: &Package) -> Option<String> {
        self.help_url
            .as_ref()
            .map(String::from)
            .or_else(|| manifest.documentation.clone())
            .or_else(|| manifest.homepage.clone())
            .or_else(|| manifest.repository.clone())
    }

    fn licenses(&self, manifest: &Package) -> Result<Licenses> {
        let output_dir = self
            .output
            .as_deref()
            .and_then(|p| p.parent())
            .and_then(Utf8Path::from_path);
        let licenses = Licenses::new(
            output_dir,
            self.license.as_deref(),
            self.eula.as_deref(),
            manifest,
        )?;
        Ok(licenses)
    }

    fn manufacturer(&self, manifest: &Package) -> Result<String> {
        if let Some(ref m) = self.manufacturer {
            Ok(m.to_owned())
        } else {
            super::authors(manifest)
        }
    }

    fn path_guid(&self, manifest: &Package) -> Result<String> {
        if let Some(ref u) = self.path_guid {
            trace!("An path GUID has been explicitly specified");
            Ok(u.to_owned())
        } else if let Some(pkg_meta_wix_path_guid) = manifest
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("path-guid"))
            .and_then(|u| u.as_str())
        {
            Uuid::from_str(pkg_meta_wix_path_guid)
                .map(|u| u.as_hyphenated().to_string().to_uppercase())
                .map_err(Error::from)
        } else {
            Ok(Uuid::new_v4().as_hyphenated().to_string().to_uppercase())
        }
    }

    fn upgrade_guid(&self, manifest: &Package) -> Result<String> {
        if let Some(ref u) = self.upgrade_guid {
            trace!("An upgrade GUID has been explicitly specified");
            Ok(u.to_owned())
        } else if let Some(pkg_meta_wix_upgrade_guid) = manifest
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("upgrade-guid"))
            .and_then(|u| u.as_str())
        {
            Uuid::from_str(pkg_meta_wix_upgrade_guid)
                .map(|u| u.as_hyphenated().to_string().to_uppercase())
                .map_err(Error::from)
        } else {
            Ok(Uuid::new_v4().as_hyphenated().to_string().to_uppercase())
        }
    }

    fn banner_image(&self, manifest: &Package) -> Option<StoredPathBuf> {
        if let Some(path) = &self.banner {
            trace!("A banner image has been explicitly specified");
            Some(path.clone())
        } else {
            manifest
                .metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("banner"))
                .and_then(|p| p.as_str())
                .map(|p| StoredPathBuf::new(p.to_owned()))
        }
    }

    fn dialog_image(&self, manifest: &Package) -> Option<StoredPathBuf> {
        if let Some(path) = &self.dialog {
            trace!("A dialog image has been explicitly specified");
            Some(path.clone())
        } else {
            manifest
                .metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("dialog"))
                .and_then(|p| p.as_str())
                .map(|p| StoredPathBuf::new(p.to_owned()))
        }
    }

    fn product_icon(&self, manifest: &Package) -> Option<StoredPathBuf> {
        if let Some(path) = &self.product_icon {
            trace!("A product icon has been explicitly specified");
            Some(path.clone())
        } else {
            manifest
                .metadata
                .get("wix")
                .and_then(|w| w.as_object())
                .and_then(|t| t.get("product-icon"))
                .and_then(|p| p.as_str())
                .map(|p| StoredPathBuf::new(p.to_owned()))
        }
    }

    #[cfg(test)]
    pub fn for_test(input: &Path) -> Self {
        let input = Utf8Path::from_path(input).expect("utf8 path");
        let output = input
            .parent()
            .expect("Cargo.toml to not be a root")
            .join(crate::WIX)
            .join(format!(
                "{}.{}",
                crate::WIX_SOURCE_FILE_NAME,
                crate::WIX_SOURCE_FILE_EXTENSION
            ));
        Builder::new()
            .input(Some(input.as_str()))
            .output(Some(output.as_str()))
            .build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use maplit::hashmap;

    mod builder {
        use super::*;

        #[test]
        fn banner_works() {
            const EXPECTED: &str = "img\\Banner.bmp";
            let mut actual = Builder::new();
            actual.banner(Some(EXPECTED));
            assert_eq!(actual.banner, Some(EXPECTED));
        }

        #[test]
        fn binaries_name_works() {
            const EXPECTED: &str = "bin\\Example.exe";
            let mut actual = Builder::new();
            actual.binaries(Some(vec![EXPECTED]));
            assert_eq!(actual.binaries, Some(vec![EXPECTED]));
        }

        #[test]
        fn description_works() {
            const EXPECTED: &str = "This is a description.";
            let mut actual = Builder::new();
            actual.description(Some(EXPECTED));
            assert_eq!(actual.description, Some(EXPECTED));
        }

        #[test]
        fn dialog_work() {
            const EXPECTED: &str = "img\\Dialog.bmp";
            let mut actual = Builder::new();
            actual.dialog(Some(EXPECTED));
            assert_eq!(actual.dialog, Some(EXPECTED));
        }

        #[test]
        fn eula_works() {
            const EXPECTED: &str = "Example_Eula.rtf";
            let mut actual = Builder::new();
            actual.eula(Some(EXPECTED));
            assert_eq!(actual.eula, Some(EXPECTED));
        }

        #[test]
        fn help_url_works() {
            const EXPECTED: &str = "http://www.example.com";
            let mut actual = Builder::new();
            actual.help_url(Some(EXPECTED));
            assert_eq!(actual.help_url, Some(EXPECTED));
        }

        #[test]
        fn input_works() {
            const EXPECTED: &str = "C:\\example\\Cargo.toml";
            let mut actual = Builder::new();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }

        #[test]
        fn license_works() {
            const EXPECTED: &str = "C:\\example\\Example License.rtf";
            let mut actual = Builder::new();
            actual.license(Some(EXPECTED));
            assert_eq!(actual.license, Some(EXPECTED));
        }

        #[test]
        fn manufacturer_works() {
            const EXPECTED: &str = "Example";
            let mut actual = Builder::new();
            actual.manufacturer(Some(EXPECTED));
            assert_eq!(actual.manufacturer, Some(EXPECTED));
        }

        #[test]
        fn output_works() {
            const EXPECTED: &str = "C:\\example\\output";
            let mut actual = Builder::new();
            actual.output(Some(EXPECTED));
            assert_eq!(actual.output, Some(EXPECTED));
        }

        #[test]
        fn path_guid_works() {
            let expected = Uuid::new_v4().as_hyphenated().to_string().to_uppercase();
            let mut actual = Builder::new();
            actual.path_guid(Some(&expected));
            assert_eq!(actual.path_guid, Some(expected.as_ref()));
        }

        #[test]
        fn product_icon_works() {
            const EXPECTED: &str = "img\\Product.ico";
            let mut actual = Builder::new();
            actual.product_icon(Some(EXPECTED));
            assert_eq!(actual.product_icon, Some(EXPECTED));
        }

        #[test]
        fn product_name_works() {
            const EXPECTED: &str = "Example Product Name";
            let mut actual = Builder::new();
            actual.product_name(Some(EXPECTED));
            assert_eq!(actual.product_name, Some(EXPECTED));
        }

        #[test]
        fn upgrade_guid_works() {
            let expected = Uuid::new_v4().as_hyphenated().to_string().to_uppercase();
            let mut actual = Builder::new();
            actual.upgrade_guid(Some(&expected));
            assert_eq!(actual.upgrade_guid, Some(expected.as_ref()));
        }

        #[test]
        fn schema_default_is_none() {
            let actual = Builder::new();
            assert_eq!(actual.schema, None);
        }

        #[test]
        fn schema_v4_works() {
            use crate::toolset::project::WxsSchema;
            let mut actual = Builder::new();
            actual.schema(Some(WxsSchema::V4));
            assert_eq!(actual.schema, Some(WxsSchema::V4));
        }

        #[test]
        fn schema_defaults_to_legacy_in_execution() {
            use crate::toolset::project::WxsSchema;
            let execution = Builder::new().build();
            assert!(matches!(execution.schema, WxsSchema::Legacy));
        }
    }

    mod execution {
        extern crate assert_fs;

        use super::*;
        use crate::tests::setup_project;
        use crate::{LICENSE_FILE_NAME, RTF_FILE_EXTENSION, WIX};
        use std::fs::File;

        const MIN_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
        "#;

        const MIT_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"
        "#;

        const GPL3_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "GPL-3.0"
        "#;

        const APACHE2_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "Apache-2.0"
        "#;

        const UNKNOWN_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "XYZ"
        "#;

        const MIT_MANIFEST_BIN: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [[bin]]
            name = "Different"
        "#;

        const MULTIPLE_BIN_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [[bin]]
            name = "binary0"
            path = "src/binary0/main.rs"

            [[bin]]
            name = "binary1"
            path = "src/binary1/main.rs"

            [[bin]]
            name = "binary2"
            path = "src/binary2/main.rs"
        "#;

        const DOCUMENTATION_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"
            documentation = "http://www.example.com"
        "#;

        const HOMEPAGE_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"
            homepage = "http://www.example.com"
        "#;

        const REPOSITORY_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"
            repository = "http://www.example.com"
        "#;

        const LICENSE_FILE_RTF_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license-file = "Example.rtf"
        "#;

        const LICENSE_FILE_TXT_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license-file = "Example.txt"
        "#;

        const LICENSE_FALSE_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            license = false
            eula = true
        "#;

        const EULA_FALSE_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            license = true
            eula = false
        "#;

        const EULA_AND_LICENSE_FALSE_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            license = false
            eula = false
        "#;

        const LICENSE_PATH_RTF_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            license = "MyLicense.rtf"
        "#;

        const LICENSE_PATH_TXT_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            license = "MyLicense.txt"
        "#;

        const EULA_PATH_RTF_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            eula = "MyEula.rtf"
        "#;

        const EULA_PATH_TXT_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            eula = "MyEula.txt"
        "#;

        const EULA_AND_LICENSE_PATH_RTF_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            license = "MyLicense.rtf"
            eula = "MyEula.rtf"
        "#;

        const EULA_BAD_PATH_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            eula = "MyFakeEula.rtf"
        "#;

        const LICENSE_BAD_PATH_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license = "MIT"

            [package.metadata.wix]
            eula = "MyFakeLicense.rtf"
        "#;

        const LICENSE_FILE_BAD_PATH_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            license-file = "MyFakeLicense.rtf"
        "#;

        const PATH_GUID: &str = "C38A18DB-12CC-4BDC-8A05-DFCB981A0F33";
        const UPGRADE_GUID: &str = "71C1A58D-3FD2-493D-BB62-4B27C66FCCF9";

        const PATH_GUID_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]

            [package.metadata.wix]
            path-guid = "C38A18DB-12CC-4BDC-8A05-DFCB981A0F33"
        "#;

        const UPGRADE_GUID_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]

            [package.metadata.wix]
            upgrade-guid = "71C1A58D-3FD2-493D-BB62-4B27C66FCCF9"
        "#;

        const IMAGES_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]

            [package.metadata.wix]
            product-icon = "wix/product.ico"
            dialog = "wix/dialog.png"
            banner = "wix/banner.png"
        "#;

        #[test]
        fn license_name_with_mit_license_field_works() {
            let project = setup_project(MIT_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source
                .expect("source license")
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
        }

        #[test]
        fn license_name_with_gpl3_license_field_works() {
            let project = setup_project(GPL3_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source
                .expect("source license")
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
        }

        #[test]
        fn license_name_with_apache2_license_field_works() {
            let project = setup_project(APACHE2_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source
                .expect("source license")
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
        }

        #[test]
        fn license_name_with_unknown_license_field_works() {
            let project = setup_project(UNKNOWN_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source;
            assert!(actual.is_none());
        }

        #[test]
        fn license_source_with_mit_license_field_works() {
            let project = setup_project(MIT_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source
                .expect("source license")
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
        }

        #[test]
        fn license_source_with_gpl3_license_field_works() {
            let project = setup_project(GPL3_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source
                .expect("source license")
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
        }

        #[test]
        fn license_source_with_apache2_license_field_works() {
            let project = setup_project(APACHE2_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source
                .expect("source license")
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
        }

        #[test]
        fn license_source_with_unknown_license_field_works() {
            let project = setup_project(UNKNOWN_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses")
                .source;
            assert!(actual.is_none());
        }

        #[test]
        fn license_false_works() {
            let project = setup_project(LICENSE_FALSE_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(licenses.source, None);
            assert_eq!(licenses.end_user, None);
        }

        #[test]
        fn eula_false_works() {
            let project = setup_project(EULA_FALSE_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(
                licenses.source.unwrap().stored_path,
                StoredPathBuf::from(format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"))
            );
            assert_eq!(licenses.end_user, None);
        }

        #[test]
        fn eula_and_license_false_works() {
            let project = setup_project(EULA_AND_LICENSE_FALSE_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(licenses.source, None);
            assert_eq!(licenses.end_user, None);
        }

        #[test]
        fn license_path_rtf_works() {
            let project = setup_project(LICENSE_PATH_RTF_MANIFEST);
            let license_file_path = project.path().join("MyLicense.rtf");
            let _license_file_handle = File::create(license_file_path).expect("Create file");
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(
                licenses.source.unwrap().stored_path.as_str(),
                "MyLicense.rtf"
            );
            assert_eq!(
                licenses.end_user.unwrap().stored_path.as_str(),
                "MyLicense.rtf"
            );
        }

        #[test]
        fn license_path_txt_works() {
            let project = setup_project(LICENSE_PATH_TXT_MANIFEST);
            let license_file_path = project.path().join("MyLicense.txt");
            let _license_file_handle = File::create(license_file_path).expect("Create file");
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(
                licenses.source.unwrap().stored_path.as_str(),
                "MyLicense.txt"
            );
            assert_eq!(licenses.end_user, None);
        }

        #[test]
        fn eula_path_rtf_works() {
            let project = setup_project(EULA_PATH_RTF_MANIFEST);
            let license_file_path = project.path().join("MyEula.rtf");
            let _license_file_handle = File::create(license_file_path).expect("Create file");
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(
                licenses.source.unwrap().stored_path.as_str(),
                format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}")
            );
            assert_eq!(
                licenses.end_user.unwrap().stored_path.as_str(),
                "MyEula.rtf"
            );
        }

        #[test]
        fn eula_path_txt_works() {
            let project = setup_project(EULA_PATH_TXT_MANIFEST);
            let license_file_path = project.path().join("MyEula.txt");
            let _license_file_handle = File::create(license_file_path).expect("Create file");
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(
                licenses.source.unwrap().stored_path.as_str(),
                format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}")
            );
            assert_eq!(
                licenses.end_user.unwrap().stored_path.as_str(),
                "MyEula.txt"
            );
        }

        #[test]
        fn eula_and_license_path_rtf_works() {
            let project = setup_project(EULA_AND_LICENSE_PATH_RTF_MANIFEST);
            let license_file_path = project.path().join("MyLicense.rtf");
            let _license_file_handle = File::create(license_file_path).expect("Create file");
            let eula_file_path = project.path().join("MyEula.rtf");
            let _eula_file_handle = File::create(eula_file_path).expect("Create file");
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input)
                .licenses(&package)
                .expect("licenses");
            assert_eq!(
                licenses.source.unwrap().stored_path.as_str(),
                "MyLicense.rtf"
            );
            assert_eq!(
                licenses.end_user.unwrap().stored_path.as_str(),
                "MyEula.rtf"
            );
        }

        #[test]
        fn eula_bad_path_errors() {
            let project = setup_project(EULA_BAD_PATH_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package);
            assert!(licenses.is_err());
        }

        #[test]
        fn license_bad_path_errors() {
            let project = setup_project(LICENSE_BAD_PATH_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package);
            assert!(licenses.is_err());
        }

        #[test]
        fn license_file_bad_path_errors() {
            let project = setup_project(LICENSE_FILE_BAD_PATH_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package);
            assert!(licenses.is_err());
        }

        #[test]
        fn binaries_with_no_bin_section_works() {
            let project = setup_project(MIT_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input).binaries(&package).unwrap();
            assert_eq!(
                actual,
                vec![hashmap! {
                    "binary-index" => 0.to_string(),
                    "binary-name" => String::from("Example"),
                    "binary-source" => String::from("$(var.CargoTargetBinDir)\\Example.exe")
                }]
            )
        }

        #[test]
        fn binaries_with_single_bin_section_works() {
            let project = setup_project(MIT_MANIFEST_BIN);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input).binaries(&package).unwrap();
            assert_eq!(
                actual,
                vec![hashmap! {
                    "binary-index" => 0.to_string(),
                    "binary-name" => String::from("Different"),
                    "binary-source" => String::from("$(var.CargoTargetBinDir)\\Different.exe")
                }]
            )
        }

        #[test]
        fn binaries_with_multiple_bin_sections_works() {
            let project = setup_project(MULTIPLE_BIN_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input).binaries(&package).unwrap();
            assert_eq!(
                actual,
                vec![
                    hashmap! {
                        "binary-index" => 0.to_string(),
                        "binary-name" => String::from("binary0"),
                        "binary-source" => String::from("$(var.CargoTargetBinDir)\\binary0.exe")
                    },
                    hashmap! {
                        "binary-index" => 1.to_string(),
                        "binary-name" => String::from("binary1"),
                        "binary-source" => String::from("$(var.CargoTargetBinDir)\\binary1.exe")
                    },
                    hashmap! {
                        "binary-index" => 2.to_string(),
                        "binary-name" => String::from("binary2"),
                        "binary-source" => String::from("$(var.CargoTargetBinDir)\\binary2.exe")
                    }
                ]
            )
        }

        #[test]
        fn manufacturer_with_defaults_works() {
            const EXPECTED: &str = "First Last";

            let project = setup_project(MIN_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input).manufacturer(&package).unwrap();
            assert_eq!(actual, String::from(EXPECTED));
        }

        #[test]
        fn manufacturer_with_override_works() {
            const EXPECTED: &str = "Example";

            let project = setup_project(MIN_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default()
                .manufacturer(Some(EXPECTED))
                .build()
                .manufacturer(&package)
                .unwrap();
            assert_eq!(actual, String::from(EXPECTED));
        }

        #[test]
        fn help_url_with_defaults_works() {
            let project = setup_project(MIN_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build().help_url(&package);
            assert!(actual.is_none());
        }

        #[test]
        fn help_url_with_documentation_works() {
            const EXPECTED: &str = "http://www.example.com";

            let project = setup_project(DOCUMENTATION_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build().help_url(&package);
            assert_eq!(actual, Some(String::from(EXPECTED)));
        }

        #[test]
        fn help_url_with_homepage_works() {
            const EXPECTED: &str = "http://www.example.com";

            let project = setup_project(HOMEPAGE_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build().help_url(&package);
            assert_eq!(actual, Some(String::from(EXPECTED)));
        }

        #[test]
        fn help_url_with_repository_works() {
            const EXPECTED: &str = "http://www.example.com";

            let project = setup_project(REPOSITORY_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build().help_url(&package);
            assert_eq!(actual, Some(String::from(EXPECTED)));
        }

        #[test]
        fn eula_with_defaults_works() {
            let project = setup_project(MIN_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .unwrap()
                .end_user;
            assert!(actual.is_none());
        }

        #[test]
        fn eula_with_mit_license_field_works() {
            let project = setup_project(MIT_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package).unwrap();
            let source = licenses.source.unwrap();
            let source_path = source.stored_path;
            let (template_out, source_template) = source.generate.unwrap();
            let eula_path = licenses.end_user.unwrap().stored_path;

            let expected_rel_path = format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}");
            let expected_abs_path = Utf8Path::from_path(input.parent().unwrap())
                .unwrap()
                .join(WIX)
                .join(format!("{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"));
            assert_eq!(source_template, Template::Mit);
            assert_eq!(source_path.as_str(), expected_rel_path);
            assert_eq!(template_out, expected_abs_path);
            assert_eq!(eula_path.as_str(), expected_rel_path);
        }

        #[test]
        fn eula_with_apache2_license_field_works() {
            let project = setup_project(APACHE2_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package).unwrap();
            let source = licenses.source.unwrap();
            let source_path = source.stored_path;
            let (template_out, source_template) = source.generate.unwrap();
            let eula_path = licenses.end_user.unwrap().stored_path;

            let expected_rel_path = format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}");
            let expected_abs_path = Utf8Path::from_path(input.parent().unwrap())
                .unwrap()
                .join(WIX)
                .join(format!("{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"));
            assert_eq!(source_template, Template::Apache2);
            assert_eq!(source_path.as_str(), expected_rel_path);
            assert_eq!(template_out, expected_abs_path);
            assert_eq!(eula_path.as_str(), expected_rel_path);
        }

        #[test]
        fn eula_with_gpl3_license_field_works() {
            let project = setup_project(GPL3_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package).unwrap();
            let source = licenses.source.unwrap();
            let source_path = source.stored_path;
            let (template_out, source_template) = source.generate.unwrap();
            let eula_path = licenses.end_user.unwrap().stored_path;

            let expected_rel_path = format!("{WIX}\\{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}");
            let expected_abs_path = Utf8Path::from_path(input.parent().unwrap())
                .unwrap()
                .join(WIX)
                .join(format!("{LICENSE_FILE_NAME}.{RTF_FILE_EXTENSION}"));
            assert_eq!(source_template, Template::Gpl3);
            assert_eq!(source_path.as_str(), expected_rel_path);
            assert_eq!(template_out, expected_abs_path);
            assert_eq!(eula_path.as_str(), expected_rel_path);
        }

        #[test]
        fn eula_with_unknown_license_field_works() {
            let project = setup_project(UNKNOWN_MANIFEST);
            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package).unwrap();
            let source = licenses.source;
            let eula = licenses.end_user;

            assert_eq!(source, None);
            assert_eq!(eula, None);
        }

        #[test]
        #[cfg(windows)]
        fn eula_with_override_works() {
            let project = setup_project(MIT_MANIFEST);
            let license_file_path = project.path().join("Example.rtf");
            let _license_file_handle = File::create(&license_file_path).expect("Create file");

            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default()
                .eula(license_file_path.to_str())
                .build()
                .licenses(&package)
                .unwrap()
                .end_user
                .unwrap()
                .stored_path;
            assert_eq!(
                actual,
                StoredPathBuf::from_std_path(&license_file_path).unwrap(),
            );
        }

        #[test]
        fn eula_with_license_file_field_works() {
            let project = setup_project(LICENSE_FILE_RTF_MANIFEST);
            let license_file_path = project.path().join("Example.rtf");
            let _license_file_handle = File::create(license_file_path).expect("Create file");

            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::for_test(&input)
                .licenses(&package)
                .unwrap()
                .end_user
                .unwrap()
                .stored_path;
            assert_eq!(actual.as_str(), "Example.rtf");
        }

        #[test]
        fn eula_with_license_file_extension_works() {
            let project = setup_project(LICENSE_FILE_TXT_MANIFEST);
            let license_file_path = project.path().join("Example.txt");
            let _license_file_handle = File::create(license_file_path).expect("Create file");

            let input = project.path().join("Cargo.toml");
            let manifest = crate::manifest(Some(&input)).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let licenses = Execution::for_test(&input).licenses(&package).unwrap();
            let source = licenses.source.unwrap();
            let eula = licenses.end_user;

            assert_eq!(source.generate, None);
            assert_eq!(source.name, None);
            assert_eq!(source.stored_path.as_str(), "Example.txt");
            assert_eq!(eula, None);
        }

        #[test]
        fn eula_with_wrong_file_extension_override_works() {
            let project = setup_project(LICENSE_FILE_TXT_MANIFEST);
            let license_file_path = project.path().join("Example.txt");
            let _license_file_handle = File::create(&license_file_path).expect("Create file");

            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            // We want to check that if the user hands us an OS-specific path here then we preserve it's format
            // So we turn the input to a string without escaping.
            let input = license_file_path.to_str().unwrap();
            let expected = StoredPathBuf::new(input.to_owned());
            let licenses = Builder::default()
                .eula(Some(input))
                .build()
                .licenses(&package)
                .unwrap();
            let eula = licenses.end_user.unwrap();

            assert_eq!(eula.stored_path, expected);
        }

        #[test]
        fn path_guid_with_override_works() {
            let expected = Uuid::new_v4().as_hyphenated().to_string().to_uppercase();

            let project = setup_project(MIN_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default()
                .path_guid(Some(&expected))
                .build()
                .path_guid(&package)
                .unwrap();
            assert_eq!(actual, expected);
        }

        #[test]
        fn path_guid_metadata_works() {
            let project = setup_project(PATH_GUID_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build().path_guid(&package).unwrap();
            assert_eq!(actual, PATH_GUID);
        }

        #[test]
        fn path_guid_metadata_and_override_works() {
            let expected = Uuid::new_v4().as_hyphenated().to_string().to_uppercase();

            let project = setup_project(PATH_GUID_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default()
                .path_guid(Some(&expected))
                .build()
                .path_guid(&package)
                .unwrap();
            assert_eq!(actual, expected);
        }

        #[test]
        fn upgrade_guid_with_override_works() {
            let expected = Uuid::new_v4().as_hyphenated().to_string().to_uppercase();

            let project = setup_project(MIN_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default()
                .upgrade_guid(Some(&expected))
                .build()
                .upgrade_guid(&package)
                .unwrap();
            assert_eq!(actual, expected);
        }

        #[test]
        fn upgrade_guid_metadata_works() {
            let project = setup_project(UPGRADE_GUID_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build().upgrade_guid(&package).unwrap();
            assert_eq!(actual, UPGRADE_GUID);
        }

        #[test]
        fn upgrade_guid_metadata_and_override_works() {
            let expected = Uuid::new_v4().as_hyphenated().to_string().to_uppercase();

            let project = setup_project(UPGRADE_GUID_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default()
                .upgrade_guid(Some(&expected))
                .build()
                .upgrade_guid(&package)
                .unwrap();
            assert_eq!(actual, expected);
        }

        #[test]
        fn image_metadata_works() {
            let project = setup_project(IMAGES_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::default().build();
            assert_eq!(
                actual.product_icon(&package).unwrap().as_str(),
                "wix/product.ico"
            );
            assert_eq!(
                actual.dialog_image(&package).unwrap().as_str(),
                "wix/dialog.png"
            );
            assert_eq!(
                actual.banner_image(&package).unwrap().as_str(),
                "wix/banner.png"
            );
        }
    }
}


================================================
FILE: src/purge.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `purge` command. This command is focused on
//! removing all files associated with `cargo wix` subcommand.

use crate::CARGO_MANIFEST_FILE;
use crate::Error;
use crate::Result;
use crate::WIX;
use crate::clean;

use log::{debug, info, trace, warn};

use std::env;
use std::ffi::OsStr;
use std::fs;
use std::path::PathBuf;

/// A builder for creating an execution context to remove all files and folders
/// related to the `cargo wix` subcommand.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    input: Option<&'a str>,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder { input: None }
    }

    /// Sets the path to a package's manifest (Cargo.toml) to be purge.
    ///
    /// The default is to use the current working directory if a Cargo.toml file
    /// is found.
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Builds an execution context to remove all WiX Toolset-related files and
    /// folders from a package.
    pub fn build(&mut self) -> Execution {
        Execution {
            input: self.input.map(PathBuf::from),
        }
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for removing WiX Toolset-related source and output files from a
/// package.
#[derive(Debug)]
pub struct Execution {
    input: Option<PathBuf>,
}

impl Execution {
    /// Removes all WiX Toolset-related files and folders, including files and
    /// folders created with the `cargo wix` subcommand, from a package.
    ///
    /// Use with caution! This cannot be undone.
    pub fn run(self) -> Result<()> {
        debug!("input = {:?}", self.input);
        let mut cleaner = clean::Builder::new();
        cleaner.input(self.input.as_ref().and_then(|p| p.to_str()));
        cleaner.build().run()?;
        let wix = self.wix()?;
        debug!("wix = {:?}", wix);
        if wix.exists() {
            trace!("The 'wix' folder exists");
            warn!("Removing the 'wix' folder");
            fs::remove_dir_all(wix)?;
        } else {
            trace!("The 'wix' folder does not exist");
            info!("Nothing to purge");
        }
        Ok(())
    }

    fn wix(&self) -> Result<PathBuf> {
        if let Some(ref input) = self.input {
            trace!("A Cargo.toml file has been explicitly specified");
            if input.exists() && input.is_file() {
                trace!("The input path exists and it is a file");
                if input.file_name() == Some(OsStr::new(CARGO_MANIFEST_FILE)) {
                    trace!("The input file is a Cargo manifest file");
                    Ok(input
                        .parent()
                        .map(|p| p.to_path_buf())
                        .map(|mut p| {
                            p.push(WIX);
                            p
                        })
                        .unwrap())
                } else {
                    Err(Error::Generic(format!(
                        "The '{}' path does not appear to be to a '{}' file",
                        input.display(),
                        CARGO_MANIFEST_FILE
                    )))
                }
            } else {
                Err(Error::Generic(format!(
                    "The '{}' path does not exist or it is not a file",
                    input.display()
                )))
            }
        } else {
            trace!(
                "An input path has NOT been explicitly specified, implicitly using the current \
                 working directory"
            );
            let mut cwd = env::current_dir()?;
            cwd.push(WIX);
            Ok(cwd)
        }
    }
}

impl Default for Execution {
    fn default() -> Self {
        Builder::new().build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    mod builder {
        use super::*;

        #[test]
        fn input_works() {
            const EXPECTED: &str = "C:\\Cargo.toml";
            let mut actual = Builder::default();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }
    }

    mod execution {
        extern crate assert_fs;

        use super::*;
        use std::fs::File;

        #[test]
        fn wix_works() {
            let actual = Execution::default().wix().unwrap();
            let cwd = env::current_dir()
                .expect("Current Working Directory")
                .join(WIX);
            assert_eq!(actual, cwd);
        }

        #[test]
        fn wix_with_nonexistent_manifest_fails() {
            let result = Builder::new().input(Some("C:\\Cargo.toml")).build().wix();
            assert!(result.is_err());
        }

        #[test]
        fn wix_with_existing_file_but_not_cargo_toml_fails() {
            let temp_dir = assert_fs::TempDir::new().unwrap();
            let non_cargo_toml_path = temp_dir.path().join("Example.txt");
            let _non_cargo_toml_handle = File::create(&non_cargo_toml_path).expect("Create file");
            let result = Builder::new()
                .input(non_cargo_toml_path.to_str())
                .build()
                .wix();
            assert!(result.is_err());
        }

        #[test]
        fn wix_with_existing_cargo_toml_works() {
            let temp_dir = assert_fs::TempDir::new().unwrap();
            let cargo_toml_path = temp_dir.path().join("Cargo.toml");
            let expected = temp_dir.path().join(WIX);
            let _non_cargo_toml_handle = File::create(&cargo_toml_path).expect("Create file");
            let actual = Builder::new()
                .input(cargo_toml_path.to_str())
                .build()
                .wix()
                .unwrap();
            assert_eq!(actual, expected);
        }
    }
}


================================================
FILE: src/sign.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! The implementation for the `sign` command. This command focuses on signing
//! installers using the Windows SDK `signtool` application.

use crate::BINARY_FOLDER_NAME;
use crate::EXE_FILE_EXTENSION;
use crate::Error;
use crate::MSI_FILE_EXTENSION;
use crate::Result;
use crate::SIGNTOOL;
use crate::SIGNTOOL_PATH_KEY;
use crate::TimestampServer;
use crate::WIX;

use log::{debug, info, trace};

use std::env;
use std::ffi::OsStr;
use std::fs;
use std::io::ErrorKind;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::str::FromStr;

use cargo_metadata::Package;

/// A builder for creating an execution context to sign an installer.
#[derive(Debug, Clone)]
pub struct Builder<'a> {
    bin_path: Option<&'a str>,
    capture_output: bool,
    description: Option<&'a str>,
    homepage: Option<&'a str>,
    input: Option<&'a str>,
    installer: Option<&'a str>,
    package: Option<&'a str>,
    product_name: Option<&'a str>,
    timestamp: Option<&'a str>,
}

impl<'a> Builder<'a> {
    /// Creates a new `Builder` instance.
    pub fn new() -> Self {
        Builder {
            bin_path: None,
            capture_output: true,
            description: None,
            homepage: None,
            input: None,
            installer: None,
            package: None,
            product_name: None,
            timestamp: None,
        }
    }

    /// Sets the package on which to operate during this build
    pub fn package(&mut self, p: Option<&'a str>) -> &mut Self {
        self.package = p;
        self
    }
    /// Sets the path to the folder containing the `signtool.exe` file.
    ///
    // Normally the `signtool.exe` is installed in the `bin` folder of the
    // Windows SDK installation. The default is to use the `PATH` system
    // environment variable.
    pub fn bin_path(&mut self, b: Option<&'a str>) -> &mut Self {
        self.bin_path = b;
        self
    }

    /// Enables or disables capturing of the output from the `signtool`
    /// application.
    ///
    /// The default is to capture all output, i.e. display nothing in the
    /// console but the log statements.
    pub fn capture_output(&mut self, c: bool) -> &mut Self {
        self.capture_output = c;
        self
    }

    /// Sets the description.
    ///
    /// This override the description obtained from the `description` field in
    /// the package's manifest (Cargo.toml).
    ///
    /// The description is displayed in the ACL dialog.
    pub fn description(&mut self, d: Option<&'a str>) -> &mut Self {
        self.description = d;
        self
    }

    /// Sets the homepage URL that is displayed in the ACL dialog.
    ///
    /// The default is to use the value for the `homepage` field in the
    /// package's manifest (Cargo.toml) if it exists; otherwise, a URL
    /// is _not_ displayed in the ACL dialog.
    pub fn homepage(&mut self, h: Option<&'a str>) -> &mut Self {
        self.homepage = h;
        self
    }

    /// Sets the path to a package's manifest (Cargo.toml).
    pub fn input(&mut self, i: Option<&'a str>) -> &mut Self {
        self.input = i;
        self
    }

    /// Override default installer path.
    pub fn installer(&mut self, i: Option<&'a str>) -> &mut Self {
        self.installer = i;
        self
    }

    /// Sets the product name.
    ///
    /// The default is to use the value for the `name` field in the package's
    /// manifest (Cargo.toml).
    pub fn product_name(&mut self, p: Option<&'a str>) -> &mut Self {
        self.product_name = p;
        self
    }

    /// Sets the URL for the timestamp server used when signing an installer.
    ///
    /// The default is to _not_ use a timestamp server, even though it is highly
    /// recommended. Use this method to enable signing with the timestamp.
    pub fn timestamp(&mut self, t: Option<&'a str>) -> &mut Self {
        self.timestamp = t;
        self
    }

    /// Creates an execution context for signing a package's installer.
    pub fn build(&mut self) -> Execution {
        Execution {
            bin_path: self.bin_path.map(PathBuf::from),
            capture_output: self.capture_output,
            description: self.description.map(String::from),
            homepage: self.homepage.map(String::from),
            input: self.input.map(PathBuf::from),
            installer: self.installer.map(PathBuf::from),
            package: self.package.map(String::from),
            product_name: self.product_name.map(String::from),
            timestamp: self.timestamp.map(String::from),
        }
    }
}

impl Default for Builder<'_> {
    fn default() -> Self {
        Builder::new()
    }
}

/// A context for signing a package's installer.
#[derive(Debug)]
pub struct Execution {
    bin_path: Option<PathBuf>,
    capture_output: bool,
    description: Option<String>,
    homepage: Option<String>,
    input: Option<PathBuf>,
    installer: Option<PathBuf>,
    package: Option<String>,
    product_name: Option<String>,
    timestamp: Option<String>,
}

impl Execution {
    /// Signs a package's installer.
    pub fn run(self) -> Result<()> {
        info!("Signing the installer");
        debug!("bin_path = {:?}", self.bin_path);
        debug!("capture_output = {:?}", self.capture_output);
        debug!("description = {:?}", self.description);
        debug!("homepage = {:?}", self.homepage);
        debug!("input = {:?}", self.input);
        debug!("installer = {:?}", self.installer);
        debug!("package = {:?}", self.package);
        debug!("product_name = {:?}", self.product_name);
        debug!("timestamp = {:?}", self.timestamp);
        let manifest = super::manifest(self.input.as_ref())?;
        debug!("target_directory = {:?}", manifest.target_directory);
        let package = super::package(&manifest, self.package.as_deref())?;
        let product_name = super::product_name(self.product_name.as_ref(), &package);
        let description = if let Some(d) = super::description(self.description.clone(), &package) {
            trace!(
                "A description was provided either at the command line or in the package's manifest (Cargo.toml)."
            );
            format!("{product_name} - {d}")
        } else {
            trace!(
                "A description was not provided at the command line or in the package's manifest (Cargo.toml)."
            );
            product_name
        };
        debug!("description = {:?}", description);
        let msi = self.msi(manifest.target_directory.as_std_path())?;
        let mut signer = self.signer()?;
        debug!("signer = {:?}", signer);
        if self.capture_output {
            trace!("Capturing the {} output", SIGNTOOL);
            signer.stdout(Stdio::null());
            signer.stderr(Stdio::null());
        }
        signer
            .arg("sign")
            .arg("/a")
            .arg("/fd")
            .arg("certHash")
            .arg("/d")
            .arg(description);
        if let Some(h) = self.homepage(&package) {
            trace!("Using the '{}' URL for the expanded description", h);
            signer.arg("/du").arg(h);
        }
        if let Some(t) = self.timestamp {
            let server = TimestampServer::from_str(&t)?;
            trace!(
                "Using the '{}' timestamp server to sign the installer",
                server
            );
            signer.arg("/t");
            signer.arg(server.url());
        }
        let status = signer.arg(&msi).status().map_err(|err| {
            if err.kind() == ErrorKind::NotFound {
                Error::Generic(format!(
                    "The {SIGNTOOL} application could not be found. Please check the Windows 10 SDK \
                     (https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk) is \
                     installed and you are using the x64 or x86 Native Build Tools prompt so the \
                     {SIGNTOOL} application is available."
                ))
            } else {
                err.into()
            }
        })?;
        if !status.success() {
            return Err(Error::Command(
                SIGNTOOL,
                status.code().unwrap_or(100),
                self.capture_output,
            ));
        }
        Ok(())
    }

    fn homepage(&self, manifest: &Package) -> Option<String> {
        self.homepage
            .as_ref()
            .map(String::from)
            .or_else(|| manifest.homepage.clone())
    }

    fn msi(&self, target_directory: &Path) -> Result<PathBuf> {
        if let Some(ref i) = self.installer {
            trace!("The path to an installer to sign has been explicitly set");
            let msi = PathBuf::from(i);
            if msi.exists() {
                trace!("The installer exists");
                Ok(msi)
            } else {
                Err(Error::Generic(format!(
                    "The '{}' path does not exist for the installer",
                    msi.display()
                )))
            }
        } else {
            trace!("The path to an installer has not been explicitly set");
            let cwd = target_directory.join(WIX);
            for entry in fs::read_dir(cwd)? {
                let entry = entry?;
                let path = entry.path();
                if path.extension() == Some(OsStr::new(MSI_FILE_EXTENSION)) {
                    return Ok(path);
                }
            }
            Err(Error::Generic(format!(
                "Could not find an installer ({MSI_FILE_EXTENSION}) to sign"
            )))
        }
    }

    fn signer(&self) -> Result<Command> {
        if let Some(mut path) = self.bin_path.as_ref().map(|s| {
            let mut p = PathBuf::from(s);
            trace!(
                "Using the '{}' path to the Windows SDK '{}' folder for the signer",
                p.display(),
                BINARY_FOLDER_NAME
            );
            p.push(SIGNTOOL);
            p.set_extension(EXE_FILE_EXTENSION);
            p
        }) {
            if !path.exists() {
                path.pop(); // Remove the 'signtool' application from the path
                Err(Error::Generic(format!(
                    "The signer application ('{}') does not exist at the '{}' path specified via \
                    the '-S, --sign-path' command line argument. Please check the path is correct and \
                    the signer application exists at the path.",
                    SIGNTOOL,
                    path.display()
                )))
            } else {
                Ok(Command::new(path))
            }
        } else if let Some(mut path) = env::var_os(SIGNTOOL_PATH_KEY).map(|s| {
            let mut p = PathBuf::from(s);
            trace!(
                "Using the '{}' path to the Windows SDK '{}' folder for the signer",
                p.display(),
                BINARY_FOLDER_NAME
            );
            p.push(SIGNTOOL);
            p.set_extension(EXE_FILE_EXTENSION);
            p
        }) {
            if !path.exists() {
                path.pop(); // Remove the `signtool` application from the path
                Err(Error::Generic(format!(
                    "The signer application ('{}') does not exist at the '{}' path specified \
                     via the {} environment variable. Please check the path is correct and the \
                     signer application exists at the path.",
                    SIGNTOOL,
                    path.display(),
                    SIGNTOOL_PATH_KEY
                )))
            } else {
                Ok(Command::new(path))
            }
        } else {
            Ok(Command::new(SIGNTOOL))
        }
    }
}

impl Default for Execution {
    fn default() -> Self {
        Builder::new().build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    mod builder {
        use super::*;

        #[test]
        fn bin_path_works() {
            const EXPECTED: &str = "C:\\signtool.exe";
            let mut actual = Builder::new();
            actual.bin_path(Some(EXPECTED));
            assert_eq!(actual.bin_path, Some(EXPECTED));
        }

        #[test]
        fn capture_output_works() {
            let mut actual = Builder::new();
            actual.capture_output(false);
            assert!(!actual.capture_output);
        }

        #[test]
        fn description_works() {
            const EXPECTED: &str = "This is a description";
            let mut actual = Builder::new();
            actual.description(Some(EXPECTED));
            assert_eq!(actual.description, Some(EXPECTED));
        }

        #[test]
        fn homepage_works() {
            const EXPECTED: &str = "http://www.example.com";
            let mut actual = Builder::new();
            actual.homepage(Some(EXPECTED));
            assert_eq!(actual.homepage, Some(EXPECTED));
        }

        #[test]
        fn input_works() {
            const EXPECTED: &str = "C:\\Example";
            let mut actual = Builder::new();
            actual.input(Some(EXPECTED));
            assert_eq!(actual.input, Some(EXPECTED));
        }

        #[test]
        fn product_name_works() {
            const EXPECTED: &str = "Example";
            let mut actual = Builder::new();
            actual.product_name(Some(EXPECTED));
            assert_eq!(actual.product_name, Some(EXPECTED));
        }

        #[test]
        fn timestamp_works() {
            const EXPECTED: &str = "http://www.example.com";
            let mut actual = Builder::new();
            actual.timestamp(Some(EXPECTED));
            assert_eq!(actual.timestamp, Some(EXPECTED));
        }
    }

    mod execution {
        extern crate assert_fs;

        use std::fs::File;

        use super::*;
        use crate::tests::setup_project;

        const MIN_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
        "#;

        const HOMEPAGE_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
            homepage = "http://www.example.com"
        "#;

        #[test]
        fn homepage_without_homepage_field_works() {
            let project = setup_project(MIN_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::default().homepage(&package);
            assert!(actual.is_none());
        }

        #[test]
        fn homepage_with_homepage_field_works() {
            let project = setup_project(HOMEPAGE_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Execution::default().homepage(&package);
            assert_eq!(actual, Some(String::from("http://www.example.com")));
        }

        #[test]
        fn homepage_with_override_works() {
            const EXPECTED: &str = "http://www.another.com";

            let project = setup_project(HOMEPAGE_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();

            let actual = Builder::new()
                .homepage(Some(EXPECTED))
                .build()
                .homepage(&package);
            assert_eq!(actual, Some(String::from(EXPECTED)));
        }

        #[test]
        fn msi_with_nonexistent_installer_fails() {
            let result = Execution::default().msi(Path::new("target"));
            assert!(result.is_err());
        }

        #[test]
        fn msi_with_existing_file_works() {
            let temp_dir = assert_fs::TempDir::new().unwrap();
            let msi_path = temp_dir.path().join("Example.msi");
            let _msi_handle = File::create(&msi_path).expect("Create file");
            let actual = Builder::new()
                .installer(msi_path.to_str())
                .build()
                .msi(Path::new("target"))
                .unwrap();
            assert_eq!(actual, msi_path);
        }

        #[test]
        #[cfg(windows)]
        fn signer_works() {
            let result = Execution::default().signer();
            assert!(result.is_ok());
        }

        #[test]
        fn signer_with_nonexisting_path_fails() {
            let result = Builder::new()
                .bin_path(Some("Example.exe"))
                .build()
                .signer();
            assert!(result.is_err());
        }

        #[test]
        fn signer_with_nonexistent_environment_path_fails() {
            unsafe {
                env::set_var(SIGNTOOL_PATH_KEY, "Example");
            }
            let result = Execution::default().signer();
            unsafe {
                env::remove_var(SIGNTOOL_PATH_KEY);
            }
            assert!(result.is_err());
        }
    }
}


================================================
FILE: src/stored_path.rs
================================================
//! Utilities for working with paths that need to be stored in files in a cross-platform way.
//!
//! Big picture: work with paths however you want, as long as any path that gets written to
//! a file (e.g. via a template) always gets converted into a [`StoredPathBuf`][] first,
//! forcing all the platform-specific differences to get normalized out.
//!
//! Although both std and camino have excellent support for working with paths, they're both
//! designed to have host-platform-specific behaviour (which is good/correct) that makes them
//! unsuitable for working with paths that need to stored in persistent cross-platform
//! ways -- like writing them to files. The wxs files we generate contain paths to other files,
//! and we want to reliably produce the same wxs file on all machines, so we need something else!
//!
//! Most notably, std and camino handle path separators differently on different platforms:
//!
//! * valid separtors:
//!   * on windows, `\` and `/` are both valid path separators
//!   * on unix, only `/` is a valid separator, and `\` can appear in file names
//! * auto separators:
//!   * on windows, using APIs like `join` will use a `\` separator
//!   * on unix, using APIs like `join` will use a `/` separator
//!
//! Since cargo-wix is fundamentally concerned with producing things that work on windows, we
//! can comfortably force unix to be "like windows" to normalize the behaviour. This normalization
//! is handled by the [`StoredPath`][] and [`StoredPathBuf`][] types.
//!
//! These types have two flavours of entry-point:
//!
//! * When making a StoredPathBuf from a String, the input is assumed to be user-provided and is forwarded
//!   verbatim without any normalization. Windows is permissive of both kinds of path separator,
//!   so we never need to "fix" things up.
//!
//! * When making a StoredPathBuf from a Path or Utf8Path, the input is assumed to be tainted with
//!   platform-specific behaviour, and all path separators are normalized to `\`. The net effect is
//!   that on windows StoredPathBuf usually doesn't do anything, but on unix it forces
//!   many `/`'s to `\`'s. See [`StoredPathBuf::from_utf8_path`][] for the implementation.
//!
//! A StoredPath is not intended for doing actual i/o, and as such does not expose a way
//! for it to be turned back into a "real" path, and does not expose APIs like `exists`.
//! However it is useful/necessary to be able to ask questions like "is this file an RTF",
//! so we do need to implement basic path parsing functions like `file_name` and `extension`.
//!
//! Notably [`StoredPath::file_name`][]` considers both `\` and `/` to be path separators.
//! Ideally it should behave identically to std/camino on windows, making all platforms
//! behave like windows.

use std::{fmt, path::Path};

use camino::{Utf8Component, Utf8Path};

/// A PathBuf that will be in the output of print (and therefore saved to disk)
///
/// A proper PathBuf should not be used for that, as we don't want to introduce
/// platform-specific separators.
///
/// This type intentionally lacks some path functionality like `.exists()` because
/// we don't want to be using it for *actual* path stuff, only for writing it to output.
/// Most StoredPathBufs are just user-provided strings with no processing applied.
///
/// However sometimes we are forced to handle a PathBuf because of things like
/// cargo-metadata, in which case [`StoredPathBuf::from_utf8_path`][] or
/// [`StoredPathBuf::from_std_path`][] will convert the path to the windows path style.
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct StoredPathBuf(String);

/// A borrowed [`StoredPathBuf`][]
#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct StoredPath(str);

impl StoredPathBuf {
    /// Make a new StoredPathBuf from a String
    pub fn new(v: String) -> Self {
        Self(v)
    }

    /// Make a new StoredPath from a OS-specific path
    ///
    /// This breaks the path into its components and rewrites the slashes to `\`.
    ///
    /// Generally you should avoid this and just try to preserve the user input,
    /// but it's required when using things like the output of cargo-metadata.
    pub fn from_std_path(path: &Path) -> Option<Self> {
        Utf8Path::from_path(path).map(Self::from_utf8_path)
    }

    /// Make a new StoredPath from a OS-specific Utf8Path
    ///
    /// This breaks the path into its components and rewrites the slashes to `\`.
    ///
    /// Generally you should avoid this and just try to preserve the user input,
    /// but it's required when using things like the output of cargo-metadata.
    ///
    /// Also note that this does some handling of absolute paths, but that those
    /// are kind of nonsensical to store longterm. Still, the user can hand them
    /// to us, and we have to do our best to deal with it. Mostly this just comes
    /// up in test code.
    pub fn from_utf8_path(path: &Utf8Path) -> Self {
        // The main quirk of this code is handling absolute paths.
        // `C:\a\b\c` is given to us as `["C:", "\", "a", "b", "c"]`
        let mut result = String::new();
        let mut multipart = false;
        for component in path.components() {
            // Add separator for every part but the first,
            // ignoring root prefixes like "C:\" and "/" which
            // provide their own separators.
            if multipart {
                result.push('\\');
            }
            let part = match component {
                // "C:"
                Utf8Component::Prefix(prefix) => prefix.as_str(),
                // the root slash
                // (either the one at the end of "C:\" or the one at the start of "/a/b/c")
                Utf8Component::RootDir => "\\",
                other => {
                    // Ok we're passed the weird root stuff, now should add separators
                    multipart = true;
                    other.as_str()
                }
            };
            result.push_str(part);
        }
        Self(result)
    }
}

impl StoredPath {
    /// Make a new StoredPath from a str
    pub fn new(v: &str) -> &Self {
        // SAFETY: this is the idiomatic pattern for converting between newtyped slices.
        // See the impl of std::str::from_utf8_unchecked for an example.
        unsafe { std::mem::transmute(v) }
    }

    /// Get the inner string
    pub fn as_str(&self) -> &str {
        self
    }

    /// Extracts the extension part of the `self.file_name`
    pub fn extension(&self) -> Option<&str> {
        self.stem_and_extension().1
    }

    /// Extracts the stem (non-extension) part of the `self.file_name`.
    pub fn file_stem(&self) -> Option<&str> {
        self.stem_and_extension().0
    }

    // Implements `stem` and `extension` together based on the semantics defined by camino/std
    fn stem_and_extension(&self) -> (Option<&str>, Option<&str>) {
        let Some(name) = self.file_name() else {
            // both: None if there's no file name
            return (None, None);
        };
        if let Some((stem, extension)) = name.rsplit_once('.') {
            if stem.is_empty() {
                // stem: The entire file name if the file name begins with '.' and has no other '.'s within
                // extension: None, if the file name begins with '.' and has no other '.'s within;
                (Some(name), None)
            } else {
                // stem: Otherwise, the portion of the file name before the final '.'
                // extension: Otherwise, the portion of the file name after the final '.'
                (Some(stem), Some(extension))
            }
        } else {
            // stem: The entire file name if there is no embedded '.'
            // extension: None, if there is no embedded '.'
            (Some(name), None)
        }
    }

    /// Returns the final component of the path, if there is one.
    pub fn file_name(&self) -> Option<&str> {
        let mut path = self.as_str();

        // First repeatedly pop trailing slashes off to get to the actual path
        // Also pop trailing /. as this is a no-op.
        // trailing .. is however treated as opaque!
        while let Some(prefix) = path
            .strip_suffix('\\')
            .or_else(|| path.strip_suffix('/'))
            .or_else(|| path.strip_suffix("/."))
            .or_else(|| path.strip_suffix("\\."))
        {
            path = prefix;
        }

        // Look for either path separator (windows file names shouldn't include either,
        // so even though unix file names can have `\`, it won't work right on the actual
        // platform that matters, so we can ignore that consideration.)
        let name1 = path.rsplit_once('\\').map(|(_, name)| name);
        let name2 = path.rsplit_once('/').map(|(_, name)| name);

        // Decide which parse to use
        let name = match (name1, name2) {
            // trivial case, only one gave an answer
            (Some(name), None) | (None, Some(name)) => name,
            // Both matched, use whichever one came last (shortest file name)
            (Some(name1), Some(name2)) => {
                if name1.len() < name2.len() {
                    name1
                } else {
                    name2
                }
            }
            // No slashes left, the entire path is just the filename
            (None, None) => path,
        };

        // Several special "names" are in fact not names at all:
        if name.is_empty() || name == "." || name == ".." {
            None
        } else {
            Some(name)
        }
    }
}

impl std::ops::Deref for StoredPathBuf {
    type Target = StoredPath;
    fn deref(&self) -> &Self::Target {
        StoredPath::new(&self.0)
    }
}
impl std::ops::Deref for StoredPath {
    type Target = str;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}
impl std::borrow::Borrow<StoredPath> for StoredPathBuf {
    fn borrow(&self) -> &StoredPath {
        self
    }
}
impl std::borrow::ToOwned for StoredPath {
    type Owned = StoredPathBuf;

    fn to_owned(&self) -> StoredPathBuf {
        StoredPathBuf::new(self.0.to_owned())
    }
}
impl std::convert::From<String> for StoredPathBuf {
    fn from(v: String) -> Self {
        Self::new(v)
    }
}
impl std::convert::From<StoredPathBuf> for String {
    fn from(v: StoredPathBuf) -> Self {
        v.0
    }
}
impl<'a> std::convert::From<&'a StoredPathBuf> for String {
    fn from(v: &'a StoredPathBuf) -> Self {
        v.0.clone()
    }
}
impl<'a> std::convert::From<&'a str> for StoredPathBuf {
    fn from(v: &'a str) -> Self {
        StoredPath::new(v).to_owned()
    }
}
impl std::fmt::Debug for StoredPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        std::fmt::Debug::fmt(self.as_str(), f)
    }
}
impl std::fmt::Display for StoredPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        std::fmt::Display::fmt(self.as_str(), f)
    }
}
impl std::fmt::Debug for StoredPathBuf {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        std::fmt::Debug::fmt(self.as_str(), f)
    }
}
impl std::fmt::Display for StoredPathBuf {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        std::fmt::Display::fmt(self.as_str(), f)
    }
}

#[cfg(test)]
mod test {
    use super::StoredPathBuf;
    use camino::Utf8Path;

    #[test]
    fn absolute_windows_path_conversion() {
        // Absolute native windows format
        const INPUT: &str = "C:\\Users\\test\\AppData\\Local\\Temp\\.tmpMh0Mxg\\Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), INPUT);
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn verbatim_absolute_windows_path_conversion() {
        // Absolute native windows format (verbatim style)
        const INPUT: &str =
            "\\\\?\\C:\\Users\\test\\AppData\\Local\\Temp\\.tmpMh0Mxg\\Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), INPUT);
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn relative_windows_path_conversion() {
        // relative native windows format
        const INPUT: &str = "resource\\Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), INPUT);
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn absolute_unix_path_conversion() {
        // absolute native unix format
        const INPUT: &str = "/users/home/test/Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), "\\users\\home\\test\\Example.tar.gz");
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn relative_unix_path_conversion() {
        // relative native unix format
        const INPUT: &str = "resource/Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), "resource\\Example.tar.gz");
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn mixed_path_conversion1() {
        // a mix of both formats (natural when combining user input with OS input)
        const INPUT: &str = "resource/blah\\Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), "resource\\blah\\Example.tar.gz");
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn mixed_path_conversion2() {
        // a mix of both formats (natural when combining user input with OS input)
        const INPUT: &str = "resource\\blah/Example.tar.gz";
        let path = StoredPathBuf::from_utf8_path(Utf8Path::new(INPUT));
        assert_eq!(path.as_str(), "resource\\blah\\Example.tar.gz");
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn mixed_path_unconverted1() {
        // a mix of both formats (natural when combining user input with OS input)
        // here we're testing the verbatim `new` conversion produces a coherent value
        const INPUT: &str = "resource\\blah/Example.tar.gz";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "resource\\blah/Example.tar.gz");
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn mixed_path_unconverted2() {
        // a mix of both formats (natural when combining user input with OS input)
        // here we're testing the verbatim `new` conversion produces a coherent value
        const INPUT: &str = "resource/blah\\Example.tar.gz";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "resource/blah\\Example.tar.gz");
        assert_eq!(path.file_name(), Some("Example.tar.gz"));
        assert_eq!(path.file_stem(), Some("Example.tar"));
        assert_eq!(path.extension(), Some("gz"));
    }

    #[test]
    fn empty_path() {
        // a mix of both formats (natural when combining user input with OS input)
        // here we're testing the verbatim `new` conversion produces a coherent value
        const INPUT: &str = "";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "");
        assert_eq!(path.file_name(), None);
        assert_eq!(path.file_stem(), None);
        assert_eq!(path.extension(), None);
    }

    #[test]
    fn just_file() {
        // a mix of both formats (natural when combining user input with OS input)
        // here we're testing the verbatim `new` conversion produces a coherent value
        const INPUT: &str = "abc.txt";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_1() {
        // make sure we trim a trailing slash
        const INPUT: &str = "abc.txt/";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt/");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_2() {
        // make sure we trim a trailing slash
        const INPUT: &str = "abc.txt\\";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt\\");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_3() {
        // make sure we trim a trailing slash
        const INPUT: &str = "abc.txt\\\\\\";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt\\\\\\");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_4() {
        // make sure we trim a trailing slash
        const INPUT: &str = "abc.txt/////";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt/////");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_5() {
        // make sure we trim a trailing slash
        const INPUT: &str = "abc.txt/\\//\\//";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt/\\//\\//");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_6() {
        /// make sure we trim a trailing slash dot
        const INPUT: &str = "abc.txt/.";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt/.");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_7() {
        // make sure we trim a trailing slash dot
        const INPUT: &str = "abc.txt\\.";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt\\.");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn trail_slash_8() {
        // make sure we trim all kinds of trailing slash dot soup
        const INPUT: &str = "abc.txt/./.\\\\//\\././";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "abc.txt/./.\\\\//\\././");
        assert_eq!(path.file_name(), Some("abc.txt"));
        assert_eq!(path.file_stem(), Some("abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn just_dot() {
        // dot is not a file name, it's a relative-path directive
        const INPUT: &str = ".";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), ".");
        assert_eq!(path.file_name(), None);
        assert_eq!(path.file_stem(), None);
        assert_eq!(path.extension(), None);
    }

    #[test]
    fn just_dotfile() {
        // dotfiles are valid names, and they have no extensions
        const INPUT: &str = ".abc";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), ".abc");
        assert_eq!(path.file_name(), Some(".abc"));
        assert_eq!(path.file_stem(), Some(".abc"));
        assert_eq!(path.extension(), None);
    }

    #[test]
    fn just_dotfile_txt() {
        // dotfiles with extensions work
        const INPUT: &str = ".abc.txt";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), ".abc.txt");
        assert_eq!(path.file_name(), Some(".abc.txt"));
        assert_eq!(path.file_stem(), Some(".abc"));
        assert_eq!(path.extension(), Some("txt"));
    }

    #[test]
    fn just_dotdot() {
        // dot dot is not a file name, it's a relative-path directive
        const INPUT: &str = "..";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "..");
        assert_eq!(path.file_name(), None);
        assert_eq!(path.file_stem(), None);
        assert_eq!(path.extension(), None);
    }

    #[test]
    fn opaque_dotdot1() {
        // trailing dot dot is opaque and makes us have no filename
        const INPUT: &str = "a/b/..";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "a/b/..");
        assert_eq!(path.file_name(), None);
        assert_eq!(path.file_stem(), None);
        assert_eq!(path.extension(), None);
    }

    #[test]
    fn opaque_dotdot2() {
        // trailing dot dot is opaque and makes us have no filename
        const INPUT: &str = "a/b/../";
        let path = StoredPathBuf::new(INPUT.to_owned());
        assert_eq!(path.as_str(), "a/b/../");
        assert_eq!(path.file_name(), None);
        assert_eq!(path.file_stem(), None);
        assert_eq!(path.extension(), None);
    }
}


================================================
FILE: src/templates/Apache-2.0.rtf.mustache
================================================
{{!
Copyright (C) 2017 Christopher R. Field.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
}}
{{=<% %>=}}
{\rtf1\ansi\ansicpg1252\deff0\nouicompat{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil\fcharset0 Courier New;}}
{\colortbl ;\red0\green0\blue255;}
{\*\generator Riched20 10.0.15063}\viewkind4\uc1 
\pard\sa180\qc\fs24\lang9 Apache License\line Version 2.0, January 2004\line {{\field{\*\fldinst{HYPERLINK http://www.apache.org/licenses/ }}{\fldrslt{http://www.apache.org/licenses/\ul0\cf0}}}}\f0\fs24\par
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\par

\pard\fi-360\li360\sa180\tx360 1. Definitions.\par

\pard\sa180 "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.\par
"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License.\par
"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.\par
"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License.\par
"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files.\par
"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types.\par
"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below).\par
"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof.\par
"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution."\par
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work.\par

\pard\fi-360\li360\sa180\tx360 2. Grant of Copyright License.\par

\pard\sa180\tx360 Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form.\par

\pard\fi-360\li360\sa180\tx360 3. Grant of Patent License.\par

\pard\sa180\tx360 Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed.\par

\pard\fi-360\li360\sa180\tx360 4. Redistribution. \par

\pard\sa180\tx360 You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions:\par

\pard 
{\pntext\f0 a.\tab}{\*\pn\pnlvlbody\pnf0\pnindent0\pnstart1\pnlcltr{\pntxta.}}
\fi-360\li720\sa180\tx360 You must give any other recipients of the Work or Derivative Works a copy of this License; and\par
{\pntext\f0 b.\tab}You must cause any modified files to carry prominent notices stating that You changed the files; and\par
{\pntext\f0 c.\tab}You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and \par
{\pntext\f0 d.\tab}If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License.\par

\pard\sa180 You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License.\par

\pard\fi-360\li360\sa180\tx360 5.\tab Submission of Contributions. \par

\pard\sa180\tx360 Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions.\par

\pard\fi-360\li360\sa180\tx360 6.\tab Trademarks. \par

\pard\sa180\tx360 This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file.\par

\pard\fi-360\li360\sa180\tx360 7.\tab Disclaimer of Warranty. \par

\pard\sa180\tx360 Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License.\par

\pard\fi-360\li360\sa180\tx360 8.\tab Limitation of Liability.\par

\pard\sa180\tx360 In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages.\par

\pard\fi-360\li360\sa180\tx360 9.\tab Accepting Warranty or Additional Liability. \par

\pard\sa180\tx360 While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability.\par

\pard\sa180\qc END OF TERMS AND CONDITIONS\par
How to apply the Apache License to your work.\par

\pard\sa180 To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives.\par
\f1 Copyright (C) [YYYY] [Copyright Holder]\par
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at\par
{{\field{\*\fldinst{HYPERLINK http://www.apache.org/licenses/LICENSE-2.0 }}{\fldrslt{http://www.apache.org/licenses/LICENSE-2.0\ul0\cf0}}}}\f1\fs24\par
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" basis, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.\par
}



================================================
FILE: src/templates/GPL-3.0.rtf.mustache
================================================
{{!
Copyright (C) 2017 Christopher R. Field.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
}}
{{=<% %>=}}
{\rtf1\ansi\deff0\nouicompat{\fonttbl{\f0\fnil\fcharset0 Arial;}{\f1\fnil\fcharset0 Courier New;}}
{\colortbl ;\red0\green0\blue255;}
{\*\generator Riched20 10.0.15063}\viewkind4\uc1 
\pard\sa180\qc\fs24\lang9 GNU GENERAL PUBLIC LICENSE\line Version 3, 29 June 2007\par

\pard\sa180 Copyright (C) 2007 Free Software Foundation, Inc. {{\field{\*\fldinst{HYPERLINK http://fsf.org/ }}{\fldrslt{http://fsf.org/\ul0\cf0}}}}\f0\fs24  Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.\par

\pard\sa180\qc Preamble\par

\pard\sa180 The GNU General Public License is a free, copyleft license for software and other kinds of works.\par
The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too.\par
When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things.\par
To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others.\par
For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights.\par
Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it.\par
For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions.\par
Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users.\par
Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free.\par
The precise terms and conditions for copying, distribution and modification follow.\par

\pard\sa180\qc TERMS AND CONDITIONS\par

\pard\fi-360\li360\sa180\tx360 0.\tab Definitions.\par

\pard\sa180 "This License" refers to version 3 of the GNU General Public License.\par
"Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks.\par
"The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations.\par
To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work.\par
A "covered work" means either the unmodified Program or a work based on the Program.\par
To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well.\par
To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying.\par
An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion.\par

\pard\fi-360\li360\sa180\tx360 1.\tab Source Code.\par

\pard\sa180 The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work.\par
A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language.\par
The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it.\par
The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work.\par
The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source.\par
The Corresponding Source for a work in source code form is that same work.\par

\pard\fi-360\li360\sa180\tx360 2.\tab Basic Permissions.\par

\pard\sa180 All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law.\par
You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you.\par
Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary.\par

\pard\fi-360\li360\sa180\tx360 3.\tab Protecting Users' Legal Rights From Anti-Circumvention Law.\par

\pard\sa180 No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures.\par
When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures.\par

\pard\fi-360\li360\sa180\tx360 4.\tab Conveying Verbatim Copies.\par

\pard\sa180 You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program.\par
You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee.\par

\pard\fi-360\li360\sa180\tx360 5.\tab Conveying Modified Source Versions.\par

\pard\sa180 You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions:\par

\pard 
{\pntext\f0 a.\tab}{\*\pn\pnlvlbody\pnf0\pnindent0\pnstart1\pnlcltr{\pntxta.}}
\fi-360\li720\sa180 The work must carry prominent notices stating that you modified\lang1033  \lang9 it, and giving a relevant date.\par
{\pntext\f0 b.\tab}The work must carry prominent notices stating that it is released under this License and any conditions added under section\lang1033  \lang9 7.\lang1033  \lang9 This requirement modifies the requirement in section 4 to\lang1033  \lang9 "keep intact all notices".\par
{\pntext\f0 c.\tab}You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy.  This License will therefore apply, along with any applicable section 7\lang1033  \lang9 additional terms, to the whole of the work, and all its parts,\lang1033  \lang9 regardless of how they are packaged.  This License gives no\lang1033  \lang9 permission to license the work in any other way, but it does not\lang1033  \lang9 invalidate such permission if you have separately received it. \par
{\pntext\f0 d.\tab}If the work has interactive user interfaces, each must display\lang1033  \lang9 Appropriate Legal Notices; however, if the Program has interactive\lang1033  \lang9 interfaces that do not display Appropriate Legal Notices, your\lang1033  \lang9 work need not make them do so.\par

\pard\sa180 A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.\par

\pard\fi-360\li360\sa180\tx360 6.\tab Conveying Non-Source Forms.\par

\pard\sa180 You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways:\par

\pard 
{\pntext\f0 a.\tab}{\*\pn\pnlvlbody\pnf0\pnindent0\pnstart1\pnlcltr{\pntxta.}}
\fi-360\li720\sa180 Convey the object code in, or embodied in, a physical product\line (including a physical distribution medium), accompanied by the\line Corresponding Source fixed on a durable physical medium\line customarily used for software interchange.\par
{\pntext\f0 b.\tab}Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no\line more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge.\par
{\pntext\f0 c.\tab}Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source.  This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b.\par
{\pntext\f0 d.\tab}Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge.  You need not require recipients to copy the Corresponding Source along with the object code.  If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source.  Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements.\par
{\pntext\f0 e.\tab}Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d.\par

\pard\sa180 A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work.\par
A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product.\par
"Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made.\par
If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM).\par
The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network.\par
Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying.\par

\pard\fi-360\li360\sa180\tx360 7.\tab Additional Terms.\par

\pard\sa180 "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions.\par
When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission.\par
Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms:\par

\pard 
{\pntext\f0 a.\tab}{\*\pn\pnlvlbody\pnf0\pnindent0\pnstart1\pnlcltr{\pntxta.}}
\fi-360\li720\sa180 Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or\par
{\pntext\f0 b.\tab}Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or\par
{\pntext\f0 c.\tab}Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or\par
{\pntext\f0 d.\tab}Limiting the use for publicity purposes of names of licensors or authors of the material; or\par
{\pntext\f0 e.\tab}Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or\par
{\pntext\f0 f.\tab}Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors.\par

\pard\sa180 All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying.\par
If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms.\par
Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way.\par

\pard\fi-360\li360\sa180\tx360 8.\tab Termination.\par

\pard\sa180 You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11).\par
However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation.\par
Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice.\par
Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10.\par

\pard\fi-360\li360\sa180\tx360 9.\tab Acceptance Not Required for Having Copies.\par

\pard\sa180 You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so.\par

\pard\fi-360\li360\sa180\tx360 10.\tab Automatic Licensing of Downstream Recipients.\par

\pard\sa180 Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License.\par
An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts.\par
You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it.\par

\pard\fi-360\li360\sa180\tx360 11.\tab Patents.\par

\pard\sa180 A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version".\par
A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License.\par
Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version.\par
In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party.\par
If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid.\par
If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it.\par
A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007.\par
Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law.\par

\pard\fi-360\li360\sa180\tx360 12.\tab No Surrender of Others' Freedom.\par

\pard\sa180 If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program.\par

\pard\fi-360\li360\sa180\tx360 13.\tab Use with the GNU Affero General Public License.\par

\pard\sa180 Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such.\par

\pard\fi-360\li360\sa180\tx360 14.\tab Revised Versions of this License.\par

\pard\sa180 The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns.\par
Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation.\par
If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program.\par
Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version.\par

\pard\fi-360\li360\sa180\tx360 15.\tab Disclaimer of Warranty.\par

\pard\sa180 THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.\par

\pard\fi-360\li360\sa180\tx360 16.\tab Limitation of Liability.\par

\pard\sa180 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\par

\pard\fi-360\li360\sa180\tx360 17.\tab Interpretation of Sections 15 and 16.\par

\pard\sa180 If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee.\par

\pard\sa180\qc END OF TERMS AND CONDITIONS\par
\line How to Apply These Terms to Your New Programs\par

\pard\sa180 If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms.\par
To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found.\par
\f1 <one line to give the program's name and a brief idea of what it does.>\line Copyright (C) [copyright-year] [copyright-holder]\par
\line This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.\line\line This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.\line\line You should have received a copy of the GNU General Public License along with this program.  If not, see <{{\field{\*\fldinst{HYPERLINK "http://www.gnu.org/licenses/"}}{\fldrslt{http://www.gnu.org/licenses/\ul0\cf0}}}}\f1\fs24 >.\par
\f0 Also add information on how to contact you by electronic and paper mail.\par
If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode:\par
\f1 [product-name] Copyright (C) [copyright-year] [copyright-holder]\par
This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'. This is free software, and you are welcome to redistribute it under certain conditions; type 'show c' for details.\f0\par
The hypothetical commands {\f1 'show w'} and {\f1 'show c'} should show the appropriate arts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box".\par
You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see {{\field{\*\fldinst{HYPERLINK http://www.gnu.org/licenses/ }}{\fldrslt{http://www.gnu.org/licenses/\ul0\cf0}}}}\f0\fs24 .\par
The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read {{\field{\*\fldinst{HYPERLINK http://www.gnu.org/philosophy/why-not-lgpl.html }}{\fldrslt{http://www.gnu.org/philosophy/why-not-lgpl.html\ul0\cf0}}}}\f0\fs24 .\par
}



================================================
FILE: src/templates/main.v3.wxs.mustache
================================================
<?xml version='1.0' encoding='utf-8'?>
<!--
  Copyright (C) 2017 Christopher R. Field.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->

<!--
  The "cargo wix" subcommand provides a variety of predefined variables available
  for customization of this template. The values for each variable are set at
  installer creation time. The following variables are available:

  TargetTriple      = The rustc target triple name.
  TargetEnv         = The rustc target environment. This is typically either
                      "msvc" or "gnu" depending on the toolchain downloaded and
                      installed.
  TargetVendor      = The rustc target vendor. This is typically "pc", but Rust
                      does support other vendors, like "uwp".
  CargoTargetBinDir = The complete path to the directory containing the
                      binaries (exes) to include. The default would be
                      "target\release\". If an explicit rustc target triple is
                      used, i.e. cross-compiling, then the default path would
                      be "target\<CARGO_TARGET>\<CARGO_PROFILE>",
                      where "<CARGO_TARGET>" is replaced with the "CargoTarget"
                      variable value and "<CARGO_PROFILE>" is replaced with the
                      value from the "CargoProfile" variable. This can also
                      be overridden manually with the "target-bin-dir" flag.
  CargoTargetDir    = The path to the directory for the build artifacts, i.e.
                      "target".
  CargoProfile      = The cargo profile used to build the binaries
                      (usually "debug" or "release").
  Version           = The version for the installer. The default is the
                      "Major.Minor.Fix" semantic versioning number of the Rust
                      package.
-->

<!--
  Please do not remove these pre-processor If-Else blocks. These are used with
  the `cargo wix` subcommand to automatically determine the installation
  destination for 32-bit versus 64-bit installers. Removal of these lines will
  cause installation errors.
-->
<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64 ?>
    <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
<?else ?>
    <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
<?endif ?>

<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'>

    <Product
        Id='*'
        Name='{{product-name}}'
        UpgradeCode='{{upgrade-code-guid}}'
        Manufacturer='{{manufacturer}}'
        Language='1033'
        Codepage='1252'
        Version='$(var.Version)'>

        <Package Id='*'
            Keywords='Installer'
            {{#description}}
            Description='{{description}}'
            {{/description}}
            Manufacturer='{{manufacturer}}'
            InstallerVersion='450'
            Languages='1033'
            Compressed='yes'
            InstallScope='perMachine'
            SummaryCodepage='1252'
            />

        <MajorUpgrade
            Schedule='afterInstallInitialize'
            DowngradeErrorMessage='A newer version of [ProductName] is already installed. Setup will now exit.'/>

        <Media Id='1' Cabinet='media1.cab' EmbedCab='yes' DiskPrompt='CD-ROM #1'/>
        <Property Id='DiskPrompt' Value='{{product-name}} Installation'/>

        <Directory Id='TARGETDIR' Name='SourceDir'>
            <Directory Id='$(var.PlatformProgramFilesFolder)' Name='PFiles'>
                <Directory Id='APPLICATIONFOLDER' Name='{{product-name}}'>
                    {{#license-source}}
                    <!--
                      Disabling the license sidecar file in the installer is a two step process:

                      1. Comment out or remove the `Component` tag along with its contents.
                      2. Comment out or remove the `ComponentRef` tag with the "License" Id
                         attribute value further down in this file.
                    -->
                    <Component Id='License' Guid='*'>
                        <File Id='LicenseFile'
                            {{#license-name}}
                            Name='{{license-name}}'
                            {{/license-name}}
                            DiskId='1'
                            Source='{{license-source}}'
                            KeyPath='yes'/>
                    </Component>
                    {{/license-source}}
                    {{^license-source}}
                    <!--
                      Enabling the license sidecar file in the installer is a four step process:

                      1. Uncomment the `Component` tag and its contents.
                      2. Change the value for the `Source` attribute in the `File` tag to a path
                         to the file that should be included as the license sidecar file. The path
                         can, and probably should be, relative to this file.
                      3. Change the value for the `Name` attribute in the `File` tag to the
                         desired name for the file when it is installed alongside the `bin` folder
                         in the installation directory. This can be omitted if the desired name is
                         the same as the file name.
                      4. Uncomment the `ComponentRef` tag with the Id attribute value of "License"
                         further down in this file.
                    -->
                    <!--
                    <Component Id='License' Guid='*'>
                        <File Id='LicenseFile' Name='ChangeMe' DiskId='1' Source='C:\Path\To\File' KeyPath='yes'/>
                    </Component>
                    -->
                    {{/license-source}}

                    <Directory Id='Bin' Name='bin'>
                        <Component Id='Path' Guid='{{path-component-guid}}' KeyPath='yes'>
                            <Environment
                                Id='PATH'
                                Name='PATH'
                                Value='[Bin]'
                                Permanent='no'
                                Part='last'
                                Action='set'
                                System='yes'/>
                        </Component>
                        {{#binaries}}
                        <Component Id='binary{{binary-index}}' Guid='*'>
                            <File
                                Id='exe{{binary-index}}'
                                Name='{{binary-name}}.exe'
                                DiskId='1'
                                Source='{{binary-source}}'
                                KeyPath='yes'/>
                        </Component>
                        {{/binaries}}
                    </Directory>
                </Directory>
            </Directory>
        </Directory>

        <Feature
            Id='Binaries'
            Title='Application'
            Description='Installs all binaries and the license.'
            Level='1'
            ConfigurableDirectory='APPLICATIONFOLDER'
            AllowAdvertise='no'
            Display='expand'
            Absent='disallow'>
            {{#license-source}}
            <!--
              Comment out or remove the following `ComponentRef` tag to remove
              the license sidecar file from the installer.
            -->
            <ComponentRef Id='License'/>
            {{/license-source}}
            {{^license-source}}
            <!--
              Uncomment the following `ComponentRef` tag to add the license
              sidecar file to the installer.
            -->
            <!--<ComponentRef Id='License'/>-->
            {{/license-source}}

            {{#binaries}}
            <ComponentRef Id='binary{{binary-index}}'/>
            {{/binaries}}

            <Feature
                Id='Environment'
                Title='PATH Environment Variable'
                Description='Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location.'
                Level='1'
                Absent='allow'>
                <ComponentRef Id='Path'/>
            </Feature>
        </Feature>

        <SetProperty Id='ARPINSTALLLOCATION' Value='[APPLICATIONFOLDER]' After='CostFinalize'/>

        {{#product-icon}}
        <!--
          Disabling the custom product icon for the application in the
          Add/Remove Programs control panel requires commenting out or
          removing the following `Icon` and `Property` tags.
        -->
        <Icon Id='ProductICO' SourceFile='{{product-icon}}'/>
        <Property Id='ARPPRODUCTICON' Value='ProductICO' />
        {{/product-icon}}
        {{^product-icon}}
        <!--
          Uncomment the following `Icon` and `Property` tags to change the product icon.

          The product icon is the graphic that appears in the Add/Remove
          Programs control panel for the application.
        -->
        <!--<Icon Id='ProductICO' SourceFile='wix\Product.ico'/>-->
        <!--<Property Id='ARPPRODUCTICON' Value='ProductICO' />-->
        {{/product-icon}}

        {{#help-url}}
        <Property Id='ARPHELPLINK' Value='{{help-url}}'/>
        {{/help-url}}
        {{^help-url}}
        <!--
          Adding a URL to Add/Remove Programs control panel listing for the
          application is a two step process:

          1. Uncomment the following `Property` tag with the "ARPHELPLINK" Id
             attribute value.
          2. Change the value for `Value` attribute of the following
             `Property` tag to a valid URL.
        -->
        <!--<Property Id='ARPHELPLINK' Value='ChangeMe'/>-->
        {{/help-url}}

        <UI>
            <UIRef Id='WixUI_FeatureTree'/>
            {{#eula}}
            <!--
              Disabling the EULA dialog in the installer is a two step process:

                 1. Uncomment the following two `Publish` tags
                 2. Comment out or remove the `<WiXVariable Id='WixUILicenseRtf'...` tag further down

            -->
            <!--<Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>-->
            <!--<Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>-->
            {{/eula}}
            {{^eula}}
            <!--
              Enabling the EULA dialog in the installer is a three step process:

                1. Comment out or remove the two `Publish` tags that follow the
                   `WixVariable` tag.
                2. Uncomment the `<WixVariable Id='WixUILicenseRtf' Value='Path\to\Eula.rft'>` tag further down
                3. Replace the `Value` attribute of the `WixVariable` tag with
                   the path to a RTF file that will be used as the EULA and
                   displayed in the license agreement dialog.
            -->
            <Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>
            <Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>
            {{/eula}}

        </UI>

        {{#eula}}
        <!--
          Disabling the EULA dialog in the installer requires commenting out
          or removing the following `WixVariable` tag
        -->
        <WixVariable Id='WixUILicenseRtf' Value='{{eula}}'/>
        {{/eula}}
        {{^eula}}
        <!--
          Enabling the EULA dialog in the installer requires uncommenting
          the following `WixUILicenseRTF` tag and changing the `Value`
          attribute.
        -->
        <!-- <WixVariable Id='WixUILicenseRtf' Value='Relative\Path\to\Eula.rtf'/> -->
        {{/eula}}

        {{#banner}}
        <!--
          Disabling the banner in the installer requires commenting out or
          removing the following `WixVariable` tag.

          The banner BMP dimensions are 493 x 58 pixels.
        -->
        <WixVariable Id='WixUIBannerBmp' Value='{{banner}}'/>
        {{/banner}}
        {{^banner}}
        <!--
          Uncomment the next `WixVariable` tag to customize the installer's
          Graphical User Interface (GUI) and add a custom banner image across
          the top of each screen. See the WiX Toolset documentation for details
          about customization.

          The banner BMP dimensions are 493 x 58 pixels.
        -->
        <!--<WixVariable Id='WixUIBannerBmp' Value='wix\Banner.bmp'/>-->
        {{/banner}}

        {{#dialog}}
        <!--
          Disabling the dialog image in the installer requires commenting out or
          removing the following `WixVariable` tag.

          The dialog BMP dimensions are 493 x 312 pixels.
        -->
        <WixVariable Id='WixUIDialogBmp' Value='{{dialog}}'/>
        {{/dialog}}
        {{^dialog}}
        <!--
          Uncomment the next `WixVariable` tag to customize the installer's
          Graphical User Interface (GUI) and add a custom image to the first
          dialog, or screen. See the WiX Toolset documentation for details about
          customization.

          The dialog BMP dimensions are 493 x 312 pixels.
        -->
        <!--<WixVariable Id='WixUIDialogBmp' Value='wix\Dialog.bmp'/>-->
        {{/dialog}}

    </Product>

</Wix>


================================================
FILE: src/templates/main.v4.wxs.mustache
================================================
<!--
  Copyright (C) 2017 Christopher R. Field.

  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

  http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->

<!--
  The "cargo wix" subcommand provides a variety of predefined variables available
  for customization of this template. The values for each variable are set at
  installer creation time. The following variables are available:

  TargetTriple      = The rustc target triple name.
  TargetEnv         = The rustc target environment. This is typically either
                      "msvc" or "gnu" depending on the toolchain downloaded and
                      installed.
  TargetVendor      = The rustc target vendor. This is typically "pc", but Rust
                      does support other vendors, like "uwp".
  CargoTargetBinDir = The complete path to the directory containing the
                      binaries (exes) to include. The default would be
                      "target\release\". If an explicit rustc target triple is
                      used, i.e. cross-compiling, then the default path would
                      be "target\<CARGO_TARGET>\<CARGO_PROFILE>",
                      where "<CARGO_TARGET>" is replaced with the "CargoTarget"
                      variable value and "<CARGO_PROFILE>" is replaced with the
                      value from the "CargoProfile" variable. This can also
                      be overridden manually with the "target-bin-dir" flag.
  CargoTargetDir    = The path to the directory for the build artifacts, i.e.
                      "target".
  CargoProfile      = The cargo profile used to build the binaries
                      (usually "debug" or "release").
  Version           = The version for the installer. The default is the
                      "Major.Minor.Fix" semantic versioning number of the Rust
                      package.
-->

<!--
  Please do not remove these pre-processor If-Else blocks. These are used with
  the `cargo wix` subcommand to automatically determine the installation
  destination for 32-bit versus 64-bit installers. Removal of these lines will
  cause installation errors.
-->
<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64 ?>
    <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
<?else?>
    <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
<?endif?>

<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs" xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui">
    <Package 
        Name="{{product-name}}" 
        UpgradeCode="{{upgrade-code-guid}}"
        Manufacturer="{{manufacturer}}"
        Language="1033"
        Codepage="1252"
        Version="$(var.Version)"
        InstallerVersion="450">
        <SummaryInformation
            Keywords="Installer"
            Manufacturer="{{manufacturer}}"
            {{#description}}
            Description='{{description}}'
            {{/description}}
            />

        <MajorUpgrade
            Schedule="afterInstallInitialize"
            DowngradeErrorMessage="A newer version of [ProductName] is already installed. Setup will now exit." />

        <Media Id="1" Cabinet="media1.cab" EmbedCab="yes" DiskPrompt="CD-ROM #1" />
        <Property Id="DiskPrompt" Value="{{product-name}} Installation" />

        <Feature 
            Id="Binaries"
            Title="Application"
            Description="Installs all binaries and the license."
            Level="1"
            ConfigurableDirectory="APPLICATIONFOLDER"
            AllowAdvertise="no"
            Display="expand"
            AllowAbsent="no">
            {{#license-source}}
            <!--
              Comment out or remove the following `ComponentRef` tag to remove
              the license sidecar file from the installer.
            -->
            <ComponentRef Id='License'/>
            {{/license-source}}
            {{^license-source}}
            <!--
              Uncomment the following `ComponentRef` tag to add the license
              sidecar file to the installer.
            -->
            <!--<ComponentRef Id='License'/>-->
            {{/license-source}}

            {{#binaries}}
            <ComponentRef Id='binary{{binary-index}}'/>
            {{/binaries}}

            <Feature
                Id="Environment"
                Title="PATH Environment Variable"
                Description="Add the install location of the [ProductName] executable to the PATH system environment variable. This allows the [ProductName] executable to be called from any location."
                Level="1"
                AllowAbsent='yes'>
                <ComponentRef Id="Path" />
            </Feature>
        </Feature>

        <SetProperty Id="ARPINSTALLLOCATION" Value="[APPLICATIONFOLDER]" After="CostFinalize" />

        {{#product-icon}}
        <!--
          Disabling the custom product icon for the application in the
          Add/Remove Programs control panel requires commenting out or
          removing the following `Icon` and `Property` tags.
        -->
        <Icon Id='ProductICO' SourceFile='{{product-icon}}'/>
        <Property Id='ARPPRODUCTICON' Value='ProductICO' />
        {{/product-icon}}
        {{^product-icon}}
        <!--
          Uncomment the following `Icon` and `Property` tags to change the product icon.

          The product icon is the graphic that appears in the Add/Remove
          Programs control panel for the application.
        -->
        <!--<Icon Id='ProductICO' SourceFile='wix\Product.ico'/>-->
        <!--<Property Id='ARPPRODUCTICON' Value='ProductICO' />-->
        {{/product-icon}}

        {{#help-url}}
        <Property Id='ARPHELPLINK' Value='{{help-url}}'/>
        {{/help-url}}
        {{^help-url}}
        <!--
          Adding a URL to Add/Remove Programs control panel listing for the
          application is a two step process:

          1. Uncomment the following `Property` tag with the "ARPHELPLINK" Id
             attribute value.
          2. Change the value for `Value` attribute of the following
             `Property` tag to a valid URL.
        -->
        <!--<Property Id='ARPHELPLINK' Value='ChangeMe'/>-->
        {{/help-url}}
       
        <ui:WixUI Id="WixUI_FeatureTree" />
        {{#eula}}
          <!--
          Disabling the EULA dialog in the installer is a two step process:

          1. Uncomment the following two `Publish` tags
          2. Comment out or remove the `<WiXVariable Id='WixUILicenseRtf'...` tag further down

          -->
          <!--<Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>-->
          <!--<Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>-->
          {{/eula}}
          {{^eula}}
          <!--
          Enabling the EULA dialog in the installer is a three step process:

          1. Comment out or remove the two `Publish` tags that follow the
             `WixVariable` tag.
          2. Uncomment the `<WixVariable Id='WixUILicenseRtf' Value='Path\to\Eula.rft'>` tag further down
          3. Replace the `Value` attribute of the `WixVariable` tag with
             the path to a RTF file that will be used as the EULA and
             displayed in the license agreement dialog.
          -->
          <Publish Dialog='WelcomeDlg' Control='Next' Event='NewDialog' Value='CustomizeDlg' Order='99'>1</Publish>
          <Publish Dialog='CustomizeDlg' Control='Back' Event='NewDialog' Value='WelcomeDlg' Order='99'>1</Publish>
        {{/eula}}
            
        <StandardDirectory Id="ProgramFiles6432Folder">
            <Directory Id="APPLICATIONFOLDER" Name="{{product-name}}">
                {{#license-source}}
                <!--
                  Disabling the license sidecar file in the installer is a two step process:

                  1. Comment out or remove the `Component` tag along with its contents.
                  2. Comment out or remove the `ComponentRef` tag with the "License" Id
                     attribute value further down in this file.
                -->
                <Component Id='License' Guid='*'>
                    <File Id='LicenseFile'
                        {{#license-name}}
                        Name='{{license-name}}'
                        {{/license-name}}
                        DiskId='1'
                        Source='{{license-source}}'
                        KeyPath='yes'/>
                </Component>
                {{/license-source}}
                {{^license-source}}
                <!--
                  Enabling the license sidecar file in the installer is a four step process:

                  1. Uncomment the `Component` tag and its contents.
                  2. Change the value for the `Source` attribute in the `File` tag to a path
                     to the file that should be included as the license sidecar file. The path
                     can, and probably should be, relative to this file.
                  3. Change the value for the `Name` attribute in the `File` tag to the
                     desired name for the file when it is installed alongside the `bin` folder
                     in the installation directory. This can be omitted if the desired name is
                     the same as the file name.
                  4. Uncomment the `ComponentRef` tag with the Id attribute value of "License"
                     further down in this file.
                -->
                <!--
                <Component Id='License' Guid='*'>
                    <File Id='LicenseFile' Name='ChangeMe' DiskId='1' Source='C:\Path\To\File' KeyPath='yes'/>
                </Component>
                -->
                {{/license-source}}

                <Directory Id="Bin" Name="bin">
                    <Component Id="Path" Guid="{{path-component-guid}}" KeyPath="yes">
                        <Environment 
                            Id="PATH"
                            Name="PATH"
                            Value="[Bin]"
                            Permanent="no"
                            Part="last"
                            Action="set"
                            System="yes"/>
                    </Component>
                    {{#binaries}}
                    <Component Id='binary{{binary-index}}' Guid='*'>
                        <File
                            Id='exe{{binary-index}}'
                            Name='{{binary-name}}.exe'
                            DiskId='1'
                            Source='{{binary-source}}'
                            KeyPath='yes'/>
                    </Component>
                    {{/binaries}}
                </Directory>
            </Directory>
        </StandardDirectory>

        {{#eula}}
        <!--
          Disabling the EULA dialog in the installer requires commenting out
          or removing the following `WixVariable` tag
        -->
        <WixVariable Id='WixUILicenseRtf' Value='{{eula}}'/>
        {{/eula}}
        {{^eula}}
        <!--
          Enabling the EULA dialog in the installer requires uncommenting
          the following `WixUILicenseRTF` tag and changing the `Value`
          attribute.
        -->
        <!-- <WixVariable Id='WixUILicenseRtf' Value='Relative\Path\to\Eula.rtf'/> -->
        {{/eula}}

        {{#banner}}
        <!--
          Disabling the banner in the installer requires commenting out or
          removing the following `WixVariable` tag.

          The banner BMP dimensions are 493 x 58 pixels.
        -->
        <WixVariable Id='WixUIBannerBmp' Value='{{banner}}'/>
        {{/banner}}
        {{^banner}}
        <!--
          Uncomment the next `WixVariable` tag to customize the installer's
          Graphical User Interface (GUI) and add a custom banner image across
          the top of each screen. See the WiX Toolset documentation for details
          about customization.

          The banner BMP dimensions are 493 x 58 pixels.
        -->
        <!--<WixVariable Id='WixUIBannerBmp' Value='wix\Banner.bmp'/>-->
        {{/banner}}

        {{#dialog}}
        <!--
          Disabling the dialog image in the installer requires commenting out or
          removing the following `WixVariable` tag.

          The dialog BMP dimensions are 493 x 312 pixels.
        -->
        <WixVariable Id='WixUIDialogBmp' Value='{{dialog}}'/>
        {{/dialog}}
        {{^dialog}}
        <!--
          Uncomment the next `WixVariable` tag to customize the installer's
          Graphical User Interface (GUI) and add a custom image to the first
          dialog, or screen. See the WiX Toolset documentation for details about
          customization.

          The dialog BMP dimensions are 493 x 312 pixels.
        -->
        <!--<WixVariable Id='WixUIDialogBmp' Value='wix\Dialog.bmp'/>-->
        {{/dialog}}
    </Package>

</Wix>


================================================
FILE: src/templates/mod.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::Error;
use lazy_static::lazy_static;
use std::fmt;
use std::str::FromStr;

/// The WiX Source (wxs) template.
static WIX_V3_SOURCE_TEMPLATE: &str = include_str!("main.v3.wxs.mustache");

/// The V4 Schema WiX Source (wxs) template.
///
/// Note: Used by both Wix4 and Wix5 toolsets
static WIX_V4_SOURCE_TEMPLATE: &str = include_str!("main.v4.wxs.mustache");

/// The Apache-2.0 Rich Text Format (RTF) license template.
static APACHE2_LICENSE_TEMPLATE: &str = include_str!("Apache-2.0.rtf.mustache");

/// The GPL-3.0 Rich Text Format (RTF) license template.
static GPL3_LICENSE_TEMPLATE: &str = include_str!("GPL-3.0.rtf.mustache");

/// The MIT Rich Text Format (RTF) license template.
static MIT_LICENSE_TEMPLATE: &str = include_str!("MIT.rtf.mustache");

/// The different templates that can be printed or written to a file.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Template {
    /// The [Apache-2.0] license.
    ///
    /// [Apache-2.0]: https://opensource.org/licenses/Apache-2.0
    Apache2,
    /// The [GPL-3.0] license.
    ///
    /// [GPL-3.0]: https://opensource.org/licenses/gpl-3.0.html
    Gpl3,
    /// The [MIT] license.
    ///
    /// [MIT]: https://opensource.org/licenses/MIT
    Mit,
    /// A [WiX Source (wxs)] file.
    ///
    /// **Note**: This follows teh V3 wxs schema
    ///
    /// [Wix Source (wxs)]: http://wixtoolset.org/documentation/manual/v3/overview/files.html
    WxsV3,
    /// A [Modern Wix Source (wxs)] file.
    ///
    /// [Modern Wix Source (wxs)]: https://wixtoolset.org/docs/schema/wxs/
    WxsV4,
}

lazy_static! {
    static ref POSSIBLE_VALUES: Vec<String> = vec![
        Template::Apache2.id().to_owned(),
        Template::Apache2.id().to_lowercase(),
        Template::Gpl3.id().to_owned(),
        Template::Gpl3.id().to_lowercase(),
        Template::Mit.id().to_owned(),
        Template::Mit.id().to_lowercase(),
        Template::WxsV3.id().to_owned(),
        Template::WxsV3.id().to_lowercase(),
        Template::WxsV4.id().to_lowercase(),
        // Added for convenience instead of http://wixtoolset.org/schemas/v4/wxs
        String::from("wxs4"),
        String::from("WXS4")
    ];
}

impl Template {
    /// Gets the ID for the template.
    ///
    /// In the case of a license template, the ID is the [SPDX ID] which is also used for the
    /// `license` field in the package's manifest (Cargo.toml). This is also the same value used
    /// with the `cargo wix print` subcommand.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use wix::Template;
    ///
    /// assert_eq!(Template::Apache2.id(), "Apache-2.0");
    /// assert_eq!(Template::Gpl3.id(), "GPL-3.0");
    /// assert_eq!(Template::Mit.id(), "MIT");
    /// assert_eq!(Template::WxsV3.id(), "WXS");
    /// assert_eq!(Template::WxsV4.id(), wix::toolset::project::V4_NAMESPACE_URI);
    /// ```
    ///
    /// [SPDX ID]: https://spdx.org/licenses/
    pub fn id(&self) -> &str {
        match *self {
            Template::Apache2 => "Apache-2.0",
            Template::Gpl3 => "GPL-3.0",
            Template::Mit => "MIT",
            Template::WxsV3 => "WXS",
            Template::WxsV4 => crate::toolset::project::V4_NAMESPACE_URI,
        }
    }

    /// Gets the possible string representations of each variant.
    ///
    /// The possibilities are combination of case (upper and lower) for the
    /// various templates that are available.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use wix::Template;
    ///
    /// assert_eq!(
    ///     Template::possible_values(),
    ///     &vec![
    ///         "Apache-2.0".to_owned(),
    ///         "apache-2.0".to_owned(),
    ///         "GPL-3.0".to_owned(),
    ///         "gpl-3.0".to_owned(),
    ///         "MIT".to_owned(),
    ///         "mit".to_owned(),
    ///         "WXS".to_owned(),
    ///         "wxs".to_owned(),
    ///         wix::toolset::project::V4_NAMESPACE_URI.to_owned(),
    ///         "wxs4".to_owned(),
    ///         "WXS4".to_owned()
    ///     ]
    /// );
    /// ```
    pub fn possible_values() -> &'static Vec<String> {
        &POSSIBLE_VALUES
    }

    /// Gets the IDs of all supported licenses.
    ///
    /// # Examples
    ///
    /// ```rust
    /// use wix::Template;
    ///
    /// assert_eq!(
    ///     Template::license_ids(),
    ///     vec![
    ///         "Apache-2.0".to_owned(),
    ///         "GPL-3.0".to_owned(),
    ///         "MIT".to_owned(),
    ///     ]
    /// );
    /// ```
    pub fn license_ids() -> Vec<String> {
        vec![
            Template::Apache2.id().to_owned(),
            Template::Gpl3.id().to_owned(),
            Template::Mit.id().to_owned(),
        ]
    }

    /// Gets the embedded contents of the template as a string.
    pub fn to_str(&self) -> &str {
        match *self {
            Template::Apache2 => APACHE2_LICENSE_TEMPLATE,
            Template::Gpl3 => GPL3_LICENSE_TEMPLATE,
            Template::Mit => MIT_LICENSE_TEMPLATE,
            Template::WxsV3 => WIX_V3_SOURCE_TEMPLATE,
            Template::WxsV4 => WIX_V4_SOURCE_TEMPLATE,
        }
    }
}

impl fmt::Display for Template {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.id())
    }
}

impl FromStr for Template {
    type Err = Error;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        match s.to_lowercase().trim() {
            "apache-2.0" => Ok(Template::Apache2),
            "gpl-3.0" => Ok(Template::Gpl3),
            "mit" => Ok(Template::Mit),
            "wxs" => Ok(Template::WxsV3),
            crate::toolset::project::V4_NAMESPACE_URI | "wxs4" | "WXS4" => Ok(Template::WxsV4),
            _ => Err(Error::Generic(format!(
                "Cannot convert from '{s}' to a Template variant"
            ))),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::str::FromStr;

    #[test]
    fn from_str_wxs_returns_v3() {
        assert_eq!(Template::from_str("wxs").unwrap(), Template::WxsV3);
    }

    #[test]
    fn from_str_wxs_uppercase_returns_v3() {
        assert_eq!(Template::from_str("WXS").unwrap(), Template::WxsV3);
    }

    #[test]
    fn from_str_wxs4_returns_v4() {
        assert_eq!(Template::from_str("wxs4").unwrap(), Template::WxsV4);
    }

    #[test]
    fn from_str_wxs4_uppercase_returns_v4() {
        assert_eq!(Template::from_str("WXS4").unwrap(), Template::WxsV4);
    }

    #[test]
    fn from_str_v4_namespace_uri_returns_v4() {
        assert_eq!(
            Template::from_str(crate::toolset::project::V4_NAMESPACE_URI).unwrap(),
            Template::WxsV4
        );
    }

    #[test]
    fn from_str_unknown_fails() {
        assert!(Template::from_str("unknown_template").is_err());
    }

    #[test]
    fn wxs_v3_to_str_is_not_empty() {
        assert!(!Template::WxsV3.to_str().is_empty());
    }

    #[test]
    fn wxs_v4_to_str_is_not_empty() {
        assert!(!Template::WxsV4.to_str().is_empty());
    }

    #[test]
    fn wxs_v4_to_str_contains_v4_namespace() {
        assert!(
            Template::WxsV4
                .to_str()
                .contains(crate::toolset::project::V4_NAMESPACE_URI),
            "V4 template should contain the v4 namespace URI"
        );
    }

    #[test]
    fn possible_values_contains_wxs4() {
        let values = Template::possible_values();
        assert!(
            values.iter().any(|v| v == "wxs4"),
            "possible_values should include wxs4"
        );
    }
}


================================================
FILE: src/toolset/ext.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use log::debug;
use semver::Version;
use std::{
    collections::{BTreeMap, BTreeSet},
    path::PathBuf,
};

use super::{Toolset, ToolsetAction};

/// Type-alias for .wxs extension dependency
pub type WxsDependency = Box<dyn WixExtension>;

/// Trait to provide wix extension identifiers w/ use the `wix extension` command
pub trait WixExtension {
    /// Returns the .wixext package name used to identify the extension
    fn package_name(&self) -> &str;
    /// Returns the xmlns prefix
    fn namespace_prefix(&self) -> &str;
    /// Returns the xmlns uri
    fn namespace_uri(&self) -> &str;
}

/// Contains a map of locally/globally installed packages
#[derive(Debug)]
pub struct PackageCache {
    /// Installed packages
    installed: BTreeMap<String, Version>,
    /// Packages that are indicated as missing from the package cache
    missing: BTreeSet<String>,
    /// Toolset in used with this package cache
    toolset: Toolset,
}

impl PackageCache {
    /// Add an installed package to the cache
    #[inline]
    pub fn add(&mut self, name: impl Into<String>, version: Version) {
        self.installed.insert(name.into(), version);
    }

    /// Returns true if an ext is installed matching the
    #[inline]
    pub fn installed(&self, ext: &impl WixExtension) -> bool {
        self.installed_package_name(ext.package_name())
    }

    /// Returns true if an installed package_name exists
    #[inline]
    pub fn installed_package_name(&self, package_name: &str) -> bool {
        self.installed.contains_key(package_name)
    }

    /// Returns an iterator over missing extensions
    #[inline]
    pub fn iter_missing(&self) -> impl Iterator<Item = &String> {
        self.missing.iter()
    }

    /// Returns an iterator over installed extensions
    #[inline]
    pub fn iter_installed(&self) -> impl Iterator<Item = (&String, &Version)> {
        self.installed.iter()
    }

    /// Add's a missing package to the package cache for later installation
    #[inline]
    pub fn add_missing(&mut self, name: impl Into<String>) {
        self.missing.insert(name.into());
    }

    /// Installs all missing packages
    #[inline]
    pub fn install_missing(
        &self,
        global_cache: bool,
        version: Version,
        work_dir: Option<&PathBuf>,
    ) -> crate::Result<()> {
        if self.missing.is_empty() {
            debug!("No missing extensions, skipping extension restore");
            return Ok(());
        }
        let mut wix = self.toolset.wix("extension add")?;

        if let Some(work_dir) = work_dir {
            wix.current_dir(work_dir);
        }

        if global_cache {
            wix.arg("--global");
            wix.action = ToolsetAction::AddGlobalExtension;
        }

        for m in self.missing.iter() {
            let ext_ref = format!("{m}/{}.{}.{}", version.major, version.minor, version.patch);
            debug!("Installing missing ext {ext_ref}");
            wix.arg(ext_ref);
        }

        let output = wix.output()?;
        if output.status.success() {
            Ok(())
        } else {
            Err("Could not install missing dependencies".into())
        }
    }
}

impl From<Toolset> for PackageCache {
    fn from(toolset: Toolset) -> Self {
        Self {
            installed: Default::default(),
            missing: Default::default(),
            toolset,
        }
    }
}

impl WixExtension for WxsDependency {
    fn package_name(&self) -> &str {
        self.as_ref().package_name()
    }

    fn namespace_prefix(&self) -> &str {
        self.as_ref().namespace_prefix()
    }

    fn namespace_uri(&self) -> &str {
        self.as_ref().namespace_uri()
    }
}

impl<'a> From<&sxd_document::dom::Namespace<'a>> for WxsDependency {
    fn from(value: &sxd_document::dom::Namespace<'a>) -> Self {
        match (value.prefix(), value.uri()) {
            (BAL_NS_PREFIX, BAL_NS_URI) => Box::new(WellKnownExtentions::BootstrapperApplications),
            (COMPLUS_NS_PREFIX, COMPLUS_NS_URI) => Box::new(WellKnownExtentions::ComPlus),
            (DEPENDENCY_NS_PREFIX, DEPENDENCY_NS_URI) => Box::new(WellKnownExtentions::Dependency),
            (DIRECTX_NS_PREFIX, DIRECTX_NS_URI) => Box::new(WellKnownExtentions::DirectX),
            (FIREWALL_NS_PREFIX, FIREWALL_NS_URI) => Box::new(WellKnownExtentions::Firewall),
            (HTTP_NS_PREFIX, HTTP_NS_URI) => Box::new(WellKnownExtentions::Http),
            (IIS_NS_PREFIX, IIS_NS_URI) => Box::new(WellKnownExtentions::Iis),
            (MSMQ_NS_PREFIX, MSMQ_NS_URI) => Box::new(WellKnownExtentions::Msmq),
            (NETFX_NS_PREFIX, NETFX_NS_URI) => Box::new(WellKnownExtentions::Netfx),
            (POWERSHELL_NS_PREFIX, POWERSHELL_NS_URI) => Box::new(WellKnownExtentions::Powershell),
            (SQL_NS_PREFIX, SQL_NS_URI) => Box::new(WellKnownExtentions::Sql),
            (UI_NS_PREFIX, UI_NS_URI) => Box::new(WellKnownExtentions::UI),
            (UTIL_NS_PREFIX, UTIL_NS_URI) => Box::new(WellKnownExtentions::Util),
            (VS_NS_PREFIX, VS_NS_URI) => Box::new(WellKnownExtentions::VS),
            (prefix, uri) => Box::new(UnknownExtNamespace {
                prefix: prefix.to_string(),
                uri: uri.to_string(),
            }),
        }
    }
}
/// Struct containing information on an unknown extension found in the `<Wix/>` element
pub struct UnknownExtNamespace {
    pub(crate) prefix: String,
    pub(crate) uri: String,
}

impl WixExtension for UnknownExtNamespace {
    fn package_name(&self) -> &str {
        ""
    }

    fn namespace_prefix(&self) -> &str {
        &self.prefix
    }

    fn namespace_uri(&self) -> &str {
        &self.uri
    }
}

/// Enumeration of Well-known extensions documented by the wix toolset org
///
/// # Background
/// Because XML namespaces are intended to be known ahead of time, this is an explicit enuemration of all well known extensions installable by the Wix Toolset.
/// This enables `cargo-wix` to identify which extensions are required to be installed in order for `wix build` to succeed after a V3 project has been upgraded
/// to a V4 project.
///
/// Source: <https://wixtoolset.org/docs/tools/wixext/>
#[derive(Clone, Copy)]
pub enum WellKnownExtentions {
    /// WiX Toolset Bootstrapper Applications Extension
    /// Docs: <https://wixtoolset.org/docs/schema/bal/>
    BootstrapperApplications,
    /// WiX Toolset COM+ Extension
    /// Docs: <https://wixtoolset.org/docs/schema/complus/>
    ComPlus,
    /// WiX Toolset Dependency Extension
    /// Docs: <https://wixtoolset.org/docs/schema/dependency/>
    Dependency,
    /// WiX Toolset DirectX Extension
    /// Docs: <https://wixtoolset.org/docs/schema/directx/>
    DirectX,
    /// WiX Toolset Firewall Extension
    /// Docs: <https://wixtoolset.org/docs/schema/firewall/>
    Firewall,
    /// Windows Installer XML Toolset Http Extension
    /// Docs: <https://wixtoolset.org/docs/schema/http/>
    Http,
    /// WiX Toolset Internet Information Services Extension
    /// Docs: <https://wixtoolset.org/docs/schema/iis/>
    Iis,
    /// WiX Toolset MSMQ Extension
    /// Docs: <https://wixtoolset.org/docs/schema/msmq/>
    Msmq,
    /// WiX Toolset .NET Framework Extension
    /// Docs: <https://wixtoolset.org/docs/schema/netfx/>
    Netfx,
    /// WiX Toolset PowerShell Extension
    /// Docs: <https://wixtoolset.org/docs/schema/powershell/>
    Powershell,
    /// WiX Toolset SQL Server Extension
    /// Docs: <https://wixtoolset.org/docs/schema/sql/>
    Sql,
    /// WiX Toolset UI Extension
    /// Docs: <https://wixtoolset.org/docs/schema/ui/>
    UI,
    /// WiX Toolset Utility Extension
    /// Docs: <https://wixtoolset.org/docs/schema/util/>
    Util,
    /// WiX Toolset Visual Studio Extension
    /// Docs: <https://wixtoolset.org/docs/schema/vs/>
    VS,
}

impl WixExtension for WellKnownExtentions {
    fn package_name(&self) -> &str {
        match self {
            WellKnownExtentions::BootstrapperApplications => BAL_EXT,
            WellKnownExtentions::ComPlus => COMPLUS_EXT,
            WellKnownExtentions::Dependency => DEPENDENCY_EXT,
            WellKnownExtentions::DirectX => DIRECTX_EXT,
            WellKnownExtentions::Firewall => FIREWALL_EXT,
            WellKnownExtentions::Http => HTTP_EXT,
            WellKnownExtentions::Iis => IIS_EXT,
            WellKnownExtentions::Msmq => MSMQ_EXT,
            WellKnownExtentions::Netfx => NETFX_EXT,
            WellKnownExtentions::Powershell => POWERSHELL_EXT,
            WellKnownExtentions::Sql => SQL_EXT,
            WellKnownExtentions::UI => UI_EXT,
            WellKnownExtentions::Util => UTIL_EXT,
            WellKnownExtentions::VS => VS_EXT,
        }
    }

    /// Returns the xmlns prefix
    fn namespace_prefix(&self) -> &str {
        match self {
            WellKnownExtentions::BootstrapperApplications => BAL_NS_PREFIX,
            WellKnownExtentions::ComPlus => COMPLUS_NS_PREFIX,
            WellKnownExtentions::Dependency => DEPENDENCY_NS_PREFIX,
            WellKnownExtentions::DirectX => DIRECTX_NS_PREFIX,
            WellKnownExtentions::Firewall => FIREWALL_NS_PREFIX,
            WellKnownExtentions::Http => HTTP_NS_PREFIX,
            WellKnownExtentions::Iis => IIS_NS_PREFIX,
            WellKnownExtentions::Msmq => MSMQ_NS_PREFIX,
            WellKnownExtentions::Netfx => NETFX_NS_PREFIX,
            WellKnownExtentions::Powershell => POWERSHELL_NS_PREFIX,
            WellKnownExtentions::Sql => SQL_NS_PREFIX,
            WellKnownExtentions::UI => UI_NS_PREFIX,
            WellKnownExtentions::Util => UTIL_NS_PREFIX,
            WellKnownExtentions::VS => VS_NS_PREFIX,
        }
    }

    fn namespace_uri(&self) -> &str {
        match self {
            WellKnownExtentions::BootstrapperApplications => BAL_NS_URI,
            WellKnownExtentions::ComPlus => COMPLUS_NS_URI,
            WellKnownExtentions::Dependency => DEPENDENCY_NS_URI,
            WellKnownExtentions::DirectX => DIRECTX_NS_URI,
            WellKnownExtentions::Firewall => FIREWALL_NS_URI,
            WellKnownExtentions::Http => HTTP_NS_URI,
            WellKnownExtentions::Iis => IIS_NS_URI,
            WellKnownExtentions::Msmq => MSMQ_NS_URI,
            WellKnownExtentions::Netfx => NETFX_NS_URI,
            WellKnownExtentions::Powershell => POWERSHELL_NS_URI,
            WellKnownExtentions::Sql => SQL_NS_URI,
            WellKnownExtentions::UI => UI_NS_URI,
            WellKnownExtentions::Util => UTIL_NS_URI,
            WellKnownExtentions::VS => VS_NS_URI,
        }
    }
}

const BAL_EXT: &str = "WixToolset.BootstrapperApplications.wixext";
const BAL_NS_PREFIX: &str = "bal";
const BAL_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/bal";

const COMPLUS_EXT: &str = "WixToolset.ComPlus.wixext";
const COMPLUS_NS_PREFIX: &str = "complus";
const COMPLUS_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/complus";

const DEPENDENCY_EXT: &str = "WixToolset.Dependency.wixext";
/// Source of namespace prefix:
/// https://github.com/wixtoolset/wix/blob/dd2fe20d9fe58719445411524bd730495140d02f/src/wix/test/WixToolsetTest.Converters/DependencyFixture.cs#L19
const DEPENDENCY_NS_PREFIX: &str = "dep";
const DEPENDENCY_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/dependency";

const DIRECTX_EXT: &str = "WixToolset.DirectX.wixext";
const DIRECTX_NS_PREFIX: &str = "directx";
const DIRECTX_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/directx";

const FIREWALL_EXT: &str = "WixToolset.Firewall.wixext";
/// Source of namespace prefix:
/// https://github.com/wixtoolset/wix/blob/dd2fe20d9fe58719445411524bd730495140d02f/src/wix/test/WixToolsetTest.Converters/FirewallExtensionFixture.cs#L19
const FIREWALL_NS_PREFIX: &str = "fw";
const FIREWALL_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/firewall";

const HTTP_EXT: &str = "WixToolset.Http.wixext";
const HTTP_NS_PREFIX: &str = "http";
const HTTP_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/http";

const IIS_EXT: &str = "WixToolset.Iis.wixext";
const IIS_NS_PREFIX: &str = "iis";
const IIS_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/iis";

const MSMQ_EXT: &str = "WixToolset.Msmq.wixext";
const MSMQ_NS_PREFIX: &str = "msmq";
const MSMQ_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/msmq";

const NETFX_EXT: &str = "WixToolset.Netfx.wixext";
const NETFX_NS_PREFIX: &str = "netfx";
const NETFX_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/netfx";

const POWERSHELL_EXT: &str = "WixToolset.PowerShell.wixext";
const POWERSHELL_NS_PREFIX: &str = "powershell";
const POWERSHELL_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/powershell";

const SQL_EXT: &str = "WixToolset.Sql.wixext";
const SQL_NS_PREFIX: &str = "sql";
const SQL_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/sql";

const UI_EXT: &str = "WixToolset.UI.wixext";
const UI_NS_PREFIX: &str = "ui";
const UI_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/ui";

const UTIL_EXT: &str = "WixToolset.Util.wixext";
const UTIL_NS_PREFIX: &str = "util";
const UTIL_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/util";

const VS_EXT: &str = "WixToolset.VisualStudio.wixext";
const VS_NS_PREFIX: &str = "vs";
const VS_NS_URI: &str = "http://wixtoolset.org/schemas/v4/wxs/vs";

#[cfg(test)]
mod tests {
    use std::path::PathBuf;

    use super::PackageCache;
    use crate::toolset::{ToolsetAction, ext::WellKnownExtentions, test};
    use semver::Version;

    #[test]
    fn test_package_cache_installed() {
        let mut package = PackageCache {
            installed: Default::default(),
            missing: Default::default(),
            toolset: crate::toolset::Toolset::Modern,
        };

        package.add("WixToolset.Util.wixext", Version::new(0, 0, 0));
        assert!(package.installed(&WellKnownExtentions::Util));
    }

    #[test]
    fn test_package_cache_install_missing_non_global() {
        let test_shim = test::toolset(|a: &ToolsetAction, cmd: &std::process::Command| match a {
            ToolsetAction::AddExtension => {
                let mut expected = std::process::Command::new("wix");
                expected
                    .arg("extension")
                    .arg("add")
                    .arg("Test.wixext/0.0.0");
                assert_eq!(format!("{:?}", cmd), format!("{:?}", expected));

                test::ok_stdout("")
            }
            _ => {
                unreachable!("Only extension add should be evaluated")
            }
        });

        let mut package = PackageCache::from(test_shim);

        package.add_missing("Test.wixext");
        package
            .install_missing(false, Version::new(0, 0, 0), None)
            .unwrap();
    }

    #[test]
    fn test_package_cache_install_missing_global() {
        let test_shim = test::toolset(|a: &ToolsetAction, cmd: &std::process::Command| match a {
            ToolsetAction::AddGlobalExtension => {
                let mut expected = std::process::Command::new("wix");
                expected
                    .arg("extension")
                    .arg("add")
                    .arg("--global")
                    .arg("Test.wixext/0.0.0");
                assert_eq!(format!("{:?}", cmd), format!("{:?}", expected));

                test::ok_stdout("")
            }
            a => {
                unreachable!("Only extension add should be evaluated, tried to eval {a:?}")
            }
        });

        let mut package = PackageCache::from(test_shim);
        package.add_missing("Test.wixext");
        package
            .install_missing(true, Version::new(0, 0, 0), None)
            .unwrap();
    }

    #[test]
    fn test_package_cache_install_missing_work_dir() {
        let test_shim = test::toolset(|a: &ToolsetAction, cmd: &std::process::Command| match a {
            ToolsetAction::AddGlobalExtension => {
                let mut expected = std::process::Command::new("wix");
                expected
                    .arg("extension")
                    .arg("add")
                    .arg("--global")
                    .arg("Test.wixext/0.0.0")
                    .current_dir("test_work_dir");
                assert_eq!(format!("{:?}", cmd), format!("{:?}", expected));
                assert_eq!("test_work_dir", cmd.get_current_dir().unwrap().as_os_str());

                test::ok_stdout("")
            }
            a => {
                unreachable!("Only extension add should be evaluated, tried to eval {a:?}")
            }
        });

        let mut package = PackageCache::from(test_shim);
        package.add_missing("Test.wixext");
        package
            .install_missing(
                true,
                Version::new(0, 0, 0),
                Some(&PathBuf::from("test_work_dir")),
            )
            .unwrap();
    }
}


================================================
FILE: src/toolset/includes.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use crate::{Error, WIX, WIX_SOURCE_FILE_EXTENSION, toolset::Toolset};
use cargo_metadata::Package;
use log::{debug, trace};
use std::path::PathBuf;

use super::Project;

/// Trait for returning a list of project files to include
pub trait Includes {
    /// Returns included file paths
    fn includes(&self) -> Option<&Vec<PathBuf>>;

    /// Returns a list of paths to *.wxs sources
    fn wxs_sources(&self, package: &Package) -> crate::Result<Vec<PathBuf>> {
        let project_wix_dir = package
            .manifest_path
            .parent()
            .ok_or_else(|| {
                Error::Generic(format!(
                    "The '{}' path for the package's manifest file is invalid",
                    package.manifest_path
                ))
            })
            .map(|d| PathBuf::from(d).join(WIX))?;
        let mut wix_sources = {
            if project_wix_dir.exists() {
                std::fs::read_dir(project_wix_dir)?
                    .filter_map(|r| r.ok())
                    .map(|e| e.path())
                    .filter(|p| {
                        p.extension().and_then(|s| s.to_str()) == Some(WIX_SOURCE_FILE_EXTENSION)
                    })
                    .collect()
            } else {
                Vec::new()
            }
        };
        if let Some(paths) = self.includes() {
            for p in paths {
                if p.exists() {
                    if p.is_dir() {
                        return Err(Error::Generic(format!(
                            "The '{}' path is not a file. Please check the path and ensure it is to \
                            a WiX Source (wxs) file.",
                            p.display()
                        )));
                    } else {
                        trace!("Using the '{}' WiX source file", p.display());
                    }
                } else {
                    return Err(Error::Generic(format!(
                        "The '{0}' file does not exist. Consider using the 'cargo \
                         wix print WXS > {0}' command to create it.",
                        p.display()
                    )));
                }
            }
            wix_sources.extend(paths.clone());
        } else if let Some(pkg_meta_wix_include) = package
            .metadata
            .get("wix")
            .and_then(|w| w.as_object())
            .and_then(|t| t.get("include"))
            .and_then(|i| i.as_array())
        {
            let pkg_meta_wix_sources: Vec<PathBuf> = pkg_meta_wix_include
                .iter()
                .map(|s| {
                    s.as_str().map(PathBuf::from).ok_or_else(|| {
                        Error::Generic(format!(
                            "Invalid value in 'package.metadata.wix.include': \
                             expected a string path, found '{s}'"
                        ))
                    })
                })
                .collect::<crate::Result<Vec<PathBuf>>>()?;
            for pkg_meta_wix_source in &pkg_meta_wix_sources {
                if pkg_meta_wix_source.exists() {
                    if pkg_meta_wix_source.is_dir() {
                        return Err(Error::Generic(format!(
                            "The '{}' path is not a file. Please check the path and \
                             ensure it is to a WiX Source (wxs) file in the \
                             'package.metadata.wix' section of the package's manifest \
                             (Cargo.toml).",
                            pkg_meta_wix_source.display()
                        )));
                    } else {
                        trace!(
                            "Using the '{}' WiX source file from the \
                             'package.metadata.wix' section in the package's \
                             manifest.",
                            pkg_meta_wix_source.display()
                        );
                    }
                } else {
                    return Err(Error::Generic(format!(
                        "The '{0}' file does not exist. Consider using the \
                         'cargo wix print WXS > {0} command to create it.",
                        pkg_meta_wix_source.display()
                    )));
                }
            }

            wix_sources.extend(pkg_meta_wix_sources);
        }
        if wix_sources.is_empty() {
            Err(Error::Generic(String::from(
                "There are no WXS files to create an installer",
            )))
        } else {
            Ok(wix_sources)
        }
    }
}

/// Extension functions for implementations of Include
pub trait ProjectProvider: Includes {
    /// Returns a working directory override
    fn work_dir(&self) -> Option<PathBuf> {
        None
    }

    /// Return the toolset to use when creating projects
    fn toolset(&self) -> Toolset;

    /// Derives a project from a Package and the current `impl Includes`
    ///
    /// Returns an error if the *.wxs sources cannot be enumerated, if
    /// a modern WiX toolset is not installed and available from PATH, or
    /// if a .wxs file has invalid XML
    fn create_project(&self, package: &Package) -> crate::Result<Project> {
        debug!("Getting wxs files");
        let wxs_sources = self.wxs_sources(package)?;
        debug!("wxs_sources = {wxs_sources:#?}");

        debug!("Trying to create new project");
        let mut project = Project::try_new(self.toolset())?;
        debug!("project = {project:#?}");

        for src in wxs_sources {
            debug!("Adding {src:?} to project");
            project.add_wxs(src)?;
        }

        debug!("Completed project = {project:#?}");
        Ok(project)
    }
}

impl ProjectProvider for crate::create::Execution {
    fn toolset(&self) -> Toolset {
        self.toolset.clone()
    }
}
impl ProjectProvider for crate::migrate::Execution {
    fn toolset(&self) -> Toolset {
        Toolset::Modern
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    /// Minimal Includes implementation for testing the default wxs_sources method
    struct NoIncludes;
    impl Includes for NoIncludes {
        fn includes(&self) -> Option<&Vec<PathBuf>> {
            None
        }
    }

    /// Helper to create a Package from JSON
    fn package_from_json(json: &str) -> cargo_metadata::Package {
        serde_json::from_str(json).expect("valid package JSON")
    }

    const PACKAGE_TEMPLATE: &str = r#"{
        "name": "Example",
        "version": "0.1.0",
        "authors": ["First Last <first.last@example.com>"],
        "license": "XYZ",
        "id": "",
        "dependencies": [],
        "targets": [],
        "features": {},
        "manifest_path": "C:\\Cargo.toml"
    }"#;

    #[test]
    fn non_string_metadata_include_errors() {
        let json = r#"{
            "name": "Example",
            "version": "0.1.0",
            "authors": ["First Last <first.last@example.com>"],
            "license": "XYZ",
            "id": "",
            "dependencies": [],
            "targets": [],
            "features": {},
            "manifest_path": "C:\\Cargo.toml",
            "metadata": {
                "wix": {
                    "include": [42]
                }
            }
        }"#;
        let pkg = package_from_json(json);
        let result = NoIncludes.wxs_sources(&pkg);
        assert!(
            result.is_err(),
            "Non-string include value should produce an error"
        );
        let err = format!("{}", result.unwrap_err());
        assert!(
            err.contains("expected a string path"),
            "Error should mention expected string, got: {err}"
        );
    }

    #[test]
    fn mixed_valid_and_invalid_metadata_include_errors() {
        let json = r#"{
            "name": "Example",
            "version": "0.1.0",
            "authors": ["First Last <first.last@example.com>"],
            "license": "XYZ",
            "id": "",
            "dependencies": [],
            "targets": [],
            "features": {},
            "manifest_path": "C:\\Cargo.toml",
            "metadata": {
                "wix": {
                    "include": ["valid.wxs", null, "other.wxs"]
                }
            }
        }"#;
        let pkg = package_from_json(json);
        let result = NoIncludes.wxs_sources(&pkg);
        assert!(
            result.is_err(),
            "Array with null value should produce an error"
        );
    }

    #[test]
    fn empty_metadata_include_array_errors_no_sources() {
        let json = r#"{
            "name": "Example",
            "version": "0.1.0",
            "authors": ["First Last <first.last@example.com>"],
            "license": "XYZ",
            "id": "",
            "dependencies": [],
            "targets": [],
            "features": {},
            "manifest_path": "C:\\Cargo.toml",
            "metadata": {
                "wix": {
                    "include": []
                }
            }
        }"#;
        let pkg = package_from_json(json);
        let result = NoIncludes.wxs_sources(&pkg);
        // Empty include array means no sources, should error with "no WXS files"
        assert!(result.is_err());
        let err = format!("{}", result.unwrap_err());
        assert!(
            err.contains("no WXS files"),
            "Empty include should error about no WXS files, got: {err}"
        );
    }

    #[test]
    fn no_metadata_no_wix_dir_errors() {
        let pkg = package_from_json(PACKAGE_TEMPLATE);
        let result = NoIncludes.wxs_sources(&pkg);
        assert!(result.is_err(), "No wix dir and no metadata should error");
    }
}


================================================
FILE: src/toolset/mod.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # Toolset Module
//!
//! Contains types for integrating legacy and modern WiX toolsets and facilitating various
//! project setup utilities such as converting from legacy to modern, restoring extension dependencies, or
//! automatically determining if extension dependencies that are required are currently missing from the environment.

pub mod ext;
mod includes;
pub mod project;
pub mod source;
#[cfg(test)]
pub(crate) mod test;
use cargo_metadata::Package;
pub use includes::Includes;
pub use includes::ProjectProvider;
pub use project::Project;

use crate::BINARY_FOLDER_NAME;
use crate::EXE_FILE_EXTENSION;
use crate::WIX_COMPILER;
use crate::WIX_PATH_KEY;
use clap::ValueEnum;
use log::debug;
use log::trace;
use std::ops::Deref;
use std::ops::DerefMut;
use std::path::PathBuf;
use std::process::Command;
use std::process::Output;
use std::str::FromStr;

/// Enumeration of wix-toolset options
///
/// This controls which wix build binaries are used by cargo-wix
#[derive(ValueEnum, Clone)]
pub enum Toolset {
    /// The default wix toolset uses "candle.exe" and "light.exe" to build the installer
    Legacy,
    /// Modern wix toolsets use just "wix.exe" to build the installer
    Modern,
    /// Test toolset, used to test code without needing any toolkit installed
    #[cfg(test)]
    #[clap(skip)]
    Test {
        is_legacy: bool,
        shim: test::SharedTestShim,
    },
}

impl std::fmt::Debug for Toolset {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Legacy => write!(f, "Legacy"),
            Self::Modern => write!(f, "Modern"),
            #[cfg(test)]
            Self::Test {
                is_legacy: allow_legacy,
                ..
            } => f.debug_tuple("Test").field(allow_legacy).finish(),
        }
    }
}

/// Wrapper over std::process::Command
///
/// Allows for checking args state and centralizes debug logging logic
pub struct ToolsetCommand {
    pub(crate) inner: Command,
    action: ToolsetAction,
    #[cfg(test)]
    test: Option<test::SharedTestShim>,
}

/// Enumeration of toolset actions used by this module
#[derive(Default, Debug)]
pub enum ToolsetAction {
    /// `candle`
    Compile { bin_path: Option<PathBuf> },
    /// `wix convert`
    Convert,
    /// `wix build`
    Build,
    /// `wix extension add`
    AddExtension,
    /// `wix extension add --global`
    AddGlobalExtension,
    /// `wix extension list`
    ListExtension,
    /// `wix extension list --global`
    ListGlobalExtension,
    /// `wix --version`
    #[default]
    Version,
}

/// Enumeration of wix-toolset project setup patterns that can be applied
///
/// WiX toolset project setup consists of two major-operations, **upgrade** or **restore**.
///
/// - **upgrade**: Convert Wix3 and below *.wxs files to the modern WiX format. Technically only needs to be executed once,
///   but the setup will try and do the smart thing and upgrade on an as-needed basis
/// - **restore**: Detect and install wix extensions required by *.wxs files. Requires all source files to be upgraded
///
/// The toolset setup mode indicates whether or not to apply `upgrade` and `restore`.
///
/// `upgrade` has the same behavior for all setup modes, however for `restore` there is the option of restoring extensions
/// in the current directory (vendoring) or restoring extensions globally.
#[derive(ValueEnum, Copy, Clone, Debug, Default)]
pub enum ToolsetSetupMode {
    /// Do not apply any setup logic. (Default)
    #[default]
    None,
    /// Setup project in "global" mode.
    ///
    /// Upgrade source files in place and install extensions to the global extension cache
    ///
    /// This option is suited to simple one file installer projects, where build pipeline network access will not be
    /// an issue and wix will likely be installed on a dev machine or during the build pipeline on demand.
    #[clap(name = "global")]
    Global,
    /// Setup project in "vendored" mode.
    ///
    /// Upgrade source files in place and install extensions to the current directory
    ///
    /// This option is suited to tracking changes with source version control systems such as git, and also when
    /// the build will happen in an offline environment
    #[clap(name = "vendor")]
    Vendor,
}

#[cfg(test)]
impl Toolset {
    /// Returns true if the toolset in use is legacy
    pub fn is_legacy(&self) -> bool {
        matches!(
            self,
            Toolset::Test {
                is_legacy: true,
                ..
            } | Toolset::Legacy
        )
    }

    pub fn is_modern(&self) -> bool {
        matches!(
            self,
            Toolset::Test {
                is_legacy: false,
                ..
            } | Toolset::Modern
        )
    }
}

impl Toolset {
    /// Returns true if the toolset in use is legacy
    #[cfg(not(test))]
    pub fn is_legacy(&self) -> bool {
        matches!(self, Toolset::Legacy)
    }

    /// Returns true if the toolset in use is modern
    #[cfg(not(test))]
    pub fn is_modern(&self) -> bool {
        matches!(self, Toolset::Modern)
    }

    /// Returns a new ToolsetCommand for `wix.exe`
    pub fn wix(&self, action: impl Into<ToolsetAction>) -> crate::Result<ToolsetCommand> {
        if self.is_modern() {
            #[cfg(test)]
            let mut command = ToolsetCommand::try_from(action.into())?;

            #[cfg(test)]
            if let Toolset::Test { shim, .. } = self {
                command.test = Some(shim.clone());
            }

            #[cfg(not(test))]
            let command = ToolsetCommand::try_from(action.into())?;
            Ok(command)
        } else {
            Err("Cannot use modern wix commands with legacy toolset".into())
        }
    }

    /// Returns a new ToolsetCommand for `candle.exe`
    pub fn compiler(&self, bin_path: Option<PathBuf>) -> crate::Result<ToolsetCommand> {
        if self.is_legacy() {
            #[cfg(test)]
            let mut command: ToolsetCommand = ToolsetAction::Compile { bin_path }.try_into()?;

            #[cfg(test)]
            if let Toolset::Test { shim, .. } = self {
                command.test = Some(shim.clone());
            }

            #[cfg(not(test))]
            let command: ToolsetCommand = ToolsetAction::Compile { bin_path }.try_into()?;
            Ok(command)
        } else {
            Err("Cannot use legacy wix commands with modern toolset".into())
        }
    }
}

impl ToolsetSetupMode {
    /// Returns a project and applies any required project setup required
    ///
    /// If vendor mode is enabled, this will ensure a local extension cache folder has been created
    ///
    /// If the current toolset setup mode is not `ToolsetSetupMode::None`, this will also apply project migration before returning the project
    #[inline]
    pub fn setup(
        &self,
        provider: &impl ProjectProvider,
        package: &Package,
        work_dir: Option<PathBuf>,
    ) -> crate::Result<Project> {
        if matches!(self, ToolsetSetupMode::Vendor) {
            debug!("Vendored mode is enabled, check for the local extension cache");
            let work_dir = work_dir.unwrap_or(std::env::current_dir()?);

            let local_ext_dir = work_dir.join(".wix").join("extensions");
            if !local_ext_dir.exists() {
                debug!("Vendored mode is enabled, check for the local extension cache");
                std::fs::create_dir_all(local_ext_dir)?;
            }
        }

        let mut project = provider.create_project(package)?;
        match self {
            ToolsetSetupMode::None => {}
            _ => {
                debug!("Starting project upgrade");
                project.upgrade(None)?;
                debug!("Restoring any missing extension packages");
                project.restore(self.use_global(), None)?;
            }
        }
        Ok(project)
    }

    /// Returns true if setup is enabled
    #[inline]
    pub fn is_enabled(&self) -> bool {
        !matches!(self, ToolsetSetupMode::None)
    }

    /// Returns true if the global extension package cache should be used
    #[inline]
    pub fn use_global(&self) -> bool {
        matches!(self, ToolsetSetupMode::Global)
    }
}

impl ToolsetCommand {
    /// Consumes this reference and returns the inner std::process::Command and configured toolset action
    pub fn split_into_std(self) -> (std::process::Command, ToolsetAction) {
        (self.inner, self.action)
    }

    /// Consumes the toolset command and returns the output
    #[allow(unused_mut)] // For test shim
    pub fn output(mut self) -> crate::Result<Output> {
        debug!("command.action={:?}", self.action);
        #[cfg(not(test))]
        let output = self.inner.output()?;

        #[cfg(test)]
        let output = self.test_output();

        if output.status.success() {
            if log::log_enabled!(log::Level::Debug) && !output.stderr.is_empty() {
                let std_err = String::from_utf8(output.stderr.clone())?;
                for line in std_err.lines() {
                    debug!("{line}");
                }
            }
            Ok(output)
        } else {
            if let ToolsetAction::Convert = self.action {
                // This is expected because `wix convert` will always return a non-zero exit code
                return Ok(output);
            }
            Err(match self.action {
                ToolsetAction::Convert => "(wix.exe) Could not convert wxs file",
                ToolsetAction::Build => "(wix.exe) Could not build installer",
                ToolsetAction::AddExtension => "(wix.exe) Could not add extension package to local cache",
                ToolsetAction::AddGlobalExtension => {
                    "(wix.exe) Could not add extension package to global cache"
                }
                ToolsetAction::ListExtension => {
                    "(wix.exe) Could not list installed extensions from local cache"
                }
                ToolsetAction::ListGlobalExtension => {
                    "(wix.exe) Could not list installed extensions from global cache"
                }
                ToolsetAction::Version => {
                    "(wix.exe) command was not found from PATH env, ensure a WiX4+ toolset is installed"
                }
                ToolsetAction::Compile { .. } => "(candle.exe) Could not compile wxs files",
            }
            .into())
        }
    }

    /// Test shim for converting test parameters into an output
    #[cfg(test)]
    fn test_output(&self) -> Output {
        if let Some(shim) = self.test.as_ref() {
            let test = shim.on_output(&self.action, &self.inner);

            #[cfg(windows)]
            use std::os::windows::process::ExitStatusExt;

            #[cfg(unix)]
            use std::os::unix::process::ExitStatusExt;

            let status = if test.success {
                std::process::ExitStatus::from_raw(0)
            } else {
                std::process::ExitStatus::from_raw(1)
            };

            Output {
                status,
                stdout: test.stdout.as_bytes().to_vec(),
                stderr: test.stderr.as_bytes().to_vec(),
            }
        } else {
            todo!()
        }
    }
}

impl Default for ToolsetCommand {
    fn default() -> Self {
        Self {
            inner: Command::new("wix"),
            action: ToolsetAction::Version,
            #[cfg(test)]
            test: None,
        }
    }
}

impl From<std::process::Command> for ToolsetCommand {
    fn from(value: std::process::Command) -> Self {
        let action = ToolsetAction::from(value.get_program().to_string_lossy().as_ref());

        ToolsetCommand {
            inner: value,
            action,
            #[cfg(test)]
            test: None,
        }
    }
}

impl FromStr for ToolsetCommand {
    type Err = crate::Error;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        ToolsetAction::from(s).try_into()
    }
}

impl<'a> From<&'a str> for ToolsetAction {
    fn from(s: &'a str) -> Self {
        match s {
            "candle.exe" | "candle" | "compile" => ToolsetAction::Compile { bin_path: None },
            "convert" => ToolsetAction::Convert,
            "build" => ToolsetAction::Build,
            "extension add" => ToolsetAction::AddExtension,
            "extension list" => ToolsetAction::ListExtension,
            "extension add --global" => ToolsetAction::AddGlobalExtension,
            "extension list --global" => ToolsetAction::ListGlobalExtension,
            _ => ToolsetAction::Version,
        }
    }
}

impl TryFrom<ToolsetAction> for ToolsetCommand {
    type Error = crate::Error;

    fn try_from(value: ToolsetAction) -> crate::Result<Self> {
        let mut command = ToolsetCommand::default();
        match value {
            ToolsetAction::Convert => {
                command.action = value;
                command.arg("convert");
                Ok(command)
            }
            ToolsetAction::Build => {
                command.action = value;
                command.arg("build");
                Ok(command)
            }
            ToolsetAction::AddExtension => {
                command.action = value;
                command.args(["extension", "add"]);
                Ok(command)
            }
            ToolsetAction::ListExtension => {
                command.action = value;
                command.args(["extension", "list"]);
                Ok(command)
            }
            ToolsetAction::AddGlobalExtension => {
                command.action = value;
                command.args(["extension", "add", "--global"]);
                Ok(command)
            }
            ToolsetAction::ListGlobalExtension => {
                command.action = value;
                command.args(["extension", "list", "--global"]);
                Ok(command)
            }
            ToolsetAction::Version => {
                command.action = value;
                command.arg("--version");
                Ok(command)
            }
            ToolsetAction::Compile { bin_path } => {
                if let Some(mut path) = bin_path.as_ref().map(|s| {
                    let mut p = PathBuf::from(s);
                    trace!(
                        "Using the '{}' path to the WiX Toolset's '{}' folder for the compiler",
                        p.display(),
                        BINARY_FOLDER_NAME
                    );
                    p.push(WIX_COMPILER);
                    p.set_extension(EXE_FILE_EXTENSION);
                    p
                }) {
                    if !path.exists() {
                        path.pop(); // Remove the `candle` application from the path
                        Err(crate::Error::Generic(format!(
                            "The compiler application ('{}') does not exist at the '{}' path specified via \
                            the '-b,--bin-path' command line argument. Please check the path is correct and \
                            the compiler application exists at the path.",
                            WIX_COMPILER,
                            path.display()
                        )))
                    } else {
                        Ok(ToolsetCommand {
                            inner: Command::new(path),
                            action: ToolsetAction::Compile { bin_path },
                            #[cfg(test)]
                            test: None,
                        })
                    }
                } else if let Some(mut path) = std::env::var_os(WIX_PATH_KEY).map(|s| {
                    let mut p = PathBuf::from(s);
                    trace!(
                        "Using the '{}' path to the WiX Toolset's '{}' folder for the compiler",
                        p.display(),
                        BINARY_FOLDER_NAME
                    );
                    p.push(BINARY_FOLDER_NAME);
                    p.push(WIX_COMPILER);
                    p.set_extension(EXE_FILE_EXTENSION);
                    p
                }) {
                    if !path.exists() {
                        path.pop(); // Remove the `candle` application from the path
                        Err(crate::Error::Generic(format!(
                            "The compiler application ('{}') does not exist at the '{}' path specified \
                             via the {} environment variable. Please check the path is correct and the \
                             compiler application exists at the path.",
                            WIX_COMPILER,
                            path.display(),
                            WIX_PATH_KEY
                        )))
                    } else {
                        Ok(ToolsetCommand {
                            inner: Command::new(path),
                            action: ToolsetAction::Compile { bin_path: None },
                            #[cfg(test)]
                            test: None,
                        })
                    }
                } else {
                    Ok(ToolsetCommand {
                        inner: Command::new(WIX_COMPILER),
                        action: ToolsetAction::Compile { bin_path: None },
                        #[cfg(test)]
                        test: None,
                    })
                }
            }
        }
    }
}

impl std::fmt::Debug for ToolsetCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ToolsetCommand")
            .field("inner", &self.inner)
            .field("action", &self.action)
            .finish()
    }
}

impl Deref for ToolsetCommand {
    type Target = std::process::Command;

    fn deref(&self) -> &Self::Target {
        &self.inner
    }
}

impl DerefMut for ToolsetCommand {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.inner
    }
}

#[cfg(test)]
mod tests {
    use serial_test::serial;

    use super::ToolsetAction;
    use super::test;
    use crate::toolset::ProjectProvider;
    use crate::toolset::Toolset;
    use crate::toolset::ToolsetSetupMode;
    use std::path::PathBuf;

    #[test]
    #[cfg(windows)]
    fn test_toolset_compiler_is_correct_with_defaults() {
        use std::{path::PathBuf, process::Command};

        use crate::{
            BINARY_FOLDER_NAME, EXE_FILE_EXTENSION, WIX_COMPILER, WIX_PATH_KEY,
            toolset::{Toolset, ToolsetAction},
        };

        let expected = Command::new(
            std::env::var_os(WIX_PATH_KEY)
                .map(|s| {
                    let mut p = PathBuf::from(s);
                    p.push(BINARY_FOLDER_NAME);
                    p.push(WIX_COMPILER);
                    p.set_extension(EXE_FILE_EXTENSION);
                    p
                })
                .unwrap(),
        );
        let e = Toolset::Legacy.compiler(None).unwrap();
        let (actual, action) = e.split_into_std();
        assert_eq!(format!("{actual:?}"), format!("{expected:?}"));
        assert!(
            matches!(action, ToolsetAction::Compile { bin_path: None }),
            "{action:?}"
        );
    }

    #[test]
    fn test_toolset_wix_action() {
        let toolset =
            super::test::toolset(
                |action: &ToolsetAction, _: &std::process::Command| match action {
                    ToolsetAction::Compile { .. } => test::fail_stdout("out"),
                    ToolsetAction::Convert => test::ok_stdout("converted"),
                    ToolsetAction::Build => test::ok_stdout("built"),
                    ToolsetAction::AddExtension => test::ok_stdout("added"),
                    ToolsetAction::AddGlobalExtension => test::ok_stdout("added_global"),
                    ToolsetAction::ListExtension => test::ok_stdout("list_ext"),
                    ToolsetAction::ListGlobalExtension => test::ok_stdout("list_global_ext"),
                    ToolsetAction::Version => test::ok_stdout("version"),
                },
            );

        let output = toolset.wix("convert").unwrap();
        assert_eq!(&b"converted"[..], &output.output().unwrap().stdout[..]);

        let output = toolset.wix("build").unwrap();
        assert_eq!(&b"built"[..], &output.output().unwrap().stdout[..]);

        let output = toolset.wix("extension add").unwrap();
        assert_eq!(&b"added"[..], &output.output().unwrap().stdout[..]);

        let output = toolset.wix("extension add --global").unwrap();
        assert_eq!(&b"added_global"[..], &output.output().unwrap().stdout[..]);

        let output = toolset.wix("extension list").unwrap();
        assert_eq!(&b"list_ext"[..], &output.output().unwrap().stdout[..]);

        let output = toolset.wix("extension list --global").unwrap();
        assert_eq!(
            &b"list_global_ext"[..],
            &output.output().unwrap().stdout[..]
        );

        let output = toolset.wix("--version").unwrap();
        assert_eq!(&b"version"[..], &output.output().unwrap().stdout[..]);

        let output = toolset.wix("--version").unwrap();
        assert_eq!(&b"version"[..], &output.output().unwrap().stdout[..]);

        toolset.compiler(None).expect_err(
            "should not be allowed to create a compiler command if toolset is not legacy",
        );
    }

    #[test]
    fn test_toolset_legacy_action() {
        let toolset =
            super::test::legacy_toolset(|action: &ToolsetAction, _: &std::process::Command| {
                match action {
                    ToolsetAction::Compile { bin_path: None } => {
                        test::ok_stdout("compile_bin_path_none")
                    }
                    ToolsetAction::Compile { bin_path: Some(..) } => {
                        unreachable!("should fail before this can be executed")
                    }
                    _ => {
                        panic!("should not execute non-legacy actions")
                    }
                }
            });

        let output = toolset.compiler(None).unwrap();
        assert_eq!(
            &b"compile_bin_path_none"[..],
            &output.output().unwrap().stdout[..]
        );

        toolset
            .compiler(Some(PathBuf::new()))
            .expect_err("should not have candle in an empty dir");
    }

    #[test]
    fn test_toolset_fmt_debug() {
        assert_eq!("Legacy", format!("{:?}", Toolset::Legacy));
        assert_eq!("Modern", format!("{:?}", Toolset::Modern));
    }

    #[test]
    fn test_toolset_wix_command_err_on_modern() {
        Toolset::Legacy
            .wix(ToolsetAction::Version)
            .expect_err("should not be able to use modern actions with legacy toolset");
    }

    #[test]
    #[serial]
    fn test_toolset_migrate_global_mode() {
        let test_toolset = super::project::tests::TestProject::new(
            stringify!(test_toolset_setup_mode_migrate),
            "well_known_exts",
        );
        let project = ToolsetSetupMode::Global
            .setup(
                &test_toolset,
                &test_toolset.package,
                test_toolset.work_dir(),
            )
            .expect("should work");
        assert!(
            !test_toolset
                .work_dir()
                .unwrap()
                .join(".wix")
                .join("extensions")
                .exists(),
            "Ensure local extension cache was not created, since global uses global extension cache"
        );
        for s in project.sources() {
            // Check source was upgraded
            assert!(s.is_modern());
        }
    }

    #[test]
    #[serial]
    fn test_toolset_migrate_vendor_mode() {
        let test_toolset = super::project::tests::TestProject::new(
            stringify!(test_toolset_migrate_vendor_mode),
            "well_known_exts",
        );
        let project = ToolsetSetupMode::Vendor
            .setup(
                &test_toolset,
                &test_toolset.package,
                test_toolset.work_dir(),
            )
            .expect("should work");
        assert!(
            test_toolset
                .work_dir()
                .unwrap()
                .join(".wix")
                .join("extensions")
                .exists(),
            "Must create local wix extension cache in vendor mode"
        );

        for s in project.sources() {
            // Check source was upgraded
            assert!(s.is_modern());
        }
    }
}


================================================
FILE: src/toolset/project.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//! # Project Module
//!
//! This module orchestrates project state hydration by analyzing *.wxs files and
//! determining the current wix toolset installation state.
//!
//! The `Project` type is the entrypoint for all major utilities provided by the toolset module.

use crate::create::InstallerKind;
use crate::toolset::ToolsetCommand;

use super::source::WixSource;
use super::{Toolset, ext::PackageCache};
use clap::ValueEnum;
use log::debug;
use std::collections::BTreeSet;
use std::{collections::BTreeMap, path::PathBuf};
use sxd_xpath::{Context, Factory, Value, evaluate_xpath};

/// Wix3 XML Namespace URI
const LEGACY_NAMESPACE_URI: &str = "http://schemas.microsoft.com/wix/2006/wi";

/// Wix4+ XML Namespace URI
pub const V4_NAMESPACE_URI: &str = "http://wixtoolset.org/schemas/v4/wxs";

/// XPATH query for the root `<Wix/>` element
const WIX_ROOT_ELEMENT_XPATH: &str = "/*[local-name()='Wix']";

const WIX_PACKAGE_ROOT_ELEMENT_XPATH: &str = "//w:Package";

/// Enumerations of wix wxs schemas
#[derive(Debug, Clone, Copy, ValueEnum, PartialEq)]
pub enum WxsSchema {
    /// Wix3 is not compatible with Wix4 and must always be upgraded
    #[clap(name = "2006")]
    Legacy,
    /// Wix4, Wix5 these versions are backwards compatible and share the same namespace
    ///
    /// If the V4 namespace is detected, then a wxs format upgrade is not required
    #[clap(name = "v4")]
    V4,
    /// Unsupported wxs schema
    #[clap(skip)]
    Unsupported,
}

/// Opens a .wxs source from path and identifies the version
pub fn open_wxs_source(path: PathBuf) -> crate::Result<WixSource> {
    let source = std::fs::read_to_string(&path)?;

    // If this isn't set correctly, wix convert will **SILENTLY** fail. Throw an error so that the user can go and fix these files manually
    if source.contains("<?xml version='1.0' encoding='windows-1252'?>") {
        return Err(format!("Source file {path:?} has an xml header with encoding `windows-1252`. This must be changed to `utf-8` otherwise subsequent tooling will silently fail.").as_str().into());
    }

    debug!("Trying to parse xml document");
    let package = sxd_document::parser::parse(source.trim_start_matches('\u{FEFF}'))?;
    let document = package.as_document();

    let root = evaluate_xpath(&document, WIX_ROOT_ELEMENT_XPATH)?;
    match root {
        Value::Nodeset(ns) => {
            if let Some((default, exts)) = ns
                .document_order_first()
                .and_then(|e| e.element())
                .map(|e| (e.default_namespace_uri(), e.namespaces_in_scope()))
            {
                let exts = exts
                    .iter()
                    .filter(|e| e.prefix() != "xml")
                    .map(super::ext::WxsDependency::from)
                    .collect();

                let wix_version = match default {
                    Some(LEGACY_NAMESPACE_URI) => WxsSchema::Legacy,
                    Some(V4_NAMESPACE_URI) => WxsSchema::V4,
                    _ => WxsSchema::Unsupported,
                };

                // Check if this .wxs file is a "package"
                let is_package = match default {
                    Some(ns) => {
                        let mut context = Context::new();
                        context.set_namespace("w", ns);
                        let factory = Factory::new();
                        if let Ok(Some(xpath)) = factory.build(WIX_PACKAGE_ROOT_ELEMENT_XPATH) {
                            let value = xpath.evaluate(&context, document.root())?;
                            matches!(value, Value::Nodeset(ns) if ns.size() > 0)
                        } else {
                            false
                        }
                    }
                    _ => false,
                };
                Ok(WixSource {
                    is_package,
                    wxs_schema: wix_version,
                    path,
                    exts,
                    toolset: if matches!(wix_version, WxsSchema::Legacy) {
                        Toolset::Legacy
                    } else {
                        Toolset::Modern
                    },
                })
            } else {
                Err("Corrupted .wxs file".into())
            }
        }
        _ => Err("Invalid .wxs file".into()),
    }
}

/// Context wix project related information such as the current toolset version, *.wxs files, and installed extension packages in scope
#[derive(Debug)]
pub struct Project {
    /// Current version of `wix` command
    wix_version: semver::Version,
    /// Paths to all wxs sources
    wxs_sources: BTreeMap<PathBuf, WixSource>,
    /// Extension package cache
    package_cache: PackageCache,
    /// Toolset
    toolset: Toolset,
}

impl Project {
    /// Tries to create a new WiX project context
    ///
    /// Returns an error if the modern wix toolset is not installed
    #[inline]
    pub fn try_new(toolset: Toolset) -> crate::Result<Self> {
        let wix_version_output = toolset.wix("--version")?.output()?;

        if wix_version_output.status.success() && !wix_version_output.stdout.is_empty() {
            let output = String::from_utf8(wix_version_output.stdout)?;

            let version = semver::Version::parse(output.trim())?;

            let mut upgrade = Self {
                wix_version: version,
                wxs_sources: BTreeMap::new(),
                package_cache: PackageCache::from(toolset.clone()),
                toolset,
            };

            upgrade.load_ext_cache()?;
            Ok(upgrade)
        } else {
            Err("wix.exe could not be found from PATH. Ensure that WiX4+ is installed.".into())
        }
    }

    /// Configures a toolset command from project state
    #[inline]
    pub fn configure_toolset_extensions(&self, toolset: &mut ToolsetCommand) -> crate::Result<()> {
        // Find all Wix extensions being used
        let ext_flags = self
            .sources()
            .flat_map(|s| s.exts.iter().map(|e| e.package_name()))
            .fold(BTreeSet::new(), |mut acc, p| {
                acc.insert(p);
                acc
            });

        // Apply all required `-ext` flags to toolset command
        for ext in ext_flags.iter() {
            debug!("Adding WiX extension flag: -ext {}", ext);
            toolset.args(["-ext", ext]);
        }

        Ok(())
    }

    /// Adds a *.wxs source to the upgrade context
    ///
    /// Analyzes the *.wxs file to determine if the source requires conversion
    ///
    /// Returns an error if the *.wxs file is not valid XML
    #[inline]
    pub fn add_wxs(&mut self, source: PathBuf) -> crate::Result<()> {
        if let std::collections::btree_map::Entry::Vacant(e) =
            self.wxs_sources.entry(source.clone())
        {
            debug!("Opening and parsing wxs source file to insert into project");
            let mut wix_source = open_wxs_source(source)?;
            wix_source.toolset = self.toolset.clone();
            debug!("Inserting wix_source={wix_source:?}");
            e.insert(wix_source);
        }
        Ok(())
    }

    /// Converts all of the source files that are part of the upgrade
    ///
    /// If a target directory is provided, none of the original source files will be updated.
    /// Returns an error if multiple source files share the same file name under different
    /// directories, since the work_dir copy would cause collisions.
    #[inline]
    pub fn upgrade(&mut self, work_dir: Option<&PathBuf>) -> crate::Result<()> {
        if work_dir.is_some() {
            // Check for duplicate file names across different directories
            let mut seen: BTreeMap<std::ffi::OsString, &std::path::Path> = BTreeMap::new();
            for path in self.wxs_sources.keys() {
                if let Some(name) = path.file_name() {
                    if let Some(prev) = seen.get(name) {
                        return Err(crate::Error::Generic(format!(
                            "Multiple WiX source files share the file name '{}' \
                             (found in '{}' and '{}'). The migrate command does not support \
                             duplicate file names across different directories. Please rename \
                             one of the files before running migrate.",
                            name.to_string_lossy(),
                            prev.display(),
                            path.display(),
                        )));
                    }
                    seen.insert(name.to_os_string(), path.as_path());
                }
            }
        }

        let mut converted = BTreeMap::new();
        for (path, src) in self.wxs_sources.iter().collect::<Vec<_>>() {
            if src.can_upgrade() {
                log::debug!("Upgrading {path:?}");
                // Upgrade will not modify the original file if a work_dir is provided
                let converted_src = src.upgrade(work_dir)?;

                // Finds missing dependencies in the package cache
                converted_src.check_deps(&mut self.package_cache);

                // If target_dir is enabled, conversion will not modify the original files and will instead
                // convert and copy the files to the target_dir
                converted.insert(converted_src.path.clone(), converted_src);
            } else {
                log::debug!("Skipping upgrade for {path:?}");
                if src.is_modern() {
                    // Finds missing dependencies in the package cache
                    src.check_deps(&mut self.package_cache);
                }
            }
        }

        // Update the state of the current set of sources
        self.wxs_sources = converted;
        Ok(())
    }

    /// Restores any missing extensions
    #[inline]
    pub fn restore(&mut self, use_global: bool, work_dir: Option<&PathBuf>) -> crate::Result<()> {
        self.package_cache
            .install_missing(use_global, self.wix_version.clone(), work_dir)?;
        Ok(())
    }

    /// Returns an iterator over wix sources
    #[inline]
    pub fn sources(&self) -> impl Iterator<Item = &WixSource> {
        self.wxs_sources.values()
    }

    /// Returns the number of package sources (wxs files that define a `<Package>`)
    #[inline]
    pub fn package_count(&self) -> usize {
        self.wxs_sources.values().filter(|s| s.is_package).count()
    }

    /// Determines whether the project produces a bundle (.exe) or a package (.msi)
    ///
    /// If any source uses the bootstrapper applications (bal) namespace, this is a bundle.
    /// Otherwise it defaults to an MSI package.
    #[inline]
    pub fn is_bundle(&self) -> bool {
        self.wxs_sources.values().any(|s| s.is_bundle())
    }

    /// Returns the installer kind for this project (Exe for bundles, Msi otherwise)
    #[inline]
    pub fn installer_kind(&self) -> InstallerKind {
        if self.is_bundle() {
            InstallerKind::Exe
        } else {
            InstallerKind::Msi
        }
    }

    /// Load installed ext cache
    #[inline]
    fn load_ext_cache(&mut self) -> crate::Result<()> {
        fn build_package_cache(
            output: std::process::Output,
            cache: &mut PackageCache,
        ) -> crate::Result<()> {
            if output.status.success() {
                let std_out = String::from_utf8(output.stdout)?;

                for (package_name, version) in std_out
                    .lines()
                    // If the current wix version doesn't match the extension that is installed, it will append "(damaged)"
                    .filter(|l| !l.trim().ends_with("(damaged)"))
                    .filter_map(|l| l.split_once(' '))
                {
                    if let Ok(version) = semver::Version::parse(version) {
                        cache.add(package_name, version);
                    }
                }

                Ok(())
            } else {
                Err("Could not load installed WiX extensions".into())
            }
        }

        match self.toolset.wix("extension list")?.output() {
            Ok(wix_ext_list) => {
                build_package_cache(wix_ext_list, &mut self.package_cache)?;
            }
            Err(err) => {
                // If this returns an error check to see if a local extension cache exists
                // Docs: https://docs.firegiant.com/wix/development/wips/6184-command-line-extension-acquisition-and-cache/
                // The path is always .wix\extensions in the current directory
                if std::env::current_dir()?
                    .join(".wix")
                    .join("extensions")
                    .exists()
                {
                    log::error!("Could not list extensions {err}");
                    return Err("Listing local extensions failed".into());
                }
            }
        }

        let wix_ext_list_global = self.toolset.wix("extension list --global")?.output()?;
        build_package_cache(wix_ext_list_global, &mut self.package_cache)?;

        Ok(())
    }
}

#[cfg(test)]
pub(crate) mod tests {
    use assert_fs::TempDir;
    use cargo_metadata::Package;

    use super::Project;
    use crate::{
        tests::setup_project,
        toolset::{
            Includes, ProjectProvider, Toolset, ToolsetAction,
            ext::{WellKnownExtentions, WixExtension},
            project::{WxsSchema, open_wxs_source},
            source::WixSource,
            test::{self, ok_stdout},
        },
    };
    use serial_test::serial;
    use std::{collections::BTreeSet, path::PathBuf};

    #[test]
    fn test_open_wxs() {
        let main = open_wxs_source(PathBuf::from("./tests/common/post_v4/main.wxs"))
            .expect("must be able to open wxs file");
        assert!(main.is_package);

        let fragment = open_wxs_source(PathBuf::from("./tests/common/post_v4/fragment.wxs"))
            .expect("must be able to open wxs file");
        assert!(!fragment.is_package);
    }

    #[test]
    fn test_project_create() {
        let shim = test::toolset(|a: &ToolsetAction, _: &std::process::Command| match a {
            ToolsetAction::ListExtension => ok_stdout("WixToolset.PowerShell.wixext 0.0.0"),
            ToolsetAction::ListGlobalExtension => ok_stdout("WixToolset.VisualStudio.wixext 0.0.0"),
            ToolsetAction::Version => ok_stdout("0.0.0"),
            _ => {
                unreachable!("Should only be executing version and list actions")
            }
        });

        let project = Project::try_new(shim).unwrap();
        assert!(
            project
                .package_cache
                .installed(&WellKnownExtentions::Powershell)
        );
        assert!(project.package_cache.installed(&WellKnownExtentions::VS));
    }

    #[test]
    fn test_project_upgrade() {
        let test_toolset = TestProject::new(stringify!(test_project_upgrade), "post_v4");
        let mut project = test_toolset.create_project(&test_toolset.package).unwrap();
        project
            .upgrade(test_toolset.work_dir().as_ref())
            .expect("should be able to convert");

        let missing = project
            .package_cache
            .iter_missing()
            .next()
            .expect("should have a missing package");
        assert_eq!("WixToolset.UI.wixext", missing);
    }

    #[test]
    fn test_project_upgrade_extension_detection() {
        let test_toolset = TestProject::new(
            stringify!(test_project_upgrade_extension_detection),
            "well_known_exts",
        );
        let mut project = test_toolset.create_project(&test_toolset.package).unwrap();
        project
            .upgrade(test_toolset.work_dir().as_ref())
            .expect("should be able to convert");

        let test_wxs = test_toolset
            .work_dir()
            .unwrap()
            .join("main.test_project_upgrade_extension_detection.wxs");
        let wxs_source = project
            .wxs_sources
            .get(&test_wxs)
            .expect("should have been added to the project");

        assert_eq!(WxsSchema::V4, wxs_source.wxs_schema);
        assert_eq!(test_wxs, wxs_source.path);
        assert!(wxs_source.toolset.is_modern());
        validate_wxs_ext(wxs_source, WellKnownExtentions::BootstrapperApplications);
        validate_wxs_ext(wxs_source, WellKnownExtentions::ComPlus);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Dependency);
        validate_wxs_ext(wxs_source, WellKnownExtentions::DirectX);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Firewall);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Http);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Iis);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Msmq);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Netfx);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Powershell);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Sql);
        validate_wxs_ext(wxs_source, WellKnownExtentions::UI);
        validate_wxs_ext(wxs_source, WellKnownExtentions::Util);
        validate_wxs_ext(wxs_source, WellKnownExtentions::VS);
    }

    pub fn validate_wxs_ext(source: &WixSource, ext: impl WixExtension) {
        assert!(
            source
                .exts
                .iter()
                .find(|e| e.package_name() == ext.package_name()
                    && e.namespace_prefix() == ext.namespace_prefix()
                    && e.namespace_uri() == ext.namespace_uri())
                .is_some()
        );
    }

    pub struct TestProject {
        test_dir: TempDir,
        expected_wxs_name: &'static str,
        includes: Vec<PathBuf>,
        pub(crate) package: Package,
    }
    const MIN_MANIFEST: &str = r#"[package]
            name = "Example"
            version = "0.1.0"
            authors = ["First Last <first.last@example.com>"]
        "#;

    impl TestProject {
        /// Creates a new test toolset
        pub fn new(test_name: &str, expected_wxs_name: &'static str) -> Self {
            let project = setup_project(MIN_MANIFEST);
            let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
            let package = crate::package(&manifest, None).unwrap();
            let test_dir = project.path().to_path_buf();
            let test_src_file_name = format!("main.{test_name}.wxs");
            let test_src = test_dir.join(test_src_file_name);
            std::fs::copy(
                PathBuf::from("tests")
                    .join("common")
                    .join("pre_v4")
                    .join("main.wxs"),
                &test_src,
            )
            .unwrap();
            Self {
                test_dir: project,
                expected_wxs_name,
                includes: vec![test_src],
                package,
            }
        }
    }

    impl Includes for TestProject {
        fn includes(&self) -> Option<&Vec<PathBuf>> {
            Some(&self.includes)
        }
    }

    impl ProjectProvider for TestProject {
        fn work_dir(&self) -> Option<PathBuf> {
            Some(self.test_dir.path().to_path_buf().clone())
        }

        fn toolset(&self) -> Toolset {
            const PACKAGES: &[&str] = &[
                "WixToolset.BootstrapperApplications.wixext/0.0.0",
                "WixToolset.ComPlus.wixext/0.0.0",
                "WixToolset.Dependency.wixext/0.0.0",
                "WixToolset.DirectX.wixext/0.0.0",
                "WixToolset.Firewall.wixext/0.0.0",
                "WixToolset.Http.wixext/0.0.0",
                "WixToolset.Iis.wixext/0.0.0",
                "WixToolset.Msmq.wixext/0.0.0",
                "WixToolset.Netfx.wixext/0.0.0",
                "WixToolset.PowerShell.wixext/0.0.0",
                "WixToolset.Sql.wixext/0.0.0",
                "WixToolset.UI.wixext/0.0.0",
                "WixToolset.Util.wixext/0.0.0",
                "WixToolset.VisualStudio.wixext/0.0.0",
            ];

            let expected_wxs_name = self.expected_wxs_name;
            // Define test shim to do the "conversion" which is copying over a pre-baked converted file
            test::toolset(
                move |a: &ToolsetAction, cmd: &std::process::Command| match a {
                    ToolsetAction::Convert => {
                        let args = cmd.get_args();
                        let dest = args.last().expect("should be the dest");

                        std::fs::copy(
                            PathBuf::from("tests")
                                .join("common")
                                .join(expected_wxs_name)
                                .join("main.wxs"),
                            PathBuf::from(dest),
                        )
                        .unwrap();
                        ok_stdout("")
                    }
                    ToolsetAction::AddGlobalExtension => {
                        let args = cmd.get_args().map(|a| a.to_string_lossy().to_string());
                        let args = BTreeSet::from_iter(args);
                        assert!(PACKAGES.iter().all(|p| args.contains(*p)));
                        ok_stdout("")
                    }
                    ToolsetAction::AddExtension => {
                        let args = cmd.get_args().map(|a| a.to_string_lossy().to_string());
                        let args = BTreeSet::from_iter(args);
                        assert!(PACKAGES.iter().all(|p| args.contains(*p)));
                        ok_stdout("")
                    }
                    ToolsetAction::ListExtension => ok_stdout(""),
                    ToolsetAction::ListGlobalExtension => ok_stdout(""),
                    ToolsetAction::Version => ok_stdout("0.0.0"),
                    a => {
                        unreachable!("Unexpected action, tried to execute {a:?}")
                    }
                },
            )
        }
    }

    #[test]
    fn test_project_package_count() {
        let test_toolset = TestProject::new(stringify!(test_project_package_count), "post_v4");
        let project = test_toolset.create_project(&test_toolset.package).unwrap();
        // The includes list only has the pre_v4 source (no <Package> element)
        assert_eq!(0, project.package_count());
    }

    #[test]
    fn test_project_installer_kind_msi() {
        let test_toolset = TestProject::new(stringify!(test_project_installer_ext_msi), "post_v4");
        let project = test_toolset.create_project(&test_toolset.package).unwrap();
        // post_v4 has no bal namespace, so should produce msi
        assert_eq!(crate::create::InstallerKind::Msi, project.installer_kind());
        assert!(!project.is_bundle());
    }

    #[test]
    fn test_project_installer_extension_from_well_known_exts() {
        // Open well_known_exts directly (which has bal namespace) and verify is_bundle
        let source = open_wxs_source(PathBuf::from("./tests/common/well_known_exts/main.wxs"))
            .expect("must be able to open wxs file");
        assert!(
            source.is_bundle(),
            "well_known_exts has bal namespace and should be a bundle"
        );
    }

    #[test]
    #[serial]
    fn test_upgrade_duplicate_filenames_errors() {
        let project = setup_project(MIN_MANIFEST);
        let manifest = crate::manifest(Some(&project.path().join("Cargo.toml"))).unwrap();
        let package = crate::package(&manifest, None).unwrap();
        let test_dir = project.path().to_path_buf();

        // Create two wxs files with the same name under different subdirs
        let sub_a = test_dir.join("a");
        let sub_b = test_dir.join("b");
        std::fs::create_dir_all(&sub_a).unwrap();
        std::fs::create_dir_all(&sub_b).unwrap();

        let src_a = sub_a.join("main.wxs");
        let src_b = sub_b.join("main.wxs");
        std::fs::copy(
            PathBuf::from("tests")
                .join("common")
                .join("pre_v4")
                .join("main.wxs"),
            &src_a,
        )
        .unwrap();
        std::fs::copy(
            PathBuf::from("tests")
                .join("common")
                .join("pre_v4")
                .join("main.wxs"),
            &src_b,
        )
        .unwrap();

        struct DupProvider {
            includes: Vec<PathBuf>,
            work_dir: PathBuf,
        }
        impl Includes for DupProvider {
            fn includes(&self) -> Option<&Vec<PathBuf>> {
                Some(&self.includes)
            }
        }
        impl ProjectProvider for DupProvider {
            fn work_dir(&self) -> Option<PathBuf> {
                Some(self.work_dir.clone())
            }
            fn toolset(&self) -> Toolset {
                test::toolset(|a: &ToolsetAction, _: &std::process::Command| match a {
                    ToolsetAction::ListExtension => ok_stdout(""),
                    ToolsetAction::ListGlobalExtension => ok_stdout(""),
                    ToolsetAction::Version => ok_stdout("0.0.0"),
                    _ => ok_stdout(""),
                })
            }
        }

        let provider = DupProvider {
            includes: vec![src_a, src_b],
            work_dir: test_dir.clone(),
        };
        let mut proj = provider.create_project(&package).unwrap();
        let result = proj.upgrade(Some(&test_dir));
        assert!(
            result.is_err(),
            "Should error on duplicate file names with work_dir"
        );
        let err = format!("{}", result.unwrap_err());
        assert!(
            err.contains("duplicate file names"),
            "Error message should mention duplicate file names, got: {err}"
        );
    }

    #[test]
    fn test_project_package_count_multiple() {
        // Create a project with two wxs files that both define <Package>
        let test_toolset = TestProject::new(stringify!(test_project_pkg_count_multi), "post_v4");
        let mut project = test_toolset.create_project(&test_toolset.package).unwrap();

        // Add two sources that have <Package>
        let first_pkg = open_wxs_source(PathBuf::from("./tests/common/post_v4/main.wxs"))
            .expect("must be able to open wxs file");
        assert!(first_pkg.is_package);
        let second_pkg = open_wxs_source(PathBuf::from("./tests/common/post_v4/main.wxs"))
            .expect("must be able to open wxs file");
        assert!(second_pkg.is_package);

        project
            .wxs_sources
            .insert(PathBuf::from("first_main.wxs"), first_pkg);
        project
            .wxs_sources
            .insert(PathBuf::from("second_main.wxs"), second_pkg);
        assert_eq!(2, project.package_count());
    }

    #[test]
    fn test_project_fragment_only_has_zero_packages() {
        // A project with only fragment sources should have package_count == 0
        let test_toolset = TestProject::new(stringify!(test_project_fragment_only), "post_v4");
        let mut project = test_toolset.create_project(&test_toolset.package).unwrap();

        // Replace all sources with just a fragment (no <Package>)
        project.wxs_sources.clear();
        let fragment = open_wxs_source(PathBuf::from("./tests/common/post_v4/fragment.wxs"))
            .expect("must be able to open wxs file");
        assert!(!fragment.is_package, "fragment.wxs should not be a package");
        project
            .wxs_sources
            .insert(PathBuf::from("fragment.wxs"), fragment);

        assert_eq!(0, project.package_count());
        assert!(!project.is_bundle());
        // This is the condition that triggers the "no Package or Bundle" error in create.rs
        assert_eq!(crate::create::InstallerKind::Msi, project.installer_kind());
    }

    #[test]
    fn test_project_bundle_installer_kind() {
        // A project with a bal-namespace source should return InstallerKind::Exe
        let test_toolset = TestProject::new(stringify!(test_project_bundle_kind), "post_v4");
        let mut project = test_toolset.create_project(&test_toolset.package).unwrap();

        // Replace sources with well_known_exts which has bal namespace
        project.wxs_sources.clear();
        let bundle = open_wxs_source(PathBuf::from("./tests/common/well_known_exts/main.wxs"))
            .expect("must be able to open wxs file");
        project
            .wxs_sources
            .insert(PathBuf::from("bundle.wxs"), bundle);

        assert!(project.is_bundle());
        assert_eq!(crate::create::InstallerKind::Exe, project.installer_kind());
    }
}


================================================
FILE: src/toolset/source.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use log::{debug, error, trace, warn};

use super::Toolset;
use super::ext::{PackageCache, WxsDependency};
use super::project::{WxsSchema, open_wxs_source};
use std::ffi::OsStr;
use std::path::PathBuf;

/// Struct containing information about a wxs source file
pub struct WixSource {
    /// WiX toolset version
    pub(super) wxs_schema: WxsSchema,
    /// Path to this *.wxs file
    pub(super) path: PathBuf,
    /// Extensions this wix source is dependent on
    pub(super) exts: Vec<WxsDependency>,
    /// Toolset this source is using
    pub(super) toolset: Toolset,
    /// True if this source defines a package
    pub(super) is_package: bool,
}

impl WixSource {
    /// Returns true if the format of this *.wxs source can be upgraded
    pub fn can_upgrade(&self) -> bool {
        match (self.wxs_schema, &self.toolset) {
            (WxsSchema::Legacy, Toolset::Modern) => true,
            #[cfg(test)]
            (
                WxsSchema::Legacy,
                Toolset::Test {
                    is_legacy: false, ..
                },
            ) => true,
            _ => false,
        }
    }

    /// Returns true if this source is in the modern format
    ///
    /// This is relevant because in the modern formats, extensions are namespaced. Knowing
    /// if the wxs format is "modern" indicates that extensions can be derived programatically.
    pub fn is_modern(&self) -> bool {
        matches!(self.wxs_schema, WxsSchema::V4)
    }

    /// Returns true if this source uses the bootstrapper applications (bal) namespace,
    /// indicating it produces a bundle (.exe) rather than an MSI package.
    ///
    /// The `bal` (WixBalExtension) namespace is required for bootstrapper bundles,
    /// so its presence reliably indicates a bundle.
    pub fn is_bundle(&self) -> bool {
        self.exts.iter().any(|e| e.namespace_prefix() == "bal")
    }

    /// Checks that the dependencies required by this *.wxs file exist in the package cache
    pub fn check_deps(&self, package_cache: &mut PackageCache) {
        for ext in self
            .exts
            .iter()
            .filter(|e| !package_cache.installed(*e))
            .collect::<Vec<_>>()
        {
            // Package names are known ahead of time because they map to a well known extension uri
            // If a package name returns as empty, it means that tooling is not aware of it
            if !ext.package_name().is_empty() {
                debug!(
                    "Missing extension, xmlns:{}='{}'",
                    ext.namespace_prefix(),
                    ext.namespace_uri()
                );
                package_cache.add_missing(ext.package_name());
            } else {
                warn!(
                    "Unknown extension, xmlns:{}='{}'",
                    ext.namespace_prefix(),
                    ext.namespace_uri()
                );
            }
        }
    }

    /// Upgrades the current wix source file using `wix convert` if applicable
    ///
    /// Returns an updated WixSource object if the conversion and dependent ext install is successful
    pub fn upgrade(&self, work_dir: Option<&PathBuf>) -> crate::Result<Self> {
        let mut convert = self.toolset.wix("convert")?;
        let converted_path = if work_dir.is_some() {
            // If a work dir is specified, do not modify the input file directly
            let temp = std::env::temp_dir().join(
                self.path
                    .file_name()
                    .expect("should have a file name because requires opening to create type"),
            );
            std::fs::copy(&self.path, &temp)?;
            convert.arg(&temp);
            temp
        } else {
            convert.arg(&self.path);
            self.path.clone()
        };

        let content = std::fs::read_to_string(&converted_path)?;
        let has_bom = content.starts_with('\u{FEFF}');

        let output = convert.output()?;

        if !output.status.success() {
            // This is expected, `wix convert`` decided to always return a non-zero exit code because
            // it will output a log of the changes it made
            if log::log_enabled!(log::Level::Debug) && !output.stderr.is_empty() {
                let std_err = String::from_utf8(output.stderr.clone())?;
                for line in std_err.lines() {
                    debug!("{line}");
                }
            }
        }

        // The converted_path must be a valid file name
        let converted_path =
            if let Some((work_dir, file_name)) = work_dir.zip(converted_path.file_name()) {
                let dest = work_dir.join(file_name);
                std::fs::copy(converted_path, &dest)?;
                dest
            } else {
                converted_path
            };
        if !has_bom {
            // Strip the BOM if the previous file did not have a BOM
            let content = std::fs::read_to_string(&converted_path)?;
            let has_bom = content.starts_with('\u{FEFF}');
            if has_bom {
                debug!(
                    "Detected BOM, previous file did not have a BOM, removing to preserve tooling"
                );
                std::fs::write(&converted_path, content.trim_start_matches('\u{FEFF}'))?;
            }
        }
        open_wxs_source(converted_path)
    }

    pub fn try_move_to_installer_destination(
        &self,
        name: &str,
        version: &str,
        cfg: &rustc_cfg::Cfg,
        debug_name: bool,
        target_directory: &std::path::Path,
        output: Option<&String>,
    ) -> crate::Result<()> {
        if !self.is_package {
            return Ok(());
        }

        // Won't know the extension until we scan for the file
        // Capture what we need to do to create the filename
        // TODO: This would have been easier to just use PathBuf::add_extension, but it requires 1.91
        let file_name_with_ext = |ext: &str| -> PathBuf {
            let name = if self.is_main() {
                name
            } else {
                self.path
                    .file_stem()
                    .and_then(|f| f.to_str())
                    .unwrap_or(name)
            };
            let filename = if debug_name {
                format!("{}-{}-{}-debug.{}", name, version, cfg.target_arch, ext)
            } else {
                format!("{}-{}-{}.{}", name, version, cfg.target_arch, ext)
            };
            if let Some(path_str) = output {
                trace!("Using the explicitly specified output path for the MSI destination");
                let path = std::path::Path::new(path_str);
                if path_str.ends_with('/') || path_str.ends_with('\\') || path.is_dir() {
                    path.join(filename)
                } else {
                    path.to_owned()
                }
            } else {
                trace!(
                    "Using the package's manifest (Cargo.toml) file path to specify the MSI destination"
                );
                target_directory.join(crate::WIX).join(filename)
            }
        };

        let mut path = self.path.clone();
        for output_type in ["msi", "exe"] {
            path.set_extension(output_type);
            if path.exists() {
                let filename = file_name_with_ext(output_type);
                std::fs::rename(&path, &filename)?;
                debug!("Moving {path:?} to {filename:?}");
                return Ok(());
            }
        }

        error!("Expected {:?} to have output files", self.path);
        Err("Could not find package output for source".into())
    }

    fn is_main(&self) -> bool {
        self.path.file_stem() == Some(OsStr::new("main"))
    }
}

impl std::fmt::Debug for WixSource {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("WixSource")
            .field("wxs_schema", &self.wxs_schema)
            .field("path", &self.path)
            .finish()
    }
}

mod tests {

    #[test]
    fn test_source_can_upgrade() {
        use crate::toolset::{project::WxsSchema, source::WixSource};
        use std::path::PathBuf;

        assert!(
            !WixSource {
                is_package: false,
                wxs_schema: WxsSchema::Legacy,
                path: PathBuf::new(),
                exts: vec![],
                toolset: crate::toolset::Toolset::Legacy
            }
            .can_upgrade(),
            "should not be able to upgrade legacy w/ legacy toolset"
        );

        assert!(
            WixSource {
                is_package: false,
                wxs_schema: WxsSchema::Legacy,
                path: PathBuf::new(),
                exts: vec![],
                toolset: crate::toolset::Toolset::Modern
            }
            .can_upgrade(),
            "should be able to upgrade legacy w/ modern toolset"
        );

        assert!(
            !WixSource {
                is_package: false,
                wxs_schema: WxsSchema::V4,
                path: PathBuf::new(),
                exts: vec![],
                toolset: crate::toolset::Toolset::Modern
            }
            .can_upgrade(),
            "should not be able to upgrade from v4"
        );
    }

    #[test]
    fn test_skip_add_unknown_ext_to_package_cache() {
        use super::WixSource;
        use crate::toolset::ext::{PackageCache, UnknownExtNamespace};
        use std::path::PathBuf;

        let source = WixSource {
            is_package: true,
            wxs_schema: crate::toolset::project::WxsSchema::V4,
            path: PathBuf::new(),
            exts: vec![Box::new(UnknownExtNamespace {
                prefix: String::from("test"),
                uri: String::from("test_uri"),
            })],
            toolset: crate::toolset::Toolset::Modern,
        };

        let mut package_cache = PackageCache::from(crate::toolset::Toolset::Modern);
        source.check_deps(&mut package_cache);

        assert_eq!(0, package_cache.iter_missing().count());
    }

    #[test]
    fn test_source_is_bundle() {
        use super::WixSource;
        use crate::toolset::ext::WellKnownExtentions;
        use std::path::PathBuf;

        let source_with_bal = WixSource {
            is_package: true,
            wxs_schema: crate::toolset::project::WxsSchema::V4,
            path: PathBuf::new(),
            exts: vec![Box::new(WellKnownExtentions::BootstrapperApplications)],
            toolset: crate::toolset::Toolset::Modern,
        };
        assert!(
            source_with_bal.is_bundle(),
            "source with bal namespace should be a bundle"
        );

        let source_without_bal = WixSource {
            is_package: true,
            wxs_schema: crate::toolset::project::WxsSchema::V4,
            path: PathBuf::new(),
            exts: vec![Box::new(WellKnownExtentions::UI)],
            toolset: crate::toolset::Toolset::Modern,
        };
        assert!(
            !source_without_bal.is_bundle(),
            "source without bal namespace should not be a bundle"
        );

        let source_no_exts = WixSource {
            is_package: true,
            wxs_schema: crate::toolset::project::WxsSchema::V4,
            path: PathBuf::new(),
            exts: vec![],
            toolset: crate::toolset::Toolset::Modern,
        };
        assert!(
            !source_no_exts.is_bundle(),
            "source with no exts should not be a bundle"
        );
    }
}


================================================
FILE: src/toolset/test.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

use super::{Toolset, ToolsetAction};
use std::{fmt::Debug, sync::Arc};

/// Type-alias for a boxed test shim
pub type SharedTestShim = Arc<dyn TestShim + 'static>;

/// Struct containing test output for a toolset command action
#[cfg(test)]
#[derive(Clone, Default)]
pub struct ToolsetTest {
    pub success: bool,
    pub stdout: String,
    pub stderr: String,
}

/// Returns an ok status and the provided string as stdout
pub fn ok_stdout(out: impl Into<String>) -> ToolsetTest {
    test::<true>(out, "")
}

/// Returns a failure status and the provided string as stdout
pub fn fail_stdout(out: impl Into<String>) -> ToolsetTest {
    test::<false>(out, "")
}

/// Return a toolset test w/ stdout set
fn test<const SUCCESS: bool>(out: impl Into<String>, err: impl Into<String>) -> ToolsetTest {
    ToolsetTest {
        success: SUCCESS,
        stdout: out.into(),
        stderr: err.into(),
    }
}

/// This shim allows unit test code without requiring dependencies to be installed on the test machine
pub trait TestShim {
    /// Called when `.output()` is called
    fn on_output(&self, action: &ToolsetAction, cmd: &std::process::Command) -> ToolsetTest;
}

/// Boxes a test shim, is_legacy will return false
pub fn toolset(shim: impl TestShim + 'static) -> Toolset {
    Toolset::Test {
        shim: Arc::new(shim),
        is_legacy: false,
    }
}

/// Returns a test toolset with shim, is_legacy will return true
pub fn legacy_toolset(shim: impl TestShim + 'static) -> Toolset {
    Toolset::Test {
        shim: Arc::new(shim),
        is_legacy: true,
    }
}

impl<T> TestShim for T
where
    T: Fn(&ToolsetAction, &std::process::Command) -> ToolsetTest + Clone + 'static,
{
    fn on_output(&self, action: &ToolsetAction, cmd: &std::process::Command) -> ToolsetTest {
        match action {
            ToolsetAction::Compile { .. } => {
                let program = cmd.get_program().to_string_lossy().to_string();
                assert!(
                    program == "candle" || program.ends_with("candle.exe"),
                    "expected program to be 'candle' or end with 'candle.exe', got '{program}'"
                );
            }
            ToolsetAction::Convert => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(["convert"], &cmd.get_args().take(1).collect::<Vec<_>>()[..]);
            }
            ToolsetAction::Build => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(["build"], &cmd.get_args().take(1).collect::<Vec<_>>()[..]);
            }
            ToolsetAction::AddExtension => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(
                    ["extension", "add"],
                    &cmd.get_args().take(2).collect::<Vec<_>>()[..]
                );
            }
            ToolsetAction::AddGlobalExtension => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(
                    ["extension", "add", "--global"],
                    &cmd.get_args().take(3).collect::<Vec<_>>()[..]
                );
            }
            ToolsetAction::ListExtension => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(
                    ["extension", "list"],
                    &cmd.get_args().collect::<Vec<_>>()[..]
                );
            }
            ToolsetAction::ListGlobalExtension => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(
                    ["extension", "list", "--global"],
                    &cmd.get_args().collect::<Vec<_>>()[..]
                );
            }
            ToolsetAction::Version => {
                assert_eq!("wix", cmd.get_program());
                assert_eq!(["--version"], &cmd.get_args().collect::<Vec<_>>()[..]);
            }
        }
        self(action, cmd)
    }
}

impl Debug for ToolsetTest {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ToolsetTest")
            .field("success", &self.success)
            .field("stdout", &self.stdout)
            .field("stderr", &self.stderr)
            .finish()
    }
}


================================================
FILE: tests/common/mod.rs
================================================
#![allow(dead_code)]

extern crate assert_fs;
extern crate env_logger;
extern crate log;
extern crate sxd_document;
extern crate sxd_xpath;

use assert_fs::prelude::*;

use self::sxd_document::parser;
use self::sxd_xpath::{Context, Factory};

use assert_fs::TempDir;

use env_logger::Builder;
use env_logger::fmt::style::{AnsiColor as LogColor, Style};

use log::{Level, LevelFilter};

use std::env;
use std::fs;
use std::fs::{File, OpenOptions};
use std::io::{Read, Write};
use std::path::Path;
use std::process::Command;

use toml::{Table, Value};

pub const TARGET_NAME: &str = "target";

// Cannot use dashes. WiX Toolset only allows A-Z, a-z, digits, underscores (_), or periods (.)
// for attribute IDs.
pub const PACKAGE_NAME: &str = "cargowixtest";

pub const NO_CAPTURE_VAR_NAME: &str = "CARGO_WIX_TEST_NO_CAPTURE";

pub const PERSIST_VAR_NAME: &str = "CARGO_WIX_TEST_PERSIST";

pub const MISC_NAME: &str = "misc";

pub const SUBPACKAGE1_NAME: &str = "subproject1";
pub const SUBPACKAGE2_NAME: &str = "subproject2";

fn create_test_package_at_path(path: &Path, package_name: &str) {
    let cargo_init_status = Command::new("cargo")
        .arg("init")
        .arg("--bin")
        .arg("--quiet")
        .arg("--vcs")
        .arg("none")
        .arg("--name")
        .arg(package_name)
        .arg(path)
        .status()
        .expect("Creation of test Cargo package");
    assert!(cargo_init_status.success());
    let cargo_path = path.join("Cargo.toml");

    let mut toml = {
        let mut cargo_toml_handle = File::open(&cargo_path).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        cargo_toml_content.parse::<Table>().unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(
                        String::from("authors"),
                        Value::Array(vec![Value::from("author1"), Value::from("author2")]),
                    ),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(cargo_path).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
}

pub fn add_license_to_package(path: &Path, license: &str) {
    let cargo_path = path.join("Cargo.toml");

    let mut toml = {
        let mut cargo_toml_handle = File::open(&cargo_path).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        cargo_toml_content.parse::<Table>().unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(String::from("license"), Value::from(license)),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(cargo_path).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
}

/// Create a new cargo project/package for a binary project in a temporary
/// directory.
///
/// This provides a unique, isolated Cargo project/package for testing. A
/// temporary directory is created. Then, a cargo project is initialized within
/// the temporary directory. The package/project is initialized without any
/// version control system (vcs). The command that is ultimately executed to
/// create the cargo project in the temporary directory is:
///
/// ```
/// > cargo init --bin --quiet --vcs none --name cargowixtest "C:\Users\<username>\AppData\Local\Temp\cargo_wix_text_######"
/// ```
///
/// where `<username>` is replaced with the current logged in user for the
/// Windows Operating System (OS) and `######` is a hash ID that guarantees the
/// folder is unique.
///
/// # Panics
///
/// This will panic if a temporary directory fails to be created or if cargo
/// fails to create the project/package.
pub fn create_test_package() -> TempDir {
    let temp_dir = TempDir::new().unwrap();
    create_test_package_at_path(temp_dir.path(), PACKAGE_NAME);
    temp_dir.into_persistent_if(env::var(PERSIST_VAR_NAME).is_ok())
}

/// Create a new cargo project/package for a project with multiple binaries in a
/// temporary directory. See the [create_test_package] function for more
/// information.
///
/// Following creation of the project, the manifest file (Cargo.toml) is
/// modified to include multiple `[[bin]]` sections for multiple binaries. The
/// original `main.rs` file that is created for the first binary is copied for
/// each of the other binaries. A total of three (3) binaries will be created
/// and added to the manifest file.
///
/// [create_test_package]: fn.create_test_package.html
///
/// # Panics
///
/// This will panic if a temporary directory fails to be created or if cargo
/// fails to create the project/package.
///
/// It will also panic if it cannot modify the manifest file (Cargo.toml) or the
/// project layout for multiple binaries.
pub fn create_test_package_multiple_binaries() -> TempDir {
    let package = create_test_package();
    let package_manifest = package.child("Cargo.toml");
    let package_src = package.child("src");
    {
        let mut cargo_toml_handle = OpenOptions::new()
            .read(true)
            .append(true)
            .open(package_manifest.path())
            .unwrap();
        cargo_toml_handle
            .write_all(
                r#"[[bin]]
name = "main1"
path = "src/main1.rs"

[[bin]]
name = "main2"
path = "src/main2.rs"

[[bin]]
name = "main3"
path = "src/main3.rs"
"#
                .as_bytes(),
            )
            .unwrap();
    }
    let package_original_main = package_src.child("main.rs");
    fs::copy(
        package_original_main.path(),
        package_src.child("main1.rs").path(),
    )
    .unwrap();
    fs::copy(
        package_original_main.path(),
        package_src.child("main2.rs").path(),
    )
    .unwrap();
    fs::copy(
        package_original_main.path(),
        package_src.child("main3.rs").path(),
    )
    .unwrap();
    fs::remove_file(package_original_main.path()).unwrap();
    package
}

/// Create a new cargo project/package for a project with a
/// `[package.metadata.wix]` section.
///
/// Following creation of the project, the manifest file (Cargo.toml) is
/// modified to include a `[package.metadata.wix]` section.
///
/// # Panics
///
/// This will panic if a temporary directory fails to be created or if cargo
/// fails to create the project/package.
///
/// It will also panic if it cannot modify the manifest file (Cargo.toml) or the
/// project layout for multiple binaries.
pub fn create_test_package_metadata() -> TempDir {
    let package = create_test_package();
    let package_manifest = package.child("Cargo.toml");
    let mut cargo_toml_handle = OpenOptions::new()
        .read(true)
        .append(true)
        .open(package_manifest.path())
        .unwrap();
    cargo_toml_handle
        .write_all(
            r#"[package.metadata.wix]
name = "Metadata"
version = "2.1.0"
compiler-args = ["-nologo", "-wx", "-arch", "x64"]
linker-args = ["-nologo"]
"#
            .as_bytes(),
        )
        .unwrap();
    package
}

/// Create a new cargo project/package for a project with a
/// `[profile.{profile}]` section.
///
/// Following creation of the project, the manifest file (Cargo.toml) is
/// modified to include a `[profile.{profile}]` section.
///
/// # Panics
///
/// This will panic if a temporary directory fails to be created or if cargo
/// fails to create the project/package.
///
/// It will also panic if it cannot modify the manifest file (Cargo.toml) or the
/// project layout for multiple binaries.
pub fn create_test_package_profile(profile: &str) -> TempDir {
    let package = create_test_package();
    let package_manifest = package.child("Cargo.toml");
    let mut cargo_toml_handle = OpenOptions::new()
        .read(true)
        .append(true)
        .open(package_manifest.path())
        .unwrap();
    cargo_toml_handle
        .write_all(
            format!(
                r#"
[profile.{profile}]
inherits = "release"
lto = "thin"
"#
            )
            .as_bytes(),
        )
        .unwrap();
    package
}

/// Create a new cargo project/package for a project with multiple WXS files.
///
/// # Panics
///
/// This will panic if a temporary directory fails to be created or if cargo
/// fails to create the project/package.
///
/// It will also panic if it cannot modify the manifest file (Cargo.toml) or the
/// project layout for multiple binaries.
///
/// This function will panic if the `wix` sub-folder could not be created.
pub fn create_test_package_multiple_wxs_sources() -> TempDir {
    let one_wxs = include_str!("one.wxs");
    let two_wxs = include_str!("two.wxs");
    let three_wxs = include_str!("three.wxs");
    let package = create_test_package();
    let mut misc_dir = package.path().join(MISC_NAME);
    fs::create_dir(&misc_dir).unwrap();
    misc_dir.push("one.wxs");
    let mut one_wxs_handle = File::create(&misc_dir).unwrap();
    one_wxs_handle.write_all(one_wxs.as_bytes()).unwrap();
    misc_dir.pop();
    misc_dir.push("two.wxs");
    let mut two_wxs_handle = File::create(&misc_dir).unwrap();
    two_wxs_handle.write_all(two_wxs.as_bytes()).unwrap();
    misc_dir.pop();
    misc_dir.push("three.wxs");
    let mut three_wxs_handle = File::create(&misc_dir).unwrap();
    three_wxs_handle.write_all(three_wxs.as_bytes()).unwrap();
    package
}

/// Create a new cargo workspace with multiple sub-projects in a
/// temporary directory. See the [create_test_package] function for more
/// information.
pub fn create_test_workspace() -> TempDir {
    let temp_dir = TempDir::new().unwrap();
    fs::create_dir(temp_dir.path().join(SUBPACKAGE1_NAME)).unwrap();
    fs::create_dir(temp_dir.path().join(SUBPACKAGE2_NAME)).unwrap();
    create_test_package_at_path(&temp_dir.path().join(SUBPACKAGE1_NAME), SUBPACKAGE1_NAME);
    create_test_package_at_path(&temp_dir.path().join(SUBPACKAGE2_NAME), SUBPACKAGE2_NAME);
    fs::write(
        temp_dir.path().join("Cargo.toml"),
        format!(
            r#"[workspace]
            members = [{SUBPACKAGE1_NAME:?}, {SUBPACKAGE2_NAME:?}]"#
        ),
    )
    .unwrap();
    temp_dir.into_persistent_if(env::var(PERSIST_VAR_NAME).is_ok())
}

/// Evaluates an XPath expression for a WiX Source file.
///
/// This registers the WiX XML namespace with the `wix` prefix. So, XPath
/// expressions should use `/wix:Wix/` as the start and prefix all element/node
/// names with the `wix:` prefix. Note, attributes should _not_ have the `wix:`
/// prefix.
///
/// All values are currently returned as strings.
pub fn evaluate_xpath(wxs: &Path, xpath: &str) -> String {
    let mut wxs = File::open(wxs).expect("Open Wix Source file");
    let mut wxs_content = String::new();
    wxs.read_to_string(&mut wxs_content)
        .expect("Read WiX Source file");
    let wxs_package = parser::parse(&wxs_content).expect("Parsing WiX Source file");
    let wxs_document = wxs_package.as_document();
    let mut context = Context::new();
    context.set_namespace("wix", "http://schemas.microsoft.com/wix/2006/wi");
    let xpath = Factory::new().build(xpath).unwrap().unwrap();
    xpath
        .evaluate(&context, wxs_document.root())
        .unwrap()
        .string()
}

/// Initializes the logging for the integration tests.
///
/// When a test fails, it is useful to re-run the tests with logging statements
/// enabled to debug the failed test. This initializes the logging based on the
/// `CARGO_WIX_TEST_LOG` environment variable, which takes an integer as a
/// value. A `0` value, or not setting the environment variable, turns off
/// logging. Each increment of the integer value will increase the number of
/// statements that are logged up to 5 (Trace).
///
/// If the `CARGO_WIX_TEST_LOG` value is greater than zero (0), then log
/// statements will be emitted to the terminal/console regardless of the
/// `--nocapture` option for cargo tests. In other words, log statements are
/// *not* captured by cargo's testing framework with this implementation. Thus,
/// it is recommended to *not* activate logging if running all of the tests.
/// Logging should be done for isolated tests. Not capturing the log statements
/// by cargo's test framework keeps the formatting and coloring. There might be
/// a decrease in performance as well.
///
/// Log statements are formatted the same as the verbosity format for the CLI.
///
/// # Examples
///
/// Enabling logging for tests in Powershell requires two commands and an
/// optional third command to undo:
///
/// ```powershell
/// PS C:\Path\to\Cargo\Wix> $env:CARGO_WIX_TEST_LOG=5
/// PS C:\Path\to\Cargo\Wix> cargo test
/// PS C:\Path\to\Cargo\Wix> Remove-Item Env:\CARGO_WIX_TEST_LOG
/// ```
///
/// This can be collapsed into a single line as:
///
/// ```powershell
/// PS C:\Path\to\Cargo\Wix> $env:CARGO_WIX_TEST_LOG=5; cargo test; Remove-Item Env:\CARGO_WIX_TEST_LOG
/// ```
///
/// But again, logging should only be activated for isolated tests to avoid
/// relatively large number of statements being written:
///
/// ```powershell
/// PS C:\Path\to\Cargo\Wix> $env:CARGO_WIX_TEST_LOG=5; cargo test <TEST_NAME>; Remove-Item Env:\CARGO_WIX_TEST_LOG
/// ```
///
/// where `<TEST_NAME>` is the name of a test, a.k.a. function name with the `#[test]` attribute.
pub fn init_logging() {
    let log_level = match std::env::var("CARGO_WIX_TEST_LOG") {
        Ok(level) => level
            .parse::<i32>()
            .expect("Integer for CARGO_WIX_TEST_LOG value"),
        Err(_) => 0,
    };
    let mut builder = Builder::new();
    builder
        .format(|buf, record| {
            let level = record.level();
            // This implementation for a format is copied from the default format implemented for the
            // `env_logger` crate but modified to use a colon, `:`, to separate the level from the
            // message and change the colors to match the previous colors used by the `loggerv` crate.
            let style = match level {
                // Light Gray, or just Gray, is not a supported color for non-ANSI enabled Windows
                // consoles, so TRACE and DEBUG statements are differentiated by boldness but use the
                // same white color.
                Level::Trace => Style::new().fg_color(Some(LogColor::White.into())),
                Level::Debug => Style::new().fg_color(Some(LogColor::White.into())).bold(),
                Level::Info => Style::new().fg_color(Some(LogColor::Green.into())).bold(),
                Level::Warn => Style::new().fg_color(Some(LogColor::Yellow.into())).bold(),
                Level::Error => Style::new().fg_color(Some(LogColor::Red.into())).bold(),
            };
            let write_level = write!(buf, "{style}{level:>5}{style:#}: ");
            let write_args = writeln!(buf, "{}", record.args());
            write_level.and(write_args)
        })
        .filter(
            Some("wix"),
            match log_level {
                0 => LevelFilter::Off,
                1 => LevelFilter::Error,
                2 => LevelFilter::Warn,
                3 => LevelFilter::Info,
                4 => LevelFilter::Debug,
                _ => LevelFilter::Trace,
            },
        )
        .try_init()
        .ok();
}


================================================
FILE: tests/common/one.wxs
================================================
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Product Id="*" 
    Name="My Software"
    Language="1033"
    Manufacturer="My Company"
    Version="1.0.0.0" 
    UpgradeCode="8c7d85db-b0d1-4a9a-85ea-130836aeef67">
    
    <Package InstallerVersion="200" Compressed="yes" InstallScope="perMachine" />

    <MajorUpgrade DowngradeErrorMessage="A newer version of [ProductName] is already installed." />
    <MediaTemplate EmbedCab="yes" />

    <Feature Id="ProductFeature" Title="The main feature" Level="1">
      <ComponentGroupRef Id="ProductComponents" />
    </Feature>
  </Product>
</Wix>


================================================
FILE: tests/common/post_v4/fragment.wxs
================================================
<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs" xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui">
    <Fragment test="1"></Fragment>
</Wix>

================================================
FILE: tests/common/post_v4/main.wxs
================================================
<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs" xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui">
    <Package></Package>
</Wix>

================================================
FILE: tests/common/pre_v4/main.wxs
================================================
<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'></Wix>

================================================
FILE: tests/common/three.wxs
================================================
<?xml version="1.0" encoding="UTF-8"?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Fragment>
    <Feature Id="ProductFeature" Title="The main feature" Level="1">
      <ComponentGroupRef Id="ProductComponents" />
    </Feature>
  </Fragment>
</Wix>


================================================
FILE: tests/common/two.wxs
================================================
<?xml version="1.0" encoding="UTF-8"?>
<?if $(sys.BUILDARCH) = x64 or $(sys.BUILDARCH) = arm64 ?>
    <?define PlatformProgramFilesFolder = "ProgramFiles64Folder" ?>
<?else ?>
    <?define PlatformProgramFilesFolder = "ProgramFilesFolder" ?>
<?endif ?>
<Wix xmlns="http://schemas.microsoft.com/wix/2006/wi">
  <Fragment>
    <Directory Id="TARGETDIR" Name="SourceDir">
      <Directory Id="$(var.PlatformProgramFilesFolder)">
        <Directory Id="INSTALLFOLDER" Name="My Software" />
      </Directory>
    </Directory>
  </Fragment>

  <Fragment>
    <ComponentGroup Id="ProductComponents" Directory="INSTALLFOLDER">
      <Component Id="cmpCargoTOML" Guid="*">
        <File Source="Cargo.toml" />
      </Component>
    </ComponentGroup>
  </Fragment>
</Wix>


================================================
FILE: tests/common/well_known_exts/main.wxs
================================================
<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs"
    xmlns:ui="http://wixtoolset.org/schemas/v4/wxs/ui"
    xmlns:bal="http://wixtoolset.org/schemas/v4/wxs/bal"
    xmlns:complus="http://wixtoolset.org/schemas/v4/wxs/complus"
    xmlns:dep="http://wixtoolset.org/schemas/v4/wxs/dependency"
    xmlns:directx="http://wixtoolset.org/schemas/v4/wxs/directx"
    xmlns:fw="http://wixtoolset.org/schemas/v4/wxs/firewall"
    xmlns:http="http://wixtoolset.org/schemas/v4/wxs/http"
    xmlns:iis="http://wixtoolset.org/schemas/v4/wxs/iis"
    xmlns:msmq="http://wixtoolset.org/schemas/v4/wxs/msmq"
    xmlns:netfx="http://wixtoolset.org/schemas/v4/wxs/netfx"
    xmlns:powershell="http://wixtoolset.org/schemas/v4/wxs/powershell"
    xmlns:sql="http://wixtoolset.org/schemas/v4/wxs/sql"
    xmlns:util="http://wixtoolset.org/schemas/v4/wxs/util"
    xmlns:vs="http://wixtoolset.org/schemas/v4/wxs/vs"
    ></Wix>

================================================
FILE: tests/create.rs
================================================
#![cfg(windows)]

// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

mod common;

use assert_fs::prelude::*;

use predicates::prelude::*;

use crate::common::init_logging;
use crate::common::{
    MISC_NAME, NO_CAPTURE_VAR_NAME, PACKAGE_NAME, PERSIST_VAR_NAME, SUBPACKAGE1_NAME,
};

use assert_fs::TempDir;

use lazy_static::lazy_static;

use serial_test::serial;

use std::env;
use std::fs::{self, File};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};

use toml::{Table, Value};

use wix::create::Builder;
use wix::initialize;
use wix::{CARGO_MANIFEST_FILE, Result, WIX};

lazy_static! {
    static ref TARGET_WIX_DIR: PathBuf = {
        let mut p = TARGET_NAME.clone();
        p.push(WIX);
        p
    };
}

lazy_static! {
    static ref TARGET_NAME: PathBuf = PathBuf::from("target");
}

/// Run the _create_ subcommand with the output capture toggled by the
/// `CARGO_WIX_TEST_NO_CAPTURE` environment variable.
fn run(b: &mut Builder) -> Result<()> {
    run_with_package(b, &std::env::current_dir()?)
}

/// Run the _create_ subcommand with the output capture toggled by the
/// `CARGO_WIX_TEST_NO_CAPTURE` environment variable, and the CARGO_TARGET_DIR
/// env variable set to <package path>/target.
fn run_with_package(b: &mut Builder, package_path: &Path) -> Result<()> {
    // Forcefully set the target dir to its default location
    unsafe {
        env::set_var("CARGO_TARGET_DIR", package_path.join("target"));
    }
    b.capture_output(env::var(NO_CAPTURE_VAR_NAME).is_err())
        .build()
        .run()
}

#[test]
#[serial]
fn default_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn russian_culture_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().culture(Some("ru-ru")));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn debug_build_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().debug_build(true));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn profile_build_works() {
    init_logging();
    const PROFILE: &str = "dist";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_profile(PROFILE);
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    eprintln!("{}", expected_msi_file.display());
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().profile(Some(PROFILE)));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn debug_name_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64-debug.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().debug_name(true));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn metadata_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_metadata();
    let expected_msi_file = TARGET_WIX_DIR.join("Metadata-2.1.0-x86_64.msi");
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn output_trailing_forwardslash_works() {
    init_logging();
    let output_dir = TARGET_NAME.join("output_dir");
    let output_dir_str = format!("{}/", output_dir.to_str().unwrap());
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = output_dir.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().output(Some(output_dir_str.as_str())));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn output_trailing_backslash_works() {
    init_logging();
    let output_dir = TARGET_NAME.join("output_dir");
    let output_dir_str = format!("{}\\", output_dir.to_str().unwrap());
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = output_dir.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().output(Some(output_dir_str.as_str())));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn output_existing_dir_works() {
    init_logging();
    let output_dir = PathBuf::from("output_dir");
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = output_dir.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    fs::create_dir(&output_dir).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().output(output_dir.to_str()));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn output_file_without_extension_works() {
    init_logging();
    let output_dir = TARGET_NAME.join("output_dir");
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let output_file = output_dir.join(PACKAGE_NAME);
    let expected_msi_file = output_dir.join(format!("{PACKAGE_NAME}.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().output(output_file.to_str()));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn output_file_with_extension_works() {
    init_logging();
    let output_dir = TARGET_NAME.join("output_dir");
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = output_dir.join(format!("{PACKAGE_NAME}.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().output(expected_msi_file.to_str()));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_package_section_fields_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let package_manifest = package.child("Cargo.toml");
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => {
                        t.insert(
                            String::from("description"),
                            Value::from("This is a description"),
                        );
                        t.insert(
                            String::from("documentation"),
                            Value::from("https://www.example.com/docs"),
                        );
                        t.insert(
                            String::from("homepage"),
                            Value::from("https://www.example.com"),
                        );
                        t.insert(String::from("license"), Value::from("MIT"));
                        t.insert(
                            String::from("repository"),
                            Value::from("https://www.example.com/repo"),
                        );
                    }
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    initialize::Execution::default().run().unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_all_options_works() {
    init_logging();
    const LICENSE_FILE: &str = "License_Example.txt";
    const EULA_FILE: &str = "Eula_Example.rtf";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let bin_example_path = package.path().join("bin").join("Example.exe");
    fs::create_dir(bin_example_path.parent().unwrap()).unwrap();
    {
        let _bin_example_handle = File::create(&bin_example_path).unwrap();
    }
    let banner_path = package.path().join("img").join("Banner.bmp");
    fs::create_dir(banner_path.parent().unwrap()).unwrap();
    {
        let _banner_handle = File::create(&banner_path).unwrap();
    }
    let dialog_path = package.path().join("img").join("Dialog.bmp");
    {
        let _dialog_handle = File::create(&dialog_path).unwrap();
    }
    let package_license = package.child(LICENSE_FILE);
    {
        let _license_handle = File::create(package_license.path()).unwrap();
    }
    let package_eula = package.child(EULA_FILE);
    {
        let _eula_handle = File::create(package_eula.path()).unwrap();
    }
    let product_icon_path = package.path().join("img").join("Product.ico");
    {
        let _product_icon_handle = File::create(&product_icon_path).unwrap();
    }
    initialize::Builder::new()
        .banner(banner_path.to_str())
        .binaries(bin_example_path.to_str().map(|b| vec![b]))
        .description(Some("This is a description"))
        .dialog(dialog_path.to_str())
        .eula(package_eula.path().to_str())
        .help_url(Some("http://www.example.com"))
        .license(package_license.path().to_str())
        .manufacturer(Some("Example Manufacturer"))
        .product_icon(product_icon_path.to_str())
        .product_name(Some("Example Product Name"))
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_banner_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let banner_path = package.path().join("img").join("Banner.bmp");
    fs::create_dir(banner_path.parent().unwrap()).unwrap();
    {
        let _banner_handle = File::create(&banner_path).unwrap();
    }
    initialize::Builder::new()
        .banner(banner_path.to_str())
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_binaries_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let bin_example_path = package.path().join("bin").join("Example.exe");
    fs::create_dir(bin_example_path.parent().unwrap()).unwrap();
    {
        let _bin_example_handle = File::create(&bin_example_path).unwrap();
    }
    initialize::Builder::new()
        .binaries(bin_example_path.to_str().map(|b| vec![b]))
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_multiple_binaries_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_multiple_binaries();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::new().build().run().unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_description_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::new()
        .description(Some("This is a description"))
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_dialog_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let dialog_path = package.path().join("img").join("Dialog.bmp");
    fs::create_dir(dialog_path.parent().unwrap()).unwrap();
    {
        let _dialog_handle = File::create(&dialog_path).unwrap();
    }
    initialize::Builder::new()
        .dialog(dialog_path.to_str())
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_eula_in_cwd_works() {
    init_logging();
    const EULA_FILE: &str = "Eula_Example.rtf";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let package_eula = package.child(EULA_FILE);
    {
        let _eula_handle = File::create(package_eula.path()).unwrap();
    }
    initialize::Builder::new()
        .eula(package_eula.path().to_str())
        .build()
        .run()
        .expect("Initialization");
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_eula_in_docs_works() {
    init_logging();
    const EULA_FILE: &str = "Eula_Example.rtf";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let package_docs = package.child("docs");
    fs::create_dir(package_docs.path()).unwrap();
    let package_eula = package_docs.path().join(EULA_FILE);
    {
        let _eula_handle = File::create(&package_eula).unwrap();
    }
    initialize::Builder::new()
        .eula(package_eula.to_str())
        .build()
        .run()
        .expect("Initialization");
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_help_url_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::new()
        .help_url(Some("http://www.example.com"))
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_license_in_cwd_works() {
    init_logging();
    const LICENSE_FILE: &str = "License_Example.txt";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let package_license = package.child(LICENSE_FILE);
    {
        let _license_handle = File::create(package_license.path()).unwrap();
    }
    initialize::Builder::new()
        .license(package_license.path().to_str())
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_license_in_docs_works() {
    init_logging();
    const EULA_FILE: &str = "License_Example.txt";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let package_docs = package.child("docs");
    fs::create_dir(package_docs.path()).unwrap();
    let package_license = package_docs.path().join(EULA_FILE);
    {
        let _license_handle = File::create(&package_license).unwrap();
    }
    initialize::Builder::new()
        .license(package_license.to_str())
        .build()
        .run()
        .expect("Initialization");
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_manufacturer_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::new()
        .manufacturer(Some("Example Manufacturer"))
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_product_icon_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    let product_icon_path = package.path().join("img").join("Product.ico");
    fs::create_dir(product_icon_path.parent().unwrap()).unwrap();
    {
        let _product_icon_handle = File::create(&product_icon_path).unwrap();
    }
    initialize::Builder::new()
        .product_icon(product_icon_path.to_str())
        .build()
        .run()
        .unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn init_with_product_name_option_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::new()
        .product_name(Some("Example Product Name"))
        .build()
        .run()
        .unwrap();
    let mut wxs_handle =
        File::open(package.child(PathBuf::from(WIX).join("main.wxs")).path()).unwrap();
    let mut wxs_content = String::new();
    wxs_handle.read_to_string(&mut wxs_content).unwrap();
    println!("{wxs_content}");
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn input_works_inside_cwd() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default().build().run().unwrap();
    let result = run(Builder::default().input(package_manifest.path().to_str()));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn input_works_outside_cwd() {
    init_logging();
    let package = common::create_test_package();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let expected_msi_file =
        package.child(TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi")));
    initialize::Builder::default()
        .input(package_manifest.path().to_str())
        .build()
        .run()
        .unwrap();
    let result = run_with_package(
        Builder::default().input(package_manifest.path().to_str()),
        package.path(),
    );
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file.path())
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn includes_works_with_wix_dir() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_multiple_wxs_sources();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    let two_wxs = package.path().join(MISC_NAME).join("two.wxs");
    let three_wxs = package.path().join(MISC_NAME).join("three.wxs");
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default().build().run().unwrap();
    let result = run(Builder::default().includes(Some(vec![
        two_wxs.to_str().unwrap(),
        three_wxs.to_str().unwrap(),
    ])));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn includes_works_without_wix_dir() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_multiple_wxs_sources();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    let one_wxs = package.path().join(MISC_NAME).join("one.wxs");
    let two_wxs = package.path().join(MISC_NAME).join("two.wxs");
    env::set_current_dir(package.path()).unwrap();
    let result = run(Builder::default().includes(Some(vec![
        one_wxs.to_str().unwrap(),
        two_wxs.to_str().unwrap(),
    ])));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn includes_works_with_input_outside_cwd() {
    init_logging();
    let package = common::create_test_package_multiple_wxs_sources();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let expected_msi_file =
        package.child(TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi")));
    let two_wxs = package.path().join(MISC_NAME).join("two.wxs");
    let three_wxs = package.path().join(MISC_NAME).join("three.wxs");
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default()
        .input(package_manifest.path().to_str())
        .build()
        .run()
        .unwrap();
    let result = run(Builder::default()
        .input(package_manifest.path().to_str())
        .includes(Some(vec![
            two_wxs.to_str().unwrap(),
            three_wxs.to_str().unwrap(),
        ])));
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file.path())
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn compiler_args_flags_only_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default().build().run().unwrap();
    let result = run(Builder::default().compiler_args(Some(vec!["-nologo", "-wx"])));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn compiler_args_options_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default().build().run().unwrap();
    let result = run(Builder::default().compiler_args(Some(vec!["-arch", "x64"])));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[ignore = "currently requires a binary to be installed"]
#[test]
#[serial]
fn linker_args_flags_only_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default().build().run().unwrap();
    let result = run(Builder::default().linker_args(Some(vec!["-nologo", "-wx"])));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn compiler_and_linker_args_works_with_metadata() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_metadata();
    let expected_msi_file = TARGET_WIX_DIR.join("Metadata-2.1.0-x86_64.msi");
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::default().build().run().unwrap();
    let result = run(&mut Builder::default());
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn custom_target_dir_works() {
    init_logging();
    let target_tmpdir = TempDir::new()
        .unwrap()
        .into_persistent_if(env::var(PERSIST_VAR_NAME).is_ok());

    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = Path::new(WIX).join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    unsafe {
        env::set_var("CARGO_TARGET_DIR", target_tmpdir.path());
    }
    let result = Builder::default()
        .capture_output(env::var(NO_CAPTURE_VAR_NAME).is_err())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    target_tmpdir.child(WIX).assert(predicate::path::exists());
    target_tmpdir
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn workspace_package_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_workspace();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{SUBPACKAGE1_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Builder::new()
        .package(Some(SUBPACKAGE1_NAME))
        .build()
        .run()
        .unwrap();
    let result = run(Builder::default().package(Some(SUBPACKAGE1_NAME)));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn cross_compilation_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default().target(Some("x86_64-pc-windows-msvc")));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn profile_cross_compilation_works() {
    // Makes sure we handle customizing profile+target, in terms of target paths
    init_logging();
    const PROFILE: &str = "dist";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_profile(PROFILE);
    let expected_msi_file = TARGET_WIX_DIR.join(format!("{PACKAGE_NAME}-0.1.0-x86_64.msi"));
    eprintln!("{}", expected_msi_file.display());
    env::set_current_dir(package.path()).unwrap();
    initialize::Execution::default().run().unwrap();
    let result = run(Builder::default()
        .profile(Some(PROFILE))
        .target(Some("x86_64-pc-windows-msvc")));
    env::set_current_dir(original_working_directory).unwrap();
    result.expect("OK result");
    package
        .child(TARGET_WIX_DIR.as_path())
        .assert(predicate::path::exists());
    package
        .child(expected_msi_file)
        .assert(predicate::path::exists());
}


================================================
FILE: tests/initialize.rs
================================================
// Copyright (C) 2017 Christopher R. Field.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

mod common;

use assert_fs::prelude::*;
use predicates::prelude::*;

use assert_fs::TempDir;

use lazy_static::lazy_static;

use serial_test::serial;

use std::env;
use std::fs::{self, File};
use std::io::{Read, Write};
use std::path::PathBuf;

use toml::{Table, Value};

use wix::initialize::{Builder, Execution};
use wix::stored_path::StoredPathBuf;
use wix::{
    CARGO_MANIFEST_FILE, LICENSE_FILE_NAME, RTF_FILE_EXTENSION, WIX, WIX_SOURCE_FILE_EXTENSION,
    WIX_SOURCE_FILE_NAME,
};

use crate::common::{SUBPACKAGE1_NAME, SUBPACKAGE2_NAME, add_license_to_package, init_logging};

lazy_static! {
    static ref MAIN_WXS: String = WIX_SOURCE_FILE_NAME.to_owned() + "." + WIX_SOURCE_FILE_EXTENSION;
    static ref LICENSE_RTF: String = LICENSE_FILE_NAME.to_owned() + "." + RTF_FILE_EXTENSION;
    static ref WIX_PATH: PathBuf = PathBuf::from(WIX);
    static ref MAIN_WXS_PATH: PathBuf = PathBuf::from(WIX).join(MAIN_WXS.as_str());
    static ref LICENSE_RTF_PATH: PathBuf = PathBuf::from(WIX).join(LICENSE_RTF.as_str());
}

#[test]
#[serial]
fn default_works() {
    // Save the current working directory so that we can change back to it at
    // the end of the test. This avoids polluting the `tests` folder for the
    // source code with test artifacts.
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let result = Execution::default().run();
    env::set_current_dir(original_working_directory).unwrap();
    println!("{result:?}");
    assert!(result.is_ok());
    package
        .child(WIX_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(MAIN_WXS_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(LICENSE_RTF_PATH.as_path())
        .assert(predicate::path::missing());
}

#[test]
#[serial]
fn description_works() {
    const EXPECTED: &str = "This is a description";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default().description(Some(EXPECTED)).build().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    let actual = common::evaluate_xpath(
        package.child(MAIN_WXS_PATH.as_path()).path(),
        "/wix:Wix/wix:Product/wix:Package/@Description",
    );
    assert_eq!(actual, EXPECTED);
}

#[test]
#[serial]
fn help_url_works() {
    const EXPECTED: &str = "http://www.example.com";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default().help_url(Some(EXPECTED)).build().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    let actual = common::evaluate_xpath(
        package.child(MAIN_WXS_PATH.as_path()).path(),
        "/wix:Wix/wix:Product/wix:Property[@Id='ARPHELPLINK']/@Value",
    );
    assert_eq!(actual, EXPECTED);
}

#[test]
#[serial]
fn manufacturer_works() {
    const EXPECTED: &str = "Example Manufacturer";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default()
        .manufacturer(Some(EXPECTED))
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    let actual = common::evaluate_xpath(
        package.child(MAIN_WXS_PATH.as_path()).path(),
        "/wix:Wix/wix:Product/wix:Package/@Manufacturer",
    );
    assert_eq!(actual, EXPECTED);
}

#[test]
#[serial]
fn product_name_works() {
    const EXPECTED: &str = "Example Product Name";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default()
        .product_name(Some(EXPECTED))
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "/wix:Wix/wix:Product/@Name"
        ),
        EXPECTED
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "/wix:Wix/wix:Product/wix:Property[@Id='DiskPrompt']/@Value"
        ),
        EXPECTED.to_string() + " Installation"
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:Directory[@Id='APPLICATIONFOLDER']/@Name"
        ),
        EXPECTED
    );
}

#[test]
#[serial]
fn binaries_works() {
    const EXPECTED: &str = "bin\\Example.exe";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default()
        .binaries(Some(vec![EXPECTED]))
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe0']/@Name"
        ),
        "Example.exe"
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe0']/@Source"
        ),
        EXPECTED
    );
}

#[test]
fn input_works() {
    let package = common::create_test_package();
    Builder::default()
        .input(package.child(CARGO_MANIFEST_FILE).path().to_str())
        .build()
        .run()
        .expect("OK result");
    package.child(WIX).assert(predicate::path::exists());
    package
        .child(MAIN_WXS_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(LICENSE_RTF_PATH.as_path())
        .assert(predicate::path::missing());
}

#[test]
#[serial]
fn output_works() {
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let output = TempDir::new().unwrap();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default()
        .output(output.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    output
        .child(MAIN_WXS.as_str())
        .assert(predicate::path::exists());
}

#[test]
#[serial]
fn input_with_output_works() {
    let package = common::create_test_package();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let output = package.path().join("assets").join("windows");
    fs::create_dir(output.parent().unwrap()).unwrap();
    fs::create_dir(&output).unwrap();
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(String::from("license"), Value::from("MIT")),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    Builder::default()
        .input(package.child(CARGO_MANIFEST_FILE).path().to_str())
        .output(output.to_str())
        .build()
        .run()
        .expect("OK result");
    assert!(output.join(MAIN_WXS.as_str()).exists());
    assert!(output.join(LICENSE_RTF.as_str()).exists());
}

#[test]
#[serial]
fn license_with_txt_file_works() {
    const EXPECTED: &str = "License_Example.txt";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_license = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    let _license_handle = File::create(package_license.path()).unwrap();
    let result = Builder::default()
        .license(package_license.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        package_license.path().to_str().unwrap()
    );
}

#[test]
#[serial]
fn license_with_rtf_file_works() {
    const EXPECTED: &str = "License_Example.rtf";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_license = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    let _license_handle = File::create(package_license.path()).unwrap();
    let result = Builder::default()
        .license(package_license.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        package_license.path().to_str().unwrap()
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUILicenseRtf']/@Value"
        ),
        package_license.path().to_str().unwrap()
    );
}

#[test]
#[serial]
fn eula_works() {
    const EXPECTED: &str = "EULA_Example.rtf";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_eula = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    let _eula_handle = File::create(package_eula.path()).unwrap();
    let result = Builder::default()
        .eula(package_eula.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUILicenseRtf']/@Value"
        ),
        package_eula.path().to_str().unwrap()
    );
}

#[test]
#[serial]
fn mit_license_id_works() {
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(String::from("license"), Value::from("MIT")),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    let result = Execution::default().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    package
        .child(WIX_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(MAIN_WXS_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(LICENSE_RTF_PATH.as_path())
        .assert(predicate::path::exists());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        StoredPathBuf::from_std_path(LICENSE_RTF_PATH.as_path())
            .unwrap()
            .to_string()
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUILicenseRtf']/@Value"
        ),
        StoredPathBuf::from_std_path(LICENSE_RTF_PATH.as_path())
            .unwrap()
            .to_string()
    );
}

#[test]
#[serial]
fn apache2_license_id_works() {
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(String::from("license"), Value::from("Apache-2.0")),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    let result = Execution::default().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    package
        .child(WIX_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(MAIN_WXS_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(LICENSE_RTF_PATH.as_path())
        .assert(predicate::path::exists());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        StoredPathBuf::from_std_path(LICENSE_RTF_PATH.as_path())
            .unwrap()
            .to_string()
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUILicenseRtf']/@Value"
        ),
        StoredPathBuf::from_std_path(LICENSE_RTF_PATH.as_path())
            .unwrap()
            .to_string()
    );
}

#[test]
#[serial]
fn gpl3_license_id_works() {
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    env::set_current_dir(package.path()).unwrap();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(String::from("license"), Value::from("GPL-3.0")),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    let result = Execution::default().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    package
        .child(WIX_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(MAIN_WXS_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(LICENSE_RTF_PATH.as_path())
        .assert(predicate::path::exists());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        StoredPathBuf::from_std_path(LICENSE_RTF_PATH.as_path())
            .unwrap()
            .to_string()
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUILicenseRtf']/@Value"
        ),
        StoredPathBuf::from_std_path(LICENSE_RTF_PATH.as_path())
            .unwrap()
            .to_string()
    );
}

#[test]
#[serial]
fn license_file_field_with_rtf_file_works() {
    const EXPECTED: &str = "License_Example.rtf";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_license = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    let _license_handle = File::create(package_license.path()).unwrap();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(
                        String::from("license-file"),
                        Value::from(package_license.path().to_str().unwrap()),
                    ),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    let result = Execution::default().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        StoredPathBuf::from_std_path(package_license.path())
            .unwrap()
            .to_string()
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUILicenseRtf']/@Value"
        ),
        StoredPathBuf::from_std_path(package_license.path())
            .unwrap()
            .to_string()
    );
}

#[test]
#[serial]
fn license_file_field_with_txt_file_works() {
    const EXPECTED: &str = "License_Example.txt";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_license = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    let _license_handle = File::create(package_license.path()).unwrap();
    let package_manifest = package.child(CARGO_MANIFEST_FILE);
    let mut toml: Table = {
        let mut cargo_toml_handle = File::open(package_manifest.path()).unwrap();
        let mut cargo_toml_content = String::new();
        cargo_toml_handle
            .read_to_string(&mut cargo_toml_content)
            .unwrap();
        toml::from_str(&cargo_toml_content).unwrap()
    };
    {
        toml.get_mut("package")
            .map(|p| {
                match p {
                    Value::Table(t) => t.insert(
                        String::from("license-file"),
                        Value::from(package_license.path().to_str().unwrap()),
                    ),
                    _ => panic!("The 'package' section is not a table"),
                };
                Some(p)
            })
            .expect("A package section for the Cargo.toml");
        let toml_string = toml.to_string();
        let mut cargo_toml_handle = File::create(package_manifest.path()).unwrap();
        cargo_toml_handle.write_all(toml_string.as_bytes()).unwrap();
    }
    let result = Execution::default().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Name"
        ),
        ""
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='LicenseFile']/@Source"
        ),
        StoredPathBuf::from_std_path(package_license.path())
            .unwrap()
            .to_string()
    );
}

#[test]
#[serial]
fn banner_works() {
    const EXPECTED: &str = "img\\Banner.bmp";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_banner = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    fs::create_dir("img").unwrap();
    let _banner_handle = File::create(package_banner.path()).unwrap();
    let result = Builder::default()
        .banner(package_banner.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUIBannerBmp']/@Value"
        ),
        package_banner.path().to_str().unwrap()
    );
}

#[test]
#[serial]
fn dialog_works() {
    const EXPECTED: &str = "img\\Dialog.bmp";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_dialog = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    fs::create_dir("img").unwrap();
    let _dialog_handle = File::create(package_dialog.path()).unwrap();
    let result = Builder::default()
        .dialog(package_dialog.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:WixVariable[@Id='WixUIDialogBmp']/@Value"
        ),
        package_dialog.path().to_str().unwrap()
    );
}

#[test]
#[serial]
fn product_icon_works() {
    const EXPECTED: &str = "img\\Product.ico";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package();
    let package_product_icon = package.child(EXPECTED);
    env::set_current_dir(package.path()).unwrap();
    fs::create_dir("img").unwrap();
    let _product_icon_handle = File::create(package_product_icon.path()).unwrap();
    let result = Builder::default()
        .product_icon(package_product_icon.path().to_str())
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:Icon[@Id='ProductICO']/@SourceFile"
        ),
        package_product_icon.path().to_str().unwrap()
    );
}

#[test]
#[serial]
fn multiple_binaries_works() {
    const EXPECTED_NAME_1: &str = "main1";
    const EXPECTED_SOURCE_1: &str = "$(var.CargoTargetBinDir)\\main1.exe";
    const EXPECTED_NAME_2: &str = "main2";
    const EXPECTED_SOURCE_2: &str = "$(var.CargoTargetBinDir)\\main2.exe";
    const EXPECTED_NAME_3: &str = "main3";
    const EXPECTED_SOURCE_3: &str = "$(var.CargoTargetBinDir)\\main3.exe";
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_package_multiple_binaries();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default().build().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe0']/@Name"
        ),
        format!("{EXPECTED_NAME_1}.exe")
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe0']/@Source"
        ),
        EXPECTED_SOURCE_1
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe1']/@Name"
        ),
        format!("{EXPECTED_NAME_2}.exe")
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe1']/@Source"
        ),
        EXPECTED_SOURCE_2
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe2']/@Name"
        ),
        format!("{EXPECTED_NAME_3}.exe")
    );
    assert_eq!(
        common::evaluate_xpath(
            package.child(MAIN_WXS_PATH.as_path()).path(),
            "//*/wix:File[@Id='exe2']/@Source"
        ),
        EXPECTED_SOURCE_3
    );
}

#[test]
#[serial]
fn workspace_no_package_fails() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_workspace();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default().build().run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_err());
}

#[test]
#[serial]
fn workspace_package_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_workspace();
    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default()
        .package(Some(SUBPACKAGE1_NAME))
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
    package
        .child(SUBPACKAGE1_NAME)
        .child(WIX_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(SUBPACKAGE1_NAME)
        .child(MAIN_WXS_PATH.as_path())
        .assert(predicate::path::exists());
    package
        .child(SUBPACKAGE1_NAME)
        .child(LICENSE_RTF_PATH.as_path())
        .assert(predicate::path::missing());
}

#[test]
#[serial]
fn workspace_package_with_license_works() {
    init_logging();
    let original_working_directory = env::current_dir().unwrap();
    let package = common::create_test_workspace();
    add_license_to_package(&package.path().join(SUBPACKAGE1_NAME), "GPL-3.0");
    add_license_to_package(&package.path().join(SUBPACKAGE2_NAME), "GPL-3.0");

    env::set_current_dir(package.path()).unwrap();
    let result = Builder::default()
        .package(Some(SUBPACKAGE1_NAME))
        .license(Some("license"))
        .build()
        .run();
    env::set_current_dir(original_working_directory).unwrap();
    assert!(result.is_ok());
}


================================================
FILE: xtask/Cargo.toml
================================================
[package]
name = "xtask"
version = "0.1.0"
authors = ["Chris Field <cfield2@gmail.com>"]
edition = "2018"
publish = false

[dependencies]
anyhow = "1"
structopt = "0.3"


================================================
FILE: xtask/src/main.rs
================================================
use anyhow::{bail, Result};
use structopt::StructOpt;

use std::env;
use std::fs;
use std::path::{Path, PathBuf};
use std::process::Command;

#[derive(Debug, StructOpt)]
enum XTask {
    /// Upload documentation to Github Pages (ghp) via the `gh-pages` branch.
    Ghp,
}

fn copy<U: AsRef<Path>, V: AsRef<Path>>(from: U, to: V) -> Result<()> {
    let mut stack = Vec::new();
    stack.push(PathBuf::from(from.as_ref()));

    let output_root = PathBuf::from(to.as_ref());
    let input_root = PathBuf::from(from.as_ref()).components().count();

    while let Some(working_path) = stack.pop() {
        println!("process: {}", &working_path.display());

        // Generate a relative path
        let src: PathBuf = working_path.components().skip(input_root).collect();

        // Create a destination if missing
        let dest = if src.components().count() == 0 {
            output_root.clone()
        } else {
            output_root.join(&src)
        };
        if fs::metadata(&dest).is_err() {
            println!("mkdir: {}", dest.display());
            fs::create_dir_all(&dest)?;
        }

        for entry in fs::read_dir(working_path)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_dir() {
                stack.push(path);
            } else {
                match path.file_name() {
                    Some(filename) => {
                        let dest_path = dest.join(filename);
                        println!("copy: {} -> {}", &path.display(), &dest_path.display());
                        fs::copy(&path, &dest_path)?;
                    }
                    None => {
                        println!("failed: {}", path.display());
                    }
                }
            }
        }
    }

    Ok(())
}

fn main() -> Result<()> {
    let args = XTask::from_args();
    match args {
        XTask::Ghp => {
            let cargo = env::var("CARGO")
                .map(PathBuf::from)
                .ok()
                .unwrap_or_else(|| PathBuf::from("cargo"));
            if !Command::new(cargo)
                .arg("doc")
                .arg("--no-deps")
                .status()?
                .success()
            {
                bail!("The 'cargo doc --no-deps' command failed");
            }
            if !Command::new("git")
                .arg("checkout")
                .arg("gh-pages")
                .status()?
                .success()
            {
                bail!("The 'git checkout gh-pages' command failed");
            }
            let mut target_doc_dir = PathBuf::from("target");
            target_doc_dir.push("doc");
            copy(target_doc_dir, env::current_dir()?)?;
            if !Command::new("git")
                .arg("add")
                .arg("--verbose")
                .arg("--all")
                .status()?
                .success()
            {
                bail!("The 'git add --verbose --all' command failed")
            }
            if Command::new("git")
                .arg("commit")
                .arg("--verbose")
                .arg("-m")
                .arg("Change content to match latest revision")
                .status()?
                .success()
            {
                if !Command::new("git").arg("push").status()?.success() {
                    bail!("The 'git push' command failed");
                }
            }
            if !Command::new("git")
                .arg("checkout")
                .arg("-")
                .status()?
                .success()
            {
                bail!("The 'git checkout main' command failed");
            }
        }
    }
    Ok(())
}