diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
new file mode 100644
index 0000000..c0090a3
--- /dev/null
+++ b/.github/workflows/lint.yml
@@ -0,0 +1,25 @@
+name: Lint
+
+on: [push, pull_request]
+
+env:
+  GITHUB_TOKEN: ${{ github.token }}
+
+jobs:
+  lint:
+    name: Check that code is lint clean using precious
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Configure Git
+        run: |
+          git config --global user.email "jdoe@example.com"
+          git config --global user.name "J. Doe"
+      - name: Run install-dev-tools.sh
+        run: |
+          set -e
+          mkdir $HOME/bin
+          ./dev/bin/install-dev-tools.sh
+      - name: Run precious
+        run: |
+          PATH=$PATH:$HOME/bin precious lint -a
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
new file mode 100644
index 0000000..f703d65
--- /dev/null
+++ b/.github/workflows/test.yml
@@ -0,0 +1,62 @@
+name: Self-test
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  test:
+    name: Test
+    strategy:
+      fail-fast: false
+      matrix:
+        platform:
+          - platform_name: Linux-x86_64
+            os: ubuntu-20.04
+            target: x86_64-unknown-linux-musl
+            cache-cross-binary: true
+          - platform_name: Linux-powerpc64
+            os: ubuntu-20.04
+            target: powerpc64-unknown-linux-gnu
+            cache-cross-binary: true
+          - platform_name: Windows-x86_64
+            os: windows-latest
+            target: x86_64-pc-windows-msvc
+          - platform_name: macOS-aarch64
+            os: macOS-latest
+            target: aarch64-apple-darwin
+
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Copy test project to root
+        shell: bash
+        run: |
+          cp -a test-project/* .
+          rm -fr test-project
+      - name: Build binary
+        uses: houseabsolute/actions-rust-cross@v0
+        with:
+          command: build
+          args: "--release"
+          target: ${{ matrix.platform.target }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      - name: Release
+        id: release
+        uses: ./
+        with:
+          executable-name: test-project
+          target: ${{ matrix.platform.target }}
+      - name: Install psutils on Windows
+        run: choco install --ignore-checksums psutils
+        if: runner.os == 'Windows'
+      - name: Check release artifacts
+        shell: bash
+        run: |
+          ./tests/check-release.pl \
+              --artifact-id "${{ steps.release.outputs.artifact-id }}" \
+              --executable-name test-project \
+              --github-token "${{ github.token }}" \
+              --repo houseabsolute/actions-rust-release \
+              --target "${{ matrix.platform.target }}"
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d87531b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+/node_modules
+/package-lock.json
+/package.json
+.\#*
+\#*\#
+test-project/**/target/**
diff --git a/Changes.md b/Changes.md
new file mode 100644
index 0000000..0747097
--- /dev/null
+++ b/Changes.md
@@ -0,0 +1,3 @@
+## 0.0.1 - 2024-09-14
+
+- First release upon an unsuspecting world.
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..261eeb9
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                                 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 [yyyy] [name of copyright owner]
+
+   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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..634066c
--- /dev/null
+++ b/README.md
@@ -0,0 +1,130 @@
+# GitHub Action to Release Rust Projects
+
+This action helps you create
+[GitHub Releases](https://docs.github.com/en/repositories/releasing-projects-on-github/managing-releases-in-a-repository)
+for Rust projects that produce an executable.
+
+Here's an example from the release workflow for
+[my tool `precious`](https://github.com/houseabsolute/precious):
+
+```yaml
+jobs:
+  release:
+    name: Release - ${{ matrix.platform.release_for }}
+    strategy:
+      matrix:
+        platform:
+          - os_name: Linux-x86_64
+            os: ubuntu-20.04
+            target: x86_64-unknown-linux-musl
+
+          - os_name: macOS-x86_64
+            os: macOS-latest
+            target: x86_64-apple-darwin
+
+            # more release targets here ...
+
+    runs-on: ${{ matrix.platform.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: Build executable
+        uses: houseabsolute/actions-rust-cross@v0
+        with:
+          target: ${{ matrix.platform.target }}
+          args: "--locked --release"
+          strip: true
+      - name: Publish artifacts and release
+        uses: houseabsolute/actions-rust-release@v0
+        with:
+          executable-name: ubi
+          target: ${{ matrix.platform.target }}
+        if: matrix.toolchain == 'stable'
+```
+
+## What It Does
+
+This action will do the following:
+
+- Package an executable, along with any additional files you specify (defaults to `README*` and
+  `Changes.md`). It will produce a tarball on all platforms but Windows, where it produces a zip
+  file.
+- Create a SHA256 checksum file for the tarball or zip file using `shasum`.
+- Upload the archive and checksum files as artifacts for your workflow.
+- If this action is called for a tag that matches the specified prefix (defaults to `v`), then it
+  will also create/update a GitHub Release for this tag, attaching the archive and checksum files as
+  release artifacts
+
+If you have a matrix build that creates executables for many platforms, you should call this action
+for each platform. It should work on any platform supported by GitHub Actions (Linux, macOS,
+Windows).
+
+## Input Parameters
+
+This action takes the following parameters:
+
+### `executable-name`
+
+- **Required**: yes
+
+The name of the executable that your project compiles to. In most cases, this is just the name of
+your project, like `cross` or `mise`.
+
+### `release-tag-prefix`
+
+- **Required**: no
+- **Default**: `"v"`
+
+The prefix for release tags. The default is "v", so that tags like "v1.2.3" trigger a release.
+
+### `target`
+
+- **Required:** no, if `archive-name` is provided.
+
+The target triple that this release was compiled for. This should be one of the targets found by
+running `rustup target list`.
+
+Either this input or the `archive-name` input must be provided.
+
+### `archive-name`
+
+- **Required**: no, if `target` is provided
+
+The name of the archive file to produce. This will contain the executable and any additional files
+specified in the `files-to-package` input, if any. If this isn't given, then one will be created
+based, starting with the `executable-name` and followed by elements from the `target` input.
+
+Either this input or the `target` input must be provided.
+
+### `extra-files`
+
+- **Required**: no
+
+This is a list of additional files or globs to include in the archive files for a release. This
+should be provided as a newline-separate list.
+
+Defaults to the file specified by the `changes-file` input and any file matching `README*` in the
+project root.
+
+If you _do_ specify any files, then you will need to also list the changes file and README
+explicitly if you want them to be included.
+
+### `changes-file`
+
+- **Required**: no
+- **Default**: `"Changes.md"`
+
+The name of the file that contains the changelog for this project. This will be used to generate a
+description for the GitHub Release.
+
+## Outputs
+
+This action provides two outputs.
+
+### `artifact-id`
+
+The ID of the workflow artifact that was created.
+
+### `artifact-url`
+
+The URL of the workflow artifact that was created.
diff --git a/action.yml b/action.yml
new file mode 100644
index 0000000..362925a
--- /dev/null
+++ b/action.yml
@@ -0,0 +1,133 @@
+name: "Release Rust project binaries as GitHub releases"
+author: "Dave Rolsky <autarch@urth.org>"
+branding:
+  icon: home
+  color: gray-dark
+description: |
+  This action provides tooling for releasing binaries from Rust projects as GitHub releases. It will
+  create a release from a tag and attach binaries to it. The binaries will be packed as either
+  tarballs (most platforms) or zip files (Windows). For each archive, a SHA-256 checksum file will
+  also published.
+
+  This action also uploads an artifact containing the files that _would_ be released every time it
+  is run, even if it doesn't do a release. This is useful in letting you see what a release for the
+  code would look like at any stage of development.
+
+  This is mostly a thin wrapper around
+  [softprops/action-gh-release](https://github.com/softprops/action-gh-release) with some additional
+  Rust-related bits.
+inputs:
+  executable-name:
+    description: |
+      The name of the executable. In most cases, this is just the name of your project, like `cross` or
+      `mise`. This is required.
+    required: true
+  release-tag-prefix:
+    description: |
+      The prefix for release tags. The default is "v", so that tags like "v1.2.3" trigger a
+      release.
+    default: "v"
+  target:
+    description: |
+      The rust target name, like "x86_64-unknown-linux-gnu". This is used to find the output of
+      `cargo build`. If this isn't provided, then this action will look for the build output under
+      `target/release`, instead of something like `target/x86_64-unknown-linux-gnu/release`.
+
+      Either this input or the `archive-name` input must be provided.
+  archive-name:
+    description: |
+      The name of the archive file to produce. This will contain the executable and any additional
+      files specified in the `files-to-package` input, if any. If this isn't given, then one will be
+      created based, starting with the `executable-name` and followed by elements from the `target`
+      input.
+
+      Either this input or the `target` input must be provided.
+  extra-files:
+    description: |
+      A newline separated list of additional files or globs to include in the archive files for a
+      release.
+
+      Defaults to the file specified by the `changes-file` input and any file matching `README*` in
+      the project root.
+
+      If you _do_ specify any files, then you will need to also list the changes file and README
+      explicitly if you want them to be included.
+  changes-file:
+    description: |
+      The name of the file that contains the changelog for this project. This will be used to
+      generate a description for the GitHub Release. The default is `Changes.md`.
+    default: "Changes.md"
+outputs:
+  artifact-id:
+    description: |
+      This is the ID of the artifact created by this action.
+    value: ${{ steps.publish-release-artifact.outputs.artifact-id }}
+  artifact-url:
+    description: |
+      This is the URL of the artifact created by this action.
+    value: ${{ steps.publish-release-artifact.outputs.artifact-url }}
+runs:
+  using: composite
+  steps:
+    - name: Show config
+      shell: bash
+      run: |
+        echo "release-tag-prefix = ${{ inputs.release-tag-prefix }}"
+        echo "executable-name = ${{ inputs.executable-name }}"
+        echo "target = ${{ inputs.target }}"
+        echo "archive-name = ${{ inputs.archive-name }}"
+        echo "extra-files = ${{ inputs.extra-files }}"
+        echo "changes-file = ${{ inputs.changes-file }}"
+        echo "github.ref = ${{ github.ref }}"
+        echo "github.ref_type = ${{ github.ref_type }}"
+        echo "matches release-tag-prefix = ${{ startsWith( github.ref_name, inputs.release-tag-prefix ) }}"
+    - name: Add this action's path to PATH
+      shell: bash
+      run: echo "${{ github.action_path }}" >> $GITHUB_PATH
+    - name: Package as archive
+      id: package-archive
+      shell: bash
+      run: |
+        make-archive.pl \
+            --executable-name "${{ inputs.executable-name }}" \
+            --target "${{ inputs.target }}" \
+            --archive-name "${{ inputs.archive-name }}" \
+            --changes-file "${{ inputs.changes-file }}" \
+            --extra-files "${{ inputs.extra-files }}"
+    - name: Generate SHA-256 checksum file (*nix)
+      shell: bash
+      run: |
+        set -e
+        set -x
+
+        shasum --algorithm 256 \
+            "${{ steps.package-archive.outputs.archive-basename }}" \
+            > "${{ steps.package-archive.outputs.archive-basename }}.sha256"
+      if: runner.os != 'Windows'
+    - name: Install dos2unix and psutils on Windows
+      shell: powershell
+      run: |
+        choco install --ignore-checksums dos2unix psutils
+      if: runner.os == 'Windows'
+    - name: Generate SHA-256 checksum file (Windows)
+      shell: powershell
+      run: |
+        shasum --algorithm 256 `
+            "${{ steps.package-archive.outputs.archive-basename }}" `
+            > "${{ steps.package-archive.outputs.archive-basename }}.sha256"
+        dos2unix "${{ steps.package-archive.outputs.archive-basename }}.sha256"
+      if: runner.os == 'Windows'
+    - name: Publish release artifact for run
+      id: publish-release-artifact
+      uses: actions/upload-artifact@v4
+      with:
+        name: ${{ steps.package-archive.outputs.archive-basename }}
+        path: ${{ steps.package-archive.outputs.archive-basename }}*
+    - name: Publish GitHub release
+      uses: softprops/action-gh-release@v2
+      with:
+        draft: true
+        # The trailing "*" should pick up the checksum file.
+        files: ${{ steps.package-archive.outputs.archive-basename }}*
+        body_path: ${{ inputs.changes-file }}
+      if: github.ref_type == 'tag' && startsWith( github.ref_name, inputs.release-tag-prefix )
diff --git a/dev/bin/install-dev-tools.sh b/dev/bin/install-dev-tools.sh
new file mode 100755
index 0000000..9234136
--- /dev/null
+++ b/dev/bin/install-dev-tools.sh
@@ -0,0 +1,51 @@
+#!/bin/bash
+
+set -eo pipefail
+set -x
+
+function run() {
+    echo "$1"
+    eval "$1"
+}
+
+function install_tools() {
+    curl --silent --location \
+        https://raw.githubusercontent.com/houseabsolute/ubi/master/bootstrap/bootstrap-ubi.sh |
+        sh
+    run "ubi --project houseabsolute/precious --in $HOME/bin"
+    run "ubi --project houseabsolute/omegasort --in $HOME/bin"
+    run "ubi --project koalaman/shellcheck --in $HOME/bin"
+    run "ubi --project mvdan/sh --in $HOME/bin --exe shfmt"
+    run "ubi --project crate-ci/typos --in $HOME/bin"
+    run "npm install prettier"
+    run "curl -L https://cpanmin.us/ -o $HOME/bin/cpanm"
+    run "chmod 0755 $HOME/bin/cpanm"
+    run "$HOME/bin/cpanm --sudo --notest Perl::Tidy"
+}
+
+if [ "$1" == "-v" ]; then
+    set -x
+fi
+
+mkdir -p "$HOME"/bin
+
+set +e
+echo ":$PATH:" | grep --extended-regexp ":$HOME/bin:" >&/dev/null
+# shellcheck disable=SC2181
+if [ "$?" -eq "0" ]; then
+    path_has_home_bin=1
+fi
+set -e
+
+if [ -z "$path_has_home_bin" ]; then
+    PATH=$HOME/bin:$PATH
+fi
+
+install_tools
+
+echo "Tools were installed into $HOME/bin."
+if [ -z "$path_has_home_bin" ]; then
+    echo "You should add $HOME/bin to your PATH."
+fi
+
+exit 0
diff --git a/git/hooks/pre-commit.sh b/git/hooks/pre-commit.sh
new file mode 100755
index 0000000..c8b5eb4
--- /dev/null
+++ b/git/hooks/pre-commit.sh
@@ -0,0 +1,14 @@
+#!/bin/bash
+
+status=0
+
+PRECIOUS=$(which precious)
+if [[ -z $PRECIOUS ]]; then
+    PRECIOUS=./bin/precious
+fi
+
+if ! "$PRECIOUS" lint -s; then
+    status=$((status + 1))
+fi
+
+exit $status
diff --git a/git/setup.pl b/git/setup.pl
new file mode 100755
index 0000000..8c99cb8
--- /dev/null
+++ b/git/setup.pl
@@ -0,0 +1,27 @@
+#!/usr/bin/env perl
+
+use strict;
+use warnings;
+
+use Cwd qw( abs_path );
+
+symlink_hook('pre-commit');
+
+sub symlink_hook {
+    my $hook = shift;
+
+    my $dot  = ".git/hooks/$hook";
+    my $file = "git/hooks/$hook.sh";
+    my $link = "../../$file";
+
+    if ( -e $dot ) {
+        if ( -l $dot ) {
+            return if readlink $dot eq $link;
+        }
+        warn "You already have a hook at $dot!\n";
+        return;
+    }
+
+    symlink $link, $dot
+        or die "Could not link $dot => $link: $!";
+}
diff --git a/make-archive.pl b/make-archive.pl
new file mode 100755
index 0000000..f73a8eb
--- /dev/null
+++ b/make-archive.pl
@@ -0,0 +1,208 @@
+#!/usr/bin/perl
+
+use v5.30;
+use strict;
+use warnings;
+no warnings 'experimental::signatures';
+use feature 'signatures';
+use autodie;
+
+use FindBin qw( $Bin );
+use File::Spec;
+use lib File::Spec->catdir( $Bin, 'lib' );
+
+use Cwd            qw( abs_path );
+use File::Basename qw( basename );
+use File::Copy     qw( copy );
+use File::Temp     qw( tempdir );
+use Getopt::Long;
+
+sub main {
+    GetOptions(
+        'executable-name=s' => \my $executable_name,
+        'target=s'          => \my $target,
+        'archive-name=s'    => \my $archive_name,
+        'changes-file=s'    => \my $changes_file,
+        'extra-files=s'     => \my $extra_files,
+    );
+
+    if ( !$executable_name ) {
+        die 'The --executable-name option is required.';
+    }
+
+    if ( !( $target || $archive_name ) ) {
+        die 'You must provide either a target or archive-name when using this action.';
+    }
+
+    if ( $changes_file && !-f $changes_file ) {
+        die "Changes file '$changes_file' does not exist.";
+    }
+
+    if ( !$archive_name ) {
+        $archive_name = $executable_name . q{-} . target_to_archive_name($target);
+    }
+
+    my $archive_extension = $ENV{RUNNER_OS} eq 'Windows' ? '.zip' : '.tar.gz';
+    my $archive_file = File::Spec->catfile( abs_path('.'), $archive_name . $archive_extension );
+
+    $executable_name .= '.exe' if $ENV{RUNNER_OS} eq 'Windows';
+
+    my @look_for = (
+        File::Spec->catfile( 'target', $target,   'release', $executable_name ),
+        File::Spec->catfile( 'target', 'release', $executable_name )
+    );
+    my @files;
+    for my $file (@look_for) {
+        if ( -f $file ) {
+            say "Found executable at $file";
+            push @files, $file;
+            last;
+        }
+    }
+
+    if ( !@files ) {
+        my $msg = "Could not find executable in any of:\n";
+        $msg .= "  $_\n" for @look_for;
+        die $msg;
+    }
+
+    if ($extra_files) {
+        $extra_files =~ s/^\s+|\s+$//gs;
+        push @files, split /\n/, $extra_files;
+    }
+    else {
+        push @files, $changes_file;
+        push @files, glob 'README*';
+    }
+
+    my $td = tempdir( CLEANUP => 1 );
+    for my $file (@files) {
+        copy( $file => $td )
+            or die "Cannot copy $file => $td: $!";
+    }
+
+    chdir $td;
+
+    my @cmd
+        = $ENV{RUNNER_OS} eq 'Windows'
+        ? ( '7z', 'a', $archive_file, glob('*') )
+        : ( 'tar', 'czf', $archive_file, glob('*') );
+
+    say "Running [@cmd]";
+    system(@cmd);
+
+    open my $fh, '>>', $ENV{GITHUB_OUTPUT};
+    my $archive_basename = basename($archive_file);
+    say {$fh} "archive-basename=$archive_basename";
+    close $fh;
+}
+
+sub target_to_archive_name($target) {
+    my ( $cpu, @rest ) = split /-/, $target;
+    $cpu =~ s/aarch64/arm64/;
+
+    if ( $rest[0] =~ /^(?:apple|pc|sun|unknown)$/ ) {
+        shift @rest;
+    }
+    my $os = shift @rest;
+
+    # If there's more it's something like "-gnu" or "-msvc".
+    if (@rest) {
+        $os .= '-' . $rest[0];
+    }
+
+    unless ( $os =~ s/darwin/macOS/
+        || $os =~ s/freebsd/FreeBSD/
+        || $os =~ s/ios/iOS/
+        || $os =~ s/netbsd/NetBSD/
+        || $os =~ s/openbsd/OpenBSD/ ) {
+
+        $os = ucfirst $os;
+    }
+
+    return "$os-$cpu";
+}
+
+sub test {
+    require Test::More;
+    Test::More->import;
+
+    my %tests = (
+        'aarch64-apple-darwin'                => 'macOS-arm64',
+        'aarch64-apple-ios'                   => 'iOS-arm64',
+        'aarch64-apple-ios-sim'               => 'iOS-sim-arm64',
+        'aarch64-linux-android'               => 'Linux-android-arm64',
+        'aarch64-pc-windows-gnullvm'          => 'Windows-gnullvm-arm64',
+        'aarch64-pc-windows-msvc'             => 'Windows-msvc-arm64',
+        'aarch64-unknown-fuchsia'             => 'Fuchsia-arm64',
+        'aarch64-unknown-linux-gnu'           => 'Linux-gnu-arm64',
+        'aarch64-unknown-linux-musl'          => 'Linux-musl-arm64',
+        'aarch64-unknown-linux-ohos'          => 'Linux-ohos-arm64',
+        'arm-linux-androideabi'               => 'Linux-androideabi-arm',
+        'arm-unknown-linux-gnueabi'           => 'Linux-gnueabi-arm',
+        'arm-unknown-linux-gnueabihf'         => 'Linux-gnueabihf-arm',
+        'arm-unknown-linux-musleabi'          => 'Linux-musleabi-arm',
+        'arm-unknown-linux-musleabihf'        => 'Linux-musleabihf-arm',
+        'armv5te-unknown-linux-gnueabi'       => 'Linux-gnueabi-armv5te',
+        'armv5te-unknown-linux-musleabi'      => 'Linux-musleabi-armv5te',
+        'armv7-linux-androideabi'             => 'Linux-androideabi-armv7',
+        'armv7-unknown-linux-gnueabi'         => 'Linux-gnueabi-armv7',
+        'armv7-unknown-linux-gnueabihf'       => 'Linux-gnueabihf-armv7',
+        'armv7-unknown-linux-musleabi'        => 'Linux-musleabi-armv7',
+        'armv7-unknown-linux-musleabihf'      => 'Linux-musleabihf-armv7',
+        'armv7-unknown-linux-ohos'            => 'Linux-ohos-armv7',
+        'i586-pc-windows-msvc'                => 'Windows-msvc-i586',
+        'i586-unknown-linux-gnu'              => 'Linux-gnu-i586',
+        'i586-unknown-linux-musl'             => 'Linux-musl-i586',
+        'i686-linux-android'                  => 'Linux-android-i686',
+        'i686-pc-windows-gnu'                 => 'Windows-gnu-i686',
+        'i686-pc-windows-gnullvm'             => 'Windows-gnullvm-i686',
+        'i686-pc-windows-msvc'                => 'Windows-msvc-i686',
+        'i686-unknown-freebsd'                => 'FreeBSD-i686',
+        'i686-unknown-linux-gnu'              => 'Linux-gnu-i686',
+        'i686-unknown-linux-musl'             => 'Linux-musl-i686',
+        'loongarch64-unknown-linux-gnu'       => 'Linux-gnu-loongarch64',
+        'powerpc-unknown-linux-gnu'           => 'Linux-gnu-powerpc',
+        'powerpc64-unknown-linux-gnu'         => 'Linux-gnu-powerpc64',
+        'powerpc64le-unknown-linux-gnu'       => 'Linux-gnu-powerpc64le',
+        'riscv64gc-unknown-linux-gnu'         => 'Linux-gnu-riscv64gc',
+        's390x-unknown-linux-gnu'             => 'Linux-gnu-s390x',
+        'sparc64-unknown-linux-gnu'           => 'Linux-gnu-sparc64',
+        'sparcv9-sun-solaris'                 => 'Solaris-sparcv9',
+        'thumbv7neon-linux-androideabi'       => 'Linux-androideabi-thumbv7neon',
+        'thumbv7neon-unknown-linux-gnueabihf' => 'Linux-gnueabihf-thumbv7neon',
+        'x86_64-apple-darwin'                 => 'macOS-x86_64',
+        'x86_64-apple-ios'                    => 'iOS-x86_64',
+        'x86_64-linux-android'                => 'Linux-android-x86_64',
+        'x86_64-pc-solaris'                   => 'Solaris-x86_64',
+        'x86_64-pc-windows-gnu'               => 'Windows-gnu-x86_64',
+        'x86_64-pc-windows-gnullvm'           => 'Windows-gnullvm-x86_64',
+        'x86_64-pc-windows-msvc'              => 'Windows-msvc-x86_64',
+        'x86_64-unknown-freebsd'              => 'FreeBSD-x86_64',
+        'x86_64-unknown-fuchsia'              => 'Fuchsia-x86_64',
+        'x86_64-unknown-illumos'              => 'Illumos-x86_64',
+        'x86_64-unknown-linux-gnu'            => 'Linux-gnu-x86_64',
+        'x86_64-unknown-linux-gnux32'         => 'Linux-gnux32-x86_64',
+        'x86_64-unknown-linux-musl'           => 'Linux-musl-x86_64',
+        'x86_64-unknown-linux-ohos'           => 'Linux-ohos-x86_64',
+        'x86_64-unknown-netbsd'               => 'NetBSD-x86_64',
+        'x86_64-unknown-redox'                => 'Redox-x86_64',
+    );
+
+    for my $target ( keys %tests ) {
+        is(
+            target_to_archive_name($target),
+            $tests{$target},
+            "$target == $tests{$target}",
+        );
+    }
+
+    done_testing();
+}
+
+if ( $ENV{TAP_VERSION} ) {
+    test();
+}
+else {
+    main();
+}
diff --git a/perltidyrc b/perltidyrc
new file mode 100644
index 0000000..863fe02
--- /dev/null
+++ b/perltidyrc
@@ -0,0 +1,22 @@
+-l=100
+-i=4
+-ci=4
+-se
+-b
+-bar
+-boc
+-vt=0
+-vtc=0
+-cti=0
+-pt=1
+-bt=1
+-sbt=1
+-bbt=1
+-nolq
+-npro
+-nsfs
+--blank-lines-before-packages=0
+--opening-hash-brace-right
+--no-outdent-long-comments
+--iterations=2
+-wbb="% + - * / x != == >= <= =~ !~ < > | & >= < = **= += *= &= <<= &&= -= /= |= >>= ||= .= %= ^= x="
diff --git a/precious.toml b/precious.toml
new file mode 100644
index 0000000..c6ef685
--- /dev/null
+++ b/precious.toml
@@ -0,0 +1,74 @@
+exclude = [
+  "target",
+  "tests/lib/**/*",
+]
+
+[commands.typos]
+type = "both"
+include = "**/*"
+exclude = "**/*.tar.gz"
+invoke = "once"
+cmd = "typos"
+tidy_flags = "--write-changes"
+ok-exit-codes = 0
+lint-failure-exit-codes = 2
+
+[commands.perltidy]
+type = "both"
+include = [ "**/*.{pl,pm,t,psgi}" ]
+exclude = "tests/lib/**"
+cmd = [ "perltidy", "--profile=$PRECIOUS_ROOT/perltidyrc" ]
+lint_flags = [ "--assert-tidy", "--no-standard-output", "--outfile=/dev/null" ]
+tidy_flags = [ "--backup-and-modify-in-place", "--backup-file-extension=/" ]
+ok_exit_codes = 0
+lint_failure_exit_codes = 2
+ignore_stderr = "Begin Error Output Stream"
+
+[commands.prettier-md]
+type    = "both"
+include = [ "**/*.md" ]
+cmd     = [ "./node_modules/.bin/prettier", "--no-config", "--print-width", "100", "--prose-wrap", "always" ]
+lint_flags = "--check"
+tidy_flags = "--write"
+ok_exit_codes = 0
+lint_failure_exit_codes = 1
+ignore_stderr = [ "Code style issues" ]
+
+[commands.prettier-yml]
+type    = "both"
+include = [ "**/*.yml" ]
+cmd     = [ "./node_modules/.bin/prettier", "--no-config" ]
+lint_flags = "--check"
+tidy_flags = "--write"
+ok_exit_codes = 0
+lint_failure_exit_codes = 1
+ignore_stderr = [ "Code style issues" ]
+
+[commands.omegasort-gitignore]
+type = "both"
+include = "**/.gitignore"
+cmd = [ "omegasort", "--sort", "path", "--unique" ]
+lint_flags = "--check"
+tidy_flags = "--in-place"
+ok_exit_codes = 0
+lint_failure_exit_codes = 1
+ignore_stderr = [
+    "The .+ file is not sorted",
+    "The .+ file is not unique",
+]
+
+[commands.shellcheck]
+type = "lint"
+include = "**/*.sh"
+cmd = "shellcheck"
+ok_exit_codes = 0
+lint_failure_exit_codes = 1
+
+[commands.shfmt]
+type = "both"
+include = "**/*.sh"
+cmd = ["shfmt", "--simplify", "--indent", "4"]
+lint_flags = "--diff"
+tidy_flags = "--write"
+ok_exit_codes = 0
+lint_failure_exit_codes = 1
diff --git a/test-project/Cargo.lock b/test-project/Cargo.lock
new file mode 100644
index 0000000..6e82782
--- /dev/null
+++ b/test-project/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "test-project"
+version = "0.1.0"
diff --git a/test-project/Cargo.toml b/test-project/Cargo.toml
new file mode 100644
index 0000000..7fded9f
--- /dev/null
+++ b/test-project/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "test-project"
+version = "0.1.0"
+edition = "2021"
+
+# workaround for https://github.com/cross-rs/cross/issues/1345
+[package.metadata.cross.target.x86_64-unknown-netbsd]
+pre-build = [
+    "mkdir -p /tmp/netbsd",
+    "curl https://cdn.netbsd.org/pub/NetBSD/NetBSD-9.2/amd64/binary/sets/base.tar.xz -O",
+    "tar -C /tmp/netbsd -xJf base.tar.xz",
+    "cp /tmp/netbsd/usr/lib/libexecinfo.so /usr/local/x86_64-unknown-netbsd/lib",
+    "rm base.tar.xz",
+    "rm -rf /tmp/netbsd",
+]
diff --git a/test-project/src/main.rs b/test-project/src/main.rs
new file mode 100644
index 0000000..b80f5b7
--- /dev/null
+++ b/test-project/src/main.rs
@@ -0,0 +1,11 @@
+fn main() {
+    println!("Hello, world!");
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn test_something() {
+        assert_eq!(1, 1);
+    }
+}
diff --git a/tests/check-release.pl b/tests/check-release.pl
new file mode 100755
index 0000000..516e0ff
--- /dev/null
+++ b/tests/check-release.pl
@@ -0,0 +1,89 @@
+#!/usr/bin/env perl
+
+use v5.30;
+use strict;
+use warnings;
+no warnings 'experimental::signatures';
+use feature 'signatures';
+
+use FindBin qw( $Bin );
+use File::Spec;
+use lib File::Spec->catdir( $Bin, 'lib' );
+
+use autodie qw( :all );
+
+use Digest::SHA;
+use File::Temp qw( tempdir );
+use Getopt::Long;
+use IPC::System::Simple qw( capturex );
+use Test::More;
+
+sub main {
+    my $artifact_id;
+    my $executable_name;
+    my $github_token;
+    my $repo;
+    my $target;
+
+    GetOptions(
+        'artifact-id=s'     => \$artifact_id,
+        'executable-name=s' => \$executable_name,
+        'github-token=s'    => \$github_token,
+        'repo=s'            => \$repo,
+        'target=s'          => \$target,
+    );
+
+    # We want to run this in a clean dir to avoid any conflicts with files in the current dir, like
+    # the archive file containing the release.
+    my $td = tempdir();
+    chdir $td;
+
+    system(
+        'curl',
+        '-L',
+        '-H', 'Accept: application/vnd.github+json',
+        '-H', "Authorization: Bearer $github_token",
+        '-o', 'artifact.zip',
+        "https://api.github.com/repos/$repo/actions/artifacts/$artifact_id/zip",
+    );
+
+    system( 'unzip', 'artifact.zip' );
+
+    my $glob  = $target =~ /windows/i ? 'test-project*.zip*' : 'test-project*.tar.gz*';
+    my @files = glob $glob;
+
+    is( scalar @files, 2, 'found two files in the artifact tarball' )
+        or diag("@files");
+    my ($archive_file)  = grep { !/sha256/ } @files;
+    my ($checksum_file) = grep {/sha256/} @files;
+
+    ok( $archive_file,  'found an archive file in the artifact tarball' );
+    ok( $checksum_file, 'found a checksum file in the artifact tarball' );
+
+    open my $fh, '<', $checksum_file;
+    my $sha256_contents = do { local $/; <$fh> };
+    $sha256_contents =~ s/^\s+|\s+$//g;
+    my ( $checksum, $filename ) = $sha256_contents =~ /^(\S+) [ \*](\S+)$/;
+    is( $filename, $archive_file, 'filename in checksum file matches archive filename' )
+        or diag($sha256_contents);
+
+    # I would prefer to just run shasum but I wasn't able to get it to run on Windows.
+    my $sha = Digest::SHA->new(256);
+    $sha->addfile($filename);
+    is( $checksum, $sha->hexdigest, 'checksum in checksum file is correct' );
+
+    if ( $archive_file =~ /\.zip$/ ) {
+        system( 'unzip', $archive_file );
+    }
+    else {
+        system( 'tar', 'xzf', $archive_file );
+    }
+
+    for my $file ( $executable_name, qw( README.md Changes.md ) ) {
+        ok( -f $file, "$file exists after unpacking archive" );
+    }
+
+    done_testing();
+}
+
+main();
diff --git a/tests/lib/IPC/System/Simple.pm b/tests/lib/IPC/System/Simple.pm
new file mode 100644
index 0000000..c869862
--- /dev/null
+++ b/tests/lib/IPC/System/Simple.pm
@@ -0,0 +1,1115 @@
+package IPC::System::Simple;
+
+# ABSTRACT: Run commands simply, with detailed diagnostics
+
+use 5.006;
+use strict;
+use warnings;
+use re 'taint';
+use Carp;
+use List::Util qw(first);
+use Scalar::Util qw(tainted);
+use Config;
+use constant WINDOWS => ($^O eq 'MSWin32');
+use constant VMS     => ($^O eq 'VMS');
+
+BEGIN {
+
+    # It would be lovely to use the 'if' module here, but it didn't
+    # enter core until 5.6.2, and we want to keep 5.6.0 compatibility.
+
+
+    if (WINDOWS) {
+
+        ## no critic (ProhibitStringyEval)
+
+        eval q{
+            use Win32::Process qw(INFINITE NORMAL_PRIORITY_CLASS);
+            use File::Spec;
+            use Win32;
+            use Win32::ShellQuote;
+
+            # This uses the same rules as the core win32.c/get_shell() call.
+            use constant WINDOWS_SHELL => eval { Win32::IsWinNT() }
+                ? [ File::Spec->catfile(Win32::GetFolderPath(Win32::CSIDL_SYSTEM), 'cmd.exe'), '/x/d/c' ]
+                : [ File::Spec->catfile(Win32::GetFolderPath(Win32::CSIDL_SYSTEM), 'command.com'), '/c' ];
+
+            # These are used when invoking _win32_capture
+            use constant NO_SHELL  => 0;
+            use constant USE_SHELL => 1;
+
+        };
+
+        ## use critic
+
+        # Die nosily if any of the above broke.
+        die $@ if $@;
+    }
+}
+
+# Note that we don't use WIFSTOPPED because perl never uses
+# the WUNTRACED flag, and hence will never return early from
+# system() if the child processes is suspended with a SIGSTOP.
+
+use POSIX qw(WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG);
+
+use constant FAIL_START     => q{"%s" failed to start: "%s"};
+use constant FAIL_PLUMBING  => q{Error in IPC::System::Simple plumbing: "%s" - "%s"};
+use constant FAIL_CMD_BLANK => q{Entirely blank command passed: "%s"};
+use constant FAIL_INTERNAL  => q{Internal error in IPC::System::Simple: "%s"};
+use constant FAIL_TAINT     => q{%s called with tainted argument "%s"};
+use constant FAIL_TAINT_ENV => q{%s called with tainted environment $ENV{%s}};
+use constant FAIL_SIGNAL    => q{"%s" died to signal "%s" (%d)%s};
+use constant FAIL_BADEXIT   => q{"%s" unexpectedly returned exit value %d};
+
+use constant FAIL_UNDEF     => q{%s called with undefined command};
+
+
+use constant FAIL_POSIX     => q{IPC::System::Simple does not understand the POSIX error '%s'.  Please check https://metacpan.org/pod/IPC::System::Simple to see if there is an updated version.  If not please report this as a bug to https://github.com/pjf/ipc-system-simple/issues};
+
+# On Perl's older than 5.8.x we can't assume that there'll be a
+# $^{TAINT} for us to check, so we assume that our args may always
+# be tainted.
+use constant ASSUME_TAINTED => ($] < 5.008);
+
+use constant EXIT_ANY_CONST => -1;			# Used internally
+use constant EXIT_ANY       => [ EXIT_ANY_CONST ];	# Exported
+
+use constant UNDEFINED_POSIX_RE => qr{not (?:defined|a valid) POSIX macro|not implemented on this architecture};
+
+require Exporter;
+our @ISA = qw(Exporter);
+
+our @EXPORT_OK = qw( 
+    capture  capturex
+    run      runx
+    system   systemx
+    $EXITVAL EXIT_ANY
+);
+
+our $VERSION = '1.30';
+$VERSION =~ tr/_//d;
+
+our $EXITVAL = -1;
+
+my @Signal_from_number = split(' ', $Config{sig_name});
+
+# Environment variables we don't want to see tainted.
+my @Check_tainted_env = qw(PATH IFS CDPATH ENV BASH_ENV);
+if (WINDOWS) {
+	push(@Check_tainted_env, 'PERL5SHELL');
+}
+if (VMS) {
+	push(@Check_tainted_env, 'DCL$PATH');
+}
+
+# Not all systems implement the WIFEXITED calls, but POSIX
+# will always export them (even if they're just stubs that
+# die with an error).  Test for the presence of a working
+# WIFEXITED and friends, or define our own.
+
+eval { WIFEXITED(0); };
+
+if ($@ =~ UNDEFINED_POSIX_RE) {
+        no warnings 'redefine';  ## no critic
+	*WIFEXITED   = sub { not $_[0] & 0xff };
+	*WEXITSTATUS = sub { $_[0] >> 8  };
+	*WIFSIGNALED = sub { $_[0] & 127 };
+	*WTERMSIG    = sub { $_[0] & 127 };
+} elsif ($@) {
+	croak sprintf FAIL_POSIX, $@;
+}
+
+# None of the POSIX modules I've found define WCOREDUMP, although
+# many systems define it.  Check the POSIX module in the hope that
+# it may actually be there.
+
+
+# TODO: Ideally, $NATIVE_WCOREDUMP should be a constant.
+
+my $NATIVE_WCOREDUMP;
+
+eval { POSIX::WCOREDUMP(1); };
+
+if ($@ =~ UNDEFINED_POSIX_RE) {
+	*WCOREDUMP = sub { $_[0] & 128 };
+        $NATIVE_WCOREDUMP = 0;
+} elsif ($@) {
+	croak sprintf FAIL_POSIX, $@;
+} else {
+	# POSIX actually has it defined!  Huzzah!
+	*WCOREDUMP = \&POSIX::WCOREDUMP;
+        $NATIVE_WCOREDUMP = 1;
+}
+
+sub _native_wcoredump {
+    return $NATIVE_WCOREDUMP;
+}
+
+# system simply calls run
+
+no warnings 'once'; ## no critic
+*system  = \&run;
+*systemx = \&runx;
+use warnings;
+
+# run is our way of running a process with system() semantics
+
+sub run {
+
+	_check_taint(@_);
+
+	my ($valid_returns, $command, @args) = _process_args(@_);
+
+        # If we have arguments, we really want to call systemx,
+        # so we do so.
+
+	if (@args) {
+                return systemx($valid_returns, $command, @args);
+	}
+
+    if (WINDOWS) {
+        my $pid = _spawn_or_die(&WINDOWS_SHELL->[0], join ' ', @{&WINDOWS_SHELL}, $command);
+        $pid->Wait(INFINITE);	# Wait for process exit.
+        $pid->GetExitCode($EXITVAL);
+        return _check_exit($command,$EXITVAL,$valid_returns);
+    }
+
+    # Without arguments, we're calling system, and checking
+        # the results.
+
+	# We're throwing our own exception on command not found, so
+	# we don't need a warning from Perl.
+
+        {
+            # silence 'Statement unlikely to be reached' warning
+            no warnings 'exec';             ## no critic
+            CORE::system($command,@args);
+        }
+
+	return _process_child_error($?,$command,$valid_returns);
+}
+
+# runx is just like system/run, but *never* invokes the shell.
+
+sub runx {
+    _check_taint(@_);
+
+    my ($valid_returns, $command, @args) = _process_args(@_);
+
+    if (WINDOWS) {
+        our $EXITVAL = -1;
+
+        my $pid = _spawn_or_die($command, Win32::ShellQuote::quote_native($command, @args));
+
+        $pid->Wait(INFINITE);	# Wait for process exit.
+        $pid->GetExitCode($EXITVAL);
+        return _check_exit($command,$EXITVAL,$valid_returns);
+    }
+
+    # If system() fails, we throw our own exception.  We don't
+    # need to have perl complain about it too.
+
+    no warnings; ## no critic
+
+    CORE::system { $command } $command, @args;
+
+    return _process_child_error($?, $command, $valid_returns);
+}
+
+# capture is our way of running a process with backticks/qx semantics
+
+sub capture {
+	_check_taint(@_);
+
+	my ($valid_returns, $command, @args) = _process_args(@_);
+
+        if (@args) {
+            return capturex($valid_returns, $command, @args);
+        }
+
+        if (WINDOWS) {
+            # USE_SHELL really means "You may use the shell if you need it."
+            return _win32_capture(USE_SHELL, $valid_returns, $command);
+        }
+
+	our $EXITVAL = -1;
+
+	my $wantarray = wantarray();
+
+	# We'll produce our own warnings on failure to execute.
+	no warnings 'exec';	## no critic
+
+        if ($wantarray) {
+                my @results = qx($command);
+                _process_child_error($?,$command,$valid_returns);
+                return @results;
+        } 
+
+        my $results = qx($command);
+        _process_child_error($?,$command,$valid_returns);
+        return $results;
+}
+
+# _win32_capture implements the capture and capurex commands on Win32.
+# We need to wrap the whole internals of this sub into
+# an if (WINDOWS) block to avoid it being compiled on non-Win32 systems.
+
+sub _win32_capture {
+    if (not WINDOWS) {
+        croak sprintf(FAIL_INTERNAL, "_win32_capture called when not under Win32");
+    } else {
+
+        my ($use_shell, $valid_returns, $command, @args) = @_;
+
+        my $wantarray = wantarray();
+
+        # Perl doesn't support multi-arg open under
+        # Windows.  Perl also doesn't provide very good
+        # feedback when normal backtails fail, either;
+        # it returns exit status from the shell
+        # (which is indistinguishable from the command
+        # running and producing the same exit status).
+
+        # As such, we essentially have to write our own
+        # backticks.
+
+        # We start by dup'ing STDOUT.
+
+        open(my $saved_stdout, '>&', \*STDOUT)  ## no critic
+                or croak sprintf(FAIL_PLUMBING, "Can't dup STDOUT", $!);
+
+        # We now open up a pipe that will allow us to	
+        # communicate with the new process.
+
+        pipe(my ($read_fh, $write_fh))
+                or croak sprintf(FAIL_PLUMBING, "Can't create pipe", $!);
+
+        # Allow CRLF sequences to become "\n", since
+        # this is what Perl backticks do.
+
+        binmode($read_fh, ':crlf');
+
+        # Now we re-open our STDOUT to $write_fh...
+
+        open(STDOUT, '>&', $write_fh)  ## no critic
+                or croak sprintf(FAIL_PLUMBING, "Can't redirect STDOUT", $!);
+
+        # If we have args, or we're told not to use the shell, then
+        # we treat $command as our shell.  Otherwise we grub around
+        # in our command to look for a command to run.
+        #
+        # Note that we don't actually *use* the shell (although in
+        # a future version we might).  Being told not to use the shell
+        # (capturex) means we treat our command as really being a command,
+        # and not a command line.
+
+        my $exe =   @args                      ? $command :
+                    (! $use_shell)             ? $command :
+                    $command =~ m{^"([^"]+)"}x ? $1       :
+                    $command =~ m{(\S+)     }x ? $1       :
+                    croak sprintf(FAIL_CMD_BLANK, $command);
+
+        # And now we spawn our new process with inherited
+        # filehandles.
+
+        my $err;
+        my $pid = eval { 
+                _spawn_or_die($exe, @args ? Win32::ShellQuote::quote_native($command, @args) : $command);
+        }
+        or do {
+                $err = $@;
+        };
+
+        # Regardless of whether our command ran, we must restore STDOUT.
+        # RT #48319
+        open(STDOUT, '>&', $saved_stdout)  ## no critic
+                or croak sprintf(FAIL_PLUMBING,"Can't restore STDOUT", $!);
+
+        # And now, if there was an actual error , propagate it.
+        die $err if defined $err;   # If there's an error from _spawn_or_die
+
+        # Clean-up the filehandles we no longer need...
+
+        close($write_fh)
+                or croak sprintf(FAIL_PLUMBING,q{Can't close write end of pipe}, $!);
+        close($saved_stdout)
+                or croak sprintf(FAIL_PLUMBING,q{Can't close saved STDOUT}, $!);
+
+        # Read the data from our child...
+
+        my (@results, $result);
+
+        if ($wantarray) {
+                @results = <$read_fh>;
+        } else {
+                $result = join("",<$read_fh>);
+        }
+
+        # Tidy up our windows process and we're done!
+
+        $pid->Wait(INFINITE);	# Wait for process exit.
+        $pid->GetExitCode($EXITVAL);
+
+        _check_exit($command,$EXITVAL,$valid_returns);
+
+        return $wantarray ? @results : $result;
+
+    }
+}
+
+# capturex() is just like backticks/qx, but never invokes the shell.
+
+sub capturex {
+	_check_taint(@_);
+
+	my ($valid_returns, $command, @args) = _process_args(@_);
+
+	our $EXITVAL = -1;
+
+	my $wantarray = wantarray();
+
+	if (WINDOWS) {
+            return _win32_capture(NO_SHELL, $valid_returns, $command, @args);
+        }
+
+	# We can't use a multi-arg piped open here, since 5.6.x
+	# doesn't like them.  Instead we emulate what 5.8.x does,
+	# which is to create a pipe(), set the close-on-exec flag
+	# on the child, and the fork/exec.  If the exec fails, the
+	# child writes to the pipe.  If the exec succeeds, then
+	# the pipe closes without data.
+
+	pipe(my ($read_fh, $write_fh))
+		or croak sprintf(FAIL_PLUMBING, "Can't create pipe", $!);
+
+	# This next line also does an implicit fork.
+	my $pid = open(my $pipe, '-|');	 ## no critic
+
+	if (not defined $pid) {
+		croak sprintf(FAIL_START, $command, $!);
+	} elsif (not $pid) {
+		# Child process, execs command.
+
+		close($read_fh);
+
+		# TODO: 'no warnings exec' doesn't get rid
+		# of the 'unlikely to be reached' warnings.
+		# This is a bug in perl / perldiag / perllexwarn / warnings.
+
+		no warnings;   ## no critic
+
+		CORE::exec { $command } $command, @args;
+
+		# Oh no, exec fails!  Send the reason why to
+		# the parent.
+
+		print {$write_fh} int($!);
+		exit(-1);
+	}
+
+	{
+		# In parent process.
+
+		close($write_fh);
+
+		# Parent process, check for child error.
+		my $error = <$read_fh>;
+
+		# Tidy up our pipes.
+		close($read_fh);
+
+		# Check for error.
+		if ($error) {
+			# Setting $! to our child error number gives
+			# us nice looking strings when printed.
+			local $! = $error;
+			croak sprintf(FAIL_START, $command, $!);
+		}
+	}
+
+	# Parent process, we don't care about our pid, but we
+	# do go and read our pipe.
+
+	if ($wantarray) {
+		my @results = <$pipe>;
+		close($pipe);
+		_process_child_error($?,$command,$valid_returns);
+		return @results;
+	}
+
+	# NB: We don't check the return status on close(), since
+	# on failure it sets $?, which we then inspect for more
+	# useful information.
+
+	my $results = join("",<$pipe>);
+	close($pipe);
+	_process_child_error($?,$command,$valid_returns);
+	
+	return $results;
+
+}
+
+# Tries really hard to spawn a process under Windows.  Returns
+# the pid on success, or undef on error.
+
+sub _spawn_or_die {
+
+	# We need to wrap practically the entire sub in an
+	# if block to ensure it doesn't get compiled under non-Win32
+	# systems.  Compiling on these systems would not only be a
+	# waste of time, but also results in complaints about
+	# the NORMAL_PRIORITY_CLASS constant.
+
+	if (not WINDOWS) {
+		croak sprintf(FAIL_INTERNAL, "_spawn_or_die called when not under Win32");
+	} else {
+		my ($orig_exe, $cmdline) = @_;
+		my $pid;
+
+		my $exe = $orig_exe;
+
+		# If our command doesn't have an extension, add one.
+		$exe .= $Config{_exe} if ($exe !~ m{\.});
+
+		Win32::Process::Create(
+			$pid, $exe, $cmdline, 1, NORMAL_PRIORITY_CLASS, "."
+		) and return $pid;
+
+		my @path = split(/;/,$ENV{PATH});
+
+		foreach my $dir (@path) {
+			my $fullpath = File::Spec->catfile($dir,$exe);
+
+			# We're using -x here on the assumption that stat()
+			# is faster than spawn, so trying to spawn a process
+			# for each path element will be unacceptably
+			# inefficient.
+
+			if (-x $fullpath) {
+				Win32::Process::Create(
+					$pid, $fullpath, $cmdline, 1,
+					NORMAL_PRIORITY_CLASS, "."
+				) and return $pid;
+			}
+		}
+
+		croak sprintf(FAIL_START, $orig_exe, $^E);
+	}
+}
+
+# Complain on tainted arguments or environment.
+# ASSUME_TAINTED is true for 5.6.x, since it's missing ${^TAINT}
+
+sub _check_taint {
+	return if not (ASSUME_TAINTED or ${^TAINT});
+	my $caller = (caller(1))[3];
+	foreach my $var (@_) {
+		if (tainted $var) {
+			croak sprintf(FAIL_TAINT, $caller, $var);
+		}
+	}
+	foreach my $var (@Check_tainted_env) {
+		if (tainted $ENV{$var} ) {
+			croak sprintf(FAIL_TAINT_ENV, $caller, $var);
+		}
+	}
+
+	return;
+
+}
+
+# This subroutine performs the difficult task of interpreting
+# $?.  It's not intended to be called directly, as it will
+# croak on errors, and its implementation and interface may
+# change in the future.
+
+sub _process_child_error {
+	my ($child_error, $command, $valid_returns) = @_;
+	
+	$EXITVAL = -1;
+
+	my $coredump = WCOREDUMP($child_error);
+
+        # There's a bug in perl 5.8.9 and 5.10.0 where if the system
+        # does not provide a native WCOREDUMP, then $? will
+        # never contain coredump information.  This code
+        # checks to see if we have the bug, and works around
+        # it if needed.
+
+        if ($] >= 5.008009 and not $NATIVE_WCOREDUMP) {
+            $coredump ||= WCOREDUMP( ${^CHILD_ERROR_NATIVE} );
+        }
+
+	if ($child_error == -1) {
+		croak sprintf(FAIL_START, $command, $!);
+
+	} elsif ( WIFEXITED( $child_error ) ) {
+		$EXITVAL = WEXITSTATUS( $child_error );
+
+		return _check_exit($command,$EXITVAL,$valid_returns);
+
+	} elsif ( WIFSIGNALED( $child_error ) ) {
+		my $signal_no   = WTERMSIG( $child_error );
+		my $signal_name = $Signal_from_number[$signal_no] || "UNKNOWN";
+
+		croak sprintf FAIL_SIGNAL, $command, $signal_name, $signal_no, ($coredump ? " and dumped core" : "");
+
+
+	} 
+
+	croak sprintf(FAIL_INTERNAL, qq{'$command' ran without exit value or signal});
+
+}
+
+# A simple subroutine for checking exit values.  Results in better
+# assurance of consistent error messages, and better forward support
+# for new features in I::S::S.
+
+sub _check_exit {
+	my ($command, $exitval, $valid_returns) = @_;
+
+	# If we have a single-value list consisting of the EXIT_ANY
+	# value, then we're happy with whatever exit value we're given.
+	if (@$valid_returns == 1 and $valid_returns->[0] == EXIT_ANY_CONST) {
+		return $exitval;
+	}
+
+	if (not defined first { $_ == $exitval } @$valid_returns) {
+		croak sprintf FAIL_BADEXIT, $command, $exitval;
+	}	
+	return $exitval;
+}
+
+
+# This subroutine simply determines a list of valid returns, the command
+# name, and any arguments that we need to pass to it.
+
+sub _process_args {
+	my $valid_returns = [ 0 ];
+	my $caller = (caller(1))[3];
+
+	if (not @_) {
+		croak "$caller called with no arguments";
+	}
+
+	if (ref $_[0] eq "ARRAY") {
+		$valid_returns = shift(@_);
+	}
+
+	if (not @_) {
+		croak "$caller called with no command";
+	}
+
+	my $command = shift(@_);
+
+        if (not defined $command) {
+                croak sprintf( FAIL_UNDEF, $caller );
+        }
+
+	return ($valid_returns,$command,@_);
+
+}
+
+1;
+
+__END__
+
+=head1 NAME
+
+IPC::System::Simple - Run commands simply, with detailed diagnostics
+
+=head1 SYNOPSIS
+
+  use IPC::System::Simple qw(system systemx capture capturex);
+
+  system("some_command");        # Command succeeds or dies!
+
+  system("some_command",@args);  # Succeeds or dies, avoids shell if @args
+
+  systemx("some_command",@args); # Succeeds or dies, NEVER uses the shell
+
+
+  # Capture the output of a command (just like backticks). Dies on error.
+  my $output = capture("some_command");
+
+  # Just like backticks in list context.  Dies on error.
+  my @output = capture("some_command");
+
+  # As above, but avoids the shell if @args is non-empty
+  my $output = capture("some_command", @args);
+
+  # As above, but NEVER invokes the shell.
+  my $output = capturex("some_command", @args);
+  my @output = capturex("some_command", @args);
+
+=head1 DESCRIPTION
+
+Calling Perl's in-built C<system()> function is easy, 
+determining if it was successful is I<hard>.  Let's face it,
+C<$?> isn't the nicest variable in the world to play with, and
+even if you I<do> check it, producing a well-formatted error
+string takes a lot of work.
+
+C<IPC::System::Simple> takes the hard work out of calling 
+external commands.  In fact, if you want to be really lazy,
+you can just write:
+
+    use IPC::System::Simple qw(system);
+
+and all of your C<system> commands will either succeed (run to
+completion and return a zero exit value), or die with rich diagnostic
+messages.
+
+The C<IPC::System::Simple> module also provides a simple replacement
+to Perl's backticks operator.  Simply write:
+
+    use IPC::System::Simple qw(capture);
+
+and then use the L</capture()> command just like you'd use backticks.
+If there's an error, it will die with a detailed description of what
+went wrong.  Better still, you can even use C<capturex()> to run the
+equivalent of backticks, but without the shell:
+
+    use IPC::System::Simple qw(capturex);
+
+    my $result = capturex($command, @args);
+
+If you want more power than the basic interface, including the
+ability to specify which exit values are acceptable, trap errors,
+or process diagnostics, then read on!
+
+=head1 ADVANCED SYNOPSIS
+
+  use IPC::System::Simple qw(
+    capture capturex system systemx run runx $EXITVAL EXIT_ANY
+  );
+
+  # Run a command, throwing exception on failure
+
+  run("some_command");
+
+  runx("some_command",@args);  # Run a command, avoiding the shell
+
+  # Do the same thing, but with the drop-in system replacement.
+
+  system("some_command");
+
+  systemx("some_command", @args);
+
+  # Run a command which must return 0..5, avoid the shell, and get the
+  # exit value (we could also look at $EXITVAL)
+
+  my $exit_value = runx([0..5], "some_command", @args);
+
+  # The same, but any exit value will do.
+
+  my $exit_value = runx(EXIT_ANY, "some_command", @args);
+
+  # Capture output into $result and throw exception on failure
+
+  my $result = capture("some_command");	
+
+  # Check exit value from captured command
+
+  print "some_command exited with status $EXITVAL\n";
+
+  # Captures into @lines, splitting on $/
+  my @lines = capture("some_command"); 
+
+  # Run a command which must return 0..5, capture the output into
+  # @lines, and avoid the shell.
+
+  my @lines  = capturex([0..5], "some_command", @args);
+
+=head1 ADVANCED USAGE
+
+=head2 run() and system()
+
+C<IPC::System::Simple> provides a subroutine called
+C<run>, that executes a command using the same semantics as
+Perl's built-in C<system>:
+
+    use IPC::System::Simple qw(run);
+
+    run("cat *.txt");           # Execute command via the shell
+    run("cat","/etc/motd");     # Execute command without shell
+
+The primary difference between Perl's in-built system and
+the C<run> command is that C<run> will throw an exception on
+failure, and allows a list of acceptable exit values to be set.
+See L</Exit values> for further information.
+
+In fact, you can even have C<IPC::System::Simple> replace the
+default C<system> function for your package so it has the
+same behaviour:
+
+    use IPC::System::Simple qw(system);
+
+    system("cat *.txt");  # system now succeeds or dies!
+
+C<system> and C<run> are aliases to each other.
+
+See also L</runx(), systemx() and capturex()> for variants of
+C<system()> and C<run()> that never invoke the shell, even with
+a single argument.
+
+=head2 capture()
+
+A second subroutine, named C<capture> executes a command with
+the same semantics as Perl's built-in backticks (and C<qx()>):
+
+    use IPC::System::Simple qw(capture);
+
+    # Capture text while invoking the shell.
+    my $file  = capture("cat /etc/motd");
+    my @lines = capture("cat /etc/passwd");
+
+However unlike regular backticks, which always use the shell, C<capture>
+will bypass the shell when called with multiple arguments:
+
+    # Capture text while avoiding the shell.
+    my $file  = capture("cat", "/etc/motd");
+    my @lines = capture("cat", "/etc/passwd");
+
+See also L</runx(), systemx() and capturex()> for a variant of
+C<capture()> that never invokes the shell, even with a single
+argument.
+
+=head2 runx(), systemx() and capturex()
+
+The C<runx()>, C<systemx()> and C<capturex()> commands are identical
+to the multi-argument forms of C<run()>, C<system()> and C<capture()>
+respectively, but I<never> invoke the shell, even when called with a
+single argument.  These forms are particularly useful when a command's
+argument list I<might> be empty, for example:
+
+    systemx($cmd, @args);
+
+The use of C<systemx()> here guarantees that the shell will I<never>
+be invoked, even if C<@args> is empty.
+
+=head2 Exception handling
+
+In the case where the command returns an unexpected status, both C<run> and
+C<capture> will throw an exception, which if not caught will terminate your
+program with an error.
+
+Capturing the exception is easy:
+
+    eval {
+        run("cat *.txt");
+    };
+
+    if ($@) {
+        print "Something went wrong - $@\n";
+    }
+
+See the diagnostics section below for more details.
+
+=head3 Exception cases
+
+C<IPC::System::Simple> considers the following to be unexpected,
+and worthy of exception:
+
+=over 4
+
+=item *
+
+Failing to start entirely (eg, command not found, permission denied).
+
+=item *
+
+Returning an exit value other than zero (but see below).
+
+=item *
+
+Being killed by a signal.
+
+=item *
+
+Being passed tainted data (in taint mode).
+
+=back
+
+=head2 Exit values
+
+Traditionally, system commands return a zero status for success and a
+non-zero status for failure.  C<IPC::System::Simple> will default to throwing
+an exception if a non-zero exit value is returned.
+
+You may specify a range of values which are considered acceptable exit
+values by passing an I<array reference> as the first argument.  The
+special constant C<EXIT_ANY> can be used to allow I<any> exit value
+to be returned.
+
+	use IPC::System::Simple qw(run system capture EXIT_ANY);
+
+	run( [0..5], "cat *.txt");             # Exit values 0-5 are OK
+
+	system( [0..5], "cat *.txt");          # This works the same way
+
+	my @lines = capture( EXIT_ANY, "cat *.txt"); # Any exit is fine.
+
+The C<run> and replacement C<system> subroutines returns the exit
+value of the process:
+
+	my $exit_value = run( [0..5], "cat *.txt");
+
+	# OR:
+
+	my $exit_value = system( [0..5] "cat *.txt");
+
+	print "Program exited with value $exit_value\n";
+
+=head3 $EXITVAL
+
+The exit value of any command executed by C<IPC::System::Simple>
+can always be retrieved from the C<$IPC::System::Simple::EXITVAL>
+variable:
+
+This is particularly useful when inspecting results from C<capture>,
+which returns the captured text from the command.
+
+	use IPC::System::Simple qw(capture $EXITVAL EXIT_ANY);
+
+	my @enemies_defeated = capture(EXIT_ANY, "defeat_evil", "/dev/mordor");
+
+	print "Program exited with value $EXITVAL\n";
+
+C<$EXITVAL> will be set to C<-1> if the command did not exit normally (eg,
+being terminated by a signal) or did not start.  In this situation an
+exception will also be thrown.
+
+=head2 WINDOWS-SPECIFIC NOTES
+
+The C<run> subroutine make available the full 32-bit exit value on
+Win32 systems. This has been true since C<IPC::System::Simple> v0.06
+when called with multiple arguments, and since v1.25 when called with
+a single argument.  This is different from the previous versions of
+C<IPC::System::Simple> and from Perl's in-build C<system()> function,
+which can only handle 8-bit return values.
+
+The C<capture> subroutine always returns the 32-bit exit value under
+Windows.  The C<capture> subroutine also never uses the shell,
+even when passed a single argument.
+
+The C<run> subroutine always uses a shell when passed a single
+argument. On NT systems, it uses C<cmd.exe> in the system root, and on
+non-NT systems it uses C<command.com> in the system root.
+
+As of C<IPC::System::Simple> v1.25, the C<runx> and C<capturex>
+subroutines, as well as multiple-argument calls to the C<run> and
+C<capture> subroutines, have their arguments properly quoted, so that
+arugments with spaces and the like work properly. Unfortunately, this
+breaks any attempt to invoke the shell itself. If you really need to
+execute C<cmd.exe> or C<command.com>, use the single-argument form.
+For single-argument calls to C<run> and C<capture>, the argument must
+be properly shell-quoted in advance of the call.
+
+Versions of C<IPC::System::Simple> before v0.09 would not search
+the C<PATH> environment variable when the multi-argument form of
+C<run()> was called.  Versions from v0.09 onwards correctly search
+the path provided the command is provided including the extension
+(eg, C<notepad.exe> rather than just C<notepad>, or C<gvim.bat> rather
+than just C<gvim>).  If no extension is provided, C<.exe> is
+assumed.
+
+Signals are not supported on Windows systems.  Sending a signal
+to a Windows process will usually cause it to exit with the signal
+number used.
+
+=head1 DIAGNOSTICS
+
+=over 4
+
+=item "%s" failed to start: "%s"
+
+The command specified did not even start.  It may not exist, or
+you may not have permission to use it.  The reason it could not
+start (as determined from C<$!>) will be provided.
+
+=item "%s" unexpectedly returned exit value %d
+
+The command ran successfully, but returned an exit value we did
+not expect.  The value returned is reported.
+
+=item "%s" died to signal "%s" (%d) %s
+
+The command was killed by a signal.  The name of the signal
+will be reported, or C<UNKNOWN> if it cannot be determined.  The
+signal number is always reported.  If we detected that the
+process dumped core, then the string C<and dumped core> is
+appended.
+
+=item IPC::System::Simple::%s called with no arguments
+
+You attempted to call C<run> or C<capture> but did not provide any
+arguments at all.  At the very lease you need to supply a command
+to run.
+
+=item IPC::System::Simple::%s called with no command
+
+You called C<run> or C<capture> with a list of acceptable exit values,
+but no actual command.
+
+=item IPC::System::Simple::%s called with tainted argument "%s"
+
+You called C<run> or C<capture> with tainted (untrusted) arguments, which is
+almost certainly a bad idea.  To untaint your arguments you'll need to pass
+your data through a regular expression and use the resulting match variables.
+See L<perlsec/Laundering and Detecting Tainted Data> for more information.
+
+=item IPC::System::Simple::%s called with tainted environment $ENV{%s}
+
+You called C<run> or C<capture> but part of your environment was tainted
+(untrusted).  You should either delete the named environment
+variable before calling C<run>, or set it to an untainted value
+(usually one set inside your program).  See
+L<perlsec/Cleaning Up Your Path> for more information.
+
+=item Error in IPC::System::Simple plumbing: "%s" - "%s"
+
+Implementing the C<capture> command involves dark and terrible magicks
+involving pipes, and one of them has sprung a leak.  This could be due to a
+lack of file descriptors, although there are other possibilities.
+
+If you are able to reproduce this error, you are encouraged
+to submit a bug report according to the L</Reporting bugs> section below.
+
+=item Internal error in IPC::System::Simple: "%s"
+
+You've found a bug in C<IPC::System::Simple>.  Please check to
+see if an updated version of C<IPC::System::Simple> is available.
+If not, please file a bug report according to the L</Reporting bugs> section
+below.
+
+=item IPC::System::Simple::%s called with undefined command
+
+You've passed the undefined value as a command to be executed.
+While this is a very Zen-like action, it's not supported by
+Perl's current implementation.
+
+=back
+
+=head1 DEPENDENCIES
+
+This module depends upon L<Win32::Process> when used on Win32
+system.  C<Win32::Process> is bundled as a core module in ActivePerl 5.6
+and above.
+
+There are no non-core dependencies on non-Win32 systems.
+
+=head1 COMPARISON TO OTHER APIs
+
+Perl provides a range of in-built functions for handling external
+commands, and CPAN provides even more.  The C<IPC::System::Simple>
+differentiates itself from other options by providing:
+
+=over 4
+
+=item Extremely detailed diagnostics
+
+The diagnostics produced by C<IPC::System::Simple> are designed
+to provide as much information as possible.  Rather than requiring
+the developer to inspect C<$?>, C<IPC::System::Simple> does the
+hard work for you.
+
+If an odd exit status is provided, you're informed of what it is.  If a
+signal kills your process, you are informed of both its name and number.
+If tainted data or environment prevents your command from running, you
+are informed of exactly which data or environmental variable is
+tainted.
+
+=item Exceptions on failure
+
+C<IPC::System::Simple> takes an aggressive approach to error handling.
+Rather than allow commands to fail silently, exceptions are thrown
+when unexpected results are seen.  This allows for easy development
+using a try/catch style, and avoids the possibility of accidentally
+continuing after a failed command.
+
+=item Easy access to exit status
+
+The C<run>, C<system> and C<capture> commands all set C<$EXITVAL>,
+making it easy to determine the exit status of a command.
+Additionally, the C<system> and C<run> interfaces return the exit
+status.
+
+=item Consistent interfaces
+
+When called with multiple arguments, the C<run>, C<system> and
+C<capture> interfaces I<never> invoke the shell.  This differs
+from the in-built Perl C<system> command which may invoke the
+shell under Windows when called with multiple arguments.  It
+differs from the in-built Perl backticks operator which always
+invokes the shell.
+
+=back
+
+=head1 BUGS
+
+When C<system> is exported, the exotic form C<system { $cmd } @args>
+is not supported.  Attemping to use the exotic form is a syntax
+error.  This affects the calling package I<only>.  Use C<CORE::system>
+if you need it, or consider using the L<autodie> module to replace
+C<system> with lexical scope.
+
+Core dumps are only checked for when a process dies due to a
+signal.  It is not believed there are any systems where processes
+can dump core without dying to a signal.
+
+C<WIFSTOPPED> status is not checked, as perl never spawns processes
+with the C<WUNTRACED> option.
+
+Signals are not supported under Win32 systems, since they don't
+work at all like Unix signals.  Win32 signals cause commands to
+exit with a given exit value, which this modules I<does> capture.
+
+=head2 Reporting bugs
+
+Before reporting a bug, please check to ensure you are using the
+most recent version of C<IPC::System::Simple>.  Your problem may
+have already been fixed in a new release.
+
+You can find the C<IPC::System::Simple> bug-tracker at
+L<http://rt.cpan.org/Public/Dist/Display.html?Name=IPC-System-Simple> .
+Please check to see if your bug has already been reported; if
+in doubt, report yours anyway.
+
+Submitting a patch and/or failing test case will greatly expedite
+the fixing of bugs.
+
+=head1 FEEDBACK
+
+If you find this module useful, please consider rating it on the
+CPAN Ratings service at
+L<http://cpanratings.perl.org/rate/?distribution=IPC-System-Simple> .
+
+The module author loves to hear how C<IPC::System::Simple> has made
+your life better (or worse).  Feedback can be sent to
+E<lt>pjf@perltraining.com.auE<gt>.
+
+=head1 SEE ALSO
+
+L<autodie> uses C<IPC::System::Simple> to provide succeed-or-die
+replacements to C<system> (and other built-ins) with lexical scope.
+
+L<POSIX>, L<IPC::Run::Simple>, L<perlipc>, L<perlport>, L<IPC::Run>,
+L<IPC::Run3>, L<Win32::Process>
+
+=head1 AUTHOR
+
+Paul Fenwick E<lt>pjf@cpan.orgE<gt>
+
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (C) 2006-2008 by Paul Fenwick
+
+This library is free software; you can redistribute it and/or modify
+it under the same terms as Perl itself, either Perl version 5.6.0 or,
+at your option, any later version of Perl 5 you may have available.
+
+=for Pod::Coverage WCOREDUMP
+
+=cut
diff --git a/tests/lib/Path/Tiny.pm b/tests/lib/Path/Tiny.pm
new file mode 100644
index 0000000..b8c6804
--- /dev/null
+++ b/tests/lib/Path/Tiny.pm
@@ -0,0 +1,3880 @@
+use 5.008001;
+use strict;
+use warnings;
+
+package Path::Tiny;
+# ABSTRACT: File path utility
+
+our $VERSION = '0.144';
+
+# Dependencies
+use Config;
+use Exporter 5.57   (qw/import/);
+use File::Spec 0.86 ();          # shipped with 5.8.1
+use Carp ();
+
+our @EXPORT    = qw/path/;
+our @EXPORT_OK = qw/cwd rootdir tempfile tempdir/;
+
+use constant {
+    PATH     => 0,
+    CANON    => 1,
+    VOL      => 2,
+    DIR      => 3,
+    FILE     => 4,
+    TEMP     => 5,
+    IS_WIN32 => ( $^O eq 'MSWin32' ),
+};
+
+use overload (
+    q{""}    => 'stringify',
+    bool     => sub () { 1 },
+    fallback => 1,
+);
+
+# FREEZE/THAW per Sereal/CBOR/Types::Serialiser protocol
+sub THAW   { return path( $_[2] ) }
+{ no warnings 'once'; *TO_JSON = *FREEZE = \&stringify };
+
+my $HAS_UU; # has Unicode::UTF8; lazily populated
+
+sub _check_UU {
+    local $SIG{__DIE__}; # prevent outer handler from being called
+    !!eval {
+        require Unicode::UTF8;
+        Unicode::UTF8->VERSION(0.58);
+        1;
+    };
+}
+
+my $HAS_PU;              # has PerlIO::utf8_strict; lazily populated
+
+sub _check_PU {
+    local $SIG{__DIE__}; # prevent outer handler from being called
+    !!eval {
+        # MUST preload Encode or $SIG{__DIE__} localization fails
+        # on some Perl 5.8.8 (maybe other 5.8.*) compiled with -O2.
+        require Encode;
+        require PerlIO::utf8_strict;
+        PerlIO::utf8_strict->VERSION(0.003);
+        1;
+    };
+}
+
+my $HAS_FLOCK = $Config{d_flock} || $Config{d_fcntl_can_lock} || $Config{d_lockf};
+
+# notions of "root" directories differ on Win32: \\server\dir\ or C:\ or \
+my $SLASH      = qr{[\\/]};
+my $NOTSLASH   = qr{[^\\/]};
+my $DRV_VOL    = qr{[a-z]:}i;
+my $UNC_VOL    = qr{$SLASH $SLASH $NOTSLASH+ $SLASH $NOTSLASH+}x;
+my $WIN32_ROOT = qr{(?: $UNC_VOL $SLASH | $DRV_VOL $SLASH | $SLASH )}x;
+
+sub _win32_vol {
+    my ( $path, $drv ) = @_;
+    require Cwd;
+    my $dcwd = eval { Cwd::getdcwd($drv) }; # C: -> C:\some\cwd
+    # getdcwd on non-existent drive returns empty string
+    # so just use the original drive Z: -> Z:
+    $dcwd = "$drv" unless defined $dcwd && length $dcwd;
+    # normalize dwcd to end with a slash: might be C:\some\cwd or D:\ or Z:
+    $dcwd =~ s{$SLASH?\z}{/};
+    # make the path absolute with dcwd
+    $path =~ s{^$DRV_VOL}{$dcwd};
+    return $path;
+}
+
+# This is a string test for before we have the object; see is_rootdir for well-formed
+# object test
+sub _is_root {
+    return IS_WIN32() ? ( $_[0] =~ /^$WIN32_ROOT\z/ ) : ( $_[0] eq '/' );
+}
+
+BEGIN {
+    *_same = IS_WIN32() ? sub { lc( $_[0] ) eq lc( $_[1] ) } : sub { $_[0] eq $_[1] };
+}
+
+# mode bits encoded for chmod in symbolic mode
+my %MODEBITS = ( om => 0007, gm => 0070, um => 0700 ); ## no critic
+{ my $m = 0; $MODEBITS{$_} = ( 1 << $m++ ) for qw/ox ow or gx gw gr ux uw ur/ };
+
+sub _symbolic_chmod {
+    my ( $mode, $symbolic ) = @_;
+    for my $clause ( split /,\s*/, $symbolic ) {
+        if ( $clause =~ m{\A([augo]+)([=+-])([rwx]+)\z} ) {
+            my ( $who, $action, $perms ) = ( $1, $2, $3 );
+            $who =~ s/a/ugo/g;
+            for my $w ( split //, $who ) {
+                my $p = 0;
+                $p |= $MODEBITS{"$w$_"} for split //, $perms;
+                if ( $action eq '=' ) {
+                    $mode = ( $mode & ~$MODEBITS{"${w}m"} ) | $p;
+                }
+                else {
+                    $mode = $action eq "+" ? ( $mode | $p ) : ( $mode & ~$p );
+                }
+            }
+        }
+        else {
+            Carp::croak("Invalid mode clause '$clause' for chmod()");
+        }
+    }
+    return $mode;
+}
+
+# flock doesn't work on NFS on BSD or on some filesystems like lustre.
+# Since program authors often can't control or detect that, we warn once
+# instead of being fatal if we can detect it and people who need it strict
+# can fatalize the 'flock' category
+
+#<<< No perltidy
+{ package flock; use warnings::register }
+#>>>
+
+my $WARNED_NO_FLOCK = 0;
+
+sub _throw {
+    my ( $self, $function, $file, $msg ) = @_;
+    if (   $function =~ /^flock/
+        && $! =~ /operation not supported|function not implemented/i
+        && !warnings::fatal_enabled('flock') )
+    {
+        if ( !$WARNED_NO_FLOCK ) {
+            warnings::warn( flock => "Flock not available: '$!': continuing in unsafe mode" );
+            $WARNED_NO_FLOCK++;
+        }
+    }
+    else {
+        $msg = $! unless defined $msg;
+        Path::Tiny::Error->throw( $function, ( defined $file ? $file : $self->[PATH] ),
+            $msg );
+    }
+    return;
+}
+
+# cheapo option validation
+sub _get_args {
+    my ( $raw, @valid ) = @_;
+    if ( defined($raw) && ref($raw) ne 'HASH' ) {
+        my ( undef, undef, undef, $called_as ) = caller(1);
+        $called_as =~ s{^.*::}{};
+        Carp::croak("Options for $called_as must be a hash reference");
+    }
+    my $cooked = {};
+    for my $k (@valid) {
+        $cooked->{$k} = delete $raw->{$k} if exists $raw->{$k};
+    }
+    if ( keys %$raw ) {
+        my ( undef, undef, undef, $called_as ) = caller(1);
+        $called_as =~ s{^.*::}{};
+        Carp::croak( "Invalid option(s) for $called_as: " . join( ", ", keys %$raw ) );
+    }
+    return $cooked;
+}
+
+#--------------------------------------------------------------------------#
+# Constructors
+#--------------------------------------------------------------------------#
+
+#pod =construct path
+#pod
+#pod     $path = path("foo/bar");
+#pod     $path = path("/tmp", "file.txt"); # list
+#pod     $path = path(".");                # cwd
+#pod
+#pod Constructs a C<Path::Tiny> object.  It doesn't matter if you give a file or
+#pod directory path.  It's still up to you to call directory-like methods only on
+#pod directories and file-like methods only on files.  This function is exported
+#pod automatically by default.
+#pod
+#pod The first argument must be defined and have non-zero length or an exception
+#pod will be thrown.  This prevents subtle, dangerous errors with code like
+#pod C<< path( maybe_undef() )->remove_tree >>.
+#pod
+#pod B<DEPRECATED>: If and only if the B<first> character of the B<first> argument
+#pod to C<path> is a tilde ('~'), then tilde replacement will be applied to the
+#pod first path segment. A single tilde will be replaced with C<glob('~')> and a
+#pod tilde followed by a username will be replaced with output of
+#pod C<glob('~username')>. B<No other method does tilde expansion on its arguments>.
+#pod See L</Tilde expansion (deprecated)> for more.
+#pod
+#pod On Windows, if the path consists of a drive identifier without a path component
+#pod (C<C:> or C<D:>), it will be expanded to the absolute path of the current
+#pod directory on that volume using C<Cwd::getdcwd()>.
+#pod
+#pod If called with a single C<Path::Tiny> argument, the original is returned unless
+#pod the original is holding a temporary file or directory reference in which case a
+#pod stringified copy is made.
+#pod
+#pod     $path = path("foo/bar");
+#pod     $temp = Path::Tiny->tempfile;
+#pod
+#pod     $p2 = path($path); # like $p2 = $path
+#pod     $t2 = path($temp); # like $t2 = path( "$temp" )
+#pod
+#pod This optimizes copies without proliferating references unexpectedly if a copy is
+#pod made by code outside your control.
+#pod
+#pod Current API available since 0.017.
+#pod
+#pod =cut
+
+sub path {
+    my $path = shift;
+    Carp::croak("Path::Tiny paths require defined, positive-length parts")
+      unless 1 + @_ == grep { defined && length } $path, @_;
+
+    # non-temp Path::Tiny objects are effectively immutable and can be reused
+    if ( !@_ && ref($path) eq __PACKAGE__ && !$path->[TEMP] ) {
+        return $path;
+    }
+
+    # stringify objects
+    $path = "$path";
+
+    # do any tilde expansions
+    my ($tilde) = $path =~ m{^(~[^/]*)};
+    if ( defined $tilde ) {
+        # Escape File::Glob metacharacters
+        (my $escaped = $tilde) =~ s/([\[\{\*\?\\])/\\$1/g;
+        require File::Glob;
+        my ($homedir) = File::Glob::bsd_glob($escaped);
+        if (defined $homedir && ! $File::Glob::ERROR) {
+            $homedir =~ tr[\\][/] if IS_WIN32();
+            $path =~ s{^\Q$tilde\E}{$homedir};
+        }
+    }
+
+    unshift @_, $path;
+    goto &_pathify;
+}
+
+# _path is like path but without tilde expansion
+sub _path {
+    my $path = shift;
+    Carp::croak("Path::Tiny paths require defined, positive-length parts")
+      unless 1 + @_ == grep { defined && length } $path, @_;
+
+    # non-temp Path::Tiny objects are effectively immutable and can be reused
+    if ( !@_ && ref($path) eq __PACKAGE__ && !$path->[TEMP] ) {
+        return $path;
+    }
+
+    # stringify objects
+    $path = "$path";
+
+    unshift @_, $path;
+    goto &_pathify;
+}
+
+# _pathify expects one or more string arguments, then joins and canonicalizes
+# them into an object.
+sub _pathify {
+    my $path = shift;
+
+    # expand relative volume paths on windows; put trailing slash on UNC root
+    if ( IS_WIN32() ) {
+        $path = _win32_vol( $path, $1 ) if $path =~ m{^($DRV_VOL)(?:$NOTSLASH|\z)};
+        $path .= "/" if $path =~ m{^$UNC_VOL\z};
+    }
+
+    # concatenations stringifies objects, too
+    if (@_) {
+        $path .= ( _is_root($path) ? "" : "/" ) . join( "/", @_ );
+    }
+
+
+    # canonicalize, but with unix slashes and put back trailing volume slash
+    my $cpath = $path = File::Spec->canonpath($path);
+    $path =~ tr[\\][/] if IS_WIN32();
+    $path = "/" if $path eq '/..'; # for old File::Spec
+    $path .= "/" if IS_WIN32() && $path =~ m{^$UNC_VOL\z};
+
+    # root paths must always have a trailing slash, but other paths must not
+    if ( _is_root($path) ) {
+        $path =~ s{/?\z}{/};
+    }
+    else {
+        $path =~ s{/\z}{};
+    }
+
+    bless [ $path, $cpath ], __PACKAGE__;
+}
+
+#pod =construct new
+#pod
+#pod     $path = Path::Tiny->new("foo/bar");
+#pod
+#pod This is just like C<path>, but with method call overhead.  (Why would you
+#pod do that?)
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+sub new { shift; path(@_) }
+
+#pod =construct cwd
+#pod
+#pod     $path = Path::Tiny->cwd; # path( Cwd::getcwd )
+#pod     $path = cwd; # optional export
+#pod
+#pod Gives you the absolute path to the current directory as a C<Path::Tiny> object.
+#pod This is slightly faster than C<< path(".")->absolute >>.
+#pod
+#pod C<cwd> may be exported on request and used as a function instead of as a
+#pod method.
+#pod
+#pod Current API available since 0.018.
+#pod
+#pod =cut
+
+sub cwd {
+    require Cwd;
+    return _path( Cwd::getcwd() );
+}
+
+#pod =construct rootdir
+#pod
+#pod     $path = Path::Tiny->rootdir; # /
+#pod     $path = rootdir;             # optional export 
+#pod
+#pod Gives you C<< File::Spec->rootdir >> as a C<Path::Tiny> object if you're too
+#pod picky for C<path("/")>.
+#pod
+#pod C<rootdir> may be exported on request and used as a function instead of as a
+#pod method.
+#pod
+#pod Current API available since 0.018.
+#pod
+#pod =cut
+
+sub rootdir { _path( File::Spec->rootdir ) }
+
+#pod =construct tempfile, tempdir
+#pod
+#pod     $temp = Path::Tiny->tempfile( @options );
+#pod     $temp = Path::Tiny->tempdir( @options );
+#pod     $temp = $dirpath->tempfile( @options );
+#pod     $temp = $dirpath->tempdir( @options );
+#pod     $temp = tempfile( @options ); # optional export
+#pod     $temp = tempdir( @options );  # optional export
+#pod
+#pod C<tempfile> passes the options to C<< File::Temp->new >> and returns a
+#pod C<Path::Tiny> object with the file name.  The C<TMPDIR> option will be enabled
+#pod by default, but you can override that by passing C<< TMPDIR => 0 >> along with
+#pod the options.  (If you use an absolute C<TEMPLATE> option, you will want to
+#pod disable C<TMPDIR>.)
+#pod
+#pod The resulting C<File::Temp> object is cached. When the C<Path::Tiny> object is
+#pod destroyed, the C<File::Temp> object will be as well.
+#pod
+#pod C<File::Temp> annoyingly requires you to specify a custom template in slightly
+#pod different ways depending on which function or method you call, but
+#pod C<Path::Tiny> lets you ignore that and can take either a leading template or a
+#pod C<TEMPLATE> option and does the right thing.
+#pod
+#pod     $temp = Path::Tiny->tempfile( "customXXXXXXXX" );             # ok
+#pod     $temp = Path::Tiny->tempfile( TEMPLATE => "customXXXXXXXX" ); # ok
+#pod
+#pod The tempfile path object will be normalized to have an absolute path, even if
+#pod created in a relative directory using C<DIR>.  If you want it to have
+#pod the C<realpath> instead, pass a leading options hash like this:
+#pod
+#pod     $real_temp = tempfile({realpath => 1}, @options);
+#pod
+#pod C<tempdir> is just like C<tempfile>, except it calls
+#pod C<< File::Temp->newdir >> instead.
+#pod
+#pod Both C<tempfile> and C<tempdir> may be exported on request and used as
+#pod functions instead of as methods.
+#pod
+#pod The methods can be called on an instances representing a
+#pod directory. In this case, the directory is used as the base to create the
+#pod temporary file/directory, setting the C<DIR> option in File::Temp.
+#pod
+#pod     my $target_dir = path('/to/destination');
+#pod     my $tempfile = $target_dir->tempfile('foobarXXXXXX');
+#pod     $tempfile->spew('A lot of data...');  # not atomic
+#pod     $tempfile->move($target_dir->child('foobar')); # hopefully atomic
+#pod
+#pod In this case, any value set for option C<DIR> is ignored.
+#pod
+#pod B<Note>: for tempfiles, the filehandles from File::Temp are closed and not
+#pod reused.  This is not as secure as using File::Temp handles directly, but is
+#pod less prone to deadlocks or access problems on some platforms.  Think of what
+#pod C<Path::Tiny> gives you to be just a temporary file B<name> that gets cleaned
+#pod up.
+#pod
+#pod B<Note 2>: if you don't want these cleaned up automatically when the object
+#pod is destroyed, File::Temp requires different options for directories and
+#pod files.  Use C<< CLEANUP => 0 >> for directories and C<< UNLINK => 0 >> for
+#pod files.
+#pod
+#pod B<Note 3>: Don't lose the temporary object by chaining a method call instead
+#pod of storing it:
+#pod
+#pod     my $lost = tempdir()->child("foo"); # tempdir cleaned up right away
+#pod
+#pod B<Note 4>: The cached object may be accessed with the L</cached_temp> method.
+#pod Keeping a reference to, or modifying the cached object may break the
+#pod behavior documented above and is not supported.  Use at your own risk.
+#pod
+#pod Current API available since 0.119.
+#pod
+#pod =cut
+
+sub tempfile {
+    my ( $opts, $maybe_template, $args )
+        = _parse_file_temp_args(tempfile => @_);
+
+    # File::Temp->new demands TEMPLATE
+    $args->{TEMPLATE} = $maybe_template->[0] if @$maybe_template;
+
+    require File::Temp;
+    my $temp = File::Temp->new( TMPDIR => 1, %$args );
+    close $temp;
+    my $self = $opts->{realpath} ? _path($temp)->realpath : _path($temp)->absolute;
+    $self->[TEMP] = $temp;                # keep object alive while we are
+    return $self;
+}
+
+sub tempdir {
+    my ( $opts, $maybe_template, $args )
+        = _parse_file_temp_args(tempdir => @_);
+
+    require File::Temp;
+    my $temp = File::Temp->newdir( @$maybe_template, TMPDIR => 1, %$args );
+    my $self = $opts->{realpath} ? _path($temp)->realpath : _path($temp)->absolute;
+    $self->[TEMP] = $temp;                # keep object alive while we are
+    # Some ActiveState Perls for Windows break Cwd in ways that lead
+    # File::Temp to get confused about what path to remove; this
+    # monkey-patches the object with our own view of the absolute path
+    $temp->{REALNAME} = $self->[CANON] if IS_WIN32;
+    return $self;
+}
+
+# normalize the various ways File::Temp does templates
+sub _parse_file_temp_args {
+    my $called_as = shift;
+    if ( @_ && $_[0] eq 'Path::Tiny' ) { shift } # class method
+    elsif ( @_ && eval{$_[0]->isa('Path::Tiny')} ) {
+        my $dir = shift;
+        if (! $dir->is_dir) {
+            $dir->_throw( $called_as, $dir, "is not a directory object" );
+        }
+        push @_, DIR => $dir->stringify; # no overriding
+    }
+    my $opts = ( @_ && ref $_[0] eq 'HASH' ) ? shift @_ : {};
+    $opts = _get_args( $opts, qw/realpath/ );
+
+    my $leading_template = ( scalar(@_) % 2 == 1 ? shift(@_) : '' );
+    my %args = @_;
+    %args = map { uc($_), $args{$_} } keys %args;
+    my @template = (
+          exists $args{TEMPLATE} ? delete $args{TEMPLATE}
+        : $leading_template      ? $leading_template
+        :                          ()
+    );
+
+    return ( $opts, \@template, \%args );
+}
+
+#--------------------------------------------------------------------------#
+# Private methods
+#--------------------------------------------------------------------------#
+
+sub _splitpath {
+    my ($self) = @_;
+    @{$self}[ VOL, DIR, FILE ] = File::Spec->splitpath( $self->[PATH] );
+}
+
+sub _resolve_symlinks {
+    my ($self) = @_;
+    my $new = $self;
+    my ( $count, %seen ) = 0;
+    while ( -l $new->[PATH] ) {
+        if ( $seen{ $new->[PATH] }++ ) {
+            $self->_throw( 'readlink', $self->[PATH], "symlink loop detected" );
+        }
+        if ( ++$count > 100 ) {
+            $self->_throw( 'readlink', $self->[PATH], "maximum symlink depth exceeded" );
+        }
+        my $resolved = readlink $new->[PATH];
+        $new->_throw( 'readlink', $new->[PATH] ) unless defined $resolved;
+        $resolved = _path($resolved);
+        $new = $resolved->is_absolute ? $resolved : $new->sibling($resolved);
+    }
+    return $new;
+}
+
+sub _replacment_path {
+    my ($self) = @_;
+
+    my $unique_suffix = $$ . int( rand( 2**31 ) );
+    my $temp          = _path( $self . $unique_suffix );
+
+    # If filename with process+random suffix is too long, use a shorter
+    # version that doesn't preserve the basename.
+    if ( length $temp->basename > 255 ) {
+        $temp = $self->sibling( "temp" . $unique_suffix );
+    }
+
+    return $temp;
+}
+
+#--------------------------------------------------------------------------#
+# Public methods
+#--------------------------------------------------------------------------#
+
+#pod =method absolute
+#pod
+#pod     $abs = path("foo/bar")->absolute;
+#pod     $abs = path("foo/bar")->absolute("/tmp");
+#pod
+#pod Returns a new C<Path::Tiny> object with an absolute path (or itself if already
+#pod absolute).  If no argument is given, the current directory is used as the
+#pod absolute base path.  If an argument is given, it will be converted to an
+#pod absolute path (if it is not already) and used as the absolute base path.
+#pod
+#pod This will not resolve upward directories ("foo/../bar") unless C<canonpath>
+#pod in L<File::Spec> would normally do so on your platform.  If you need them
+#pod resolved, you must call the more expensive C<realpath> method instead.
+#pod
+#pod On Windows, an absolute path without a volume component will have it added
+#pod based on the current drive.
+#pod
+#pod Current API available since 0.101.
+#pod
+#pod =cut
+
+sub absolute {
+    my ( $self, $base ) = @_;
+
+    # absolute paths handled differently by OS
+    if (IS_WIN32) {
+        return $self if length $self->volume;
+        # add missing volume
+        if ( $self->is_absolute ) {
+            require Cwd;
+            # use Win32::GetCwd not Cwd::getdcwd because we're sure
+            # to have the former but not necessarily the latter
+            my ($drv) = Win32::GetCwd() =~ /^($DRV_VOL | $UNC_VOL)/x;
+            return _path( $drv . $self->[PATH] );
+        }
+    }
+    else {
+        return $self if $self->is_absolute;
+    }
+
+    # no base means use current directory as base
+    require Cwd;
+    return _path( Cwd::getcwd(), $_[0]->[PATH] ) unless defined $base;
+
+    # relative base should be made absolute; we check is_absolute rather
+    # than unconditionally make base absolute so that "/foo" doesn't become
+    # "C:/foo" on Windows.
+    $base = _path($base);
+    return _path( ( $base->is_absolute ? $base : $base->absolute ), $_[0]->[PATH] );
+}
+
+#pod =method append, append_raw, append_utf8
+#pod
+#pod     path("foo.txt")->append(@data);
+#pod     path("foo.txt")->append(\@data);
+#pod     path("foo.txt")->append({binmode => ":raw"}, @data);
+#pod     path("foo.txt")->append_raw(@data);
+#pod     path("foo.txt")->append_utf8(@data);
+#pod
+#pod Appends data to a file.  The file is locked with C<flock> prior to writing
+#pod and closed afterwards.  An optional hash reference may be used to pass
+#pod options.  Valid options are:
+#pod
+#pod =for :list
+#pod * C<binmode>: passed to C<binmode()> on the handle used for writing.
+#pod * C<truncate>: truncates the file after locking and before appending
+#pod
+#pod The C<truncate> option is a way to replace the contents of a file
+#pod B<in place>, unlike L</spew> which writes to a temporary file and then
+#pod replaces the original (if it exists).
+#pod
+#pod C<append_raw> is like C<append> with a C<binmode> of C<:unix> for a fast,
+#pod unbuffered, raw write.
+#pod
+#pod C<append_utf8> is like C<append> with an unbuffered C<binmode>
+#pod C<:unix:encoding(UTF-8)> (or C<:unix:utf8_strict> with
+#pod L<PerlIO::utf8_strict>).  If L<Unicode::UTF8> 0.58+ is installed, an
+#pod unbuffered, raw append will be done instead on the data encoded with
+#pod C<Unicode::UTF8>.
+#pod
+#pod Current API available since 0.060.
+#pod
+#pod =cut
+
+sub append {
+    my ( $self, @data ) = @_;
+    my $args = ( @data && ref $data[0] eq 'HASH' ) ? shift @data : {};
+    $args = _get_args( $args, qw/binmode truncate/ );
+    my $binmode = $args->{binmode};
+    $binmode = ( ( caller(0) )[10] || {} )->{'open>'} unless defined $binmode;
+    my $mode = $args->{truncate} ? ">" : ">>";
+    my $fh = $self->filehandle( { locked => 1 }, $mode, $binmode );
+    print( {$fh} map { ref eq 'ARRAY' ? @$_ : $_ } @data ) or self->_throw('print');
+    close $fh or $self->_throw('close');
+}
+
+sub append_raw {
+    my ( $self, @data ) = @_;
+    my $args = ( @data && ref $data[0] eq 'HASH' ) ? shift @data : {};
+    $args = _get_args( $args, qw/binmode truncate/ );
+    $args->{binmode} = ':unix';
+    append( $self, $args, @data );
+}
+
+sub append_utf8 {
+    my ( $self, @data ) = @_;
+    my $args = ( @data && ref $data[0] eq 'HASH' ) ? shift @data : {};
+    $args = _get_args( $args, qw/binmode truncate/ );
+    if ( defined($HAS_UU) ? $HAS_UU : ( $HAS_UU = _check_UU() ) ) {
+        $args->{binmode} = ":unix";
+        append( $self, $args, map { Unicode::UTF8::encode_utf8($_) } @data );
+    }
+    elsif ( defined($HAS_PU) ? $HAS_PU : ( $HAS_PU = _check_PU() ) ) {
+        $args->{binmode} = ":unix:utf8_strict";
+        append( $self, $args, @data );
+    }
+    else {
+        $args->{binmode} = ":unix:encoding(UTF-8)";
+        append( $self, $args, @data );
+    }
+}
+
+#pod =method assert
+#pod
+#pod     $path = path("foo.txt")->assert( sub { $_->exists } );
+#pod
+#pod Returns the invocant after asserting that a code reference argument returns
+#pod true.  When the assertion code reference runs, it will have the invocant
+#pod object in the C<$_> variable.  If it returns false, an exception will be
+#pod thrown.  The assertion code reference may also throw its own exception.
+#pod
+#pod If no assertion is provided, the invocant is returned without error.
+#pod
+#pod Current API available since 0.062.
+#pod
+#pod =cut
+
+sub assert {
+    my ( $self, $assertion ) = @_;
+    return $self unless $assertion;
+    if ( ref $assertion eq 'CODE' ) {
+        local $_ = $self;
+        $assertion->()
+          or Path::Tiny::Error->throw( "assert", $self->[PATH], "failed assertion" );
+    }
+    else {
+        Carp::croak("argument to assert must be a code reference argument");
+    }
+    return $self;
+}
+
+#pod =method basename
+#pod
+#pod     $name = path("foo/bar.txt")->basename;        # bar.txt
+#pod     $name = path("foo.txt")->basename('.txt');    # foo
+#pod     $name = path("foo.txt")->basename(qr/.txt/);  # foo
+#pod     $name = path("foo.txt")->basename(@suffixes);
+#pod
+#pod Returns the file portion or last directory portion of a path.
+#pod
+#pod Given a list of suffixes as strings or regular expressions, any that match at
+#pod the end of the file portion or last directory portion will be removed before
+#pod the result is returned.
+#pod
+#pod Current API available since 0.054.
+#pod
+#pod =cut
+
+sub basename {
+    my ( $self, @suffixes ) = @_;
+    $self->_splitpath unless defined $self->[FILE];
+    my $file = $self->[FILE];
+    for my $s (@suffixes) {
+        my $re = ref($s) eq 'Regexp' ? qr/$s\z/ : qr/\Q$s\E\z/;
+        last if $file =~ s/$re//;
+    }
+    return $file;
+}
+
+#pod =method canonpath
+#pod
+#pod     $canonical = path("foo/bar")->canonpath; # foo\bar on Windows
+#pod
+#pod Returns a string with the canonical format of the path name for
+#pod the platform.  In particular, this means directory separators
+#pod will be C<\> on Windows.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+sub canonpath { $_[0]->[CANON] }
+
+#pod =method cached_temp
+#pod
+#pod Returns the cached C<File::Temp> or C<File::Temp::Dir> object if the
+#pod C<Path::Tiny> object was created with C</tempfile> or C</tempdir>.
+#pod If there is no such object, this method throws.
+#pod
+#pod B<WARNING>: Keeping a reference to, or modifying the cached object may
+#pod break the behavior documented for temporary files and directories created
+#pod with C<Path::Tiny> and is not supported.  Use at your own risk.
+#pod
+#pod Current API available since 0.101.
+#pod
+#pod =cut
+
+sub cached_temp {
+    my $self = shift;
+    $self->_throw( "cached_temp", $self, "has no cached File::Temp object" )
+      unless defined $self->[TEMP];
+    return $self->[TEMP];
+}
+
+#pod =method child
+#pod
+#pod     $file = path("/tmp")->child("foo.txt"); # "/tmp/foo.txt"
+#pod     $file = path("/tmp")->child(@parts);
+#pod
+#pod Returns a new C<Path::Tiny> object relative to the original.  Works
+#pod like C<catfile> or C<catdir> from File::Spec, but without caring about
+#pod file or directories.
+#pod
+#pod B<WARNING>: because the argument could contain C<..> or refer to symlinks,
+#pod there is no guarantee that the new path refers to an actual descendent of
+#pod the original.  If this is important to you, transform parent and child with
+#pod L</realpath> and check them with L</subsumes>.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+sub child {
+    my ( $self, @parts ) = @_;
+    return _path( $self->[PATH], @parts );
+}
+
+#pod =method children
+#pod
+#pod     @paths = path("/tmp")->children;
+#pod     @paths = path("/tmp")->children( qr/\.txt\z/ );
+#pod
+#pod Returns a list of C<Path::Tiny> objects for all files and directories
+#pod within a directory.  Excludes "." and ".." automatically.
+#pod
+#pod If an optional C<qr//> argument is provided, it only returns objects for child
+#pod names that match the given regular expression.  Only the base name is used
+#pod for matching:
+#pod
+#pod     @paths = path("/tmp")->children( qr/^foo/ );
+#pod     # matches children like the glob foo*
+#pod
+#pod Current API available since 0.028.
+#pod
+#pod =cut
+
+sub children {
+    my ( $self, $filter ) = @_;
+    my $dh;
+    opendir $dh, $self->[PATH] or $self->_throw('opendir');
+    my @children = readdir $dh;
+    closedir $dh or $self->_throw('closedir');
+
+    if ( not defined $filter ) {
+        @children = grep { $_ ne '.' && $_ ne '..' } @children;
+    }
+    elsif ( $filter && ref($filter) eq 'Regexp' ) {
+        @children = grep { $_ ne '.' && $_ ne '..' && $_ =~ $filter } @children;
+    }
+    else {
+        Carp::croak("Invalid argument '$filter' for children()");
+    }
+
+    return map { _path( $self->[PATH], $_ ) } @children;
+}
+
+#pod =method chmod
+#pod
+#pod     path("foo.txt")->chmod(0777);
+#pod     path("foo.txt")->chmod("0755");
+#pod     path("foo.txt")->chmod("go-w");
+#pod     path("foo.txt")->chmod("a=r,u+wx");
+#pod
+#pod Sets file or directory permissions.  The argument can be a numeric mode, a
+#pod octal string beginning with a "0" or a limited subset of the symbolic mode use
+#pod by F</bin/chmod>.
+#pod
+#pod The symbolic mode must be a comma-delimited list of mode clauses.  Clauses must
+#pod match C<< qr/\A([augo]+)([=+-])([rwx]+)\z/ >>, which defines "who", "op" and
+#pod "perms" parameters for each clause.  Unlike F</bin/chmod>, all three parameters
+#pod are required for each clause, multiple ops are not allowed and permissions
+#pod C<stugoX> are not supported.  (See L<File::chmod> for more complex needs.)
+#pod
+#pod Current API available since 0.053.
+#pod
+#pod =cut
+
+sub chmod {
+    my ( $self, $new_mode ) = @_;
+
+    my $mode;
+    if ( $new_mode =~ /\d/ ) {
+        $mode = ( $new_mode =~ /^0/ ? oct($new_mode) : $new_mode );
+    }
+    elsif ( $new_mode =~ /[=+-]/ ) {
+        $mode = _symbolic_chmod( $self->stat->mode & 07777, $new_mode ); ## no critic
+    }
+    else {
+        Carp::croak("Invalid mode argument '$new_mode' for chmod()");
+    }
+
+    CORE::chmod( $mode, $self->[PATH] ) or $self->_throw("chmod");
+
+    return 1;
+}
+
+#pod =method copy
+#pod
+#pod     path("/tmp/foo.txt")->copy("/tmp/bar.txt");
+#pod
+#pod Copies the current path to the given destination using L<File::Copy>'s
+#pod C<copy> function. Upon success, returns the C<Path::Tiny> object for the
+#pod newly copied file.
+#pod
+#pod Current API available since 0.070.
+#pod
+#pod =cut
+
+# XXX do recursively for directories?
+sub copy {
+    my ( $self, $dest ) = @_;
+    require File::Copy;
+    File::Copy::copy( $self->[PATH], $dest )
+      or Carp::croak("copy failed for $self to $dest: $!");
+
+    return -d $dest ? _path( $dest, $self->basename ) : _path($dest);
+}
+
+#pod =method digest
+#pod
+#pod     $obj = path("/tmp/foo.txt")->digest;        # SHA-256
+#pod     $obj = path("/tmp/foo.txt")->digest("MD5"); # user-selected
+#pod     $obj = path("/tmp/foo.txt")->digest( { chunk_size => 1e6 }, "MD5" );
+#pod
+#pod Returns a hexadecimal digest for a file.  An optional hash reference of options may
+#pod be given.  The only option is C<chunk_size>.  If C<chunk_size> is given, that many
+#pod bytes will be read at a time.  If not provided, the entire file will be slurped
+#pod into memory to compute the digest.
+#pod
+#pod Any subsequent arguments are passed to the constructor for L<Digest> to select
+#pod an algorithm.  If no arguments are given, the default is SHA-256.
+#pod
+#pod Current API available since 0.056.
+#pod
+#pod =cut
+
+sub digest {
+    my ( $self, @opts ) = @_;
+    my $args = ( @opts && ref $opts[0] eq 'HASH' ) ? shift @opts : {};
+    $args = _get_args( $args, qw/chunk_size/ );
+    unshift @opts, 'SHA-256' unless @opts;
+    require Digest;
+    my $digest = Digest->new(@opts);
+    if ( $args->{chunk_size} ) {
+        my $fh = $self->filehandle( { locked => 1 }, "<", ":unix" );
+        my $buf;
+        while (!eof($fh)) {
+            my $rc = read $fh, $buf, $args->{chunk_size};
+            $self->_throw('read') unless defined $rc;
+            $digest->add($buf);
+        }
+    }
+    else {
+        $digest->add( $self->slurp_raw );
+    }
+    return $digest->hexdigest;
+}
+
+#pod =method dirname (deprecated)
+#pod
+#pod     $name = path("/tmp/foo.txt")->dirname; # "/tmp/"
+#pod
+#pod Returns the directory portion you would get from calling
+#pod C<< File::Spec->splitpath( $path->stringify ) >> or C<"."> for a path without a
+#pod parent directory portion.  Because L<File::Spec> is inconsistent, the result
+#pod might or might not have a trailing slash.  Because of this, this method is
+#pod B<deprecated>.
+#pod
+#pod A better, more consistently approach is likely C<< $path->parent->stringify >>,
+#pod which will not have a trailing slash except for a root directory.
+#pod
+#pod Deprecated in 0.056.
+#pod
+#pod =cut
+
+sub dirname {
+    my ($self) = @_;
+    $self->_splitpath unless defined $self->[DIR];
+    return length $self->[DIR] ? $self->[DIR] : ".";
+}
+
+#pod =method edit, edit_raw, edit_utf8
+#pod
+#pod     path("foo.txt")->edit( \&callback, $options );
+#pod     path("foo.txt")->edit_utf8( \&callback );
+#pod     path("foo.txt")->edit_raw( \&callback );
+#pod
+#pod These are convenience methods that allow "editing" a file using a single
+#pod callback argument. They slurp the file using C<slurp>, place the contents
+#pod inside a localized C<$_> variable, call the callback function (without
+#pod arguments), and then write C<$_> (presumably mutated) back to the
+#pod file with C<spew>.
+#pod
+#pod An optional hash reference may be used to pass options.  The only option is
+#pod C<binmode>, which is passed to C<slurp> and C<spew>.
+#pod
+#pod C<edit_utf8> and C<edit_raw> act like their respective C<slurp_*> and
+#pod C<spew_*> methods.
+#pod
+#pod Current API available since 0.077.
+#pod
+#pod =cut
+
+sub edit {
+    my $self = shift;
+    my $cb   = shift;
+    my $args = _get_args( shift, qw/binmode/ );
+    Carp::croak("Callback for edit() must be a code reference")
+      unless defined($cb) && ref($cb) eq 'CODE';
+
+    local $_ =
+      $self->slurp( exists( $args->{binmode} ) ? { binmode => $args->{binmode} } : () );
+    $cb->();
+    $self->spew( $args, $_ );
+
+    return;
+}
+
+# this is done long-hand to benefit from slurp_utf8 optimizations
+sub edit_utf8 {
+    my ( $self, $cb ) = @_;
+    Carp::croak("Callback for edit_utf8() must be a code reference")
+      unless defined($cb) && ref($cb) eq 'CODE';
+
+    local $_ = $self->slurp_utf8;
+    $cb->();
+    $self->spew_utf8($_);
+
+    return;
+}
+
+sub edit_raw { $_[2] = { binmode => ":unix" }; goto &edit }
+
+#pod =method edit_lines, edit_lines_utf8, edit_lines_raw
+#pod
+#pod     path("foo.txt")->edit_lines( \&callback, $options );
+#pod     path("foo.txt")->edit_lines_utf8( \&callback );
+#pod     path("foo.txt")->edit_lines_raw( \&callback );
+#pod
+#pod These are convenience methods that allow "editing" a file's lines using a
+#pod single callback argument.  They iterate over the file: for each line, the
+#pod line is put into a localized C<$_> variable, the callback function is
+#pod executed (without arguments) and then C<$_> is written to a temporary file.
+#pod When iteration is finished, the temporary file is atomically renamed over
+#pod the original.
+#pod
+#pod An optional hash reference may be used to pass options.  The only option is
+#pod C<binmode>, which is passed to the method that open handles for reading and
+#pod writing.
+#pod
+#pod C<edit_lines_raw> is like C<edit_lines> with a buffered C<binmode> of
+#pod C<:raw>.
+#pod
+#pod C<edit_lines_utf8> is like C<edit_lines> with a buffered C<binmode>
+#pod C<:raw:encoding(UTF-8)> (or C<:raw:utf8_strict> with
+#pod L<PerlIO::utf8_strict>).
+#pod
+#pod Current API available since 0.077.
+#pod
+#pod =cut
+
+sub edit_lines {
+    my $self = shift;
+    my $cb   = shift;
+    my $args = _get_args( shift, qw/binmode/ );
+    Carp::croak("Callback for edit_lines() must be a code reference")
+      unless defined($cb) && ref($cb) eq 'CODE';
+
+    my $binmode = $args->{binmode};
+    # get default binmode from caller's lexical scope (see "perldoc open")
+    $binmode = ( ( caller(0) )[10] || {} )->{'open>'} unless defined $binmode;
+
+    # writing needs to follow the link and create the tempfile in the same
+    # dir for later atomic rename
+    my $resolved_path = $self->_resolve_symlinks;
+    my $temp          = $resolved_path->_replacment_path;
+
+    my $temp_fh = $temp->filehandle( { exclusive => 1, locked => 1 }, ">", $binmode );
+    my $in_fh = $self->filehandle( { locked => 1 }, '<', $binmode );
+
+    local $_;
+    while (! eof($in_fh) ) {
+        defined( $_ = readline($in_fh) ) or $self->_throw('readline');
+        $cb->();
+        $temp_fh->print($_) or self->_throw('print', $temp);
+    }
+
+    close $temp_fh or $self->_throw( 'close', $temp );
+    close $in_fh or $self->_throw('close');
+
+    return $temp->move($resolved_path);
+}
+
+sub edit_lines_raw { $_[2] = { binmode => ":raw" }; goto &edit_lines }
+
+sub edit_lines_utf8 {
+    if ( defined($HAS_PU) ? $HAS_PU : ( $HAS_PU = _check_PU() ) ) {
+        $_[2] = { binmode => ":raw:utf8_strict" };
+    }
+    else {
+        $_[2] = { binmode => ":raw:encoding(UTF-8)" };
+    }
+    goto &edit_lines;
+}
+
+#pod =method exists, is_file, is_dir
+#pod
+#pod     if ( path("/tmp")->exists ) { ... }     # -e
+#pod     if ( path("/tmp")->is_dir ) { ... }     # -d
+#pod     if ( path("/tmp")->is_file ) { ... }    # -e && ! -d
+#pod
+#pod Implements file test operations, this means the file or directory actually has
+#pod to exist on the filesystem.  Until then, it's just a path.
+#pod
+#pod B<Note>: C<is_file> is not C<-f> because C<-f> is not the opposite of C<-d>.
+#pod C<-f> means "plain file", excluding symlinks, devices, etc. that often can be
+#pod read just like files.
+#pod
+#pod Use C<-f> instead if you really mean to check for a plain file.
+#pod
+#pod Current API available since 0.053.
+#pod
+#pod =cut
+
+sub exists { -e $_[0]->[PATH] }
+
+sub is_file { -e $_[0]->[PATH] && !-d _ }
+
+sub is_dir { -d $_[0]->[PATH] }
+
+#pod =method filehandle
+#pod
+#pod     $fh = path("/tmp/foo.txt")->filehandle($mode, $binmode);
+#pod     $fh = path("/tmp/foo.txt")->filehandle({ locked => 1 }, $mode, $binmode);
+#pod     $fh = path("/tmp/foo.txt")->filehandle({ exclusive => 1  }, $mode, $binmode);
+#pod
+#pod Returns an open file handle.  The C<$mode> argument must be a Perl-style
+#pod read/write mode string ("<" ,">", ">>", etc.).  If a C<$binmode>
+#pod is given, it is set during the C<open> call.
+#pod
+#pod An optional hash reference may be used to pass options.
+#pod
+#pod The C<locked> option governs file locking; if true, handles opened for writing,
+#pod appending or read-write are locked with C<LOCK_EX>; otherwise, they are
+#pod locked with C<LOCK_SH>.  When using C<locked>, ">" or "+>" modes will delay
+#pod truncation until after the lock is acquired.
+#pod
+#pod The C<exclusive> option causes the open() call to fail if the file already
+#pod exists.  This corresponds to the O_EXCL flag to sysopen / open(2).
+#pod C<exclusive> implies C<locked> and will set it for you if you forget it.
+#pod
+#pod See C<openr>, C<openw>, C<openrw>, and C<opena> for sugar.
+#pod
+#pod Current API available since 0.066.
+#pod
+#pod =cut
+
+# Note: must put binmode on open line, not subsequent binmode() call, so things
+# like ":unix" actually stop perlio/crlf from being added
+
+sub filehandle {
+    my ( $self, @args ) = @_;
+    my $args = ( @args && ref $args[0] eq 'HASH' ) ? shift @args : {};
+    $args = _get_args( $args, qw/locked exclusive/ );
+    $args->{locked} = 1 if $args->{exclusive};
+    my ( $opentype, $binmode ) = @args;
+
+    $opentype = "<" unless defined $opentype;
+    Carp::croak("Invalid file mode '$opentype'")
+      unless grep { $opentype eq $_ } qw/< +< > +> >> +>>/;
+
+    $binmode = ( ( caller(0) )[10] || {} )->{ 'open' . substr( $opentype, -1, 1 ) }
+      unless defined $binmode;
+    $binmode = "" unless defined $binmode;
+
+    my ( $fh, $lock, $trunc );
+    if ( $HAS_FLOCK && $args->{locked} && !$ENV{PERL_PATH_TINY_NO_FLOCK} ) {
+        require Fcntl;
+        # truncating file modes shouldn't truncate until lock acquired
+        if ( grep { $opentype eq $_ } qw( > +> ) ) {
+            # sysopen in write mode without truncation
+            my $flags = $opentype eq ">" ? Fcntl::O_WRONLY() : Fcntl::O_RDWR();
+            $flags |= Fcntl::O_CREAT();
+            $flags |= Fcntl::O_EXCL() if $args->{exclusive};
+            sysopen( $fh, $self->[PATH], $flags ) or $self->_throw("sysopen");
+
+            # fix up the binmode since sysopen() can't specify layers like
+            # open() and binmode() can't start with just :unix like open()
+            if ( $binmode =~ s/^:unix// ) {
+                # eliminate pseudo-layers
+                binmode( $fh, ":raw" ) or $self->_throw("binmode (:raw)");
+                # strip off real layers until only :unix is left
+                while ( 1 < ( my $layers =()= PerlIO::get_layers( $fh, output => 1 ) ) ) {
+                    binmode( $fh, ":pop" ) or $self->_throw("binmode (:pop)");
+                }
+            }
+
+            # apply any remaining binmode layers
+            if ( length $binmode ) {
+                binmode( $fh, $binmode ) or $self->_throw("binmode ($binmode)");
+            }
+
+            # ask for lock and truncation
+            $lock  = Fcntl::LOCK_EX();
+            $trunc = 1;
+        }
+        elsif ( $^O eq 'aix' && $opentype eq "<" ) {
+            # AIX can only lock write handles, so upgrade to RW and LOCK_EX if
+            # the file is writable; otherwise give up on locking.  N.B.
+            # checking -w before open to determine the open mode is an
+            # unavoidable race condition
+            if ( -w $self->[PATH] ) {
+                $opentype = "+<";
+                $lock     = Fcntl::LOCK_EX();
+            }
+        }
+        else {
+            $lock = $opentype eq "<" ? Fcntl::LOCK_SH() : Fcntl::LOCK_EX();
+        }
+    }
+
+    unless ($fh) {
+        my $mode = $opentype . $binmode;
+        open $fh, $mode, $self->[PATH] or $self->_throw("open ($mode)");
+    }
+
+    do { flock( $fh, $lock ) or $self->_throw("flock ($lock)") } if $lock;
+    do { truncate( $fh, 0 ) or $self->_throw("truncate") } if $trunc;
+
+    return $fh;
+}
+
+#pod =method has_same_bytes
+#pod
+#pod     if ( path("foo.txt")->has_same_bytes("bar.txt") ) {
+#pod        # ...
+#pod     }
+#pod
+#pod This method returns true if both the invocant and the argument can be opened as
+#pod file handles and the handles contain the same bytes.  It returns false if their
+#pod contents differ.  If either can't be opened as a file (e.g. a directory or
+#pod non-existent file), the method throws an exception.  If both can be opened and
+#pod both have the same C<realpath>, the method returns true without scanning any
+#pod data.
+#pod
+#pod Current API available since 0.125.
+#pod
+#pod =cut
+
+sub has_same_bytes {
+    my ($self, $other_path) = @_;
+    my $other = _path($other_path);
+
+    my $fh1 = $self->openr_raw({ locked => 1 });
+    my $fh2 = $other->openr_raw({ locked => 1 });
+
+    # check for directories
+    if (-d $fh1) {
+        $self->_throw('has_same_bytes', $self->[PATH], "directory not allowed");
+    }
+    if (-d $fh2) {
+        $self->_throw('has_same_bytes', $other->[PATH], "directory not allowed");
+    }
+
+    # Now that handles are open, we know the inputs are readable files that
+    # exist, so it's safe to compare via realpath
+    if ($self->realpath eq $other->realpath) {
+        return 1
+    }
+
+    # result is 0 for equal, 1 for unequal, -1 for error
+    require File::Compare;
+    my $res = File::Compare::compare($fh1, $fh2, 65536);
+    if ($res < 0) {
+        $self->_throw('has_same_bytes')
+    }
+
+    return $res == 0;
+}
+
+#pod =method is_absolute, is_relative
+#pod
+#pod     if ( path("/tmp")->is_absolute ) { ... }
+#pod     if ( path("/tmp")->is_relative ) { ... }
+#pod
+#pod Booleans for whether the path appears absolute or relative.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+sub is_absolute { substr( $_[0]->dirname, 0, 1 ) eq '/' }
+
+sub is_relative { substr( $_[0]->dirname, 0, 1 ) ne '/' }
+
+#pod =method is_rootdir
+#pod
+#pod     while ( ! $path->is_rootdir ) {
+#pod         $path = $path->parent;
+#pod         ...
+#pod     }
+#pod
+#pod Boolean for whether the path is the root directory of the volume.  I.e. the
+#pod C<dirname> is C<q[/]> and the C<basename> is C<q[]>.
+#pod
+#pod This works even on C<MSWin32> with drives and UNC volumes:
+#pod
+#pod     path("C:/")->is_rootdir;             # true
+#pod     path("//server/share/")->is_rootdir; #true
+#pod
+#pod Current API available since 0.038.
+#pod
+#pod =cut
+
+sub is_rootdir {
+    my ($self) = @_;
+    $self->_splitpath unless defined $self->[DIR];
+    return $self->[DIR] eq '/' && $self->[FILE] eq '';
+}
+
+#pod =method iterator
+#pod
+#pod     $iter = path("/tmp")->iterator( \%options );
+#pod
+#pod Returns a code reference that walks a directory lazily.  Each invocation
+#pod returns a C<Path::Tiny> object or undef when the iterator is exhausted.
+#pod
+#pod     $iter = path("/tmp")->iterator;
+#pod     while ( $path = $iter->() ) {
+#pod         ...
+#pod     }
+#pod
+#pod The current and parent directory entries ("." and "..") will not
+#pod be included.
+#pod
+#pod If the C<recurse> option is true, the iterator will walk the directory
+#pod recursively, breadth-first.  If the C<follow_symlinks> option is also true,
+#pod directory links will be followed recursively.  There is no protection against
+#pod loops when following links. If a directory is not readable, it will not be
+#pod followed.
+#pod
+#pod The default is the same as:
+#pod
+#pod     $iter = path("/tmp")->iterator( {
+#pod         recurse         => 0,
+#pod         follow_symlinks => 0,
+#pod     } );
+#pod
+#pod For a more powerful, recursive iterator with built-in loop avoidance, see
+#pod L<Path::Iterator::Rule>.
+#pod
+#pod See also L</visit>.
+#pod
+#pod Current API available since 0.016.
+#pod
+#pod =cut
+
+sub iterator {
+    my $self = shift;
+    my $args = _get_args( shift, qw/recurse follow_symlinks/ );
+    my @dirs = $self;
+    my $current;
+    return sub {
+        my $next;
+        while (@dirs) {
+            if ( ref $dirs[0] eq 'Path::Tiny' ) {
+                if ( !-r $dirs[0] ) {
+                    # Directory is missing or not readable, so skip it.  There
+                    # is still a race condition possible between the check and
+                    # the opendir, but we can't easily differentiate between
+                    # error cases that are OK to skip and those that we want
+                    # to be exceptions, so we live with the race and let opendir
+                    # be fatal.
+                    shift @dirs and next;
+                }
+                $current = $dirs[0];
+                my $dh;
+                opendir( $dh, $current->[PATH] )
+                  or $self->_throw( 'opendir', $current->[PATH] );
+                $dirs[0] = $dh;
+                if ( -l $current->[PATH] && !$args->{follow_symlinks} ) {
+                    # Symlink attack! It was a real dir, but is now a symlink!
+                    # N.B. we check *after* opendir so the attacker has to win
+                    # two races: replace dir with symlink before opendir and
+                    # replace symlink with dir before -l check above
+                    shift @dirs and next;
+                }
+            }
+            while ( defined( $next = readdir $dirs[0] ) ) {
+                next if $next eq '.' || $next eq '..';
+                my $path = $current->child($next);
+                push @dirs, $path
+                  if $args->{recurse} && -d $path && !( !$args->{follow_symlinks} && -l $path );
+                return $path;
+            }
+            shift @dirs;
+        }
+        return;
+    };
+}
+
+#pod =method lines, lines_raw, lines_utf8
+#pod
+#pod     @contents = path("/tmp/foo.txt")->lines;
+#pod     @contents = path("/tmp/foo.txt")->lines(\%options);
+#pod     @contents = path("/tmp/foo.txt")->lines_raw;
+#pod     @contents = path("/tmp/foo.txt")->lines_utf8;
+#pod
+#pod     @contents = path("/tmp/foo.txt")->lines( { chomp => 1, count => 4 } );
+#pod
+#pod Returns a list of lines from a file.  Optionally takes a hash-reference of
+#pod options.  Valid options are C<binmode>, C<count> and C<chomp>.
+#pod
+#pod If C<binmode> is provided, it will be set on the handle prior to reading.
+#pod
+#pod If a positive C<count> is provided, that many lines will be returned from the
+#pod start of the file.  If a negative C<count> is provided, the entire file will be
+#pod read, but only C<abs(count)> will be kept and returned.  If C<abs(count)>
+#pod exceeds the number of lines in the file, all lines will be returned.
+#pod
+#pod If C<chomp> is set, any end-of-line character sequences (C<CR>, C<CRLF>, or
+#pod C<LF>) will be removed from the lines returned.
+#pod
+#pod Because the return is a list, C<lines> in scalar context will return the number
+#pod of lines (and throw away the data).
+#pod
+#pod     $number_of_lines = path("/tmp/foo.txt")->lines;
+#pod
+#pod C<lines_raw> is like C<lines> with a C<binmode> of C<:raw>.  We use C<:raw>
+#pod instead of C<:unix> so PerlIO buffering can manage reading by line.
+#pod
+#pod C<lines_utf8> is like C<lines> with a C<binmode> of C<:raw:encoding(UTF-8)>
+#pod (or C<:raw:utf8_strict> with L<PerlIO::utf8_strict>).  If L<Unicode::UTF8>
+#pod 0.58+ is installed, a raw, unbuffered UTF-8 slurp will be done and then the
+#pod lines will be split.  This is actually faster than relying on
+#pod IO layers, though a bit memory intensive.  If memory use is a
+#pod concern, consider C<openr_utf8> and iterating directly on the handle.
+#pod
+#pod Current API available since 0.065.
+#pod
+#pod =cut
+
+sub lines {
+    my $self    = shift;
+    my $args    = _get_args( shift, qw/binmode chomp count/ );
+    my $binmode = $args->{binmode};
+    $binmode = ( ( caller(0) )[10] || {} )->{'open<'} unless defined $binmode;
+    my $fh = $self->filehandle( { locked => 1 }, "<", $binmode );
+    my $chomp = $args->{chomp};
+    # XXX more efficient to read @lines then chomp(@lines) vs map?
+    if ( $args->{count} ) {
+        my ( $counter, $mod, @result ) = ( 0, abs( $args->{count} ) );
+        my $line;
+        while ( !eof($fh) ) {
+            defined( $line = readline($fh) ) or $self->_throw('readline');
+
+            $line =~ s/(?:\x{0d}?\x{0a}|\x{0d})\z// if $chomp;
+            $result[ $counter++ ] = $line;
+            # for positive count, terminate after right number of lines
+            last if $counter == $args->{count};
+            # for negative count, eventually wrap around in the result array
+            $counter %= $mod;
+        }
+        # reorder results if full and wrapped somewhere in the middle
+        splice( @result, 0, 0, splice( @result, $counter ) )
+          if @result == $mod && $counter % $mod;
+        return @result;
+    }
+    elsif ($chomp) {
+        local $!;
+        my @lines = map { s/(?:\x{0d}?\x{0a}|\x{0d})\z//; $_ } <$fh>; ## no critic
+        $self->_throw('readline') if $!;
+        return @lines;
+    }
+    else {
+        if ( wantarray ) {
+            local $!;
+            my @lines = <$fh>;
+            $self->_throw('readline') if $!;
+            return @lines;
+        } else {
+            local $!;
+            my $count =()= <$fh>;
+            $self->_throw('readline') if $!;
+            return $count;
+        }
+    }
+}
+
+sub lines_raw {
+    my $self = shift;
+    my $args = _get_args( shift, qw/binmode chomp count/ );
+    if ( $args->{chomp} && !$args->{count} ) {
+        return split /\n/, slurp_raw($self);                    ## no critic
+    }
+    else {
+        $args->{binmode} = ":raw";
+        return lines( $self, $args );
+    }
+}
+
+my $CRLF = qr/(?:\x{0d}?\x{0a}|\x{0d})/;
+
+sub lines_utf8 {
+    my $self = shift;
+    my $args = _get_args( shift, qw/binmode chomp count/ );
+    if (   ( defined($HAS_UU) ? $HAS_UU : ( $HAS_UU = _check_UU() ) )
+        && $args->{chomp}
+        && !$args->{count} )
+    {
+        my $slurp = slurp_utf8($self);
+        $slurp =~ s/$CRLF\z//; # like chomp, but full CR?LF|CR
+        return split $CRLF, $slurp, -1; ## no critic
+    }
+    elsif ( defined($HAS_PU) ? $HAS_PU : ( $HAS_PU = _check_PU() ) ) {
+        $args->{binmode} = ":raw:utf8_strict";
+        return lines( $self, $args );
+    }
+    else {
+        $args->{binmode} = ":raw:encoding(UTF-8)";
+        return lines( $self, $args );
+    }
+}
+
+#pod =method mkdir
+#pod
+#pod     path("foo/bar/baz")->mkdir;
+#pod     path("foo/bar/baz")->mkdir( \%options );
+#pod
+#pod Like calling C<make_path> from L<File::Path>.  An optional hash reference
+#pod is passed through to C<make_path>.  Errors will be trapped and an exception
+#pod thrown.  Returns the the path object to facilitate chaining.
+#pod
+#pod B<NOTE>: unlike Perl's builtin C<mkdir>, this will create intermediate paths
+#pod similar to the Unix C<mkdir -p> command.  It will not error if applied to an
+#pod existing directory.
+#pod
+#pod Current API available since 0.125.
+#pod
+#pod =cut
+
+sub mkdir {
+    my ( $self, $args ) = @_;
+    $args = {} unless ref $args eq 'HASH';
+    my $err;
+    $args->{error} = \$err unless defined $args->{error};
+    require File::Path;
+    my @dirs;
+    my $ok = eval {
+        File::Path::make_path( $self->[PATH], $args );
+        1;
+    };
+    if (!$ok) {
+        $self->_throw('mkdir', $self->[PATH], "error creating path: $@");
+    }
+    if ( $err && @$err ) {
+        my ( $file, $message ) = %{ $err->[0] };
+        $self->_throw('mkdir', $file, $message);
+    }
+    return $self;
+}
+
+#pod =method mkpath (deprecated)
+#pod
+#pod Like calling C<mkdir>, but returns the list of directories created or an empty list if
+#pod the directories already exist, just like C<make_path>.
+#pod
+#pod Deprecated in 0.125.
+#pod
+#pod =cut
+
+sub mkpath {
+    my ( $self, $args ) = @_;
+    $args = {} unless ref $args eq 'HASH';
+    my $err;
+    $args->{error} = \$err unless defined $args->{error};
+    require File::Path;
+    my @dirs = File::Path::make_path( $self->[PATH], $args );
+    if ( $err && @$err ) {
+        my ( $file, $message ) = %{ $err->[0] };
+        Carp::croak("mkpath failed for $file: $message");
+    }
+    return @dirs;
+}
+
+#pod =method move
+#pod
+#pod     path("foo.txt")->move("bar.txt");
+#pod
+#pod Moves the current path to the given destination using L<File::Copy>'s
+#pod C<move> function. Upon success, returns the C<Path::Tiny> object for the
+#pod newly moved file.
+#pod
+#pod If the destination already exists and is a directory, and the source is not a
+#pod directory, then the source file will be renamed into the directory
+#pod specified by the destination.
+#pod
+#pod If possible, move() will simply rename the file. Otherwise, it
+#pod copies the file to the new location and deletes the original. If an
+#pod error occurs during this copy-and-delete process, you may be left
+#pod with a (possibly partial) copy of the file under the destination
+#pod name.
+#pod
+#pod Current API available since 0.124. Prior versions used Perl's
+#pod -built-in (and less robust) L<rename|perlfunc/rename> function
+#pod and did not return an object.
+#pod
+#pod =cut
+
+sub move {
+    my ( $self, $dest ) = @_;
+    require File::Copy;
+    File::Copy::move( $self->[PATH], $dest )
+      or $self->_throw( 'move', $self->[PATH] . "' -> '$dest" );
+
+    return -d $dest ? _path( $dest, $self->basename ) : _path($dest);
+}
+
+#pod =method openr, openw, openrw, opena
+#pod
+#pod     $fh = path("foo.txt")->openr($binmode);  # read
+#pod     $fh = path("foo.txt")->openr_raw;
+#pod     $fh = path("foo.txt")->openr_utf8;
+#pod
+#pod     $fh = path("foo.txt")->openw($binmode);  # write
+#pod     $fh = path("foo.txt")->openw_raw;
+#pod     $fh = path("foo.txt")->openw_utf8;
+#pod
+#pod     $fh = path("foo.txt")->opena($binmode);  # append
+#pod     $fh = path("foo.txt")->opena_raw;
+#pod     $fh = path("foo.txt")->opena_utf8;
+#pod
+#pod     $fh = path("foo.txt")->openrw($binmode); # read/write
+#pod     $fh = path("foo.txt")->openrw_raw;
+#pod     $fh = path("foo.txt")->openrw_utf8;
+#pod
+#pod Returns a file handle opened in the specified mode.  The C<openr> style methods
+#pod take a single C<binmode> argument.  All of the C<open*> methods have
+#pod C<open*_raw> and C<open*_utf8> equivalents that use buffered I/O layers C<:raw>
+#pod and C<:raw:encoding(UTF-8)> (or C<:raw:utf8_strict> with
+#pod L<PerlIO::utf8_strict>).
+#pod
+#pod An optional hash reference may be used to pass options.  The only option is
+#pod C<locked>.  If true, handles opened for writing, appending or read-write are
+#pod locked with C<LOCK_EX>; otherwise, they are locked for C<LOCK_SH>.
+#pod
+#pod     $fh = path("foo.txt")->openrw_utf8( { locked => 1 } );
+#pod
+#pod See L</filehandle> for more on locking.
+#pod
+#pod Current API available since 0.011.
+#pod
+#pod =cut
+
+# map method names to corresponding open mode
+my %opens = (
+    opena  => ">>",
+    openr  => "<",
+    openw  => ">",
+    openrw => "+<"
+);
+
+while ( my ( $k, $v ) = each %opens ) {
+    no strict 'refs';
+    # must check for lexical IO mode hint
+    *{$k} = sub {
+        my ( $self, @args ) = @_;
+        my $args = ( @args && ref $args[0] eq 'HASH' ) ? shift @args : {};
+        $args = _get_args( $args, qw/locked/ );
+        my ($binmode) = @args;
+        $binmode = ( ( caller(0) )[10] || {} )->{ 'open' . substr( $v, -1, 1 ) }
+          unless defined $binmode;
+        $self->filehandle( $args, $v, $binmode );
+    };
+    *{ $k . "_raw" } = sub {
+        my ( $self, @args ) = @_;
+        my $args = ( @args && ref $args[0] eq 'HASH' ) ? shift @args : {};
+        $args = _get_args( $args, qw/locked/ );
+        $self->filehandle( $args, $v, ":raw" );
+    };
+    *{ $k . "_utf8" } = sub {
+        my ( $self, @args ) = @_;
+        my $args = ( @args && ref $args[0] eq 'HASH' ) ? shift @args : {};
+        $args = _get_args( $args, qw/locked/ );
+        my $layer;
+        if ( defined($HAS_PU) ? $HAS_PU : ( $HAS_PU = _check_PU() ) ) {
+            $layer = ":raw:utf8_strict";
+        }
+        else {
+            $layer = ":raw:encoding(UTF-8)";
+        }
+        $self->filehandle( $args, $v, $layer );
+    };
+}
+
+#pod =method parent
+#pod
+#pod     $parent = path("foo/bar/baz")->parent; # foo/bar
+#pod     $parent = path("foo/wibble.txt")->parent; # foo
+#pod
+#pod     $parent = path("foo/bar/baz")->parent(2); # foo
+#pod
+#pod Returns a C<Path::Tiny> object corresponding to the parent directory of the
+#pod original directory or file. An optional positive integer argument is the number
+#pod of parent directories upwards to return.  C<parent> by itself is equivalent to
+#pod C<parent(1)>.
+#pod
+#pod Current API available since 0.014.
+#pod
+#pod =cut
+
+# XXX this is ugly and coverage is incomplete.  I think it's there for windows
+# so need to check coverage there and compare
+sub parent {
+    my ( $self, $level ) = @_;
+    $level = 1 unless defined $level && $level > 0;
+    $self->_splitpath unless defined $self->[FILE];
+    my $parent;
+    if ( length $self->[FILE] ) {
+        if ( $self->[FILE] eq '.' || $self->[FILE] eq ".." ) {
+            $parent = _path( $self->[PATH] . "/.." );
+        }
+        else {
+            $parent = _path( _non_empty( $self->[VOL] . $self->[DIR] ) );
+        }
+    }
+    elsif ( length $self->[DIR] ) {
+        # because of symlinks, any internal updir requires us to
+        # just add more updirs at the end
+        if ( $self->[DIR] =~ m{(?:^\.\./|/\.\./|/\.\.\z)} ) {
+            $parent = _path( $self->[VOL] . $self->[DIR] . "/.." );
+        }
+        else {
+            ( my $dir = $self->[DIR] ) =~ s{/[^\/]+/\z}{/};
+            $parent = _path( $self->[VOL] . $dir );
+        }
+    }
+    else {
+        $parent = _path( _non_empty( $self->[VOL] ) );
+    }
+    return $level == 1 ? $parent : $parent->parent( $level - 1 );
+}
+
+sub _non_empty {
+    my ($string) = shift;
+    return ( ( defined($string) && length($string) ) ? $string : "." );
+}
+
+#pod =method realpath
+#pod
+#pod     $real = path("/baz/foo/../bar")->realpath;
+#pod     $real = path("foo/../bar")->realpath;
+#pod
+#pod Returns a new C<Path::Tiny> object with all symbolic links and upward directory
+#pod parts resolved using L<Cwd>'s C<realpath>.  Compared to C<absolute>, this is
+#pod more expensive as it must actually consult the filesystem.
+#pod
+#pod If the parent path can't be resolved (e.g. if it includes directories that
+#pod don't exist), an exception will be thrown:
+#pod
+#pod     $real = path("doesnt_exist/foo")->realpath; # dies
+#pod
+#pod However, if the parent path exists and only the last component (e.g. filename)
+#pod doesn't exist, the realpath will be the realpath of the parent plus the
+#pod non-existent last component:
+#pod
+#pod     $real = path("./aasdlfasdlf")->realpath; # works
+#pod
+#pod The underlying L<Cwd> module usually worked this way on Unix, but died on
+#pod Windows (and some Unixes) if the full path didn't exist.  As of version 0.064,
+#pod it's safe to use anywhere.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+# Win32 and some Unixes need parent path resolved separately so realpath
+# doesn't throw an error resolving non-existent basename
+sub realpath {
+    my $self = shift;
+    $self = $self->_resolve_symlinks;
+    require Cwd;
+    $self->_splitpath if !defined $self->[FILE];
+    my $check_parent =
+      length $self->[FILE] && $self->[FILE] ne '.' && $self->[FILE] ne '..';
+    my $realpath = eval {
+        # pure-perl Cwd can carp
+        local $SIG{__WARN__} = sub { };
+        Cwd::realpath( $check_parent ? $self->parent->[PATH] : $self->[PATH] );
+    };
+    # parent realpath must exist; not all Cwd::realpath will error if it doesn't
+    $self->_throw("resolving realpath")
+      unless defined $realpath && length $realpath && -e $realpath;
+    return ( $check_parent ? _path( $realpath, $self->[FILE] ) : _path($realpath) );
+}
+
+#pod =method relative
+#pod
+#pod     $rel = path("/tmp/foo/bar")->relative("/tmp"); # foo/bar
+#pod
+#pod Returns a C<Path::Tiny> object with a path relative to a new base path
+#pod given as an argument.  If no argument is given, the current directory will
+#pod be used as the new base path.
+#pod
+#pod If either path is already relative, it will be made absolute based on the
+#pod current directly before determining the new relative path.
+#pod
+#pod The algorithm is roughly as follows:
+#pod
+#pod =for :list
+#pod * If the original and new base path are on different volumes, an exception
+#pod   will be thrown.
+#pod * If the original and new base are identical, the relative path is C<".">.
+#pod * If the new base subsumes the original, the relative path is the original
+#pod   path with the new base chopped off the front
+#pod * If the new base does not subsume the original, a common prefix path is
+#pod   determined (possibly the root directory) and the relative path will
+#pod   consist of updirs (C<"..">) to reach the common prefix, followed by the
+#pod   original path less the common prefix.
+#pod
+#pod Unlike C<File::Spec::abs2rel>, in the last case above, the calculation based
+#pod on a common prefix takes into account symlinks that could affect the updir
+#pod process.  Given an original path "/A/B" and a new base "/A/C",
+#pod (where "A", "B" and "C" could each have multiple path components):
+#pod
+#pod =for :list
+#pod * Symlinks in "A" don't change the result unless the last component of A is
+#pod   a symlink and the first component of "C" is an updir.
+#pod * Symlinks in "B" don't change the result and will exist in the result as
+#pod   given.
+#pod * Symlinks and updirs in "C" must be resolved to actual paths, taking into
+#pod   account the possibility that not all path components might exist on the
+#pod   filesystem.
+#pod
+#pod Current API available since 0.001.  New algorithm (that accounts for
+#pod symlinks) available since 0.079.
+#pod
+#pod =cut
+
+sub relative {
+    my ( $self, $base ) = @_;
+    $base = _path( defined $base && length $base ? $base : '.' );
+
+    # relative paths must be converted to absolute first
+    $self = $self->absolute if $self->is_relative;
+    $base = $base->absolute if $base->is_relative;
+
+    # normalize volumes if they exist
+    $self = $self->absolute if !length $self->volume && length $base->volume;
+    $base = $base->absolute if length $self->volume  && !length $base->volume;
+
+    # can't make paths relative across volumes
+    if ( !_same( $self->volume, $base->volume ) ) {
+        Carp::croak("relative() can't cross volumes: '$self' vs '$base'");
+    }
+
+    # if same absolute path, relative is current directory
+    return _path(".") if _same( $self->[PATH], $base->[PATH] );
+
+    # if base is a prefix of self, chop prefix off self
+    if ( $base->subsumes($self) ) {
+        $base = "" if $base->is_rootdir;
+        my $relative = "$self";
+        $relative =~ s{\A\Q$base/}{};
+        return _path(".", $relative);
+    }
+
+    # base is not a prefix, so must find a common prefix (even if root)
+    my ( @common, @self_parts, @base_parts );
+    @base_parts = split /\//, $base->_just_filepath;
+
+    # if self is rootdir, then common directory is root (shown as empty
+    # string for later joins); otherwise, must be computed from path parts.
+    if ( $self->is_rootdir ) {
+        @common = ("");
+        shift @base_parts;
+    }
+    else {
+        @self_parts = split /\//, $self->_just_filepath;
+
+        while ( @self_parts && @base_parts && _same( $self_parts[0], $base_parts[0] ) ) {
+            push @common, shift @base_parts;
+            shift @self_parts;
+        }
+    }
+
+    # if there are any symlinks from common to base, we have a problem, as
+    # you can't guarantee that updir from base reaches the common prefix;
+    # we must resolve symlinks and try again; likewise, any updirs are
+    # a problem as it throws off calculation of updirs needed to get from
+    # self's path to the common prefix.
+    if ( my $new_base = $self->_resolve_between( \@common, \@base_parts ) ) {
+        return $self->relative($new_base);
+    }
+
+    # otherwise, symlinks in common or from common to A don't matter as
+    # those don't involve updirs
+    my @new_path = ( ("..") x ( 0+ @base_parts ), @self_parts );
+    return _path(@new_path);
+}
+
+sub _just_filepath {
+    my $self     = shift;
+    my $self_vol = $self->volume;
+    return "$self" if !length $self_vol;
+
+    ( my $self_path = "$self" ) =~ s{\A\Q$self_vol}{};
+
+    return $self_path;
+}
+
+sub _resolve_between {
+    my ( $self, $common, $base ) = @_;
+    my $path = $self->volume . join( "/", @$common );
+    my $changed = 0;
+    for my $p (@$base) {
+        $path .= "/$p";
+        if ( $p eq '..' ) {
+            $changed = 1;
+            if ( -e $path ) {
+                $path = _path($path)->realpath->[PATH];
+            }
+            else {
+                $path =~ s{/[^/]+/..\z}{/};
+            }
+        }
+        if ( -l $path ) {
+            $changed = 1;
+            $path    = _path($path)->realpath->[PATH];
+        }
+    }
+    return $changed ? _path($path) : undef;
+}
+
+#pod =method remove
+#pod
+#pod     path("foo.txt")->remove;
+#pod
+#pod This is just like C<unlink>, except for its error handling: if the path does
+#pod not exist, it returns false; if deleting the file fails, it throws an
+#pod exception.
+#pod
+#pod Current API available since 0.012.
+#pod
+#pod =cut
+
+sub remove {
+    my $self = shift;
+
+    return 0 if !-e $self->[PATH] && !-l $self->[PATH];
+
+    return unlink( $self->[PATH] ) || $self->_throw('unlink');
+}
+
+#pod =method remove_tree
+#pod
+#pod     # directory
+#pod     path("foo/bar/baz")->remove_tree;
+#pod     path("foo/bar/baz")->remove_tree( \%options );
+#pod     path("foo/bar/baz")->remove_tree( { safe => 0 } ); # force remove
+#pod
+#pod Like calling C<remove_tree> from L<File::Path>, but defaults to C<safe> mode.
+#pod An optional hash reference is passed through to C<remove_tree>.  Errors will be
+#pod trapped and an exception thrown.  Returns the number of directories deleted,
+#pod just like C<remove_tree>.
+#pod
+#pod If you want to remove a directory only if it is empty, use the built-in
+#pod C<rmdir> function instead.
+#pod
+#pod     rmdir path("foo/bar/baz/");
+#pod
+#pod Current API available since 0.013.
+#pod
+#pod =cut
+
+sub remove_tree {
+    my ( $self, $args ) = @_;
+    return 0 if !-e $self->[PATH] && !-l $self->[PATH];
+    $args = {} unless ref $args eq 'HASH';
+    my $err;
+    $args->{error} = \$err unless defined $args->{error};
+    $args->{safe}  = 1     unless defined $args->{safe};
+    require File::Path;
+    my $count = File::Path::remove_tree( $self->[PATH], $args );
+
+    if ( $err && @$err ) {
+        my ( $file, $message ) = %{ $err->[0] };
+        Carp::croak("remove_tree failed for $file: $message");
+    }
+    return $count;
+}
+
+#pod =method sibling
+#pod
+#pod     $foo = path("/tmp/foo.txt");
+#pod     $sib = $foo->sibling("bar.txt");        # /tmp/bar.txt
+#pod     $sib = $foo->sibling("baz", "bam.txt"); # /tmp/baz/bam.txt
+#pod
+#pod Returns a new C<Path::Tiny> object relative to the parent of the original.
+#pod This is slightly more efficient than C<< $path->parent->child(...) >>.
+#pod
+#pod Current API available since 0.058.
+#pod
+#pod =cut
+
+sub sibling {
+    my $self = shift;
+    return _path( $self->parent->[PATH], @_ );
+}
+
+#pod =method size, size_human
+#pod
+#pod     my $p = path("foo"); # with size 1025 bytes
+#pod
+#pod     $p->size;                            # "1025"
+#pod     $p->size_human;                      # "1.1 K"
+#pod     $p->size_human( {format => "iec"} ); # "1.1 KiB"
+#pod
+#pod Returns the size of a file.  The C<size> method is just a wrapper around C<-s>.
+#pod
+#pod The C<size_human> method provides a human-readable string similar to
+#pod C<ls -lh>.  Like C<ls>, it rounds upwards and provides one decimal place for
+#pod single-digit sizes and no decimal places for larger sizes.  The only available
+#pod option is C<format>, which has three valid values:
+#pod
+#pod =for :list
+#pod * 'ls' (the default): base-2 sizes, with C<ls> style single-letter suffixes (K, M, etc.)
+#pod * 'iec': base-2 sizes, with IEC binary suffixes (KiB, MiB, etc.)
+#pod * 'si': base-10 sizes, with SI decimal suffixes (kB, MB, etc.)
+#pod
+#pod If C<-s> would return C<undef>, C<size_human> returns the empty string.
+#pod
+#pod Current API available since 0.122.
+#pod
+#pod =cut
+
+sub size { -s $_[0]->[PATH] }
+
+my %formats = (
+    'ls'  => [ 1024, log(1024), [ "", map { " $_" } qw/K M G T/ ] ],
+    'iec' => [ 1024, log(1024), [ "", map { " $_" } qw/KiB MiB GiB TiB/ ] ],
+    'si'  => [ 1000, log(1000), [ "", map { " $_" } qw/kB MB GB TB/ ] ],
+);
+
+sub _formats { return $formats{$_[0]} }
+
+sub size_human {
+    my $self     = shift;
+    my $args     = _get_args( shift, qw/format/ );
+    my $format   = defined $args->{format} ? $args->{format} : "ls";
+    my $fmt_opts = $formats{$format}
+      or Carp::croak("Invalid format '$format' for size_human()");
+    my $size = -s $self->[PATH];
+    return defined $size ? _human_size( $size, @$fmt_opts ) : "";
+}
+
+sub _ceil {
+    return $_[0] == int($_[0]) ? $_[0] : int($_[0]+1);
+}
+
+sub _human_size {
+    my ( $size, $base, $log_base, $suffixes ) = @_;
+    return "0" if $size == 0;
+
+    my $mag = int( log($size) / $log_base );
+    $size /= $base**$mag;
+    $size =
+        $mag == 0               ? $size
+      : length( int($size) ) == 1 ? _ceil( $size * 10 ) / 10
+      :                             _ceil($size);
+    if ( $size >= $base ) {
+        $size /= $base;
+        $mag++;
+    }
+
+    my $fmt = ( $mag == 0 || length( int($size) ) > 1 ) ? "%.0f%s" : "%.1f%s";
+    return sprintf( $fmt, $size, $suffixes->[$mag] );
+}
+
+#pod =method slurp, slurp_raw, slurp_utf8
+#pod
+#pod     $data = path("foo.txt")->slurp;
+#pod     $data = path("foo.txt")->slurp( {binmode => ":raw"} );
+#pod     $data = path("foo.txt")->slurp_raw;
+#pod     $data = path("foo.txt")->slurp_utf8;
+#pod
+#pod Reads file contents into a scalar.  Takes an optional hash reference which may
+#pod be used to pass options.  The only available option is C<binmode>, which is
+#pod passed to C<binmode()> on the handle used for reading.
+#pod
+#pod C<slurp_raw> is like C<slurp> with a C<binmode> of C<:unix> for
+#pod a fast, unbuffered, raw read.
+#pod
+#pod C<slurp_utf8> is like C<slurp> with a C<binmode> of
+#pod C<:unix:encoding(UTF-8)> (or C<:unix:utf8_strict> with
+#pod L<PerlIO::utf8_strict>).  If L<Unicode::UTF8> 0.58+ is installed, a
+#pod unbuffered, raw slurp will be done instead and the result decoded with
+#pod C<Unicode::UTF8>. This is just as strict and is roughly an order of
+#pod magnitude faster than using C<:encoding(UTF-8)>.
+#pod
+#pod B<Note>: C<slurp> and friends lock the filehandle before slurping.  If
+#pod you plan to slurp from a file created with L<File::Temp>, be sure to
+#pod close other handles or open without locking to avoid a deadlock:
+#pod
+#pod     my $tempfile = File::Temp->new(EXLOCK => 0);
+#pod     my $guts = path($tempfile)->slurp;
+#pod
+#pod Current API available since 0.004.
+#pod
+#pod =cut
+
+sub slurp {
+    my $self    = shift;
+    my $args    = _get_args( shift, qw/binmode/ );
+    my $binmode = $args->{binmode};
+    $binmode = ( ( caller(0) )[10] || {} )->{'open<'} unless defined $binmode;
+    my $fh = $self->filehandle( { locked => 1 }, "<", $binmode );
+    if ( ( defined($binmode) ? $binmode : "" ) eq ":unix"
+        and my $size = -s $fh )
+    {
+        my $buf;
+        my $rc = read $fh, $buf, $size; # File::Slurp in a nutshell
+        $self->_throw('read') unless defined $rc;
+        return $buf;
+    }
+    else {
+        local $/;
+        my $buf = scalar <$fh>;
+        $self->_throw('read') unless defined $buf;
+        return $buf;
+    }
+}
+
+sub slurp_raw { $_[1] = { binmode => ":unix" }; goto &slurp }
+
+sub slurp_utf8 {
+    if ( defined($HAS_UU) ? $HAS_UU : ( $HAS_UU = _check_UU() ) ) {
+        return Unicode::UTF8::decode_utf8( slurp( $_[0], { binmode => ":unix" } ) );
+    }
+    elsif ( defined($HAS_PU) ? $HAS_PU : ( $HAS_PU = _check_PU() ) ) {
+        $_[1] = { binmode => ":unix:utf8_strict" };
+        goto &slurp;
+    }
+    else {
+        $_[1] = { binmode => ":unix:encoding(UTF-8)" };
+        goto &slurp;
+    }
+}
+
+#pod =method spew, spew_raw, spew_utf8
+#pod
+#pod     path("foo.txt")->spew(@data);
+#pod     path("foo.txt")->spew(\@data);
+#pod     path("foo.txt")->spew({binmode => ":raw"}, @data);
+#pod     path("foo.txt")->spew_raw(@data);
+#pod     path("foo.txt")->spew_utf8(@data);
+#pod
+#pod Writes data to a file atomically.  The file is written to a temporary file in
+#pod the same directory, then renamed over the original.  An optional hash reference
+#pod may be used to pass options.  The only option is C<binmode>, which is passed to
+#pod C<binmode()> on the handle used for writing.
+#pod
+#pod C<spew_raw> is like C<spew> with a C<binmode> of C<:unix> for a fast,
+#pod unbuffered, raw write.
+#pod
+#pod C<spew_utf8> is like C<spew> with a C<binmode> of C<:unix:encoding(UTF-8)>
+#pod (or C<:unix:utf8_strict> with L<PerlIO::utf8_strict>).  If L<Unicode::UTF8>
+#pod 0.58+ is installed, a raw, unbuffered spew will be done instead on the data
+#pod encoded with C<Unicode::UTF8>.
+#pod
+#pod B<NOTE>: because the file is written to a temporary file and then renamed, the
+#pod new file will wind up with permissions based on your current umask.  This is a
+#pod feature to protect you from a race condition that would otherwise give
+#pod different permissions than you might expect.  If you really want to keep the
+#pod original mode flags, use L</append> with the C<truncate> option.
+#pod
+#pod Current API available since 0.011.
+#pod
+#pod =cut
+
+sub spew {
+    my ( $self, @data ) = @_;
+    my $args = ( @data && ref $data[0] eq 'HASH' ) ? shift @data : {};
+    $args = _get_args( $args, qw/binmode/ );
+    my $binmode = $args->{binmode};
+    # get default binmode from caller's lexical scope (see "perldoc open")
+    $binmode = ( ( caller(0) )[10] || {} )->{'open>'} unless defined $binmode;
+
+    # writing needs to follow the link and create the tempfile in the same
+    # dir for later atomic rename
+    my $resolved_path = $self->_resolve_symlinks;
+    my $temp          = $resolved_path->_replacment_path;
+
+    my $fh   = $temp->filehandle( { exclusive => 1, locked => 1 }, ">", $binmode );
+    print( {$fh} map { ref eq 'ARRAY' ? @$_ : $_ } @data) or self->_throw('print', $temp->[PATH]);
+    close $fh or $self->_throw( 'close', $temp->[PATH] );
+
+    return $temp->move($resolved_path);
+}
+
+sub spew_raw { splice @_, 1, 0, { binmode => ":unix" }; goto &spew }
+
+sub spew_utf8 {
+    if ( defined($HAS_UU) ? $HAS_UU : ( $HAS_UU = _check_UU() ) ) {
+        my $self = shift;
+        spew(
+            $self,
+            { binmode => ":unix" },
+            map { Unicode::UTF8::encode_utf8($_) } map { ref eq 'ARRAY' ? @$_ : $_ } @_
+        );
+    }
+    elsif ( defined($HAS_PU) ? $HAS_PU : ( $HAS_PU = _check_PU() ) ) {
+        splice @_, 1, 0, { binmode => ":unix:utf8_strict" };
+        goto &spew;
+    }
+    else {
+        splice @_, 1, 0, { binmode => ":unix:encoding(UTF-8)" };
+        goto &spew;
+    }
+}
+
+#pod =method stat, lstat
+#pod
+#pod     $stat = path("foo.txt")->stat;
+#pod     $stat = path("/some/symlink")->lstat;
+#pod
+#pod Like calling C<stat> or C<lstat> from L<File::stat>.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+# XXX break out individual stat() components as subs?
+sub stat {
+    my $self = shift;
+    require File::stat;
+    return File::stat::stat( $self->[PATH] ) || $self->_throw('stat');
+}
+
+sub lstat {
+    my $self = shift;
+    require File::stat;
+    return File::stat::lstat( $self->[PATH] ) || $self->_throw('lstat');
+}
+
+#pod =method stringify
+#pod
+#pod     $path = path("foo.txt");
+#pod     say $path->stringify; # same as "$path"
+#pod
+#pod Returns a string representation of the path.  Unlike C<canonpath>, this method
+#pod returns the path standardized with Unix-style C</> directory separators.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+sub stringify { $_[0]->[PATH] =~ /^~/ ? './' . $_[0]->[PATH] : $_[0]->[PATH] }
+
+#pod =method subsumes
+#pod
+#pod     path("foo/bar")->subsumes("foo/bar/baz"); # true
+#pod     path("/foo/bar")->subsumes("/foo/baz");   # false
+#pod
+#pod Returns true if the first path is a prefix of the second path at a directory
+#pod boundary.
+#pod
+#pod This B<does not> resolve parent directory entries (C<..>) or symlinks:
+#pod
+#pod     path("foo/bar")->subsumes("foo/bar/../baz"); # true
+#pod
+#pod If such things are important to you, ensure that both paths are resolved to
+#pod the filesystem with C<realpath>:
+#pod
+#pod     my $p1 = path("foo/bar")->realpath;
+#pod     my $p2 = path("foo/bar/../baz")->realpath;
+#pod     if ( $p1->subsumes($p2) ) { ... }
+#pod
+#pod Current API available since 0.048.
+#pod
+#pod =cut
+
+sub subsumes {
+    my $self = shift;
+    Carp::croak("subsumes() requires a defined, positive-length argument")
+      unless defined $_[0];
+    my $other = _path(shift);
+
+    # normalize absolute vs relative
+    if ( $self->is_absolute && !$other->is_absolute ) {
+        $other = $other->absolute;
+    }
+    elsif ( $other->is_absolute && !$self->is_absolute ) {
+        $self = $self->absolute;
+    }
+
+    # normalize volume vs non-volume; do this after absolute path
+    # adjustments above since that might add volumes already
+    if ( length $self->volume && !length $other->volume ) {
+        $other = $other->absolute;
+    }
+    elsif ( length $other->volume && !length $self->volume ) {
+        $self = $self->absolute;
+    }
+
+    if ( $self->[PATH] eq '.' ) {
+        return !!1; # cwd subsumes everything relative
+    }
+    elsif ( $self->is_rootdir ) {
+        # a root directory ("/", "c:/") already ends with a separator
+        return $other->[PATH] =~ m{^\Q$self->[PATH]\E};
+    }
+    else {
+        # exact match or prefix breaking at a separator
+        return $other->[PATH] =~ m{^\Q$self->[PATH]\E(?:/|\z)};
+    }
+}
+
+#pod =method touch
+#pod
+#pod     path("foo.txt")->touch;
+#pod     path("foo.txt")->touch($epoch_secs);
+#pod
+#pod Like the Unix C<touch> utility.  Creates the file if it doesn't exist, or else
+#pod changes the modification and access times to the current time.  If the first
+#pod argument is the epoch seconds then it will be used.
+#pod
+#pod Returns the path object so it can be easily chained with other methods:
+#pod
+#pod     # won't die if foo.txt doesn't exist
+#pod     $content = path("foo.txt")->touch->slurp;
+#pod
+#pod Current API available since 0.015.
+#pod
+#pod =cut
+
+sub touch {
+    my ( $self, $epoch ) = @_;
+    if ( !-e $self->[PATH] ) {
+        my $fh = $self->openw;
+        close $fh or $self->_throw('close');
+    }
+    if ( defined $epoch ) {
+        utime $epoch, $epoch, $self->[PATH]
+          or $self->_throw("utime ($epoch)");
+    }
+    else {
+        # literal undef prevents warnings :-(
+        utime undef, undef, $self->[PATH]
+          or $self->_throw("utime ()");
+    }
+    return $self;
+}
+
+#pod =method touchpath
+#pod
+#pod     path("bar/baz/foo.txt")->touchpath;
+#pod
+#pod Combines C<mkdir> and C<touch>.  Creates the parent directory if it doesn't exist,
+#pod before touching the file.  Returns the path object like C<touch> does.
+#pod
+#pod If you need to pass options, use C<mkdir> and C<touch> separately:
+#pod
+#pod     path("bar/baz")->mkdir( \%options )->child("foo.txt")->touch($epoch_secs);
+#pod
+#pod Current API available since 0.022.
+#pod
+#pod =cut
+
+sub touchpath {
+    my ($self) = @_;
+    my $parent = $self->parent;
+    $parent->mkdir unless $parent->exists;
+    $self->touch;
+}
+
+#pod =method visit
+#pod
+#pod     path("/tmp")->visit( \&callback, \%options );
+#pod
+#pod Executes a callback for each child of a directory.  It returns a hash
+#pod reference with any state accumulated during iteration.
+#pod
+#pod The options are the same as for L</iterator> (which it uses internally):
+#pod C<recurse> and C<follow_symlinks>.  Both default to false.
+#pod
+#pod The callback function will receive a C<Path::Tiny> object as the first argument
+#pod and a hash reference to accumulate state as the second argument.  For example:
+#pod
+#pod     # collect files sizes
+#pod     my $sizes = path("/tmp")->visit(
+#pod         sub {
+#pod             my ($path, $state) = @_;
+#pod             return if $path->is_dir;
+#pod             $state->{$path} = -s $path;
+#pod         },
+#pod         { recurse => 1 }
+#pod     );
+#pod
+#pod For convenience, the C<Path::Tiny> object will also be locally aliased as the
+#pod C<$_> global variable:
+#pod
+#pod     # print paths matching /foo/
+#pod     path("/tmp")->visit( sub { say if /foo/ }, { recurse => 1} );
+#pod
+#pod If the callback returns a B<reference> to a false scalar value, iteration will
+#pod terminate.  This is not the same as "pruning" a directory search; this just
+#pod stops all iteration and returns the state hash reference.
+#pod
+#pod     # find up to 10 files larger than 100K
+#pod     my $files = path("/tmp")->visit(
+#pod         sub {
+#pod             my ($path, $state) = @_;
+#pod             $state->{$path}++ if -s $path > 102400
+#pod             return \0 if keys %$state == 10;
+#pod         },
+#pod         { recurse => 1 }
+#pod     );
+#pod
+#pod If you want more flexible iteration, use a module like L<Path::Iterator::Rule>.
+#pod
+#pod Current API available since 0.062.
+#pod
+#pod =cut
+
+sub visit {
+    my $self = shift;
+    my $cb   = shift;
+    my $args = _get_args( shift, qw/recurse follow_symlinks/ );
+    Carp::croak("Callback for visit() must be a code reference")
+      unless defined($cb) && ref($cb) eq 'CODE';
+    my $next  = $self->iterator($args);
+    my $state = {};
+    while ( my $file = $next->() ) {
+        local $_ = $file;
+        my $r = $cb->( $file, $state );
+        last if ref($r) eq 'SCALAR' && !$$r;
+    }
+    return $state;
+}
+
+#pod =method volume
+#pod
+#pod     $vol = path("/tmp/foo.txt")->volume;   # ""
+#pod     $vol = path("C:/tmp/foo.txt")->volume; # "C:"
+#pod
+#pod Returns the volume portion of the path.  This is equivalent
+#pod to what L<File::Spec> would give from C<splitpath> and thus
+#pod usually is the empty string on Unix-like operating systems or the
+#pod drive letter for an absolute path on C<MSWin32>.
+#pod
+#pod Current API available since 0.001.
+#pod
+#pod =cut
+
+sub volume {
+    my ($self) = @_;
+    $self->_splitpath unless defined $self->[VOL];
+    return $self->[VOL];
+}
+
+package Path::Tiny::Error;
+
+our @CARP_NOT = qw/Path::Tiny/;
+
+use overload ( q{""} => sub { (shift)->{msg} }, fallback => 1 );
+
+sub throw {
+    my ( $class, $op, $file, $err ) = @_;
+    chomp( my $trace = Carp::shortmess );
+    my $msg = "Error $op on '$file': $err$trace\n";
+    die bless { op => $op, file => $file, err => $err, msg => $msg }, $class;
+}
+
+1;
+
+
+# vim: ts=4 sts=4 sw=4 et:
+
+__END__
+
+=pod
+
+=encoding UTF-8
+
+=head1 NAME
+
+Path::Tiny - File path utility
+
+=head1 VERSION
+
+version 0.144
+
+=head1 SYNOPSIS
+
+  use Path::Tiny;
+
+  # Creating Path::Tiny objects
+
+  my $dir = path("/tmp");
+  my $foo = path("foo.txt");
+
+  my $subdir = $dir->child("foo");
+  my $bar = $subdir->child("bar.txt");
+
+  # Stringifies as cleaned up path
+
+  my $file = path("./foo.txt");
+  print $file; # "foo.txt"
+
+  # Reading files
+
+  my $guts = $file->slurp;
+     $guts = $file->slurp_utf8;
+
+  my @lines = $file->lines;
+     @lines = $file->lines_utf8;
+
+  my ($head) = $file->lines( {count => 1} );
+  my ($tail) = $file->lines( {count => -1} );
+
+  # Writing files
+
+  $bar->spew( @data );
+  $bar->spew_utf8( @data );
+
+  # Reading directories
+
+  for ( $dir->children ) { ... }
+
+  my $iter = $dir->iterator;
+  while ( my $next = $iter->() ) { ... }
+
+=head1 DESCRIPTION
+
+This module provides a small, fast utility for working with file paths.  It is
+friendlier to use than L<File::Spec> and provides easy access to functions from
+several other core file handling modules.  It aims to be smaller and faster
+than many alternatives on CPAN, while helping people do many common things in
+consistent and less error-prone ways.
+
+Path::Tiny does not try to work for anything except Unix-like and Win32
+platforms.  Even then, it might break if you try something particularly obscure
+or tortuous.  (Quick!  What does this mean:
+C<< ///../../..//./././a//b/.././c/././ >>?  And how does it differ on Win32?)
+
+All paths are forced to have Unix-style forward slashes.  Stringifying
+the object gives you back the path (after some clean up).
+
+File input/output methods C<flock> handles before reading or writing,
+as appropriate (if supported by the platform and/or filesystem).
+
+The C<*_utf8> methods (C<slurp_utf8>, C<lines_utf8>, etc.) operate in raw
+mode.  On Windows, that means they will not have CRLF translation from the
+C<:crlf> IO layer.  Installing L<Unicode::UTF8> 0.58 or later will speed up
+C<*_utf8> situations in many cases and is highly recommended.
+Alternatively, installing L<PerlIO::utf8_strict> 0.003 or later will be
+used in place of the default C<:encoding(UTF-8)>.
+
+This module depends heavily on PerlIO layers for correct operation and thus
+requires Perl 5.008001 or later.
+
+=head1 CONSTRUCTORS
+
+=head2 path
+
+    $path = path("foo/bar");
+    $path = path("/tmp", "file.txt"); # list
+    $path = path(".");                # cwd
+
+Constructs a C<Path::Tiny> object.  It doesn't matter if you give a file or
+directory path.  It's still up to you to call directory-like methods only on
+directories and file-like methods only on files.  This function is exported
+automatically by default.
+
+The first argument must be defined and have non-zero length or an exception
+will be thrown.  This prevents subtle, dangerous errors with code like
+C<< path( maybe_undef() )->remove_tree >>.
+
+B<DEPRECATED>: If and only if the B<first> character of the B<first> argument
+to C<path> is a tilde ('~'), then tilde replacement will be applied to the
+first path segment. A single tilde will be replaced with C<glob('~')> and a
+tilde followed by a username will be replaced with output of
+C<glob('~username')>. B<No other method does tilde expansion on its arguments>.
+See L</Tilde expansion (deprecated)> for more.
+
+On Windows, if the path consists of a drive identifier without a path component
+(C<C:> or C<D:>), it will be expanded to the absolute path of the current
+directory on that volume using C<Cwd::getdcwd()>.
+
+If called with a single C<Path::Tiny> argument, the original is returned unless
+the original is holding a temporary file or directory reference in which case a
+stringified copy is made.
+
+    $path = path("foo/bar");
+    $temp = Path::Tiny->tempfile;
+
+    $p2 = path($path); # like $p2 = $path
+    $t2 = path($temp); # like $t2 = path( "$temp" )
+
+This optimizes copies without proliferating references unexpectedly if a copy is
+made by code outside your control.
+
+Current API available since 0.017.
+
+=head2 new
+
+    $path = Path::Tiny->new("foo/bar");
+
+This is just like C<path>, but with method call overhead.  (Why would you
+do that?)
+
+Current API available since 0.001.
+
+=head2 cwd
+
+    $path = Path::Tiny->cwd; # path( Cwd::getcwd )
+    $path = cwd; # optional export
+
+Gives you the absolute path to the current directory as a C<Path::Tiny> object.
+This is slightly faster than C<< path(".")->absolute >>.
+
+C<cwd> may be exported on request and used as a function instead of as a
+method.
+
+Current API available since 0.018.
+
+=head2 rootdir
+
+    $path = Path::Tiny->rootdir; # /
+    $path = rootdir;             # optional export 
+
+Gives you C<< File::Spec->rootdir >> as a C<Path::Tiny> object if you're too
+picky for C<path("/")>.
+
+C<rootdir> may be exported on request and used as a function instead of as a
+method.
+
+Current API available since 0.018.
+
+=head2 tempfile, tempdir
+
+    $temp = Path::Tiny->tempfile( @options );
+    $temp = Path::Tiny->tempdir( @options );
+    $temp = $dirpath->tempfile( @options );
+    $temp = $dirpath->tempdir( @options );
+    $temp = tempfile( @options ); # optional export
+    $temp = tempdir( @options );  # optional export
+
+C<tempfile> passes the options to C<< File::Temp->new >> and returns a
+C<Path::Tiny> object with the file name.  The C<TMPDIR> option will be enabled
+by default, but you can override that by passing C<< TMPDIR => 0 >> along with
+the options.  (If you use an absolute C<TEMPLATE> option, you will want to
+disable C<TMPDIR>.)
+
+The resulting C<File::Temp> object is cached. When the C<Path::Tiny> object is
+destroyed, the C<File::Temp> object will be as well.
+
+C<File::Temp> annoyingly requires you to specify a custom template in slightly
+different ways depending on which function or method you call, but
+C<Path::Tiny> lets you ignore that and can take either a leading template or a
+C<TEMPLATE> option and does the right thing.
+
+    $temp = Path::Tiny->tempfile( "customXXXXXXXX" );             # ok
+    $temp = Path::Tiny->tempfile( TEMPLATE => "customXXXXXXXX" ); # ok
+
+The tempfile path object will be normalized to have an absolute path, even if
+created in a relative directory using C<DIR>.  If you want it to have
+the C<realpath> instead, pass a leading options hash like this:
+
+    $real_temp = tempfile({realpath => 1}, @options);
+
+C<tempdir> is just like C<tempfile>, except it calls
+C<< File::Temp->newdir >> instead.
+
+Both C<tempfile> and C<tempdir> may be exported on request and used as
+functions instead of as methods.
+
+The methods can be called on an instances representing a
+directory. In this case, the directory is used as the base to create the
+temporary file/directory, setting the C<DIR> option in File::Temp.
+
+    my $target_dir = path('/to/destination');
+    my $tempfile = $target_dir->tempfile('foobarXXXXXX');
+    $tempfile->spew('A lot of data...');  # not atomic
+    $tempfile->move($target_dir->child('foobar')); # hopefully atomic
+
+In this case, any value set for option C<DIR> is ignored.
+
+B<Note>: for tempfiles, the filehandles from File::Temp are closed and not
+reused.  This is not as secure as using File::Temp handles directly, but is
+less prone to deadlocks or access problems on some platforms.  Think of what
+C<Path::Tiny> gives you to be just a temporary file B<name> that gets cleaned
+up.
+
+B<Note 2>: if you don't want these cleaned up automatically when the object
+is destroyed, File::Temp requires different options for directories and
+files.  Use C<< CLEANUP => 0 >> for directories and C<< UNLINK => 0 >> for
+files.
+
+B<Note 3>: Don't lose the temporary object by chaining a method call instead
+of storing it:
+
+    my $lost = tempdir()->child("foo"); # tempdir cleaned up right away
+
+B<Note 4>: The cached object may be accessed with the L</cached_temp> method.
+Keeping a reference to, or modifying the cached object may break the
+behavior documented above and is not supported.  Use at your own risk.
+
+Current API available since 0.119.
+
+=head1 METHODS
+
+=head2 absolute
+
+    $abs = path("foo/bar")->absolute;
+    $abs = path("foo/bar")->absolute("/tmp");
+
+Returns a new C<Path::Tiny> object with an absolute path (or itself if already
+absolute).  If no argument is given, the current directory is used as the
+absolute base path.  If an argument is given, it will be converted to an
+absolute path (if it is not already) and used as the absolute base path.
+
+This will not resolve upward directories ("foo/../bar") unless C<canonpath>
+in L<File::Spec> would normally do so on your platform.  If you need them
+resolved, you must call the more expensive C<realpath> method instead.
+
+On Windows, an absolute path without a volume component will have it added
+based on the current drive.
+
+Current API available since 0.101.
+
+=head2 append, append_raw, append_utf8
+
+    path("foo.txt")->append(@data);
+    path("foo.txt")->append(\@data);
+    path("foo.txt")->append({binmode => ":raw"}, @data);
+    path("foo.txt")->append_raw(@data);
+    path("foo.txt")->append_utf8(@data);
+
+Appends data to a file.  The file is locked with C<flock> prior to writing
+and closed afterwards.  An optional hash reference may be used to pass
+options.  Valid options are:
+
+=over 4
+
+=item *
+
+C<binmode>: passed to C<binmode()> on the handle used for writing.
+
+=item *
+
+C<truncate>: truncates the file after locking and before appending
+
+=back
+
+The C<truncate> option is a way to replace the contents of a file
+B<in place>, unlike L</spew> which writes to a temporary file and then
+replaces the original (if it exists).
+
+C<append_raw> is like C<append> with a C<binmode> of C<:unix> for a fast,
+unbuffered, raw write.
+
+C<append_utf8> is like C<append> with an unbuffered C<binmode>
+C<:unix:encoding(UTF-8)> (or C<:unix:utf8_strict> with
+L<PerlIO::utf8_strict>).  If L<Unicode::UTF8> 0.58+ is installed, an
+unbuffered, raw append will be done instead on the data encoded with
+C<Unicode::UTF8>.
+
+Current API available since 0.060.
+
+=head2 assert
+
+    $path = path("foo.txt")->assert( sub { $_->exists } );
+
+Returns the invocant after asserting that a code reference argument returns
+true.  When the assertion code reference runs, it will have the invocant
+object in the C<$_> variable.  If it returns false, an exception will be
+thrown.  The assertion code reference may also throw its own exception.
+
+If no assertion is provided, the invocant is returned without error.
+
+Current API available since 0.062.
+
+=head2 basename
+
+    $name = path("foo/bar.txt")->basename;        # bar.txt
+    $name = path("foo.txt")->basename('.txt');    # foo
+    $name = path("foo.txt")->basename(qr/.txt/);  # foo
+    $name = path("foo.txt")->basename(@suffixes);
+
+Returns the file portion or last directory portion of a path.
+
+Given a list of suffixes as strings or regular expressions, any that match at
+the end of the file portion or last directory portion will be removed before
+the result is returned.
+
+Current API available since 0.054.
+
+=head2 canonpath
+
+    $canonical = path("foo/bar")->canonpath; # foo\bar on Windows
+
+Returns a string with the canonical format of the path name for
+the platform.  In particular, this means directory separators
+will be C<\> on Windows.
+
+Current API available since 0.001.
+
+=head2 cached_temp
+
+Returns the cached C<File::Temp> or C<File::Temp::Dir> object if the
+C<Path::Tiny> object was created with C</tempfile> or C</tempdir>.
+If there is no such object, this method throws.
+
+B<WARNING>: Keeping a reference to, or modifying the cached object may
+break the behavior documented for temporary files and directories created
+with C<Path::Tiny> and is not supported.  Use at your own risk.
+
+Current API available since 0.101.
+
+=head2 child
+
+    $file = path("/tmp")->child("foo.txt"); # "/tmp/foo.txt"
+    $file = path("/tmp")->child(@parts);
+
+Returns a new C<Path::Tiny> object relative to the original.  Works
+like C<catfile> or C<catdir> from File::Spec, but without caring about
+file or directories.
+
+B<WARNING>: because the argument could contain C<..> or refer to symlinks,
+there is no guarantee that the new path refers to an actual descendent of
+the original.  If this is important to you, transform parent and child with
+L</realpath> and check them with L</subsumes>.
+
+Current API available since 0.001.
+
+=head2 children
+
+    @paths = path("/tmp")->children;
+    @paths = path("/tmp")->children( qr/\.txt\z/ );
+
+Returns a list of C<Path::Tiny> objects for all files and directories
+within a directory.  Excludes "." and ".." automatically.
+
+If an optional C<qr//> argument is provided, it only returns objects for child
+names that match the given regular expression.  Only the base name is used
+for matching:
+
+    @paths = path("/tmp")->children( qr/^foo/ );
+    # matches children like the glob foo*
+
+Current API available since 0.028.
+
+=head2 chmod
+
+    path("foo.txt")->chmod(0777);
+    path("foo.txt")->chmod("0755");
+    path("foo.txt")->chmod("go-w");
+    path("foo.txt")->chmod("a=r,u+wx");
+
+Sets file or directory permissions.  The argument can be a numeric mode, a
+octal string beginning with a "0" or a limited subset of the symbolic mode use
+by F</bin/chmod>.
+
+The symbolic mode must be a comma-delimited list of mode clauses.  Clauses must
+match C<< qr/\A([augo]+)([=+-])([rwx]+)\z/ >>, which defines "who", "op" and
+"perms" parameters for each clause.  Unlike F</bin/chmod>, all three parameters
+are required for each clause, multiple ops are not allowed and permissions
+C<stugoX> are not supported.  (See L<File::chmod> for more complex needs.)
+
+Current API available since 0.053.
+
+=head2 copy
+
+    path("/tmp/foo.txt")->copy("/tmp/bar.txt");
+
+Copies the current path to the given destination using L<File::Copy>'s
+C<copy> function. Upon success, returns the C<Path::Tiny> object for the
+newly copied file.
+
+Current API available since 0.070.
+
+=head2 digest
+
+    $obj = path("/tmp/foo.txt")->digest;        # SHA-256
+    $obj = path("/tmp/foo.txt")->digest("MD5"); # user-selected
+    $obj = path("/tmp/foo.txt")->digest( { chunk_size => 1e6 }, "MD5" );
+
+Returns a hexadecimal digest for a file.  An optional hash reference of options may
+be given.  The only option is C<chunk_size>.  If C<chunk_size> is given, that many
+bytes will be read at a time.  If not provided, the entire file will be slurped
+into memory to compute the digest.
+
+Any subsequent arguments are passed to the constructor for L<Digest> to select
+an algorithm.  If no arguments are given, the default is SHA-256.
+
+Current API available since 0.056.
+
+=head2 dirname (deprecated)
+
+    $name = path("/tmp/foo.txt")->dirname; # "/tmp/"
+
+Returns the directory portion you would get from calling
+C<< File::Spec->splitpath( $path->stringify ) >> or C<"."> for a path without a
+parent directory portion.  Because L<File::Spec> is inconsistent, the result
+might or might not have a trailing slash.  Because of this, this method is
+B<deprecated>.
+
+A better, more consistently approach is likely C<< $path->parent->stringify >>,
+which will not have a trailing slash except for a root directory.
+
+Deprecated in 0.056.
+
+=head2 edit, edit_raw, edit_utf8
+
+    path("foo.txt")->edit( \&callback, $options );
+    path("foo.txt")->edit_utf8( \&callback );
+    path("foo.txt")->edit_raw( \&callback );
+
+These are convenience methods that allow "editing" a file using a single
+callback argument. They slurp the file using C<slurp>, place the contents
+inside a localized C<$_> variable, call the callback function (without
+arguments), and then write C<$_> (presumably mutated) back to the
+file with C<spew>.
+
+An optional hash reference may be used to pass options.  The only option is
+C<binmode>, which is passed to C<slurp> and C<spew>.
+
+C<edit_utf8> and C<edit_raw> act like their respective C<slurp_*> and
+C<spew_*> methods.
+
+Current API available since 0.077.
+
+=head2 edit_lines, edit_lines_utf8, edit_lines_raw
+
+    path("foo.txt")->edit_lines( \&callback, $options );
+    path("foo.txt")->edit_lines_utf8( \&callback );
+    path("foo.txt")->edit_lines_raw( \&callback );
+
+These are convenience methods that allow "editing" a file's lines using a
+single callback argument.  They iterate over the file: for each line, the
+line is put into a localized C<$_> variable, the callback function is
+executed (without arguments) and then C<$_> is written to a temporary file.
+When iteration is finished, the temporary file is atomically renamed over
+the original.
+
+An optional hash reference may be used to pass options.  The only option is
+C<binmode>, which is passed to the method that open handles for reading and
+writing.
+
+C<edit_lines_raw> is like C<edit_lines> with a buffered C<binmode> of
+C<:raw>.
+
+C<edit_lines_utf8> is like C<edit_lines> with a buffered C<binmode>
+C<:raw:encoding(UTF-8)> (or C<:raw:utf8_strict> with
+L<PerlIO::utf8_strict>).
+
+Current API available since 0.077.
+
+=head2 exists, is_file, is_dir
+
+    if ( path("/tmp")->exists ) { ... }     # -e
+    if ( path("/tmp")->is_dir ) { ... }     # -d
+    if ( path("/tmp")->is_file ) { ... }    # -e && ! -d
+
+Implements file test operations, this means the file or directory actually has
+to exist on the filesystem.  Until then, it's just a path.
+
+B<Note>: C<is_file> is not C<-f> because C<-f> is not the opposite of C<-d>.
+C<-f> means "plain file", excluding symlinks, devices, etc. that often can be
+read just like files.
+
+Use C<-f> instead if you really mean to check for a plain file.
+
+Current API available since 0.053.
+
+=head2 filehandle
+
+    $fh = path("/tmp/foo.txt")->filehandle($mode, $binmode);
+    $fh = path("/tmp/foo.txt")->filehandle({ locked => 1 }, $mode, $binmode);
+    $fh = path("/tmp/foo.txt")->filehandle({ exclusive => 1  }, $mode, $binmode);
+
+Returns an open file handle.  The C<$mode> argument must be a Perl-style
+read/write mode string ("<" ,">", ">>", etc.).  If a C<$binmode>
+is given, it is set during the C<open> call.
+
+An optional hash reference may be used to pass options.
+
+The C<locked> option governs file locking; if true, handles opened for writing,
+appending or read-write are locked with C<LOCK_EX>; otherwise, they are
+locked with C<LOCK_SH>.  When using C<locked>, ">" or "+>" modes will delay
+truncation until after the lock is acquired.
+
+The C<exclusive> option causes the open() call to fail if the file already
+exists.  This corresponds to the O_EXCL flag to sysopen / open(2).
+C<exclusive> implies C<locked> and will set it for you if you forget it.
+
+See C<openr>, C<openw>, C<openrw>, and C<opena> for sugar.
+
+Current API available since 0.066.
+
+=head2 has_same_bytes
+
+    if ( path("foo.txt")->has_same_bytes("bar.txt") ) {
+       # ...
+    }
+
+This method returns true if both the invocant and the argument can be opened as
+file handles and the handles contain the same bytes.  It returns false if their
+contents differ.  If either can't be opened as a file (e.g. a directory or
+non-existent file), the method throws an exception.  If both can be opened and
+both have the same C<realpath>, the method returns true without scanning any
+data.
+
+Current API available since 0.125.
+
+=head2 is_absolute, is_relative
+
+    if ( path("/tmp")->is_absolute ) { ... }
+    if ( path("/tmp")->is_relative ) { ... }
+
+Booleans for whether the path appears absolute or relative.
+
+Current API available since 0.001.
+
+=head2 is_rootdir
+
+    while ( ! $path->is_rootdir ) {
+        $path = $path->parent;
+        ...
+    }
+
+Boolean for whether the path is the root directory of the volume.  I.e. the
+C<dirname> is C<q[/]> and the C<basename> is C<q[]>.
+
+This works even on C<MSWin32> with drives and UNC volumes:
+
+    path("C:/")->is_rootdir;             # true
+    path("//server/share/")->is_rootdir; #true
+
+Current API available since 0.038.
+
+=head2 iterator
+
+    $iter = path("/tmp")->iterator( \%options );
+
+Returns a code reference that walks a directory lazily.  Each invocation
+returns a C<Path::Tiny> object or undef when the iterator is exhausted.
+
+    $iter = path("/tmp")->iterator;
+    while ( $path = $iter->() ) {
+        ...
+    }
+
+The current and parent directory entries ("." and "..") will not
+be included.
+
+If the C<recurse> option is true, the iterator will walk the directory
+recursively, breadth-first.  If the C<follow_symlinks> option is also true,
+directory links will be followed recursively.  There is no protection against
+loops when following links. If a directory is not readable, it will not be
+followed.
+
+The default is the same as:
+
+    $iter = path("/tmp")->iterator( {
+        recurse         => 0,
+        follow_symlinks => 0,
+    } );
+
+For a more powerful, recursive iterator with built-in loop avoidance, see
+L<Path::Iterator::Rule>.
+
+See also L</visit>.
+
+Current API available since 0.016.
+
+=head2 lines, lines_raw, lines_utf8
+
+    @contents = path("/tmp/foo.txt")->lines;
+    @contents = path("/tmp/foo.txt")->lines(\%options);
+    @contents = path("/tmp/foo.txt")->lines_raw;
+    @contents = path("/tmp/foo.txt")->lines_utf8;
+
+    @contents = path("/tmp/foo.txt")->lines( { chomp => 1, count => 4 } );
+
+Returns a list of lines from a file.  Optionally takes a hash-reference of
+options.  Valid options are C<binmode>, C<count> and C<chomp>.
+
+If C<binmode> is provided, it will be set on the handle prior to reading.
+
+If a positive C<count> is provided, that many lines will be returned from the
+start of the file.  If a negative C<count> is provided, the entire file will be
+read, but only C<abs(count)> will be kept and returned.  If C<abs(count)>
+exceeds the number of lines in the file, all lines will be returned.
+
+If C<chomp> is set, any end-of-line character sequences (C<CR>, C<CRLF>, or
+C<LF>) will be removed from the lines returned.
+
+Because the return is a list, C<lines> in scalar context will return the number
+of lines (and throw away the data).
+
+    $number_of_lines = path("/tmp/foo.txt")->lines;
+
+C<lines_raw> is like C<lines> with a C<binmode> of C<:raw>.  We use C<:raw>
+instead of C<:unix> so PerlIO buffering can manage reading by line.
+
+C<lines_utf8> is like C<lines> with a C<binmode> of C<:raw:encoding(UTF-8)>
+(or C<:raw:utf8_strict> with L<PerlIO::utf8_strict>).  If L<Unicode::UTF8>
+0.58+ is installed, a raw, unbuffered UTF-8 slurp will be done and then the
+lines will be split.  This is actually faster than relying on
+IO layers, though a bit memory intensive.  If memory use is a
+concern, consider C<openr_utf8> and iterating directly on the handle.
+
+Current API available since 0.065.
+
+=head2 mkdir
+
+    path("foo/bar/baz")->mkdir;
+    path("foo/bar/baz")->mkdir( \%options );
+
+Like calling C<make_path> from L<File::Path>.  An optional hash reference
+is passed through to C<make_path>.  Errors will be trapped and an exception
+thrown.  Returns the the path object to facilitate chaining.
+
+B<NOTE>: unlike Perl's builtin C<mkdir>, this will create intermediate paths
+similar to the Unix C<mkdir -p> command.  It will not error if applied to an
+existing directory.
+
+Current API available since 0.125.
+
+=head2 mkpath (deprecated)
+
+Like calling C<mkdir>, but returns the list of directories created or an empty list if
+the directories already exist, just like C<make_path>.
+
+Deprecated in 0.125.
+
+=head2 move
+
+    path("foo.txt")->move("bar.txt");
+
+Moves the current path to the given destination using L<File::Copy>'s
+C<move> function. Upon success, returns the C<Path::Tiny> object for the
+newly moved file.
+
+If the destination already exists and is a directory, and the source is not a
+directory, then the source file will be renamed into the directory
+specified by the destination.
+
+If possible, move() will simply rename the file. Otherwise, it
+copies the file to the new location and deletes the original. If an
+error occurs during this copy-and-delete process, you may be left
+with a (possibly partial) copy of the file under the destination
+name.
+
+Current API available since 0.124. Prior versions used Perl's
+-built-in (and less robust) L<rename|perlfunc/rename> function
+and did not return an object.
+
+=head2 openr, openw, openrw, opena
+
+    $fh = path("foo.txt")->openr($binmode);  # read
+    $fh = path("foo.txt")->openr_raw;
+    $fh = path("foo.txt")->openr_utf8;
+
+    $fh = path("foo.txt")->openw($binmode);  # write
+    $fh = path("foo.txt")->openw_raw;
+    $fh = path("foo.txt")->openw_utf8;
+
+    $fh = path("foo.txt")->opena($binmode);  # append
+    $fh = path("foo.txt")->opena_raw;
+    $fh = path("foo.txt")->opena_utf8;
+
+    $fh = path("foo.txt")->openrw($binmode); # read/write
+    $fh = path("foo.txt")->openrw_raw;
+    $fh = path("foo.txt")->openrw_utf8;
+
+Returns a file handle opened in the specified mode.  The C<openr> style methods
+take a single C<binmode> argument.  All of the C<open*> methods have
+C<open*_raw> and C<open*_utf8> equivalents that use buffered I/O layers C<:raw>
+and C<:raw:encoding(UTF-8)> (or C<:raw:utf8_strict> with
+L<PerlIO::utf8_strict>).
+
+An optional hash reference may be used to pass options.  The only option is
+C<locked>.  If true, handles opened for writing, appending or read-write are
+locked with C<LOCK_EX>; otherwise, they are locked for C<LOCK_SH>.
+
+    $fh = path("foo.txt")->openrw_utf8( { locked => 1 } );
+
+See L</filehandle> for more on locking.
+
+Current API available since 0.011.
+
+=head2 parent
+
+    $parent = path("foo/bar/baz")->parent; # foo/bar
+    $parent = path("foo/wibble.txt")->parent; # foo
+
+    $parent = path("foo/bar/baz")->parent(2); # foo
+
+Returns a C<Path::Tiny> object corresponding to the parent directory of the
+original directory or file. An optional positive integer argument is the number
+of parent directories upwards to return.  C<parent> by itself is equivalent to
+C<parent(1)>.
+
+Current API available since 0.014.
+
+=head2 realpath
+
+    $real = path("/baz/foo/../bar")->realpath;
+    $real = path("foo/../bar")->realpath;
+
+Returns a new C<Path::Tiny> object with all symbolic links and upward directory
+parts resolved using L<Cwd>'s C<realpath>.  Compared to C<absolute>, this is
+more expensive as it must actually consult the filesystem.
+
+If the parent path can't be resolved (e.g. if it includes directories that
+don't exist), an exception will be thrown:
+
+    $real = path("doesnt_exist/foo")->realpath; # dies
+
+However, if the parent path exists and only the last component (e.g. filename)
+doesn't exist, the realpath will be the realpath of the parent plus the
+non-existent last component:
+
+    $real = path("./aasdlfasdlf")->realpath; # works
+
+The underlying L<Cwd> module usually worked this way on Unix, but died on
+Windows (and some Unixes) if the full path didn't exist.  As of version 0.064,
+it's safe to use anywhere.
+
+Current API available since 0.001.
+
+=head2 relative
+
+    $rel = path("/tmp/foo/bar")->relative("/tmp"); # foo/bar
+
+Returns a C<Path::Tiny> object with a path relative to a new base path
+given as an argument.  If no argument is given, the current directory will
+be used as the new base path.
+
+If either path is already relative, it will be made absolute based on the
+current directly before determining the new relative path.
+
+The algorithm is roughly as follows:
+
+=over 4
+
+=item *
+
+If the original and new base path are on different volumes, an exception will be thrown.
+
+=item *
+
+If the original and new base are identical, the relative path is C<".">.
+
+=item *
+
+If the new base subsumes the original, the relative path is the original path with the new base chopped off the front
+
+=item *
+
+If the new base does not subsume the original, a common prefix path is determined (possibly the root directory) and the relative path will consist of updirs (C<"..">) to reach the common prefix, followed by the original path less the common prefix.
+
+=back
+
+Unlike C<File::Spec::abs2rel>, in the last case above, the calculation based
+on a common prefix takes into account symlinks that could affect the updir
+process.  Given an original path "/A/B" and a new base "/A/C",
+(where "A", "B" and "C" could each have multiple path components):
+
+=over 4
+
+=item *
+
+Symlinks in "A" don't change the result unless the last component of A is a symlink and the first component of "C" is an updir.
+
+=item *
+
+Symlinks in "B" don't change the result and will exist in the result as given.
+
+=item *
+
+Symlinks and updirs in "C" must be resolved to actual paths, taking into account the possibility that not all path components might exist on the filesystem.
+
+=back
+
+Current API available since 0.001.  New algorithm (that accounts for
+symlinks) available since 0.079.
+
+=head2 remove
+
+    path("foo.txt")->remove;
+
+This is just like C<unlink>, except for its error handling: if the path does
+not exist, it returns false; if deleting the file fails, it throws an
+exception.
+
+Current API available since 0.012.
+
+=head2 remove_tree
+
+    # directory
+    path("foo/bar/baz")->remove_tree;
+    path("foo/bar/baz")->remove_tree( \%options );
+    path("foo/bar/baz")->remove_tree( { safe => 0 } ); # force remove
+
+Like calling C<remove_tree> from L<File::Path>, but defaults to C<safe> mode.
+An optional hash reference is passed through to C<remove_tree>.  Errors will be
+trapped and an exception thrown.  Returns the number of directories deleted,
+just like C<remove_tree>.
+
+If you want to remove a directory only if it is empty, use the built-in
+C<rmdir> function instead.
+
+    rmdir path("foo/bar/baz/");
+
+Current API available since 0.013.
+
+=head2 sibling
+
+    $foo = path("/tmp/foo.txt");
+    $sib = $foo->sibling("bar.txt");        # /tmp/bar.txt
+    $sib = $foo->sibling("baz", "bam.txt"); # /tmp/baz/bam.txt
+
+Returns a new C<Path::Tiny> object relative to the parent of the original.
+This is slightly more efficient than C<< $path->parent->child(...) >>.
+
+Current API available since 0.058.
+
+=head2 size, size_human
+
+    my $p = path("foo"); # with size 1025 bytes
+
+    $p->size;                            # "1025"
+    $p->size_human;                      # "1.1 K"
+    $p->size_human( {format => "iec"} ); # "1.1 KiB"
+
+Returns the size of a file.  The C<size> method is just a wrapper around C<-s>.
+
+The C<size_human> method provides a human-readable string similar to
+C<ls -lh>.  Like C<ls>, it rounds upwards and provides one decimal place for
+single-digit sizes and no decimal places for larger sizes.  The only available
+option is C<format>, which has three valid values:
+
+=over 4
+
+=item *
+
+'ls' (the default): base-2 sizes, with C<ls> style single-letter suffixes (K, M, etc.)
+
+=item *
+
+'iec': base-2 sizes, with IEC binary suffixes (KiB, MiB, etc.)
+
+=item *
+
+'si': base-10 sizes, with SI decimal suffixes (kB, MB, etc.)
+
+=back
+
+If C<-s> would return C<undef>, C<size_human> returns the empty string.
+
+Current API available since 0.122.
+
+=head2 slurp, slurp_raw, slurp_utf8
+
+    $data = path("foo.txt")->slurp;
+    $data = path("foo.txt")->slurp( {binmode => ":raw"} );
+    $data = path("foo.txt")->slurp_raw;
+    $data = path("foo.txt")->slurp_utf8;
+
+Reads file contents into a scalar.  Takes an optional hash reference which may
+be used to pass options.  The only available option is C<binmode>, which is
+passed to C<binmode()> on the handle used for reading.
+
+C<slurp_raw> is like C<slurp> with a C<binmode> of C<:unix> for
+a fast, unbuffered, raw read.
+
+C<slurp_utf8> is like C<slurp> with a C<binmode> of
+C<:unix:encoding(UTF-8)> (or C<:unix:utf8_strict> with
+L<PerlIO::utf8_strict>).  If L<Unicode::UTF8> 0.58+ is installed, a
+unbuffered, raw slurp will be done instead and the result decoded with
+C<Unicode::UTF8>. This is just as strict and is roughly an order of
+magnitude faster than using C<:encoding(UTF-8)>.
+
+B<Note>: C<slurp> and friends lock the filehandle before slurping.  If
+you plan to slurp from a file created with L<File::Temp>, be sure to
+close other handles or open without locking to avoid a deadlock:
+
+    my $tempfile = File::Temp->new(EXLOCK => 0);
+    my $guts = path($tempfile)->slurp;
+
+Current API available since 0.004.
+
+=head2 spew, spew_raw, spew_utf8
+
+    path("foo.txt")->spew(@data);
+    path("foo.txt")->spew(\@data);
+    path("foo.txt")->spew({binmode => ":raw"}, @data);
+    path("foo.txt")->spew_raw(@data);
+    path("foo.txt")->spew_utf8(@data);
+
+Writes data to a file atomically.  The file is written to a temporary file in
+the same directory, then renamed over the original.  An optional hash reference
+may be used to pass options.  The only option is C<binmode>, which is passed to
+C<binmode()> on the handle used for writing.
+
+C<spew_raw> is like C<spew> with a C<binmode> of C<:unix> for a fast,
+unbuffered, raw write.
+
+C<spew_utf8> is like C<spew> with a C<binmode> of C<:unix:encoding(UTF-8)>
+(or C<:unix:utf8_strict> with L<PerlIO::utf8_strict>).  If L<Unicode::UTF8>
+0.58+ is installed, a raw, unbuffered spew will be done instead on the data
+encoded with C<Unicode::UTF8>.
+
+B<NOTE>: because the file is written to a temporary file and then renamed, the
+new file will wind up with permissions based on your current umask.  This is a
+feature to protect you from a race condition that would otherwise give
+different permissions than you might expect.  If you really want to keep the
+original mode flags, use L</append> with the C<truncate> option.
+
+Current API available since 0.011.
+
+=head2 stat, lstat
+
+    $stat = path("foo.txt")->stat;
+    $stat = path("/some/symlink")->lstat;
+
+Like calling C<stat> or C<lstat> from L<File::stat>.
+
+Current API available since 0.001.
+
+=head2 stringify
+
+    $path = path("foo.txt");
+    say $path->stringify; # same as "$path"
+
+Returns a string representation of the path.  Unlike C<canonpath>, this method
+returns the path standardized with Unix-style C</> directory separators.
+
+Current API available since 0.001.
+
+=head2 subsumes
+
+    path("foo/bar")->subsumes("foo/bar/baz"); # true
+    path("/foo/bar")->subsumes("/foo/baz");   # false
+
+Returns true if the first path is a prefix of the second path at a directory
+boundary.
+
+This B<does not> resolve parent directory entries (C<..>) or symlinks:
+
+    path("foo/bar")->subsumes("foo/bar/../baz"); # true
+
+If such things are important to you, ensure that both paths are resolved to
+the filesystem with C<realpath>:
+
+    my $p1 = path("foo/bar")->realpath;
+    my $p2 = path("foo/bar/../baz")->realpath;
+    if ( $p1->subsumes($p2) ) { ... }
+
+Current API available since 0.048.
+
+=head2 touch
+
+    path("foo.txt")->touch;
+    path("foo.txt")->touch($epoch_secs);
+
+Like the Unix C<touch> utility.  Creates the file if it doesn't exist, or else
+changes the modification and access times to the current time.  If the first
+argument is the epoch seconds then it will be used.
+
+Returns the path object so it can be easily chained with other methods:
+
+    # won't die if foo.txt doesn't exist
+    $content = path("foo.txt")->touch->slurp;
+
+Current API available since 0.015.
+
+=head2 touchpath
+
+    path("bar/baz/foo.txt")->touchpath;
+
+Combines C<mkdir> and C<touch>.  Creates the parent directory if it doesn't exist,
+before touching the file.  Returns the path object like C<touch> does.
+
+If you need to pass options, use C<mkdir> and C<touch> separately:
+
+    path("bar/baz")->mkdir( \%options )->child("foo.txt")->touch($epoch_secs);
+
+Current API available since 0.022.
+
+=head2 visit
+
+    path("/tmp")->visit( \&callback, \%options );
+
+Executes a callback for each child of a directory.  It returns a hash
+reference with any state accumulated during iteration.
+
+The options are the same as for L</iterator> (which it uses internally):
+C<recurse> and C<follow_symlinks>.  Both default to false.
+
+The callback function will receive a C<Path::Tiny> object as the first argument
+and a hash reference to accumulate state as the second argument.  For example:
+
+    # collect files sizes
+    my $sizes = path("/tmp")->visit(
+        sub {
+            my ($path, $state) = @_;
+            return if $path->is_dir;
+            $state->{$path} = -s $path;
+        },
+        { recurse => 1 }
+    );
+
+For convenience, the C<Path::Tiny> object will also be locally aliased as the
+C<$_> global variable:
+
+    # print paths matching /foo/
+    path("/tmp")->visit( sub { say if /foo/ }, { recurse => 1} );
+
+If the callback returns a B<reference> to a false scalar value, iteration will
+terminate.  This is not the same as "pruning" a directory search; this just
+stops all iteration and returns the state hash reference.
+
+    # find up to 10 files larger than 100K
+    my $files = path("/tmp")->visit(
+        sub {
+            my ($path, $state) = @_;
+            $state->{$path}++ if -s $path > 102400
+            return \0 if keys %$state == 10;
+        },
+        { recurse => 1 }
+    );
+
+If you want more flexible iteration, use a module like L<Path::Iterator::Rule>.
+
+Current API available since 0.062.
+
+=head2 volume
+
+    $vol = path("/tmp/foo.txt")->volume;   # ""
+    $vol = path("C:/tmp/foo.txt")->volume; # "C:"
+
+Returns the volume portion of the path.  This is equivalent
+to what L<File::Spec> would give from C<splitpath> and thus
+usually is the empty string on Unix-like operating systems or the
+drive letter for an absolute path on C<MSWin32>.
+
+Current API available since 0.001.
+
+=for Pod::Coverage openr_utf8 opena_utf8 openw_utf8 openrw_utf8
+openr_raw opena_raw openw_raw openrw_raw
+IS_WIN32 FREEZE THAW TO_JSON abs2rel
+
+=head1 EXCEPTION HANDLING
+
+Simple usage errors will generally croak.  Failures of underlying Perl
+functions will be thrown as exceptions in the class
+C<Path::Tiny::Error>.
+
+A C<Path::Tiny::Error> object will be a hash reference with the following fields:
+
+=over 4
+
+=item *
+
+C<op> — a description of the operation, usually function call and any extra info
+
+=item *
+
+C<file> — the file or directory relating to the error
+
+=item *
+
+C<err> — hold C<$!> at the time the error was thrown
+
+=item *
+
+C<msg> — a string combining the above data and a Carp-like short stack trace
+
+=back
+
+Exception objects will stringify as the C<msg> field.
+
+=head1 ENVIRONMENT
+
+=head2 PERL_PATH_TINY_NO_FLOCK
+
+If the environment variable C<PERL_PATH_TINY_NO_FLOCK> is set to a true
+value then flock will NOT be used when accessing files (this is not
+recommended).
+
+=head1 CAVEATS
+
+=head2 Subclassing not supported
+
+For speed, this class is implemented as an array based object and uses many
+direct function calls internally.  You must not subclass it and expect
+things to work properly.
+
+=head2 Tilde expansion (deprecated)
+
+Tilde expansion was a nice idea, but it can't easily be applied consistently
+across the entire API.  This was a source of bugs and confusion for users.
+Therefore, it is B<deprecated> and its use is discouraged.  Limitations to the
+existing, legacy behavior follow.
+
+Tilde expansion will only occur if the B<first> argument to C<path> begins with
+a tilde. B<No other method does tilde expansion on its arguments>.  If you want
+tilde expansion on arguments, you must explicitly wrap them in a call to
+C<path>.
+
+    path( "~/foo.txt" )->copy( path( "~/bar.txt" ) );
+
+If you need a literal leading tilde, use C<path("./~whatever")> so that the
+argument to C<path> doesn't start with a tilde, but the path still resolves to
+the current directory.
+
+Behaviour of tilde expansion with a username for non-existent users depends on
+the output of C<glob> on the system.
+
+=head2 File locking
+
+If flock is not supported on a platform, it will not be used, even if
+locking is requested.
+
+In situations where a platform normally would support locking, but the
+flock fails due to a filesystem limitation, Path::Tiny has some heuristics
+to detect this and will warn once and continue in an unsafe mode.  If you
+want this failure to be fatal, you can fatalize the 'flock' warnings
+category:
+
+    use warnings FATAL => 'flock';
+
+See additional caveats below.
+
+=head3 NFS and BSD
+
+On BSD, Perl's flock implementation may not work to lock files on an
+NFS filesystem.  If detected, this situation will warn once, as described
+above.
+
+=head3 Lustre
+
+The Lustre filesystem does not support flock.  If detected, this situation
+will warn once, as described above.
+
+=head3 AIX and locking
+
+AIX requires a write handle for locking.  Therefore, calls that normally
+open a read handle and take a shared lock instead will open a read-write
+handle and take an exclusive lock.  If the user does not have write
+permission, no lock will be used.
+
+=head2 utf8 vs UTF-8
+
+All the C<*_utf8> methods by default use C<:encoding(UTF-8)> -- either as
+C<:unix:encoding(UTF-8)> (unbuffered, for whole file operations) or
+C<:raw:encoding(UTF-8)> (buffered, for line-by-line operations). These are
+strict against the Unicode spec and disallows illegal Unicode codepoints or
+UTF-8 sequences.
+
+Unfortunately, C<:encoding(UTF-8)> is very, very slow.  If you install
+L<Unicode::UTF8> 0.58 or later, that module will be used by some C<*_utf8>
+methods to encode or decode data after a raw, binary input/output operation,
+which is much faster.  Alternatively, if you install L<PerlIO::utf8_strict>,
+that will be used instead of C<:encoding(UTF-8)> and is also very fast.
+
+If you need the performance and can accept the security risk,
+C<< slurp({binmode => ":unix:utf8"}) >> will be faster than C<:unix:encoding(UTF-8)>
+(but not as fast as C<Unicode::UTF8>).
+
+Note that the C<*_utf8> methods read in B<raw> mode.  There is no CRLF
+translation on Windows.  If you must have CRLF translation, use the regular
+input/output methods with an appropriate binmode:
+
+  $path->spew_utf8($data);                            # raw
+  $path->spew({binmode => ":encoding(UTF-8)"}, $data; # LF -> CRLF
+
+=head2 Default IO layers and the open pragma
+
+If you have Perl 5.10 or later, file input/output methods (C<slurp>, C<spew>,
+etc.) and high-level handle opening methods ( C<filehandle>, C<openr>,
+C<openw>, etc. ) respect default encodings set by the C<-C> switch or lexical
+L<open> settings of the caller.  For UTF-8, this is almost certainly slower
+than using the dedicated C<_utf8> methods if you have L<Unicode::UTF8> or
+L<PerlIP::utf8_strict>.
+
+=head1 TYPE CONSTRAINTS AND COERCION
+
+A standard L<MooseX::Types> library is available at
+L<MooseX::Types::Path::Tiny>.  A L<Type::Tiny> equivalent is available as
+L<Types::Path::Tiny>.
+
+=head1 SEE ALSO
+
+These are other file/path utilities, which may offer a different feature
+set than C<Path::Tiny>.
+
+=over 4
+
+=item *
+
+L<File::chmod>
+
+=item *
+
+L<File::Fu>
+
+=item *
+
+L<IO::All>
+
+=item *
+
+L<Path::Class>
+
+=back
+
+These iterators may be slightly faster than the recursive iterator in
+C<Path::Tiny>:
+
+=over 4
+
+=item *
+
+L<Path::Iterator::Rule>
+
+=item *
+
+L<File::Next>
+
+=back
+
+There are probably comparable, non-Tiny tools.  Let me know if you want me to
+add a module to the list.
+
+This module was featured in the L<2013 Perl Advent Calendar|http://www.perladvent.org/2013/2013-12-18.html>.
+
+=for :stopwords cpan testmatrix url bugtracker rt cpants kwalitee diff irc mailto metadata placeholders metacpan
+
+=head1 SUPPORT
+
+=head2 Bugs / Feature Requests
+
+Please report any bugs or feature requests through the issue tracker
+at L<https://github.com/dagolden/Path-Tiny/issues>.
+You will be notified automatically of any progress on your issue.
+
+=head2 Source Code
+
+This is open source software.  The code repository is available for
+public review and contribution under the terms of the license.
+
+L<https://github.com/dagolden/Path-Tiny>
+
+  git clone https://github.com/dagolden/Path-Tiny.git
+
+=head1 AUTHOR
+
+David Golden <dagolden@cpan.org>
+
+=head1 CONTRIBUTORS
+
+=for stopwords Alex Efros Aristotle Pagaltzis Chris Williams Dan Book Dave Rolsky David Steinbrunner Doug Bell Elvin Aslanov Flavio Poletti Gabor Szabo Gabriel Andrade George Hartzell Geraud Continsouzas Goro Fuji Graham Knop Ollis Ian Sillitoe James Hunt John Karr Karen Etheridge Mark Ellis Martin H. Sluka Kjeldsen Mary Ehlers Michael G. Schwern Nicolas R Rochelemagne Nigel Gregoire Philippe Bruhat (BooK) regina-verbae Roy Ivy III Shlomi Fish Smylers Tatsuhiko Miyagawa Toby Inkster Yanick Champoux 김도형 - Keedi Kim
+
+=over 4
+
+=item *
+
+Alex Efros <powerman@powerman.name>
+
+=item *
+
+Aristotle Pagaltzis <pagaltzis@gmx.de>
+
+=item *
+
+Chris Williams <bingos@cpan.org>
+
+=item *
+
+Dan Book <grinnz@grinnz.com>
+
+=item *
+
+Dave Rolsky <autarch@urth.org>
+
+=item *
+
+David Steinbrunner <dsteinbrunner@pobox.com>
+
+=item *
+
+Doug Bell <madcityzen@gmail.com>
+
+=item *
+
+Elvin Aslanov <rwp.primary@gmail.com>
+
+=item *
+
+Flavio Poletti <flavio@polettix.it>
+
+=item *
+
+Gabor Szabo <szabgab@cpan.org>
+
+=item *
+
+Gabriel Andrade <gabiruh@gmail.com>
+
+=item *
+
+George Hartzell <hartzell@cpan.org>
+
+=item *
+
+Geraud Continsouzas <geraud@scsi.nc>
+
+=item *
+
+Goro Fuji <gfuji@cpan.org>
+
+=item *
+
+Graham Knop <haarg@haarg.org>
+
+=item *
+
+Graham Ollis <plicease@cpan.org>
+
+=item *
+
+Ian Sillitoe <ian@sillit.com>
+
+=item *
+
+James Hunt <james@niftylogic.com>
+
+=item *
+
+John Karr <brainbuz@brainbuz.org>
+
+=item *
+
+Karen Etheridge <ether@cpan.org>
+
+=item *
+
+Mark Ellis <mark.ellis@cartridgesave.co.uk>
+
+=item *
+
+Martin H. Sluka <fany@cpan.org>
+
+=item *
+
+Martin Kjeldsen <mk@bluepipe.dk>
+
+=item *
+
+Mary Ehlers <regina.verb.ae@gmail.com>
+
+=item *
+
+Michael G. Schwern <mschwern@cpan.org>
+
+=item *
+
+Nicolas R <nicolas@atoomic.org>
+
+=item *
+
+Nicolas Rochelemagne <rochelemagne@cpanel.net>
+
+=item *
+
+Nigel Gregoire <nigelgregoire@gmail.com>
+
+=item *
+
+Philippe Bruhat (BooK) <book@cpan.org>
+
+=item *
+
+regina-verbae <regina-verbae@users.noreply.github.com>
+
+=item *
+
+Roy Ivy III <rivy@cpan.org>
+
+=item *
+
+Shlomi Fish <shlomif@shlomifish.org>
+
+=item *
+
+Smylers <Smylers@stripey.com>
+
+=item *
+
+Tatsuhiko Miyagawa <miyagawa@bulknews.net>
+
+=item *
+
+Toby Inkster <tobyink@cpan.org>
+
+=item *
+
+Yanick Champoux <yanick@babyl.dyndns.org>
+
+=item *
+
+김도형 - Keedi Kim <keedi@cpan.org>
+
+=back
+
+=head1 COPYRIGHT AND LICENSE
+
+This software is Copyright (c) 2014 by David Golden.
+
+This is free software, licensed under:
+
+  The Apache License, Version 2.0, January 2004
+
+=cut