openSUSE Build Service

Overview Repositories Revisions Requests Users Attributes Meta

File 5054.patch of Package git-lfs (Revision 18efc91c28176d5063fa85b6b4d89645)

Currently displaying revision 18efc91c28176d5063fa85b6b4d89645 , Show latest

From 0c66dcf15d988802255c3133cd5ab8105cbf0ef7 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 2 Jun 2022 19:13:46 +0000
Subject: [PATCH 01/21] Add AsciiDoc versions of our manual pages

Our current manual pages use ronn or ronn-ng, which converts pages from
a superset of Markdown into manual pages or HTML.  This mostly works,
but it has some limitations:

* ronn-ng requires several dependencies, some of which are C based,
  which means we must build those on older version of RHEL-compatible
  OSes.  This adds a substantial amount of porting hassle and time to
  the build.
* The superset of Markdown that ronn-ng uses is not rendered correctly
  on GitHub, leading to difficulties when people view manual pages in
  the web interface.
* Markdown, and the superset ronn-ng uses, don't contain description
  lists, which are useful for both command options and items in the FAQ,
  which we'd like to ship in the package.

Instead of using Markdown, let's switch to AsciiDoc as the format for
manual pages.  Asciidoctor, the Ruby version of the command, is written
in pure Ruby and is self-contained, and supports HTML 5, XHTML 5, man,
and DocBook 5 all in a single program.  In addition, it is the library
used for rendering AsciiDoc on GitHub, which means that whatever syntax
we use is fully supported and should render properly.

This commit introduces a simple conversion as the first step, which
we'll fix up in several subsequent commits.  The Markdown pages remain
for now and will be removed in a later commit.

This conversion was done using Debian's pandoc 2.9.2.1-3+b2 using the
following command:

(for i in *.ronn; do pandoc -f commonmark -t asciidoc -o $(basename $(basename $i .1.ronn) .5.ronn).adoc $i; done)

Note that during our conversion we remove the number in the manual page
name, since Asciidoctor will emit this automatically and we don't want a
trailing ".1.1" or ".5.5".
---
 docs/man/git-lfs-checkout.adoc        |  80 +++++
 docs/man/git-lfs-clean.adoc           |  24 ++
 docs/man/git-lfs-clone.adoc           |  53 +++
 docs/man/git-lfs-config.adoc          | 416 ++++++++++++++++++++++++
 docs/man/git-lfs-dedup.adoc           |  24 ++
 docs/man/git-lfs-env.adoc             |  13 +
 docs/man/git-lfs-ext.adoc             |  23 ++
 docs/man/git-lfs-fetch.adoc           | 139 ++++++++
 docs/man/git-lfs-filter-process.adoc  |  45 +++
 docs/man/git-lfs-fsck.adoc            |  38 +++
 docs/man/git-lfs-install.adoc         |  54 ++++
 docs/man/git-lfs-lock.adoc            |  30 ++
 docs/man/git-lfs-locks.adoc           |  44 +++
 docs/man/git-lfs-logs.adoc            |  27 ++
 docs/man/git-lfs-ls-files.adoc        |  41 +++
 docs/man/git-lfs-merge-driver.adoc    |  87 +++++
 docs/man/git-lfs-migrate.adoc         | 450 ++++++++++++++++++++++++++
 docs/man/git-lfs-pointer.adoc         |  35 ++
 docs/man/git-lfs-post-checkout.adoc   |  17 +
 docs/man/git-lfs-post-commit.adoc     |  23 ++
 docs/man/git-lfs-post-merge.adoc      |  17 +
 docs/man/git-lfs-pre-push.adoc        |  36 +++
 docs/man/git-lfs-prune.adoc           | 135 ++++++++
 docs/man/git-lfs-pull.adoc            |  51 +++
 docs/man/git-lfs-push.adoc            |  34 ++
 docs/man/git-lfs-smudge.adoc          |  48 +++
 docs/man/git-lfs-standalone-file.adoc |  21 ++
 docs/man/git-lfs-status.adoc          |  29 ++
 docs/man/git-lfs-track.adoc           |  68 ++++
 docs/man/git-lfs-uninstall.adoc       |  38 +++
 docs/man/git-lfs-unlock.adoc          |  29 ++
 docs/man/git-lfs-untrack.adoc         |  22 ++
 docs/man/git-lfs-update.adoc          |  24 ++
 docs/man/git-lfs.adoc                 | 106 ++++++
 34 files changed, 2321 insertions(+)
 create mode 100644 docs/man/git-lfs-checkout.adoc
 create mode 100644 docs/man/git-lfs-clean.adoc
 create mode 100644 docs/man/git-lfs-clone.adoc
 create mode 100644 docs/man/git-lfs-config.adoc
 create mode 100644 docs/man/git-lfs-dedup.adoc
 create mode 100644 docs/man/git-lfs-env.adoc
 create mode 100644 docs/man/git-lfs-ext.adoc
 create mode 100644 docs/man/git-lfs-fetch.adoc
 create mode 100644 docs/man/git-lfs-filter-process.adoc
 create mode 100644 docs/man/git-lfs-fsck.adoc
 create mode 100644 docs/man/git-lfs-install.adoc
 create mode 100644 docs/man/git-lfs-lock.adoc
 create mode 100644 docs/man/git-lfs-locks.adoc
 create mode 100644 docs/man/git-lfs-logs.adoc
 create mode 100644 docs/man/git-lfs-ls-files.adoc
 create mode 100644 docs/man/git-lfs-merge-driver.adoc
 create mode 100644 docs/man/git-lfs-migrate.adoc
 create mode 100644 docs/man/git-lfs-pointer.adoc
 create mode 100644 docs/man/git-lfs-post-checkout.adoc
 create mode 100644 docs/man/git-lfs-post-commit.adoc
 create mode 100644 docs/man/git-lfs-post-merge.adoc
 create mode 100644 docs/man/git-lfs-pre-push.adoc
 create mode 100644 docs/man/git-lfs-prune.adoc
 create mode 100644 docs/man/git-lfs-pull.adoc
 create mode 100644 docs/man/git-lfs-push.adoc
 create mode 100644 docs/man/git-lfs-smudge.adoc
 create mode 100644 docs/man/git-lfs-standalone-file.adoc
 create mode 100644 docs/man/git-lfs-status.adoc
 create mode 100644 docs/man/git-lfs-track.adoc
 create mode 100644 docs/man/git-lfs-uninstall.adoc
 create mode 100644 docs/man/git-lfs-unlock.adoc
 create mode 100644 docs/man/git-lfs-untrack.adoc
 create mode 100644 docs/man/git-lfs-update.adoc
 create mode 100644 docs/man/git-lfs.adoc

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
new file mode 100644
index 0000000000..e39566bd88
--- /dev/null
+++ b/docs/man/git-lfs-checkout.adoc
@@ -0,0 +1,80 @@
+== git-lfs-checkout(1) -- Update working copy with file content if available
+
+=== SYNOPSIS
+
+`git lfs checkout` [...] `git lfs checkout` --to
+\{--base|--ours|--theirs}
+
+=== DESCRIPTION
+
+Try to ensure that the working copy contains file content for Git LFS
+objects for the current ref, if the object data is available. Does not
+download any content; see git-lfs-fetch(1) for that.
+
+Checkout scans the current ref for all LFS objects that would be
+required, then where a file is either missing in the working copy, or
+contains placeholder pointer content with the same SHA, the real file
+content is written, provided we have it in the local store. Modified
+files are never overwritten.
+
+One or more s may be provided as arguments to restrict the set of files
+that are updated. Glob patterns are matched as per the format described
+in gitignore(5).
+
+When used with `--to` and the working tree is in a conflicted state due
+to a merge, this option checks out one of the three stages a conflicting
+Git LFS object into a separate file (which can be outside of the work
+tree). This can make using diff tools to inspect and resolve merges
+easier. A single Git LFS object's file path must be provided in .
+
+=== OPTIONS
+
+* `--base`: Check out the merge base of the specified file.
+* `--ours`: Check out our side (that of the current branch) of the
+conflict for the specified file.
+* `--theirs`: Check out their side (that of the other branch) of the
+conflict for the specified file.
+* `--to` : If the working tree is in a conflicted state, check out the
+portion of the conflict specified by `--base`, `--ours`, or `--theirs`
+to the given path.
+
+=== EXAMPLES
+
+* Checkout all files that are missing or placeholders:
+
+....
+$ git lfs checkout
+....
+
+* Checkout a specific couple of files:
+
+....
+$ git lfs checkout path/to/file1.png path/to.file2.png
+....
+
+* Checkout a path with a merge conflict into separate files:
+
+....
+# Attempt merge with a branch that has a merge conflict
+$ git merge conflicting-branch
+CONFLICT (content): Merge conflict in path/to/conflicting/file.dat
+
+# Checkout versions of the conflicting file into temp files
+$ git lfs checkout ours.dat --ours path/to/conflicting/file.dat
+$ git lfs checkout theirs.dat --theirs path/to/conflicting/file.dat
+
+# Compare conflicting versions in ours.dat and theirs.dat,
+# then resolve conflict (e.g., by choosing one version over
+# the other, or creating a new version)
+
+# Cleanup and continue with merge
+$ rm ours.dat theirs.dat
+$ git add path/to/conflicting/file.dat
+$ git merge --continue
+....
+
+=== SEE ALSO
+
+git-lfs-fetch(1), git-lfs-pull(1), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-clean.adoc b/docs/man/git-lfs-clean.adoc
new file mode 100644
index 0000000000..40053a67a2
--- /dev/null
+++ b/docs/man/git-lfs-clean.adoc
@@ -0,0 +1,24 @@
+== git-lfs-clean(1) -- Git clean filter that converts large files to pointers
+
+=== SYNOPSIS
+
+`git lfs clean`
+
+=== DESCRIPTION
+
+Read the contents of a large file from standard input, and write a Git
+LFS pointer file for that file to standard output.
+
+Clean is typically run by Git's clean filter, configured by the
+repository's Git attributes.
+
+Clean is not part of the user-facing Git plumbing commands. To preview
+the pointer of a large file as it would be generated, see the
+git-lfs-pointer(1) command.
+
+=== SEE ALSO
+
+git-lfs-install(1), git-lfs-push(1), git-lfs-pointer(1),
+gitattributes(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
new file mode 100644
index 0000000000..549f536dbf
--- /dev/null
+++ b/docs/man/git-lfs-clone.adoc
@@ -0,0 +1,53 @@
+== git-lfs-clone(1) -- Efficiently clone a LFS-enabled repository
+
+=== SYNOPSIS
+
+`git lfs clone` [git clone options] []
+
+=== DESCRIPTION
+
+Clone an LFS enabled Git repository more efficiently by disabling LFS
+during the git clone, then performing a 'git lfs pull' directly
+afterwards.
+
+'git lfs clone' also installs all of the repo-level hooks (.git/hooks)
+that LFS requires to operate. If `--separate-git-dir` is given, the
+hooks will be installed there.
+
+This is faster than a regular 'git clone' because that will download LFS
+content using the smudge filter, which is executed individually per file
+in the working copy. This is relatively inefficient compared to the
+batch mode and parallel downloads performed by 'git lfs pull'.
+
+=== OPTIONS
+
+All options supported by 'git clone'
+
+* `-I` `--include=`: See [INCLUDE AND EXCLUDE]
+* `-X` `--exclude=`: See [INCLUDE AND EXCLUDE]
+* `--skip-repo`: Skip installing repo-level hooks (.git/hooks) that LFS
+requires. Disabled by default.
+
+=== INCLUDE AND EXCLUDE
+
+You can configure Git LFS to only fetch objects to satisfy references in
+certain paths of the repo, and/or to exclude certain paths of the repo,
+to reduce the time you spend downloading things you do not use.
+
+In your Git configuration or in a `.lfsconfig` file, you may set either
+or both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated
+lists of paths. If `lfs.fetchinclude` is defined, Git LFS objects will
+only be fetched if their path matches one in that list, and if
+`lfs.fetchexclude` is defined, Git LFS objects will only be fetched if
+their path does not match one in that list. Paths are matched using
+wildcard matching as per gitignore(5).
+
+Note that using the command-line options `-I` and `-X` override the
+respective configuration settings. Setting either option to an empty
+string clears the value.
+
+=== SEE ALSO
+
+git-clone(1), git-lfs-pull(1), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-config.adoc b/docs/man/git-lfs-config.adoc
new file mode 100644
index 0000000000..da7dee4d49
--- /dev/null
+++ b/docs/man/git-lfs-config.adoc
@@ -0,0 +1,416 @@
+== git-lfs-config(5) -- Configuration options for git-lfs
+
+=== CONFIGURATION FILES
+
+git-lfs reads its configuration from any file supported by
+`git config -l`, including all per-repository, per-user, and per-system
+Git configuration files.
+
+Additionally, a small number of settings can be specified in a file
+called `.lfsconfig` at the root of the repository; see the "LFSCONFIG"
+section for more details. This configuration file is useful for setting
+options such as the LFS URL or access type for all users of a
+repository, especially when these differ from the default. The
+`.lfsconfig` file uses the same format as `.gitconfig`.
+
+If the `.lfsconfig` file is missing, the index is checked for a version
+of the file, and that is used instead. If both are missing, `HEAD` is
+checked for the file. If the repository is bare, only `HEAD` is checked.
+This order may change for checkouts in the future to better match Git's
+behavior.
+
+Settings from Git configuration files override the `.lfsconfig` file.
+This allows you to override settings like `lfs.url` in your local
+environment without having to modify the `.lfsconfig` file.
+
+Most options regarding git-lfs are contained in the `[lfs]` section,
+meaning they are all named `lfs.foo` or similar, although occasionally
+an lfs option can be scoped inside the configuration for a remote.
+
+=== LIST OF OPTIONS
+
+==== General settings
+
+* `lfs.url` / `remote.<remote>.lfsurl`
++
+The url used to call the Git LFS remote API. Default blank (derive from
+clone URL).
+* `lfs.pushurl` / `remote.<remote>.lfspushurl`
++
+The url used to call the Git LFS remote API when pushing. Default blank
+(derive from either LFS non-push urls or clone url).
+* `remote.lfsdefault`
++
+The remote used to find the Git LFS remote API. `lfs.url` and
+`branch.*.remote` for the current branch override this setting. If this
+setting is not specified and there is exactly one remote, that remote is
+picked; otherwise, the default is `origin`.
+* `remote.lfspushdefault`
++
+The remote used to find the Git LFS remote API when pushing. `lfs.url`
+and `branch.*.pushremote` for the current branch override this setting.
+If this setting is not set, `remote.pushdefault` is used, or if that is
+not set, the order of selection is used as specified in the
+`remote.lfsdefault` above.
+* `lfs.dialtimeout`
++
+Sets the maximum time, in seconds, that the HTTP client will wait to
+initiate a connection. This does not include the time to send a request
+and wait for a response. Default: 30 seconds
+* `lfs.tlstimeout`
++
+Sets the maximum time, in seconds, that the HTTP client will wait for a
+TLS handshake. Default: 30 seconds.
+* `lfs.activitytimeout` / `lfs.https://<host>.activitytimeout`
++
+Sets the maximum time, in seconds, that the HTTP client will wait for
+the next tcp read or write. If < 1, no activity timeout is used at all.
+Default: 30 seconds
+* `lfs.keepalive`
++
+Sets the maximum time, in seconds, for the HTTP client to maintain
+keepalive connections. Default: 30 minutes.
+* `lfs.ssh.automultiplex`
++
+When using the pure SSH-based protocol, whether to multiplex requests
+over a single connection when possible. This option requires the use of
+OpenSSH or a compatible SSH client. Default: true.
+* `lfs.ssh.retries`
++
+Specifies the number of times Git LFS will attempt to obtain
+authorization via SSH before aborting. Default: 5.
+* `core.askpass`, GIT_ASKPASS
++
+Given as a program and its arguments, this is invoked when
+authentication is needed against the LFS API. The contents of stdout are
+interpreted as the password.
+* `lfs.cachecredentials`
++
+Enables in-memory SSH and Git Credential caching for a single 'git lfs'
+command. Default: enabled.
+* `lfs.storage`
++
+Allow override LFS storage directory. Non-absolute path is relativized
+to inside of Git repository directory (usually `.git`).
++
+Note: you should not run `git lfs prune` if you have different
+repositories sharing the same storage directory.
++
+Default: `lfs` in Git repository directory (usually `.git/lfs`).
+* `lfs.largefilewarning`
++
+Warn when a file is 4 GiB or larger. Such files will be corrupted when
+using Windows (unless smudging is disabled) with a Git for Windows
+version less than 2.34.0 due to a limitation in Git. Default: true if
+the version is less than 2.34.0, false otherwise.
+
+==== Upload and download transfer settings
+
+These settings control how the upload and download of LFS content
+occurs.
+
+* `lfs.concurrenttransfers`
++
+The number of concurrent uploads/downloads. Default 8.
+* `lfs.basictransfersonly`
++
+If set to true, only basic HTTP upload/download transfers will be used,
+ignoring any more advanced transfers that the client/server may support.
+This is primarily to work around bugs or incompatibilities.
++
+The git-lfs client supports basic HTTP downloads, resumable HTTP
+downloads (using `Range` headers), and resumable uploads via tus.io
+protocol. Custom transfer methods can be added via `lfs.customtransfer`
+(see next section). However setting this value to true limits the client
+to simple HTTP.
+* `lfs.tustransfers`
++
+If set to true, this enables resumable uploads of LFS objects through
+the tus.io API. Once this feature is finalized, this setting will be
+removed, and tus.io uploads will be available for all clients.
+* `lfs.standalonetransferagent`
++
+Allows the specified custom transfer agent to be used directly for
+transferring files, without asking the server how the transfers should
+be made. The custom transfer agent has to be defined in a
+`lfs.customtransfer.<name>` settings group.
+* `lfs.customtransfer.<name>.path`
++
+`lfs.customtransfer.<name>` is a settings group which defines a custom
+transfer hook which allows you to upload/download via an intermediate
+process, using any mechanism you like (rather than just HTTP). `path`
+should point to the process you wish to invoke. The protocol between the
+git-lfs client and the custom transfer process is documented at
+https://github.com/git-lfs/git-lfs/blob/main/docs/custom-transfers.md
++
+must be a unique identifier that the LFS server understands. When
+calling the LFS API the client will include a list of supported transfer
+types. If the server also supports this named transfer type, it will
+select it and actions returned from the API will be in relation to that
+transfer type (may not be traditional URLs for example). Only if the
+server accepts as a transfer it supports will this custom transfer
+process be invoked.
+* `lfs.customtransfer.<name>.args`
++
+If the custom transfer process requires any arguments, these can be
+provided here. This string will be expanded by the shell.
+* `lfs.customtransfer.<name>.concurrent`
++
+If true (the default), git-lfs will invoke the custom transfer process
+multiple times in parallel, according to `lfs.concurrenttransfers`,
+splitting the transfer workload between the processes.
+* `lfs.customtransfer.<name>.direction`
++
+Specifies which direction the custom transfer process supports, either
+"download", "upload", or "both". The default if unspecified is "both".
+* `lfs.transfer.maxretries`
++
+Specifies how many retries LFS will attempt per OID before marking the
+transfer as failed. Must be an integer which is at least one. If the
+value is not an integer, is less than one, or is not given, a value of
+eight will be used instead.
+* `lfs.transfer.maxretrydelay`
++
+Specifies the maximum time in seconds LFS will wait between each retry
+attempt. LFS uses exponential backoff for retries, doubling the time
+between each retry until reaching this limit. If a server requests a
+delay using the `Retry-After` header, the header value overrides the
+exponential delay for that attempt and is not limited by this option.
++
+Must be an integer which is not negative. Use zero to disable delays
+between retries unless requested by a server. If the value is not an
+integer, is negative, or is not given, a value of ten will be used
+instead.
+* `lfs.transfer.maxverifies`
++
+Specifies how many verification requests LFS will attempt per OID before
+marking the transfer as failed, if the object has a verification action
+associated with it. Must be an integer which is at least one. If the
+value is not an integer, is less than one, or is not given, a default
+value of three will be used instead.
+* `lfs.transfer.enablehrefrewrite`
++
+If set to true, this enables rewriting href of LFS objects using
+`url.*.insteadof/pushinsteadof` config. `pushinsteadof` is used only for
+uploading, and `insteadof` is used for downloading and for uploading
+when `pushinsteadof` is not set.
+
+==== Push settings
+
+* `lfs.allowincompletepush`
++
+When pushing, allow objects to be missing from the local cache without
+halting a Git push. Default: false.
+
+==== Fetch settings
+
+* `lfs.fetchinclude`
++
+When fetching, only download objects which match any entry on this
+comma-separated list of paths/filenames. Wildcard matching is as per
+gitignore(5). See git-lfs-fetch(1) for examples.
+* `lfs.fetchexclude`
++
+When fetching, do not download objects which match any item on this
+comma-separated list of paths/filenames. Wildcard matching is as per
+gitignore(5). See git-lfs-fetch(1) for examples.
+* `lfs.fetchrecentrefsdays`
++
+If non-zero, fetches refs which have commits within N days of the
+current date. Only local refs are included unless
+lfs.fetchrecentremoterefs is true. Also used as a basis for pruning old
+files. The default is 7 days.
+* `lfs.fetchrecentremoterefs`
++
+If true, fetches remote refs (for the remote you're fetching) as well as
+local refs in the recent window. This is useful to fetch objects for
+remote branches you might want to check out later. The default is true;
+if you set this to false, fetching for those branches will only occur
+when you either check them out (losing the advantage of fetch --recent),
+or create a tracking local branch separately then fetch again.
+* `lfs.fetchrecentcommitsdays`
++
+In addition to fetching at refs, also fetches previous changes made
+within N days of the latest commit on the ref. This is useful if you're
+often reviewing recent changes. Also used as a basis for pruning old
+files. The default is 0 (no previous changes).
+* `lfs.fetchrecentalways`
++
+Always operate as if --recent was included in a `git lfs fetch` call.
+Default false.
+
+==== Prune settings
+
+* `lfs.pruneoffsetdays`
++
+The number of days added to the `lfs.fetchrecent*` settings to determine
+what can be pruned. Default is 3 days, i.e. that anything fetched at the
+very oldest edge of the 'recent window' is eligible for pruning 3 days
+later.
+* `lfs.pruneremotetocheck`
++
+Set the remote that LFS files must have been pushed to in order for them
+to be considered eligible for local pruning. Also the remote which is
+called if --verify-remote is enabled.
+* `lfs.pruneverifyremotealways`
++
+Always run `git lfs prune` as if `--verify-remote` was provided.
+
+==== Extensions
+
+* `lfs.extension.<name>.<setting>`
++
+Git LFS extensions enable the manipulation of files streams during
+smudge and clean. `name` groups the settings for a single extension, and
+the settings are:
+** `clean` The command which runs when files are added to the index
+** `smudge` The command which runs when files are written to the working
+copy
+** `priority` The order of this extension compared to others
+
+==== Other settings
+
+* `lfs.<url>.access`
++
+Note: this setting is normally set by LFS itself on receiving a 401
+response (authentication required), you don't normally need to set it
+manually.
++
+If set to "basic" then credentials will be requested before making batch
+requests to this url, otherwise a public request will initially be
+attempted.
+* `lfs.<url>.locksverify`
++
+Determines whether locks are checked before Git pushes. This prevents
+you from pushing changes to files that other users have locked. The Git
+LFS pre-push hook varies its behavior based on the value of this config
+key.
+** `null` - In the absence of a value, Git LFS will attempt the call,
+and warn if it returns an error. If the response is valid, Git LFS will
+set the value to `true`, and will halt the push if the user attempts to
+update a file locked by another user. If the server returns a
+`501 Not Implemented` response, Git LFS will set the value to `false.`
+** `true` - Git LFS will attempt to verify locks, halting the Git push
+if there are any server issues, or if the user attempts to update a file
+locked by another user.
+** `false` - Git LFS will completely skip the lock check in the pre-push
+hook. You should set this if you're not using File Locking, or your Git
+server verifies locked files on pushes automatically.
++
+Supports URL config lookup as described in:
+https://git-scm.com/docs/git-config#git-config-httplturlgt. To set this
+value per-host:
+`git config --global lfs.https://github.com/.locksverify [true|false]`.
+* `lfs.<url>.contenttype`
++
+Determines whether Git LFS should attempt to detect an appropriate HTTP
+`Content-Type` header when uploading using the 'basic' upload adapter.
+If set to false, the default header of
+`Content-Type: application/octet-stream` is chosen instead. Default:
+'true'.
+* `lfs.skipdownloaderrors`
++
+Causes Git LFS not to abort the smudge filter when a download error is
+encountered, which allows actions such as checkout to work when you are
+unable to download the LFS content. LFS files which could not download
+will contain pointer content instead.
++
+Note that this will result in git commands which call the smudge filter
+to report success even in cases when LFS downloads fail, which may
+affect scripts.
++
+You can also set the environment variable GIT_LFS_SKIP_DOWNLOAD_ERRORS=1
+to get the same effect.
+* `GIT_LFS_PROGRESS`
++
+This environment variable causes Git LFS to emit progress updates to an
+absolute file-path on disk when cleaning, smudging, or fetching.
++
+Progress is reported periodically in the form of a new line being
+appended to the end of the file. Each new line will take the following
+format:
++
+`<direction> <current>/<total files> <downloaded>/<total> <name>`
++
+Each field is described below:
+** `direction`: The direction of transfer, either "checkout",
+"download", or "upload".
+** `current` The index of the currently transferring file.
+** `total files` The estimated count of all files to be transferred.
+** `downloaded` The number of bytes already downloaded.
+** `total` The entire size of the file, in bytes.
+** `name` The name of the file.
+* `GIT_LFS_FORCE_PROGRESS` `lfs.forceprogress`
++
+Controls whether Git LFS will suppress progress status when the standard
+output stream is not attached to a terminal. The default is `false`
+which makes Git LFS detect whether stdout is a terminal and suppress
+progress when it's not; you can disable this behaviour and force
+progress status even when standard output stream is not a terminal by
+setting either variable to 1, 'yes' or 'true'.
+* `GIT_LFS_SKIP_SMUDGE`
++
+Sets whether or not Git LFS will skip attempting to convert pointers of
+files tracked into their corresponding objects when checked out into a
+working copy. If 'true', '1', 'on', or similar, Git LFS will skip the
+smudge process in both `git lfs smudge` and `git lfs filter-process`. If
+unset, or set to 'false', '0', 'off', or similar, Git LFS will smudge
+files as normal.
+* `GIT_LFS_SKIP_PUSH`
++
+Sets whether or not Git LFS will attempt to upload new Git LFS object in
+a pre-push hook. If 'true', '1', 'on', or similar, Git LFS will skip the
+pre-push hook, so no new Git LFS objects will be uploaded. If unset, or
+set to 'false', '0', 'off', or similar, Git LFS will proceed as normal.
+* `GIT_LFS_SET_LOCKABLE_READONLY` `lfs.setlockablereadonly`
++
+These settings, the first an environment variable and the second a
+gitconfig setting, control whether files marked as 'lockable' in
+`git lfs track` are made read-only in the working copy when not locked
+by the current user. The default is `true`; you can disable this
+behaviour and have all files writeable by setting either variable to 0,
+'no' or 'false'.
+* `lfs.lockignoredfiles`
++
+This setting controls whether Git LFS will set ignored files that match
+the lockable pattern read only as well as tracked files. The default is
+`false`; you can enable this behavior by setting the variable to 1,
+'yes', or 'true'.
+* `lfs.defaulttokenttl`
++
+This setting sets a default token TTL when git-lfs-authenticate does not
+include the TTL in the JSON response but still enforces it.
++
+Note that this is only necessary for larger repositories hosted on LFS
+servers that don't include the TTL.
+
+=== LFSCONFIG
+
+The .lfsconfig file in a repository is read and interpreted in the same
+format as the file stored in .git/config. It allows a subset of keys to
+be used, including and limited to:
+
+* lfs.allowincompletepush
+* lfs.fetchexclude
+* lfs.fetchinclude
+* lfs.gitprotocol
+* lfs.locksverify
+* lfs.pushurl
+* lfs.skipdownloaderrors
+* lfs.url
+* lfs.\{*}.access
+* remote.\{name}.lfsurl
+
+The set of keys allowed in this file is restricted for security reasons.
+
+=== EXAMPLES
+
+* Configure a custom LFS endpoint for your repository:
+
+`git config -f .lfsconfig lfs.url https://lfs.example.com/foo/bar/info/lfs`
+
+=== SEE ALSO
+
+git-config(1), git-lfs-install(1), gitattributes(5), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-dedup.adoc b/docs/man/git-lfs-dedup.adoc
new file mode 100644
index 0000000000..31146704f3
--- /dev/null
+++ b/docs/man/git-lfs-dedup.adoc
@@ -0,0 +1,24 @@
+== git-lfs-dedup(1) - Deduplicate Git LFS files
+
+=== SYNOPSIS
+
+`git lfs dedup`
+
+=== DESCRIPTION
+
+Deduplicates storage by re-creating working tree files as clones of the
+files in the Git LFS storage directory using the operating system's
+copy-on-write file creation functionality.
+
+If the operating system or file system don't support copy-on-write file
+creation, this command exits unsuccessfully.
+
+This command will also exit without success if any Git LFS extensions
+are configured, as these will typically be used to alter the file
+contents before they are written to the Git LFS storage directory, and
+therefore the working tree files should not be copy-on-write clones of
+the LFS object files.
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-env.adoc b/docs/man/git-lfs-env.adoc
new file mode 100644
index 0000000000..64565fa4a6
--- /dev/null
+++ b/docs/man/git-lfs-env.adoc
@@ -0,0 +1,13 @@
+== git-lfs-env(1) -- Display the Git LFS environment
+
+=== SYNOPSIS
+
+`git lfs env`
+
+=== DESCRIPTION
+
+Display the current Git LFS environment.
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-ext.adoc b/docs/man/git-lfs-ext.adoc
new file mode 100644
index 0000000000..062bd5db19
--- /dev/null
+++ b/docs/man/git-lfs-ext.adoc
@@ -0,0 +1,23 @@
+== git-lfs-ext(1) - View extension details
+
+=== SYNOPSIS
+
+`git lfs ext list` [...]
+
+=== DESCRIPTION
+
+Git LFS extensions enable the manipulation of files streams during
+smudge and clean.
+
+=== EXAMPLES
+
+* List details for all extensions
++
+`git lfs ext` `git lfs ext list`
+* List details for the specified extensions
++
+`git lfs ext list 'foo' 'bar'`
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
new file mode 100644
index 0000000000..ceffec6f30
--- /dev/null
+++ b/docs/man/git-lfs-fetch.adoc
@@ -0,0 +1,139 @@
+== git-lfs-fetch(1) -- Download all Git LFS files for a given ref
+
+=== SYNOPSIS
+
+`git lfs fetch` [options] [ [...]]
+
+=== DESCRIPTION
+
+Download Git LFS objects at the given refs from the specified remote.
+See [DEFAULT REMOTE] and [DEFAULT REFS] for what happens if you don't
+specify.
+
+This does not update the working copy.
+
+=== OPTIONS
+
+* `-I` `--include=`: Specify lfs.fetchinclude just for this invocation;
+see [INCLUDE AND EXCLUDE]
+* `-X` `--exclude=`: Specify lfs.fetchexclude just for this invocation;
+see [INCLUDE AND EXCLUDE]
+* `--recent`: Download objects referenced by recent branches & commits
+in addition to those that would otherwise be downloaded. See [RECENT
+CHANGES]
+* `--all`: Download all objects that are referenced by any commit
+reachable from the refs provided as arguments. If no refs are provided,
+then all refs are fetched. This is primarily for backup and migration
+purposes. Cannot be combined with --recent or --include/--exclude.
+Ignores any globally configured include and exclude paths to ensure that
+all objects are downloaded.
+* `--prune` `-p`: Prune old and unreferenced objects after fetching,
+equivalent to running `git lfs prune` afterwards. See git-lfs-prune(1)
+for more details.
+
+=== INCLUDE AND EXCLUDE
+
+You can configure Git LFS to only fetch objects to satisfy references in
+certain paths of the repo, and/or to exclude certain paths of the repo,
+to reduce the time you spend downloading things you do not use.
+
+In your Git configuration or in a `.lfsconfig` file, you may set either
+or both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated
+lists of paths. If `lfs.fetchinclude` is defined, Git LFS objects will
+only be fetched if their path matches one in that list, and if
+`lfs.fetchexclude` is defined, Git LFS objects will only be fetched if
+their path does not match one in that list. Paths are matched using
+wildcard matching as per gitignore(5).
+
+Note that using the command-line options `-I` and `-X` override the
+respective configuration settings. Setting either option to an empty
+string clears the value.
+
+==== Examples
+
+* `git config lfs.fetchinclude "textures,images/foo*"`
++
+This will only fetch objects referenced in paths in the textures folder,
+and files called foo* in the images folder
+* `git config lfs.fetchinclude "*.jpg,*.png,*.tga"`
++
+Only fetch JPG/PNG/TGA files, wherever they are in the repository
+* `git config lfs.fetchexclude "media/reallybigfiles"`
++
+Don't fetch any LFS objects referenced in the folder
+media/reallybigfiles, but fetch everything else
+* `git config lfs.fetchinclude "media"`
+`git config lfs.fetchexclude "media/excessive"`
++
+Only fetch LFS objects in the 'media' folder, but exclude those in one
+of its subfolders.
+
+=== DEFAULT REMOTE
+
+Without arguments, fetch downloads from the default remote. The default
+remote is the same as for `git fetch`, i.e. based on the remote branch
+you're tracking first, or origin otherwise.
+
+=== DEFAULT REFS
+
+If no refs are given as arguments, the currently checked out ref is
+used. In addition, if enabled, recently changed refs and commits are
+also included. See [RECENT CHANGES] for details.
+
+=== RECENT CHANGES
+
+If the `--recent` option is specified, or if the gitconfig option
+`lfs.fetchrecentalways` is true, then after the current ref (or those in
+the arguments) is fetched, we also search for 'recent' changes to fetch
+objects for, so that it's more convenient to checkout or diff those
+commits without incurring further downloads.
+
+What changes are considered 'recent' is based on a number of gitconfig
+options:
+
+* `lfs.fetchrecentrefsdays` If non-zero, includes branches which have
+commits within N days of the current date. Only local refs are included
+unless lfs.fetchrecentremoterefs is true. The default is 7 days.
+* `lfs.fetchrecentremoterefs` If true, fetches remote refs (for the
+remote you're fetching) as well as local refs in the recent window. This
+is useful to fetch objects for remote branches you might want to check
+out later. The default is true; if you set this to false, fetching for
+those branches will only occur when you either check them out (losing
+the advantage of fetch --recent), or create a tracking local branch
+separately then fetch again.
+* `lfs.fetchrecentcommitsdays` In addition to fetching at branches, also
+fetches changes made within N days of the latest commit on the branch.
+This is useful if you're often reviewing recent changes. The default is
+0 (no previous changes).
+* `lfs.fetchrecentalways` Always operate as if --recent was provided on
+the command line.
+
+=== EXAMPLES
+
+* Fetch the LFS objects for the current ref from default remote
++
+`git lfs fetch`
+* Fetch the LFS objects for the current ref AND recent changes from
+default remote
++
+`git lfs fetch --recent`
+* Fetch the LFS objects for the current ref from a secondary remote
+'upstream'
++
+`git lfs fetch upstream`
+* Fetch all the LFS objects from the default remote that are referenced
+by any commit in the `main` and `develop` branches
++
+`git lfs fetch --all origin main develop`
+* Fetch the LFS objects for a branch from origin
++
+`git lfs fetch origin mybranch`
+* Fetch the LFS objects for 2 branches and a commit from origin
++
+`git lfs fetch origin main mybranch e445b45c1c9c6282614f201b62778e4c0688b5c8`
+
+=== SEE ALSO
+
+git-lfs-checkout(1), git-lfs-pull(1), git-lfs-prune(1), gitconfig(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-filter-process.adoc b/docs/man/git-lfs-filter-process.adoc
new file mode 100644
index 0000000000..cf3af43026
--- /dev/null
+++ b/docs/man/git-lfs-filter-process.adoc
@@ -0,0 +1,45 @@
+== git-lfs-filter-process(1) -- Git filter process that converts between pointer and actual content
+
+=== SYNOPSIS
+
+`git lfs filter-process` `git lfs filter-process --skip`
+
+=== DESCRIPTION
+
+Implement the Git process filter API, exchanging handshake messages and
+then accepting and responding to requests to either clean or smudge a
+file.
+
+filter-process is always run by Git's filter process, and is configured
+by the repository's Git attributes.
+
+In your Git configuration or in a `.lfsconfig` file, you may set either
+or both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated
+lists of paths. If `lfs.fetchinclude` is defined, Git LFS pointer files
+will only be replaced with the contents of the corresponding Git LFS
+object file if their path matches one in that list, and if
+`lfs.fetchexclude` is defined, Git LFS pointer files will only be
+replaced with the contents of the corresponding Git LFS object file if
+their path does not match one in that list. Paths are matched using
+wildcard matching as per gitignore(5). Git LFS pointer files that are
+not replaced with the contents of their corresponding object files are
+simply copied to standard output without change.
+
+The filter process uses Git's pkt-line protocol to communicate, and is
+documented in detail in gitattributes(5).
+
+=== OPTIONS
+
+Without any options, filter-process accepts and responds to requests
+normally.
+
+* `--skip`: Skip automatic downloading of objects on clone or pull.
+* `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
+git-lfs-config(5).
+
+=== SEE ALSO
+
+git-lfs-clean(1), git-lfs-install(1), git-lfs-smudge(1),
+gitattributes(5), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-fsck.adoc b/docs/man/git-lfs-fsck.adoc
new file mode 100644
index 0000000000..75a517b1ec
--- /dev/null
+++ b/docs/man/git-lfs-fsck.adoc
@@ -0,0 +1,38 @@
+== git-lfs-fsck(1) -- Check GIT LFS files for consistency
+
+=== SYNOPSIS
+
+`git lfs fsck` [options] [revisions]
+
+=== DESCRIPTION
+
+Checks all Git LFS files in the current HEAD for consistency.
+
+Corrupted files are moved to ".git/lfs/bad".
+
+The revisions may be specified as either a single committish, in which
+case only that commit is inspected; specified as a range of the form
+`A..B` (and only this form), in which case that range is inspected; or
+omitted entirely, in which case HEAD (and, for --objects, the index) is
+examined.
+
+The default is to perform all checks.
+
+In your Git configuration or in a `.lfsconfig` file, you may set
+`lfs.fetchexclude` to a comma-separated list of paths. If
+`lfs.fetchexclude` is defined, then any Git LFS files whose paths match
+one in that list will not be checked for consistency. Paths are matched
+using wildcard matching as per gitignore(5).
+
+=== OPTIONS
+
+* `--objects`: Check that each object in HEAD matches its expected hash
+and that each object exists on disk.
+* `--pointers`: Check that each pointer is canonical and that each file
+which should be stored as a Git LFS file is so stored.
+
+=== SEE ALSO
+
+git-lfs-ls-files(1), git-lfs-status(1), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-install.adoc b/docs/man/git-lfs-install.adoc
new file mode 100644
index 0000000000..913f14a83c
--- /dev/null
+++ b/docs/man/git-lfs-install.adoc
@@ -0,0 +1,54 @@
+== git-lfs-install(1) -- Install Git LFS configuration.
+
+=== SYNOPSIS
+
+`git lfs install` [options]
+
+=== DESCRIPTION
+
+Perform the following actions to ensure that Git LFS is setup properly:
+
+* Set up the clean and smudge filters under the name "lfs" in the global
+Git config.
+* Install a pre-push hook to run git-lfs-pre-push(1) for the current
+repository, if run from inside one. If "core.hooksPath" is configured in
+any Git configuration (and supported, i.e., the installed Git version is
+at least 2.9.0), then the pre-push hook will be installed to that
+directory instead.
+
+=== OPTIONS
+
+Without any options, `git lfs install` will only setup the "lfs" smudge
+and clean filters if they are not already set.
+
+* `--force`: Sets the "lfs" smudge and clean filters, overwriting
+existing values.
+* `--local`: Sets the "lfs" smudge and clean filters in the local
+repository's git config, instead of the global git config
+(~/.gitconfig).
+* `--worktree`: Sets the "lfs" smudge and clean filters in the current
+working tree's git config, instead of the global git config
+(~/.gitconfig) or local repository's git config ($GIT_DIR/config). If
+multiple working trees are in use, the Git config extension
+`worktreeConfig` must be enabled to use this option. If only one working
+tree is in use, `--worktree` has the same effect as `--local`. This
+option is only available if the installed Git version is at least 2.20.0
+and therefore supports the "worktreeConfig" extension.
+* `--manual`: Print instructions for manually updating your hooks to
+include git-lfs functionality. Use this option if `git lfs install`
+fails because of existing hooks and you want to retain their
+functionality.
+* `--system`: Sets the "lfs" smudge and clean filters in the system git
+config, e.g. /etc/gitconfig instead of the global git config
+(~/.gitconfig).
+* `--skip-smudge`: Skips automatic downloading of objects on clone or
+pull. This requires a manual "git lfs pull" every time a new commit is
+checked out on your repository.
+* `--skip-repo`: Skips setup of the local repo; use if you want to
+install the global lfs filters but not make changes to the current repo.
+
+=== SEE ALSO
+
+git-lfs-uninstall(1), git-worktree(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
new file mode 100644
index 0000000000..44b1b52e40
--- /dev/null
+++ b/docs/man/git-lfs-lock.adoc
@@ -0,0 +1,30 @@
+== git-lfs-lock(1) -- Set a file as "locked" on the Git LFS server
+
+=== SYNOPSIS
+
+`git lfs lock` [options]
+
+=== DESCRIPTION
+
+Sets the given file path as "locked" against the Git LFS server, with
+the intention of blocking attempts by other users to update the given
+path. Locking a file requires the file to exist in the working copy.
+
+Once locked, LFS will verify that Git pushes do not modify files locked
+by other users. See the description of the `lfs.<url>.locksverify`
+config key in git-lfs-config(5) for details.
+
+=== OPTIONS
+
+* `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
+`lfs.url` config key is set.
+* `--json`: Writes lock info as JSON to STDOUT if the command exits
+successfully. Intended for interoperation with external tools. If the
+command returns with a non-zero exit code, plain text messages will be
+sent to STDERR.
+
+=== SEE ALSO
+
+git-lfs-unlock(1), git-lfs-locks(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-locks.adoc b/docs/man/git-lfs-locks.adoc
new file mode 100644
index 0000000000..9f783e8366
--- /dev/null
+++ b/docs/man/git-lfs-locks.adoc
@@ -0,0 +1,44 @@
+== git-lfs-locks(1) -- Lists currently locked files from the Git LFS server.
+
+=== SYNOPSIS
+
+`git lfs locks` [options]
+
+=== DESCRIPTION
+
+Lists current locks from the Git LFS server.
+
+=== OPTIONS
+
+* `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
+`lfs.url` config key is set.
+* `-i <id>` `--id=<id>`: Specifies a lock by its ID. Returns a single
+result.
+* `-p <path>` `--path=<path>`: Specifies a lock by its path. Returns a
+single result.
+* `--local`: Lists only our own locks which are cached locally. Skips a
+remote call.
+* `--cached`: Lists cached locks from the last remote call. Contrary to
+--local, this will include locks of other users as well. This option is
+intended to display the last known locks in case you are offline. There
+is no guarantee that locks on the server have not changed in the
+meanwhile.
+* `--verify`: Verifies the lock owner on the server and marks our own
+locks by 'O'. Own locks are actually held by us and corresponding files
+can be updated for the next push. All other locks are held by someone
+else. Contrary to --local, this option will also detect locks which are
+held by us despite no local lock information being available (e.g.
+because the file had been locked from a different clone); it will also
+detect 'broken' locks (e.g. if someone else has forcefully unlocked our
+files).
+* `-l <num>` `--limit=<num>`: Specifies number of results to return.
+* `--json`: Writes lock info as JSON to STDOUT if the command exits
+successfully. Intended for interoperation with external tools. If the
+command returns with a non-zero exit code, plain text messages will be
+sent to STDERR.
+
+=== SEE ALSO
+
+git-lfs-lock(1), git-lfs-unlock(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-logs.adoc b/docs/man/git-lfs-logs.adoc
new file mode 100644
index 0000000000..6fedc59e19
--- /dev/null
+++ b/docs/man/git-lfs-logs.adoc
@@ -0,0 +1,27 @@
+== git-lfs-logs(1) - Show errors from the git-lfs command
+
+=== SYNOPSIS
+
+`git lfs logs` `git lfs logs` `git lfs logs clear`
+`git lfs logs boomtown`
+
+=== DESCRIPTION
+
+Display errors from the git-lfs command. Any time it crashes, the
+details are saved to ".git/lfs/logs".
+
+=== COMMANDS
+
+* `clear`: Clears all of the existing logged errors.
+* `boomtown`: Triggers a dummy exception.
+
+=== OPTIONS
+
+Without any options, `git lfs logs` simply shows the list of error logs.
+
+* : Shows the specified error log. Use "last" to show the most recent
+error.
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
new file mode 100644
index 0000000000..5045d20e1d
--- /dev/null
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -0,0 +1,41 @@
+== git-lfs-ls-files(1) -- Show information about Git LFS files in the index and working tree
+
+=== SYNOPSIS
+
+`git lfs ls-files` [] `git lfs ls-files`
+
+=== DESCRIPTION
+
+Display paths of Git LFS files that are found in the tree at the given
+reference. If no reference is given, scan the currently checked-out
+branch. If two references are given, the LFS files that are modified
+between the two references are shown; deletions are not listed.
+
+An asterisk (*) after the OID indicates a full object, a minus (-)
+indicates an LFS pointer.
+
+=== OPTIONS
+
+* `-l` `--long`: Show the entire 64 character OID, instead of just first
+10.
+* `-s` `--size`: Show the size of the LFS object between parenthesis at
+the end of a line.
+* `-d` `--debug`: Show as much information as possible about a LFS file.
+This is intended for manual inspection; the exact format may change at
+any time.
+* `-a` `--all`: Inspects the full history of the repository, not the
+current HEAD (or other provided reference). This will include previous
+versions of LFS objects that are no longer found in the current tree.
+* `--deleted`: Shows the full history of the given reference, including
+objects that have been deleted.
+* `-I` `--include=`: Include paths matching only these patterns; see
+[FETCH SETTINGS].
+* `-X` `--exclude=`: Exclude paths matching any of these patterns; see
+[FETCH SETTINGS].
+* `-n` `--name-only`: Show only the lfs tracked file names.
+
+=== SEE ALSO
+
+git-lfs-status(1), git-lfs-config(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-merge-driver.adoc b/docs/man/git-lfs-merge-driver.adoc
new file mode 100644
index 0000000000..8a1a36490b
--- /dev/null
+++ b/docs/man/git-lfs-merge-driver.adoc
@@ -0,0 +1,87 @@
+== git-lfs-merge-driver(1) -- Merge text-based LFS files
+
+=== SYNOPSIS
+
+`git lfs merge-driver` [options]
+
+=== DESCRIPTION
+
+Merge text files stored in Git LFS using the default Git merge
+machinery, or a custom merge driver if specified. Note that this, in
+general, does not support partial renames or copies because Git does not
+support them in this case.
+
+This program is intended to be invoked automatically by Git and not by
+users manually. See [CONFIGURATION] for details on the configuration
+required for that.
+
+=== OPTIONS
+
+* `--ancestor` Specify the file containing the ancestor revision.
+* `--current` Specify the file containing the current revision.
+* `--marker-size` Specify the conflict marker size as an integer.
+* `--other` Specify the file containing the other revision.
+* `--program` Specify a command, which is passed to the shell after
+substitution, that performs the actual merge. If this is not specified,
+`git merge-file` is invoked with appropriate arguments to perform the
+merge of the file.
++
+See [CONFIGURATION] for the sequences which are substituted here.
+
+=== CONFIGURATION
+
+Git allows the use of a custom merge driver for files based on the
+`merge` attribute set in `.gitattributes`. By default, when using
+`git lfs track`, this value is set to `lfs`.
+
+Because Git LFS can be used to store both text and binary files and it
+isn't always clear which behavior should be used, Git LFS does not
+enable this merge driver by default. However, if you know that some or
+all of your files are text files, then you can set the `merge` attribute
+for those files to `lfs-text` and use `git config` to set the merge
+driver like so:
+
+[source,console]
+----
+$ git config merge.lfs-text.driver 'git lfs merge-driver --ancestor %O --current %A --other %B --marker-size %L --output %A'
+----
+
+This tells Git to invoke the custom Git LFS merge driver, which in turn
+uses Git's merge machinery, to merge files where the `merge` attribute
+is set to `lfs-text`. Note that `lfs-text` here is an example and any
+syntactically valid value can be used.
+
+If you are using a special type of file that needs rules different from
+Git's standard merge machinery, you can also specify the `--program`
+option, which is passed to `sh` after substituting its own
+percent-encoded escapes:
+
+* `%A`: the current version
+* `%B`: the other version
+* `%D`: the destination version
+* `%O`: the ancestor version
+* `%L`: the conflict marker size
+
+Note that the percent sign must typically be doubled to prevent Git from
+substituting its own values here. Therefore, specifying the default
+behavior explicitly looks like this:
+
+[source,console]
+----
+$ git config merge.lfs-text.driver \
+ 'git lfs merge-driver --ancestor %O --current %A --other %B --marker-size %L --output %A --program '\''git merge-file --stdout --marker-size=%%L %%A %%O %%B >%%D'\'''
+----
+
+The exit status from the custom command should be zero on success or
+non-zero on conflicts or other failure.
+
+Note that if no merge driver is specified for the value of the `merge`
+attribute (as is the case by default with `merge=lfs`), then the default
+Git merge strategy is used. For LFS files, this means that Git will try
+to merge the pointer files, which usually is not useful.
+
+=== SEE ALSO
+
+git-merge(1), git-merge-file(1), gitattributes(5)
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
new file mode 100644
index 0000000000..aad8db2de7
--- /dev/null
+++ b/docs/man/git-lfs-migrate.adoc
@@ -0,0 +1,450 @@
+== git-lfs-migrate(1) - Migrate history to or from Git LFS
+
+=== SYNOPSIS
+
+`git lfs migrate` [options] [--] [branch ...]
+
+=== DESCRIPTION
+
+Convert files in a Git repository to or from Git LFS pointers, or
+summarize Git file sizes by file type. The `import` mode converts Git
+files (i.e., blobs) to Git LFS, while the `export` mode does the
+reverse, and the `info` mode provides an informational summary which may
+be useful in deciding which files to import or export.
+
+In all modes, by default `git lfs migrate` operates only on the
+currently checked-out branch, and only on files (of any size and type)
+added in commits which do not exist on any remote. Multiple options are
+available to override these defaults.
+
+When converting files to or from Git LFS, the `git lfs migrate` command
+will only make changes to your local repository and working copy, never
+any remotes. This is intentional as the `import` and `export` modes are
+generally "destructive" in the sense that they rewrite your Git history,
+changing commits and generating new commit SHAs. (The exception is the
+"no-rewrite" `import` sub-mode; see [IMPORT WITHOUT REWRITING HISTORY]
+for details.)
+
+You should therefore always first commit or stash any uncommitted work
+before using the `import` or `export` modes, and then validate the
+result of the migration before pushing the changes to your remotes, for
+instance by running the `info` mode and by examining your rewritten
+commit history.
+
+Once you are satisfied with the changes, you will need to force-push the
+new Git history of any rewritten branches to all your remotes. This is a
+step which should be taken with care, since you will be altering the Git
+history on your remotes.
+
+To examine or modify files in branches other than the currently
+checked-out one, branch refs may be specified directly, or provided in
+one or more `--include-ref` options. They may also be excluded by
+prefixing them with `^` or providing them in `--exclude-ref` options.
+Use the `--everything` option to specify that all refs should be
+examined, including all remote refs. See [INCLUDE AND EXCLUDE
+REFERENCES] for details.
+
+For the `info` and `import` modes, all file types are considered by
+default; while useful in the `info` mode, this is often not desirable
+when importing, so either filename patterns (pathspecs) or the `--fixup`
+option should normally be specified in that case. (At least one include
+pathspec is required for the `export` mode.) Pathspecs may be defined
+using the `--include` and `--exclude` options (`-I` and `-X` for short),
+as described in [INCLUDE AND EXCLUDE].
+
+As typical Git LFS usage depends on tracking specific file types using
+filename patterns defined in `.gitattributes` files, the
+`git lfs migrate` command will examine, create, and modify
+`.gitattributes` files as necessary. The `.gitattributes` files will
+always be assigned the default read/write permissions mode (i.e.,
+without execute permissions). Any symbolic links with that name will
+cause the migration to halt prematurely.
+
+The `import` mode (see [IMPORT]) will convert Git objects of the file
+types specified (e.g., with `--include`) to Git LFS pointers, and will
+add entries for those file types to `.gitattributes` files, creating
+those files if they do not exist. The result should be as if
+`git lfs track` commands had been run at the points in your Git history
+corresponding to where each type of converted file first appears. The
+exception is if the `--fixup` option is given, in which case the
+`import` mode will only examine any existing `.gitattributes` files and
+then convert Git objects which should be tracked by Git LFS but are not
+yet.
+
+The `export` mode (see [EXPORT]) works as the reverse operation to the
+`import` mode, converting any Git LFS pointers that match the file types
+specified with `--include`, which must be given at least once. Note that
+`.gitattributes` entries will not be removed, nor will the files;
+instead, the `export` mode inserts "do not track" entries similar to
+those created by the `git lfs untrack` command. The `--remote` option is
+available in the `export` mode to specify the remote from which Git LFS
+objects should be fetched if they do not exist in the local Git LFS
+object cache; if not provided, `origin` is used by default.
+
+The `info` mode (see [INFO]) summarizes by file type (i.e., by filename
+extension) the total number and size of files in a repository. Note that
+like the other two modes, by default the `info` mode operates only on
+the currently checked-out branch and only on commits which do not exist
+on any remote, so to get a summary of the entire repository across all
+branches, use the `--everything` option. If objects have already been
+converted to Git LFS pointers, then by default the size of the
+referenced objects is totaled and reported separately. You may also
+choose to ignore them by using `--pointers=ignore` or to treat the
+pointers as files by using `--pointers=no-follow`. (The latter option is
+akin to how existing Git LFS pointers were handled by the `info` mode in
+prior versions of Git LFS).
+
+When using the `--everything` option, take note that it means all refs
+(local and remote) will be considered, but not necessarily all file
+types. The `import` and `info` modes consider all file types by default,
+although the `--include` and `--exclude` options constrain this
+behavior. Also note that after importing across all branches with the
+`--everything` option (and then checking to ensure the results are
+satisfactory!) it may be convenient to update multiple branches on your
+remotes by using the `--all` option to `git push`.
+
+Unless the `--skip-fetch` option is given, `git lfs migrate` always
+begins by fetching updated lists of refs from all the remotes returned
+by `git remote`, but as noted above, after making changes to your local
+Git history while converting objects, it will never automatically push
+those changes to your remotes.
+
+=== MODES
+
+* `info` Show information about repository size. See [INFO].
+* `import` Convert Git objects to Git LFS pointers. See [IMPORT] and
+[IMPORT WITHOUT REWRITING HISTORY].
+* `export` Convert Git LFS pointers to Git objects. See [EXPORT].
+
+=== OPTIONS
+
+* `-I` `--include=`: See [INCLUDE AND EXCLUDE].
+* `-X` `--exclude=`: See [INCLUDE AND EXCLUDE].
+* `--include-ref`=: See [INCLUDE AND EXCLUDE REFERENCES].
+* `--exclude-ref`=: See [INCLUDE AND EXCLUDE REFERENCES].
+* `--skip-fetch`: Assumes that the known set of remote references is
+complete, and should not be refreshed when determining the set of
+"un-pushed" commits to migrate. Has no effect when combined with
+`--include-ref` or `--exclude-ref`.
+* `--everything`: See [INCLUDE AND EXCLUDE REFERENCES].
++
+Note: Git refs are "case-sensitive" on all platforms in "packed from"
+(see `git-pack-refs(1)`). On "case-insensitive" file systems, e.g. NTFS
+on Windows or default APFS on macOS, `git-lfs-migrate(1)` would only
+migrate the first ref if two or more refs are equal except for
+upper/lower case letters.
+* `--yes`: Assume a yes answer to any prompts, permitting noninteractive
+use. Currently, the only such prompt is the one asking whether to
+overwrite (destroy) any working copy changes. Thus, specifying this
+option may cause data loss if you are not careful.
+* [branch ...]: Migrate only the set of branches listed. If not given,
+`git-lfs-migrate(1)` will migrate the currently checked out branch.
++
+References beginning with `^` will be excluded, whereas branches that do
+not begin with `^` will be included.
++
+If any of `--include-ref` or `--exclude-ref` are given, the checked out
+branch will not be appended, but branches given explicitly will be
+appended.
+
+==== INFO
+
+The `info` mode summarizes the sizes of file objects present in the Git
+history. It supports all the core `migrate` options and these additional
+ones:
+
+* `--above=<size>` Only count files whose individual filesize is above
+the given size. `size` may be specified as a number of bytes, or a
+number followed by a storage unit, e.g., "1b", "20 MB", "3 TiB", etc.
++
+If a set of files sharing a common extension has no files in that set
+whose individual size is above the given `--above` no files no entry for
+that set will be shown.
+* `--top=<n>` Only display the top `n` entries, ordered by how many
+total files match the given pathspec. The default is to show only the
+top 5 entries. When existing Git LFS objects are found, an extra,
+separate "LFS Objects" line is output in addition to the top `n`
+entries, unless the `--pointers` option is used to change this behavior.
+* `--unit=<unit>` Format the number of bytes in each entry as a quantity
+of the storage unit provided. Valid units include: * b, kib, mib, gib,
+tib, pib - for IEC storage units * b, kb, mb, gb, tb, pb - for SI
+storage units
++
+If a `--unit` is not specified, the largest unit that can fit the number
+of counted bytes as a whole number quantity is chosen.
+* `--pointers=[follow|no-follow|ignore]` Treat existing Git LFS pointers
+in the history according to one of three alternatives. In the default
+`follow` case, if any pointers are found, an additional separate "LFS
+Objects" line item is output which summarizes the total number and size
+of the Git LFS objects referenced by pointers. In the `ignore` case, any
+pointers are simply ignored, while the `no-follow` case replicates the
+behavior of the `info` mode in older Git LFS versions and treats any
+pointers it finds as if they were regular files, so the output totals
+only include the contents of the pointers, not the contents of the
+objects to which they refer.
+* `--fixup` Infer `--include` and `--exclude` filters on a per-commit
+basis based on the `.gitattributes` files in a repository. In practice,
+this option counts any filepaths which should be tracked by Git LFS
+according to the repository's `.gitattributes` file(s), but aren't
+already pointers. The `.gitattributes` files are not reported, in
+contrast to the normal output of the `info` mode. This option is
+incompatible with explicitly given `--include`, `--exclude` filters and
+with any `--pointers` setting other than `ignore`, hence `--fixup`
+implies `--pointers=ignore` if it is not explicitly set.
+
+The format of the output shows the filename pattern, the total size of
+the file objects (excluding those below the `--above` threshold, if one
+was defined), and the ratio of the number of files above the threshold
+to the total number of files; this ratio is also shown as a percentage.
+For example:
+
+....
+*.gif 93 MB 9480/10504 files(s) 90%
+*.png 14 MB 1732/1877 files(s) 92%
+....
+
+By default only the top five entries are shown, but `--top` allows for
+more or fewer to be output as desired.
+
+==== IMPORT
+
+The `import` mode migrates objects present in the Git history to pointer
+files tracked and stored with Git LFS. It supports all the core
+`migrate` options and these additional ones:
+
+* `--verbose` Print the commit oid and filename of migrated files to
+STDOUT.
+* `--above=<size>` Only migrate files whose individual filesize is above
+the given size. `size` may be specified as a number of bytes, or a
+number followed by a storage unit, e.g., "1b", "20 MB", "3 TiB", etc.
+This option cannot be used with the `--include`, `--exclude`, and
+`--fixup` options.
+* `--object-map=<path>` Write to `path` a file with the mapping of each
+rewritten commits. The file format is CSV with this pattern:
+`OLD-SHA`,`NEW-SHA`
+* `--no-rewrite` Migrate objects to Git LFS in a new commit without
+rewriting Git history. Please note that when this option is used, the
+`migrate import` command will expect a different argument list,
+specialized options will become available, and the core `migrate`
+options will be ignored. See [IMPORT WITHOUT REWRITING HISTORY].
+* `--fixup` Infer `--include` and `--exclude` filters on a per-commit
+basis based on the `.gitattributes` files in a repository. In practice,
+this option imports any filepaths which should be tracked by Git LFS
+according to the repository's `.gitattributes` file(s), but aren't
+already pointers. This option is incompatible with explicitly given
+`--include`, `--exclude` filters.
+
+If `--no-rewrite` is not provided and `--include` or `--exclude` (`-I`,
+`-X`, respectively) are given, the `.gitattributes` will be modified to
+include any new filepath patterns as given by those flags.
+
+If `--no-rewrite` is not provided and neither of those flags are given,
+the gitattributes will be incrementally modified to include new filepath
+extensions as they are rewritten in history.
+
+==== IMPORT WITHOUT REWRITING HISTORY
+
+The `import` mode has a special sub-mode enabled by the `--no-rewrite`
+flag. This sub-mode will migrate objects to pointers as in the base
+`import` mode, but will do so in a new commit without rewriting Git
+history. When using this sub-mode, the base `migrate` options, such as
+`--include-ref`, will be ignored, as will those for the base `import`
+mode. The `migrate` command will also take a different argument list. As
+a result of these changes, `--no-rewrite` will only operate on the
+current branch - any other interested branches must have the generated
+commit merged in.
+
+The `--no-rewrite` sub-mode supports the following options and
+arguments:
+
+* `-m <message> --message=<message>` Specifies a commit message for the
+newly created commit.
+* [file ...] The list of files to import. These files must be tracked by
+patterns specified in the gitattributes.
+
+If `--message` is given, the new commit will be created with the
+provided message. If no message is given, a commit message will be
+generated based on the file arguments.
+
+==== EXPORT
+
+The `export` mode migrates Git LFS pointer files present in the Git
+history out of Git LFS, converting them into their corresponding object
+files. It supports all the core `migrate` options and these additional
+ones:
+
+* `--verbose` Print the commit oid and filename of migrated files to
+STDOUT.
+* `--object-map=<path>` Write to `path` a file with the mapping of each
+rewritten commit. The file format is CSV with this pattern:
+`OLD-SHA`,`NEW-SHA`
+* `--remote=<git-remote>` Download LFS objects from the provided
+`git-remote` during the export. If not provided, defaults to `origin`.
+
+The `export` mode requires at minimum a pattern provided with the
+`--include` argument to specify which files to export. Files matching
+the `--include` patterns will be removed from Git LFS, while files
+matching the `--exclude` patterns will retain their Git LFS status. The
+export command will modify the `.gitattributes` to set/unset any
+filepath patterns as given by those flags.
+
+=== INCLUDE AND EXCLUDE
+
+You can specify that `git lfs migrate` should only convert files whose
+pathspec matches the `--include` glob patterns and does not match the
+`--exclude` glob patterns, either to reduce total migration time or to
+only migrate part of your repo. Multiple patterns may be given using
+commas as delimiters.
+
+Pattern matching is done so as to be functionally equivalent to the
+pattern matching format of `.gitattributes`. In addition to simple file
+extension matches (e.g., `*.gif`) patterns may also specify directory
+paths, in which case the `path/**` format may be used to match
+recursively.
+
+Note that this form of pattern matching for the `--include` and
+`--exclude` options used by the `git lfs migrate` command is unique
+among the suite of `git lfs` commands. Other commands which also take
+these options, such as `git lfs ls-files`, use the gitignore(5) form of
+pattern matching instead.
+
+=== INCLUDE AND EXCLUDE REFERENCES
+
+You can specify that `git lfs migrate` should only convert files added
+in commits reachable from certain references, namely those defined using
+one or more `--include-ref` options, and should ignore files in commits
+reachable from references defined in `--exclude-ref` options.
+
+....
+ D---E---F
+ / \
+ A---B------C refs/heads/my-feature
+ \ \
+ \ refs/heads/main
+ \
+ refs/remotes/origin/main
+....
+
+In the above configuration, the following commits are reachable by each
+ref:
+
+....
+refs/heads/main: C, B, A
+refs/heads/my-feature: F, E, D, B, A
+refs/remote/origin/main: A
+....
+
+The following `git lfs migrate` options would, therefore, include
+commits F, E, D, C, and B, but exclude commit A:
+
+....
+ --include-ref=refs/heads/my-feature
+ --include-ref=refs/heads/main
+ --exclude-ref=refs/remotes/origin/main
+....
+
+The presence of flag `--everything` indicates that all local and remote
+references should be migrated.
+
+=== EXAMPLES
+
+==== Migrate unpushed commits
+
+A common use case for the migrate command is to convert large Git
+objects to LFS before pushing your commits. By default, it only scans
+commits that don't exist on any remote, so long as the repository is
+non-bare.
+
+First, run `git lfs migrate info` to list the file types taking up the
+most space in your repository:
+
+....
+$ git lfs migrate info
+migrate: Fetching remote refs: ..., done
+migrate: Sorting commits: ..., done
+migrate: Examining commits: 100% (1/1), done
+*.mp3 284 MB 1/1 files(s) 100%
+*.pdf 42 MB 8/8 files(s) 100%
+*.psd 9.8 MB 15/15 files(s) 100%
+*.ipynb 6.9 MB 6/6 files(s) 100%
+*.csv 5.8 MB 2/2 files(s) 100%
+....
+
+Now, you can run `git lfs migrate import` to convert some file types to
+LFS:
+
+....
+$ git lfs migrate import --include="*.mp3,*.psd"
+migrate: Fetching remote refs: ..., done
+migrate: Sorting commits: ..., done
+migrate: Rewriting commits: 100% (1/1), done
+ main d2b959babd099fe70da1c1512e2475e8a24de163 -> 136e706bf1ae79643915c134e17a6c933fd53c61
+migrate: Updating refs: ..., done
+....
+
+If after conversion you find that some files in your working directory
+have been replaced with Git LFS pointers, this is normal, and the
+working copies of these files can be repopulated with their full
+expected contents by using `git lfs checkout`.
+
+==== Migrate local history
+
+You can also migrate the entire history of your repository:
+
+....
+# Check for large files and existing Git LFS objects in your local main branch
+$ git lfs migrate info --include-ref=main
+
+# Check for large files and existing Git LFS objects in every branch
+$ git lfs migrate info --everything
+
+# Check for large files in every branch, ignoring any existing Git LFS objects,
+# and listing the top 100 or fewer results
+$ git lfs migrate info --everything --pointers=ignore --top=100
+....
+
+The same flags will work in `import` mode:
+
+....
+# Convert all zip files in your main branch
+$ git lfs migrate import --include-ref=main --include="*.zip"
+
+# Convert all zip files in every local branch
+$ git lfs migrate import --everything --include="*.zip"
+
+# Convert all files over 100K in every local branch
+$ git lfs migrate import --everything --above=100Kb
+....
+
+Note: This will require a force-push to any existing Git remotes. Using
+the `--all` option when force-pushing may be convenient if many refs
+were updated, e.g., after importing to Git LFS with the `--everything`
+option.
+
+==== Migrate without rewriting local history
+
+You can also migrate files without modifying the existing history of
+your repository. Note that in the examples below, files in
+subdirectories are not included because they are not explicitly
+specified.
+
+Without a specified commit message:
+
+....
+$ git lfs migrate import --no-rewrite test.zip *.mp3 *.psd
+....
+
+With a specified commit message:
+
+....
+$ git lfs migrate import --no-rewrite \
+ -m "Import test.zip, .mp3, .psd files in root of repo" \
+ test.zip *.mp3 *.psd
+....
+
+=== SEE ALSO
+
+git-lfs-checkout(1), git-lfs-ls-files(1), git-lfs-track(1),
+git-lfs-untrack(1), gitattributes(5), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-pointer.adoc b/docs/man/git-lfs-pointer.adoc
new file mode 100644
index 0000000000..1730bd5dbf
--- /dev/null
+++ b/docs/man/git-lfs-pointer.adoc
@@ -0,0 +1,35 @@
+== git-lfs-pointer(1) -- Build, compare, and check pointers
+
+=== SYNOPSIS
+
+`git lfs pointer --file=path/to/file`
+`git lfs pointer --file=path/to/file --pointer=path/to/pointer`
+`git lfs pointer --file=path/to/file --stdin`
+`git lfs pointer --check --file=path/to/file`
+
+=== Description
+
+Builds and optionally compares generated pointer files to ensure
+consistency between different Git LFS implementations.
+
+=== OPTIONS
+
+* `--file`: A local file to build the pointer from.
+* `--pointer`: A local file including the contents of a pointer
+generated from another implementation. This is compared to the pointer
+generated from `--file`.
+* `--stdin`: Reads the pointer from STDIN to compare with the pointer
+generated from `--file`.
+* `--check`: Reads the pointer from STDIN (if `--stdin` is given) or the
+filepath (if `--file`) is given. If neither or both of `--stdin` and
+`--file` are given, the invocation is invalid. Exits 0 if the data read
+is a valid Git LFS pointer. Exits 1 otherwise.
+* `--strict`:
+* `--no-strict`: In conjunction with `--check`, `--strict` verifies that
+the pointer is canonical; that is, it would be the one created by Git
+LFS. If it is not, exits 2. The default, for backwards compatibility, is
+`--no-strict`, but this may change in a future version.
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-checkout.adoc b/docs/man/git-lfs-post-checkout.adoc
new file mode 100644
index 0000000000..79f3905488
--- /dev/null
+++ b/docs/man/git-lfs-post-checkout.adoc
@@ -0,0 +1,17 @@
+== git-lfs-post-checkout(1) -- Git post-checkout hook implementation
+
+=== SYNOPSIS
+
+`git lfs post-checkout` <rev_before> <ref_after> <is_branch_checkout>
+
+=== DESCRIPTION
+
+Responds to Git post-checkout events. It makes sure that any files which
+are marked as lockable by `git lfs track` are read-only in the working
+copy, if not currently locked by the local user.
+
+=== SEE ALSO
+
+git-lfs-track(1)
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-commit.adoc b/docs/man/git-lfs-post-commit.adoc
new file mode 100644
index 0000000000..50a3bc19ca
--- /dev/null
+++ b/docs/man/git-lfs-post-commit.adoc
@@ -0,0 +1,23 @@
+== git-lfs-post-commit(1) -- Git post-commit hook implementation
+
+=== SYNOPSIS
+
+`git lfs post-commit`
+
+=== DESCRIPTION
+
+Responds to Git post-commit events. It makes sure that any files which
+are marked as lockable by `git lfs track` are read-only in the working
+copy, if not currently locked by the local user.
+
+Where the `git lfs post-merge` command, which has a similar purpose,
+must examine all files in the working copy, `git lfs post-commit` can
+limit itself checking only those files which have changed in `HEAD`. It
+primarily handles newly added lockable files which have not yet been
+made read-only.
+
+=== SEE ALSO
+
+git-lfs-post-merge(1), git-lfs-track(1)
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-merge.adoc b/docs/man/git-lfs-post-merge.adoc
new file mode 100644
index 0000000000..a7d4c37817
--- /dev/null
+++ b/docs/man/git-lfs-post-merge.adoc
@@ -0,0 +1,17 @@
+== git-lfs-post-merge(1) -- Git post-merge hook implementation
+
+=== SYNOPSIS
+
+`git lfs post-merge` <is_squash>
+
+=== DESCRIPTION
+
+Responds to Git post-merge events. It makes sure that any files which
+are marked as lockable by `git lfs track` are read-only in the working
+copy, if not currently locked by the local user.
+
+=== SEE ALSO
+
+git-lfs-track(1)
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-pre-push.adoc b/docs/man/git-lfs-pre-push.adoc
new file mode 100644
index 0000000000..1b838714fe
--- /dev/null
+++ b/docs/man/git-lfs-pre-push.adoc
@@ -0,0 +1,36 @@
+== git-lfs-pre-push(1) -- Git pre-push hook implementation
+
+=== SYNOPSIS
+
+`git lfs pre-push` [remoteurl]
+
+=== DESCRIPTION
+
+Responds to Git pre-hook events. It reads the range of commits from
+STDIN, in the following format:
+
+....
+<local-ref> SP <local-sha1> SP <remote-ref> SP <remote-sha1> \n
+....
+
+It also takes the remote name and URL as arguments.
+
+If any of those Git objects are associated with Git LFS objects, those
+objects will be pushed to the Git LFS API.
+
+In the case of pushing a new branch, the list of Git objects will be all
+of the Git objects in this branch.
+
+In the case of deleting a branch, no attempts to push Git LFS objects
+will be made.
+
+=== OPTIONS
+
+* `GIT_LFS_SKIP_PUSH`: Do nothing on pre-push. For more, see:
+git-lfs-config(5).
+
+=== SEE ALSO
+
+git-lfs-clean(1), git-lfs-push(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-prune.adoc b/docs/man/git-lfs-prune.adoc
new file mode 100644
index 0000000000..e4c3ac0438
--- /dev/null
+++ b/docs/man/git-lfs-prune.adoc
@@ -0,0 +1,135 @@
+== git-lfs-prune(1) -- Delete old LFS files from local storage
+
+=== SYNOPSIS
+
+`git lfs prune` [options]
+
+=== DESCRIPTION
+
+Deletes local copies of LFS files which are old, thus freeing up disk
+space. Prune operates by enumerating all the locally stored objects, and
+then deleting any which are not referenced by at least ONE of the
+following:
+
+* the current checkout
+* all existing stashes
+* a 'recent branch'; see [RECENT FILES]
+* a 'recent commit' on the current branch or recent branches; see
+[RECENT FILES]
+* a commit which has not been pushed; see [UNPUSHED LFS FILES]
+* any other worktree checkouts; see git-worktree(1)
+
+In general terms, prune will delete files you're not currently using and
+which are not 'recent', so long as they've been pushed i.e. the local
+copy is not the only one.
+
+The reflog is not considered, only commits. Therefore LFS objects that
+are only referenced by orphaned commits are always deleted.
+
+Note: you should not run `git lfs prune` if you have different
+repositories sharing the same custom storage directory; see
+git-lfs-config(5) for more details about `lfs.storage` option.
+
+In your Git configuration or in a `.lfsconfig` file, you may set
+`lfs.fetchexclude` to a comma-separated list of paths. If
+`lfs.fetchexclude` is defined, then any Git LFS files whose paths match
+one in that list will be pruned unless they are referenced by a stash or
+an unpushed commit. Paths are matched using wildcard matching as per
+gitignore(5).
+
+=== OPTIONS
+
+* `--dry-run` `-d` Don't actually delete anything, just report on what
+would have been done
+* `--force` `-f` Prune all objects except unpushed objects, including
+objects required for currently checked out refs. Implies `--recent`.
+* `--recent` Prune even objects that would normally be preserved by the
+configuration options specified below in [RECENT FILES].
+* `--verify-remote` `-c` Contact the remote and check that copies of the
+files we would delete definitely exist before deleting. See [VERIFY
+REMOTE].
+* `--no-verify-remote` Disables remote verification if
+lfs.pruneverifyremotealways was enabled in settings. See [VERIFY
+REMOTE].
+* `--verbose` `-v` Report the full detail of what is/would be deleted.
+
+=== RECENT FILES
+
+Prune won't delete LFS files referenced by 'recent' commits, in case you
+want to use them again without having to download. The definition of
+'recent' is derived from the one used by git-lfs-fetch(1) to download
+recent objects with the `--recent` option, with an offset of a number of
+days (default 3) to ensure that we always keep files you download for a
+few days.
+
+Here are the git-config(1) settings that control this behaviour:
+
+* `lfs.pruneoffsetdays` The number of extra days added to the fetch
+recent settings when using them to decide when to prune. So for a
+reference to be considered old enough to prune, it has to be this many
+days older than the oldest reference that would be downloaded via
+`git lfs fetch --recent`. Only used if the relevant fetch recent 'days'
+setting is non-zero. Default 3 days.
+* `lfs.fetchrecentrefsdays` `lfs.fetchrecentremoterefs`
+`lfs.fetchrecentcommitsdays` These have the same meaning as
+git-lfs-fetch(1) with the `--recent` option, they are used as a base for
+the offset above. Anything which falls outside of this offsetted window
+is considered old enough to prune. If a day value is zero, that
+condition is not used at all to retain objects and they will be pruned.
+
+=== UNPUSHED LFS FILES
+
+When the only copy of an LFS file is local, and it is still reachable
+from any reference, that file can never be pruned, regardless of how old
+it is.
+
+To determine whether an LFS file has been pushed, we check the
+difference between local refs and remote refs; where the local ref is
+ahead, any LFS files referenced in those commits is unpushed and will
+not be deleted. This works because the LFS pre-push hook always ensures
+that LFS files are pushed before the remote branch is updated.
+
+See [DEFAULT REMOTE], for which remote is considered 'pushed' for
+pruning purposes.
+
+=== VERIFY REMOTE
+
+The `--verify-remote` option calls the remote to ensure that any LFS
+files to be deleted have copies on the remote before actually deleting
+them.
+
+Usually the check performed by [UNPUSHED LFS FILES] is enough to
+determine that files have been pushed, but if you want to be extra sure
+at the expense of extra overhead you can make prune actually call the
+remote API and verify the presence of the files you're about to delete
+locally. See [DEFAULT REMOTE] for which remote is checked.
+
+You can make this behaviour the default by setting
+`lfs.pruneverifyremotealways` to true.
+
+In addition to the overhead of calling the remote, using this option
+also requires prune to distinguish between totally unreachable files
+(e.g. those that were added to the index but never committed, or
+referenced only by orphaned commits), and files which are still
+referenced, but by commits which are prunable. This makes the prune
+process take longer.
+
+=== DEFAULT REMOTE
+
+When identifying [UNPUSHED LFS FILES] and performing [VERIFY REMOTE], a
+single remote, 'origin', is normally used as the reference. This one
+remote is considered canonical; even if you use multiple remotes, you
+probably want to retain your local copies until they've made it to that
+remote. 'origin' is used by default because that will usually be a main
+central repo, or your fork of it - in both cases that's a valid remote
+backup of your work. If origin doesn't exist then by default nothing
+will be pruned because everything is treated as 'unpushed'.
+
+You can alter the remote via git config: `lfs.pruneremotetocheck`. Set
+this to a different remote name to check that one instead of 'origin'.
+
+=== SEE ALSO
+
+git-lfs-fetch(1), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
new file mode 100644
index 0000000000..bc43c3592f
--- /dev/null
+++ b/docs/man/git-lfs-pull.adoc
@@ -0,0 +1,51 @@
+== git-lfs-pull(1) -- Download all Git LFS files for current ref & checkout
+
+=== SYNOPSIS
+
+`git lfs pull` [options] []
+
+=== DESCRIPTION
+
+Download Git LFS objects for the currently checked out ref, and update
+the working copy with the downloaded content if required.
+
+This is equivalent to running the following 2 commands:
+
+git lfs fetch [options] [] git lfs checkout
+
+=== OPTIONS
+
+* `-I` `--include=`: Specify lfs.fetchinclude just for this invocation;
+see [INCLUDE AND EXCLUDE]
+* `-X` `--exclude=`: Specify lfs.fetchexclude just for this invocation;
+see [INCLUDE AND EXCLUDE]
+
+=== INCLUDE AND EXCLUDE
+
+You can configure Git LFS to only fetch objects to satisfy references in
+certain paths of the repo, and/or to exclude certain paths of the repo,
+to reduce the time you spend downloading things you do not use.
+
+In your Git configuration or in a `.lfsconfig` file, you may set either
+or both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated
+lists of paths. If `lfs.fetchinclude` is defined, Git LFS objects will
+only be fetched if their path matches one in that list, and if
+`lfs.fetchexclude` is defined, Git LFS objects will only be fetched if
+their path does not match one in that list. Paths are matched using
+wildcard matching as per gitignore(5).
+
+Note that using the command-line options `-I` and `-X` override the
+respective configuration settings. Setting either option to an empty
+string clears the value.
+
+=== DEFAULT REMOTE
+
+Without arguments, pull downloads from the default remote. The default
+remote is the same as for `git pull`, i.e. based on the remote branch
+you're tracking first, or origin otherwise.
+
+=== SEE ALSO
+
+git-lfs-fetch(1), git-lfs-checkout(1), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-push.adoc b/docs/man/git-lfs-push.adoc
new file mode 100644
index 0000000000..226b83d6fb
--- /dev/null
+++ b/docs/man/git-lfs-push.adoc
@@ -0,0 +1,34 @@
+== git-lfs-push(1) -- Push queued large files to the Git LFS endpoint
+
+=== SYNOPSIS
+
+`git lfs push` [options] [...] `git lfs push` [...] `git lfs push`
+--object-id [...]
+
+=== DESCRIPTION
+
+Upload Git LFS files to the configured endpoint for the current Git
+remote. By default, it filters out objects that are already referenced
+by the local clone of the remote.
+
+=== OPTIONS
+
+* `--dry-run`: Print the files that would be pushed, without actually
+pushing them.
+* `--all`: This pushes all objects to the remote that are referenced by
+any commit reachable from the refs provided as arguments. If no refs are
+provided, then all local refs are pushed. Note that this behavior
+differs from that of git-lfs-fetch(1) when its `--all` option is used;
+in that case, all refs are fetched, including refs other than those
+under `refs/heads` and `refs/tags`. If you are migrating a repository
+with these commands, make sure to run `git lfs push` for any additional
+remote refs that contain Git LFS objects not reachable from your local
+refs.
+* `--object-id`: This pushes only the object OIDs listed at the end of
+the command, separated by spaces.
+
+=== SEE ALSO
+
+git-lfs-fetch(1), git-lfs-pre-push(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-smudge.adoc b/docs/man/git-lfs-smudge.adoc
new file mode 100644
index 0000000000..76e4fb33b2
--- /dev/null
+++ b/docs/man/git-lfs-smudge.adoc
@@ -0,0 +1,48 @@
+== git-lfs-smudge(1) -- Git smudge filter that converts pointer in blobs to the actual content
+
+=== SYNOPSIS
+
+`git lfs smudge` [] `git lfs smudge` --skip []
+
+=== DESCRIPTION
+
+Read a Git LFS pointer file from standard input and write the contents
+of the corresponding large file to standard output. If needed, download
+the file's contents from the Git LFS endpoint. The argument, if
+provided, is only used for a progress bar.
+
+Smudge is typically run by Git's smudge filter, configured by the
+repository's Git attributes.
+
+In your Git configuration or in a `.lfsconfig` file, you may set either
+or both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated
+lists of paths. If `lfs.fetchinclude` is defined, Git LFS pointer files
+will only be replaced with the contents of the corresponding Git LFS
+object file if their path matches one in that list, and if
+`lfs.fetchexclude` is defined, Git LFS pointer files will only be
+replaced with the contents of the corresponding Git LFS object file if
+their path does not match one in that list. Paths are matched using
+wildcard matching as per gitignore(5). Git LFS pointer files that are
+not replaced with the contents of their corresponding object files are
+simply copied to standard output without change.
+
+=== OPTIONS
+
+Without any options, `git lfs smudge` outputs the raw Git LFS content to
+standard output.
+
+* `--skip`: Skip automatic downloading of objects on clone or pull.
+* `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
+git-lfs-config(5).
+
+=== KNOWN BUGS
+
+On Windows, Git before 2.34.0 does not handle files in the working tree
+larger than 4 gigabytes. Newer versions of Git, as well as Unix
+versions, are unaffected.
+
+=== SEE ALSO
+
+git-lfs-install(1), gitattributes(5), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-standalone-file.adoc b/docs/man/git-lfs-standalone-file.adoc
new file mode 100644
index 0000000000..5e1f4a25e0
--- /dev/null
+++ b/docs/man/git-lfs-standalone-file.adoc
@@ -0,0 +1,21 @@
+== git-lfs-standalone-file(1) -- Standalone transfer adapter for file URLs
+
+=== SYNOPSIS
+
+`git lfs standalone-file`
+
+=== DESCRIPTION
+
+Provides a standalone transfer adapter for file URLs (local paths).
+
+By default, Git LFS requires the support of an HTTP server to implement
+the Git LFS protocol. However, this tool allows the use of URLs starting
+with `file:///` (that is, those representing local paths) in addition.
+Configuration is not necessary; Git LFS handles this internally.
+
+When invoked, this tool speaks JSON on input and output as a standalone
+transfer adapter. It is not intended for use by end users.
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-status.adoc b/docs/man/git-lfs-status.adoc
new file mode 100644
index 0000000000..eef3f4660c
--- /dev/null
+++ b/docs/man/git-lfs-status.adoc
@@ -0,0 +1,29 @@
+== git-lfs-status(1) -- Show the status of Git LFS files in the working tree
+
+=== SYNOPSIS
+
+`git lfs status` []
+
+=== DESCRIPTION
+
+Display paths of Git LFS objects that
+
+* have not been pushed to the Git LFS server. These are large files that
+would be uploaded by `git push`.
+* have differences between the index file and the current HEAD commit.
+These are large files that would be committed by `git commit`.
+* have differences between the working tree and the index file. These
+are files that could be staged using `git add`.
+
+This command must be run in a non-bare repository.
+
+=== OPTIONS
+
+* `--porcelain`: Give the output in an easy-to-parse format for scripts.
+* `--json`: Give the output in a stable json format for scripts.
+
+=== SEE ALSO
+
+git-lfs-ls-files(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-track.adoc b/docs/man/git-lfs-track.adoc
new file mode 100644
index 0000000000..c53b109b4e
--- /dev/null
+++ b/docs/man/git-lfs-track.adoc
@@ -0,0 +1,68 @@
+== git-lfs-track(1) - View or add Git LFS paths to Git attributes
+
+=== SYNOPSIS
+
+`git lfs track` [options] [...]
+
+=== DESCRIPTION
+
+Start tracking the given patterns(s) through Git LFS. The argument is
+written to .gitattributes. If no paths are provided, simply list the
+currently-tracked paths.
+
+The https://git-scm.com/docs/gitattributes[gitattributes documentation]
+states that patterns use the
+https://git-scm.com/docs/gitignore[gitignore pattern rules] to match
+paths. This means that patterns which contain asterisk (`*`), question
+mark (`?`), and the bracket characters (`[` and `]`) are treated
+specially; to disable this behavior and treat them literally instead,
+use `--filename` or escape the character with a backslash.
+
+=== OPTIONS
+
+* `--verbose` `-v`: If enabled, have `git lfs track` log files which it
+will touch. Disabled by default.
+* `--dry-run` `-d`: If enabled, have `git lfs track` log all actions it
+would normally take (adding entries to .gitattributes, touching files on
+disk, etc) without performing any mutative operations to the disk.
++
+`git lfs track --dry-run [files]` also implicitly mocks the behavior of
+passing the `--verbose`, and will log in greater detail what it is
+doing.
++
+Disabled by default.
+* `--filename` Treat the arguments as literal filenames, not as
+patterns. Any special glob characters in the filename will be escaped
+when writing the `.gitattributes` file.
+* `--lockable` `-l` Make the paths 'lockable', meaning they should be
+locked to edit them, and will be made read-only in the working copy when
+not locked.
+* `--not-lockable` Remove the lockable flag from the paths so they are
+no longer read-only unless locked.
+* `--no-excluded` Do not list patterns that are excluded in the output;
+only list patterns that are tracked.
+* `--no-modify-attrs` Makes matched entries stat-dirty so that Git can
+re-index files you wish to convert to LFS. Does not modify any
+`.gitattributes` file(s).
+
+=== EXAMPLES
+
+* List the patterns that Git LFS is currently tracking:
++
+`git lfs track`
+* Configure Git LFS to track GIF files:
++
+`git lfs track "*.gif"`
+* Configure Git LFS to track PSD files and make them read-only unless
+locked:
++
+`git lfs track --lockable "*.psd"`
+* Configure Git LFS to track the file named `project [1].psd`:
++
+`git lfs track --filename "project [1].psd"`
+
+=== SEE ALSO
+
+git-lfs-untrack(1), git-lfs-install(1), gitattributes(5), gitignore(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-uninstall.adoc b/docs/man/git-lfs-uninstall.adoc
new file mode 100644
index 0000000000..80db81ae48
--- /dev/null
+++ b/docs/man/git-lfs-uninstall.adoc
@@ -0,0 +1,38 @@
+== git-lfs-uninstall(1) -- Remove Git LFS configuration
+
+=== SYNOPSIS
+
+`git lfs uninstall`
+
+=== DESCRIPTION
+
+Perform the following actions to remove the Git LFS configuration:
+
+* Remove the "lfs" clean and smudge filters from the global Git config.
+* Uninstall the Git LFS pre-push hook if run from inside a Git
+repository.
+
+=== OPTIONS
+
+* --local: Removes the "lfs" smudge and clean filters from the local
+repository's git config, instead of the global git config
+(~/.gitconfig).
+* --worktree: Removes the "lfs" smudge and clean filters from the
+current working tree's git config, instead of the global git config
+(~/.gitconfig) or local repository's git config ($GIT_DIR/config). If
+multiple working trees are in use, the Git config extension
+`worktreeConfig` must be enabled to use this option. If only one working
+tree is in use, `--worktree` has the same effect as `--local`. This
+option is only available if the installed Git version is at least 2.20.0
+and therefore supports the "worktreeConfig" extension.
+* --system: Removes the "lfs" smudge and clean filters from the system
+git config, instead of the global git config (~/.gitconfig).
+* --skip-repo: Skips cleanup of the local repo; use if you want to
+uninstall the global lfs filters but not make changes to the current
+repo.
+
+=== SEE ALSO
+
+git-lfs-install(1), git-worktree(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
new file mode 100644
index 0000000000..da60f5907c
--- /dev/null
+++ b/docs/man/git-lfs-unlock.adoc
@@ -0,0 +1,29 @@
+== git-lfs-unlock(1) -- Remove "locked" setting for a file on the Git LFS server
+
+=== SYNOPSIS
+
+`git lfs unlock` [OPTIONS]
+
+=== DESCRIPTION
+
+Removes the given file path as "locked" on the Git LFS server. Files
+must exist and have a clean git status before they can be unlocked. The
+`--force` flag will skip these checks.
+
+=== OPTIONS
+
+* `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
+`lfs.url` config key is set.
+* `-f` `--force`: Tells the server to remove the lock, even if it's
+owned by another user.
+* `-i <id>` `--id=<id>`: Specifies a lock by its ID instead of path.
+* `--json`: Writes lock info as JSON to STDOUT if the command exits
+successfully. Intended for interoperation with external tools. If the
+command returns with a non-zero exit code, plain text messages will be
+sent to STDERR.
+
+=== SEE ALSO
+
+git-lfs-lock(1), git-lfs-locks(1).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-untrack.adoc b/docs/man/git-lfs-untrack.adoc
new file mode 100644
index 0000000000..dc72d34a60
--- /dev/null
+++ b/docs/man/git-lfs-untrack.adoc
@@ -0,0 +1,22 @@
+== git-lfs-untrack(1) - Remove Git LFS paths from Git Attributes
+
+=== SYNOPSIS
+
+`git lfs untrack` ...
+
+=== DESCRIPTION
+
+Stop tracking the given path(s) through Git LFS. The argument can be a
+glob pattern or a file path.
+
+=== EXAMPLES
+
+* Configure Git LFS to stop tracking GIF files:
++
+`git lfs untrack "*.gif"`
+
+=== SEE ALSO
+
+git-lfs-track(1), git-lfs-install(1), gitattributes(5).
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-update.adoc b/docs/man/git-lfs-update.adoc
new file mode 100644
index 0000000000..fbf700be95
--- /dev/null
+++ b/docs/man/git-lfs-update.adoc
@@ -0,0 +1,24 @@
+== git-lfs-update(1) -- Update Git hooks
+
+=== SYNOPSIS
+
+`git lfs update` [--manual | --force]
+
+=== DESCRIPTION
+
+Updates the Git hooks used by Git LFS. Silently upgrades known hook
+contents. If you have your own custom hooks you may need to use one of
+the extended options below.
+
+=== OPTIONS
+
+* `--manual` `-m` Print instructions for manually updating your hooks to
+include git-lfs functionality. Use this option if `git lfs update` fails
+because of existing hooks and you want to retain their functionality.
+* `--force` `-f` Forcibly overwrite any existing hooks with git-lfs
+hooks. Use this option if `git lfs update` fails because of existing
+hooks but you don't care about their current contents.
+
+=== SEE ALSO
+
+Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs.adoc b/docs/man/git-lfs.adoc
new file mode 100644
index 0000000000..990149d7d4
--- /dev/null
+++ b/docs/man/git-lfs.adoc
@@ -0,0 +1,106 @@
+== git-lfs(1) -- Work with large files in Git repositories
+
+=== SYNOPSIS
+
+`git lfs` []
+
+=== DESCRIPTION
+
+Git LFS is a system for managing and versioning large files in
+association with a Git repository. Instead of storing the large files
+within the Git repository as blobs, Git LFS stores special "pointer
+files" in the repository, while storing the actual file contents on a
+Git LFS server. The contents of the large file are downloaded
+automatically when needed, for example when a Git branch containing the
+large file is checked out.
+
+Git LFS works by using a "smudge" filter to look up the large file
+contents based on the pointer file, and a "clean" filter to create a new
+version of the pointer file when the large file's contents change. It
+also uses a `pre-push` hook to upload the large file contents to the Git
+LFS server whenever a commit containing a new large file version is
+about to be pushed to the corresponding Git server.
+
+=== COMMANDS
+
+Like Git, Git LFS commands are separated into high level ("porcelain")
+commands and low level ("plumbing") commands.
+
+==== High level porcelain commands
+
+* git-lfs-checkout(1): Populate working copy with real content from Git
+LFS files.
+* git-lfs-dedup(1): De-duplicate Git LFS files.
+* git-lfs-env(1): Display the Git LFS environment.
+* git-lfs-ext(1): Display Git LFS extension details.
+* git-lfs-fetch(1): Download Git LFS files from a remote.
+* git-lfs-fsck(1): Check Git LFS files for consistency.
+* git-lfs-install(1): Install Git LFS configuration.
+* git-lfs-lock(1): Set a file as "locked" on the Git LFS server.
+* git-lfs-locks(1): List currently "locked" files from the Git LFS
+server.
+* git-lfs-logs(1): Show errors from the Git LFS command.
+* git-lfs-ls-files(1): Show information about Git LFS files in the index
+and working tree.
+* git-lfs-migrate(1): Migrate history to or from Git LFS
+* git-lfs-prune(1): Delete old Git LFS files from local storage
+* git-lfs-pull(1): Fetch Git LFS changes from the remote & checkout any
+required working tree files.
+* git-lfs-push(1): Push queued large files to the Git LFS endpoint.
+* git-lfs-status(1): Show the status of Git LFS files in the working
+tree.
+* git-lfs-track(1): View or add Git LFS paths to Git attributes.
+* git-lfs-uninstall(1): Uninstall Git LFS by removing hooks and
+smudge/clean filter configuration.
+* git-lfs-unlock(1): Remove "locked" setting for a file on the Git LFS
+server.
+* git-lfs-untrack(1): Remove Git LFS paths from Git Attributes.
+* git-lfs-update(1): Update Git hooks for the current Git repository.
+* git-lfs-version(1): Report the version number.
+
+==== Low level plumbing commands
+
+* git-lfs-clean(1): Git clean filter that converts large files to
+pointers.
+* git-lfs-filter-process(1): Git process filter that converts between
+large files and pointers.
+* git-lfs-merge-driver(1): Merge text-based LFS files
+* git-lfs-pointer(1): Build and compare pointers.
+* git-lfs-post-checkout(1): Git post-checkout hook implementation.
+* git-lfs-post-commit(1): Git post-commit hook implementation.
+* git-lfs-post-merge(1): Git post-merge hook implementation.
+* git-lfs-pre-push(1): Git pre-push hook implementation.
+* git-lfs-smudge(1): Git smudge filter that converts pointer in blobs to
+the actual content.
+* git-lfs-standalone-file(1): Git LFS standalone transfer adapter for
+file URLs (local paths).
+
+=== EXAMPLES
+
+To get started with Git LFS, the following commands can be used.
+
+. Setup Git LFS on your system. You only have to do this once per
+repository per machine:
++
+....
+git lfs install
+....
+. Choose the type of files you want to track, for examples all `ISO`
+images, with git-lfs-track(1):
++
+....
+git lfs track "*.iso"
+....
+. The above stores this information in gitattributes(5) files, so that
+file needs to be added to the repository:
++
+....
+git add .gitattributes
+....
+. Commit, push and work with the files normally:
++
+....
+git add file.iso
+git commit -m "Add disk image"
+git push
+....

From 849ed67042ce17198e700a08eb976219075de5b3 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 2 Jun 2022 19:51:04 +0000
Subject: [PATCH 02/21] docs/man: fix synopses of AsciiDoc manual pages

In the conversion from Markdown to AsciiDoc, we used pandoc's CommonMark
converter.  That converter treats most entries in angle brackets as HTML
tags, unlike ronn-ng, and therefore eliminates them from our synopses.
Let's restore them back to where they were before so that they make
sense.

At the same time, make sure our synopses contain the required plus signs
if we'd like a hard line break, even if they did not contain one before.
---
 docs/man/git-lfs-checkout.adoc       | 4 ++--
 docs/man/git-lfs-clean.adoc          | 2 +-
 docs/man/git-lfs-clone.adoc          | 2 +-
 docs/man/git-lfs-ext.adoc            | 2 +-
 docs/man/git-lfs-fetch.adoc          | 2 +-
 docs/man/git-lfs-filter-process.adoc | 3 ++-
 docs/man/git-lfs-lock.adoc           | 2 +-
 docs/man/git-lfs-logs.adoc           | 4 +++-
 docs/man/git-lfs-ls-files.adoc       | 3 ++-
 docs/man/git-lfs-migrate.adoc        | 2 +-
 docs/man/git-lfs-pointer.adoc        | 6 +++---
 docs/man/git-lfs-pre-push.adoc       | 2 +-
 docs/man/git-lfs-pull.adoc           | 2 +-
 docs/man/git-lfs-push.adoc           | 5 +++--
 docs/man/git-lfs-smudge.adoc         | 3 ++-
 docs/man/git-lfs-status.adoc         | 2 +-
 docs/man/git-lfs-track.adoc          | 2 +-
 docs/man/git-lfs-unlock.adoc         | 2 +-
 docs/man/git-lfs-untrack.adoc        | 2 +-
 docs/man/git-lfs.adoc                | 2 +-
 20 files changed, 30 insertions(+), 24 deletions(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index e39566bd88..0c9bbc5104 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -2,8 +2,8 @@
 
 === SYNOPSIS
 
-`git lfs checkout` [...] `git lfs checkout` --to
-\{--base|--ours|--theirs}
+`git lfs checkout` [<glob-pattern>...] +
+`git lfs checkout` --to <file> {--base|--ours|--theirs} <conflict-obj-path>
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-clean.adoc b/docs/man/git-lfs-clean.adoc
index 40053a67a2..8d739225d3 100644
--- a/docs/man/git-lfs-clean.adoc
+++ b/docs/man/git-lfs-clean.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs clean`
+`git lfs clean` <path>
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index 549f536dbf..03c82cffa0 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs clone` [git clone options] []
+`git lfs clone` [git clone options] <repository> [<directory>]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-ext.adoc b/docs/man/git-lfs-ext.adoc
index 062bd5db19..5bba831fb8 100644
--- a/docs/man/git-lfs-ext.adoc
+++ b/docs/man/git-lfs-ext.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs ext list` [...]
+`git lfs ext list` [<name>...]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index ceffec6f30..49b19a19c1 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs fetch` [options] [ [...]]
+`git lfs fetch` [options] [<remote> [<ref>...]]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-filter-process.adoc b/docs/man/git-lfs-filter-process.adoc
index cf3af43026..bb7f6c2d1a 100644
--- a/docs/man/git-lfs-filter-process.adoc
+++ b/docs/man/git-lfs-filter-process.adoc
@@ -2,7 +2,8 @@
 
 === SYNOPSIS
 
-`git lfs filter-process` `git lfs filter-process --skip`
+`git lfs filter-process` +
+`git lfs filter-process --skip`
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
index 44b1b52e40..c879c16a09 100644
--- a/docs/man/git-lfs-lock.adoc
+++ b/docs/man/git-lfs-lock.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs lock` [options]
+`git lfs lock` [options] <path>
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-logs.adoc b/docs/man/git-lfs-logs.adoc
index 6fedc59e19..6290fb68f9 100644
--- a/docs/man/git-lfs-logs.adoc
+++ b/docs/man/git-lfs-logs.adoc
@@ -2,7 +2,9 @@
 
 === SYNOPSIS
 
-`git lfs logs` `git lfs logs` `git lfs logs clear`
+`git lfs logs` +
+`git lfs logs` <file> +
+`git lfs logs clear` +
 `git lfs logs boomtown`
 
 === DESCRIPTION
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index 5045d20e1d..d9a44f1ed3 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -2,7 +2,8 @@
 
 === SYNOPSIS
 
-`git lfs ls-files` [] `git lfs ls-files`
+`git lfs ls-files` [<ref>] +
+`git lfs ls-files` <ref> <ref>
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index aad8db2de7..538078ec11 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs migrate` [options] [--] [branch ...]
+`git lfs migrate` <mode> [options] [--] [branch ...]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-pointer.adoc b/docs/man/git-lfs-pointer.adoc
index 1730bd5dbf..d86b86c968 100644
--- a/docs/man/git-lfs-pointer.adoc
+++ b/docs/man/git-lfs-pointer.adoc
@@ -2,9 +2,9 @@
 
 === SYNOPSIS
 
-`git lfs pointer --file=path/to/file`
-`git lfs pointer --file=path/to/file --pointer=path/to/pointer`
-`git lfs pointer --file=path/to/file --stdin`
+`git lfs pointer --file=path/to/file` +
+`git lfs pointer --file=path/to/file --pointer=path/to/pointer` +
+`git lfs pointer --file=path/to/file --stdin` +
 `git lfs pointer --check --file=path/to/file`
 
 === Description
diff --git a/docs/man/git-lfs-pre-push.adoc b/docs/man/git-lfs-pre-push.adoc
index 1b838714fe..12e20178f5 100644
--- a/docs/man/git-lfs-pre-push.adoc
+++ b/docs/man/git-lfs-pre-push.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs pre-push` [remoteurl]
+`git lfs pre-push` <remote> [remoteurl]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index bc43c3592f..b839fd7bfb 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs pull` [options] []
+`git lfs pull` [options] [<remote>]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-push.adoc b/docs/man/git-lfs-push.adoc
index 226b83d6fb..1feadb4964 100644
--- a/docs/man/git-lfs-push.adoc
+++ b/docs/man/git-lfs-push.adoc
@@ -2,8 +2,9 @@
 
 === SYNOPSIS
 
-`git lfs push` [options] [...] `git lfs push` [...] `git lfs push`
---object-id [...]
+`git lfs push` [options] <remote> [<ref>...] +
+`git lfs push` <remote> [<ref>...] +
+`git lfs push` --object-id <remote> [<oid>...]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-smudge.adoc b/docs/man/git-lfs-smudge.adoc
index 76e4fb33b2..572abd2a8f 100644
--- a/docs/man/git-lfs-smudge.adoc
+++ b/docs/man/git-lfs-smudge.adoc
@@ -2,7 +2,8 @@
 
 === SYNOPSIS
 
-`git lfs smudge` [] `git lfs smudge` --skip []
+`git lfs smudge` [<path>] +
+`git lfs smudge` --skip [<path>]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-status.adoc b/docs/man/git-lfs-status.adoc
index eef3f4660c..1d6a97e83c 100644
--- a/docs/man/git-lfs-status.adoc
+++ b/docs/man/git-lfs-status.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs status` []
+`git lfs status` [<options>]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-track.adoc b/docs/man/git-lfs-track.adoc
index c53b109b4e..0734423ca0 100644
--- a/docs/man/git-lfs-track.adoc
+++ b/docs/man/git-lfs-track.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs track` [options] [...]
+`git lfs track` [options] [<pattern>...]
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
index da60f5907c..bc9ecd1904 100644
--- a/docs/man/git-lfs-unlock.adoc
+++ b/docs/man/git-lfs-unlock.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs unlock` [OPTIONS]
+`git lfs unlock` [OPTIONS] <path>
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs-untrack.adoc b/docs/man/git-lfs-untrack.adoc
index dc72d34a60..0cd6f170f1 100644
--- a/docs/man/git-lfs-untrack.adoc
+++ b/docs/man/git-lfs-untrack.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs untrack` ...
+`git lfs untrack` <path>...
 
 === DESCRIPTION
 
diff --git a/docs/man/git-lfs.adoc b/docs/man/git-lfs.adoc
index 990149d7d4..79a9464a3b 100644
--- a/docs/man/git-lfs.adoc
+++ b/docs/man/git-lfs.adoc
@@ -2,7 +2,7 @@
 
 === SYNOPSIS
 
-`git lfs` []
+`git lfs` <command> [<args>]
 
 === DESCRIPTION

From 5c2ca772fbcec25661bccde981567f9b00422545 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 2 Jun 2022 20:08:44 +0000
Subject: [PATCH 03/21] docs/man: fix titles of AsciiDoc man pages

When pandoc did our conversion to AsciiDoc, it was not aware that we
were working with manual pages.  Automatic handling of manual pages with
Asciidoctor requires that the title of the manual page be a top-level,
not a second-level, title, and that the name section be explicitly
specified.

Let's fix our manual pages to meet that standard automatically with the
following shell command.  This has the pleasant side effect of also
normalizing whether we use one or two dashes between the name and the
description to a single dash, which is what the Git manual pages use.

ruby -pi -e '$_.gsub!(/^(=+)=( \S)/, "\\1\\2")' \
  -e '$_.gsub!(/^= (\S+)($\d$) -+ (.*)$/, "= \\1\\2\n\n== NAME\n\n\\1 - \\3")' \
  *.adoc
---
 docs/man/git-lfs-checkout.adoc        | 16 +++++++-----
 docs/man/git-lfs-clean.adoc           | 12 ++++++---
 docs/man/git-lfs-clone.adoc           | 16 +++++++-----
 docs/man/git-lfs-config.adoc          | 30 ++++++++++++----------
 docs/man/git-lfs-dedup.adoc           | 12 ++++++---
 docs/man/git-lfs-env.adoc             | 12 ++++++---
 docs/man/git-lfs-ext.adoc             | 14 +++++++----
 docs/man/git-lfs-fetch.adoc           | 26 +++++++++++--------
 docs/man/git-lfs-filter-process.adoc  | 14 +++++++----
 docs/man/git-lfs-fsck.adoc            | 14 +++++++----
 docs/man/git-lfs-install.adoc         | 14 +++++++----
 docs/man/git-lfs-lock.adoc            | 14 +++++++----
 docs/man/git-lfs-locks.adoc           | 14 +++++++----
 docs/man/git-lfs-logs.adoc            | 16 +++++++-----
 docs/man/git-lfs-ls-files.adoc        | 14 +++++++----
 docs/man/git-lfs-merge-driver.adoc    | 16 +++++++-----
 docs/man/git-lfs-migrate.adoc         | 36 +++++++++++++++------------
 docs/man/git-lfs-pointer.adoc         | 14 +++++++----
 docs/man/git-lfs-post-checkout.adoc   | 12 ++++++---
 docs/man/git-lfs-post-commit.adoc     | 12 ++++++---
 docs/man/git-lfs-post-merge.adoc      | 12 ++++++---
 docs/man/git-lfs-pre-push.adoc        | 14 +++++++----
 docs/man/git-lfs-prune.adoc           | 22 +++++++++-------
 docs/man/git-lfs-pull.adoc            | 18 ++++++++------
 docs/man/git-lfs-push.adoc            | 14 +++++++----
 docs/man/git-lfs-smudge.adoc          | 16 +++++++-----
 docs/man/git-lfs-standalone-file.adoc | 12 ++++++---
 docs/man/git-lfs-status.adoc          | 14 +++++++----
 docs/man/git-lfs-track.adoc           | 16 +++++++-----
 docs/man/git-lfs-uninstall.adoc       | 14 +++++++----
 docs/man/git-lfs-unlock.adoc          | 14 +++++++----
 docs/man/git-lfs-untrack.adoc         | 14 +++++++----
 docs/man/git-lfs-update.adoc          | 14 +++++++----
 docs/man/git-lfs.adoc                 | 18 ++++++++------
 34 files changed, 338 insertions(+), 202 deletions(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index 0c9bbc5104..a0848060de 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -1,11 +1,15 @@
-== git-lfs-checkout(1) -- Update working copy with file content if available
+= git-lfs-checkout(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-checkout - Update working copy with file content if available
+
+== SYNOPSIS
 
 `git lfs checkout` [<glob-pattern>...] +
 `git lfs checkout` --to <file> {--base|--ours|--theirs} <conflict-obj-path>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Try to ensure that the working copy contains file content for Git LFS
 objects for the current ref, if the object data is available. Does not
@@ -27,7 +31,7 @@ Git LFS object into a separate file (which can be outside of the work
 tree). This can make using diff tools to inspect and resolve merges
 easier. A single Git LFS object's file path must be provided in .
 
-=== OPTIONS
+== OPTIONS
 
 * `--base`: Check out the merge base of the specified file.
 * `--ours`: Check out our side (that of the current branch) of the
@@ -38,7 +42,7 @@ conflict for the specified file.
 portion of the conflict specified by `--base`, `--ours`, or `--theirs`
 to the given path.
 
-=== EXAMPLES
+== EXAMPLES
 
 * Checkout all files that are missing or placeholders:
 
@@ -73,7 +77,7 @@ $ git add path/to/conflicting/file.dat
 $ git merge --continue
 ....
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-fetch(1), git-lfs-pull(1), gitignore(5).
 
diff --git a/docs/man/git-lfs-clean.adoc b/docs/man/git-lfs-clean.adoc
index 8d739225d3..4ec326ee0c 100644
--- a/docs/man/git-lfs-clean.adoc
+++ b/docs/man/git-lfs-clean.adoc
@@ -1,10 +1,14 @@
-== git-lfs-clean(1) -- Git clean filter that converts large files to pointers
+= git-lfs-clean(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-clean - Git clean filter that converts large files to pointers
+
+== SYNOPSIS
 
 `git lfs clean` <path>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Read the contents of a large file from standard input, and write a Git
 LFS pointer file for that file to standard output.
@@ -16,7 +20,7 @@ Clean is not part of the user-facing Git plumbing commands. To preview
 the pointer of a large file as it would be generated, see the
 git-lfs-pointer(1) command.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-install(1), git-lfs-push(1), git-lfs-pointer(1),
 gitattributes(5).
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index 03c82cffa0..278f19f8e7 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -1,10 +1,14 @@
-== git-lfs-clone(1) -- Efficiently clone a LFS-enabled repository
+= git-lfs-clone(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-clone - Efficiently clone a LFS-enabled repository
+
+== SYNOPSIS
 
 `git lfs clone` [git clone options] <repository> [<directory>]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Clone an LFS enabled Git repository more efficiently by disabling LFS
 during the git clone, then performing a 'git lfs pull' directly
@@ -19,7 +23,7 @@ content using the smudge filter, which is executed individually per file
 in the working copy. This is relatively inefficient compared to the
 batch mode and parallel downloads performed by 'git lfs pull'.
 
-=== OPTIONS
+== OPTIONS
 
 All options supported by 'git clone'
 
@@ -28,7 +32,7 @@ All options supported by 'git clone'
 * `--skip-repo`: Skip installing repo-level hooks (.git/hooks) that LFS
 requires. Disabled by default.
 
-=== INCLUDE AND EXCLUDE
+== INCLUDE AND EXCLUDE
 
 You can configure Git LFS to only fetch objects to satisfy references in
 certain paths of the repo, and/or to exclude certain paths of the repo,
@@ -46,7 +50,7 @@ Note that using the command-line options `-I` and `-X` override the
 respective configuration settings. Setting either option to an empty
 string clears the value.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-clone(1), git-lfs-pull(1), gitignore(5).
 
diff --git a/docs/man/git-lfs-config.adoc b/docs/man/git-lfs-config.adoc
index da7dee4d49..9036447f23 100644
--- a/docs/man/git-lfs-config.adoc
+++ b/docs/man/git-lfs-config.adoc
@@ -1,6 +1,10 @@
-== git-lfs-config(5) -- Configuration options for git-lfs
+= git-lfs-config(5)
 
-=== CONFIGURATION FILES
+== NAME
+
+git-lfs-config - Configuration options for git-lfs
+
+== CONFIGURATION FILES
 
 git-lfs reads its configuration from any file supported by
 `git config -l`, including all per-repository, per-user, and per-system
@@ -27,9 +31,9 @@ Most options regarding git-lfs are contained in the `[lfs]` section,
 meaning they are all named `lfs.foo` or similar, although occasionally
 an lfs option can be scoped inside the configuration for a remote.
 
-=== LIST OF OPTIONS
+== LIST OF OPTIONS
 
-==== General settings
+=== General settings
 
 * `lfs.url` / `remote.<remote>.lfsurl`
 +
@@ -104,7 +108,7 @@ using Windows (unless smudging is disabled) with a Git for Windows
 version less than 2.34.0 due to a limitation in Git. Default: true if
 the version is less than 2.34.0, false otherwise.
 
-==== Upload and download transfer settings
+=== Upload and download transfer settings
 
 These settings control how the upload and download of LFS content
 occurs.
@@ -195,14 +199,14 @@ If set to true, this enables rewriting href of LFS objects using
 uploading, and `insteadof` is used for downloading and for uploading
 when `pushinsteadof` is not set.
 
-==== Push settings
+=== Push settings
 
 * `lfs.allowincompletepush`
 +
 When pushing, allow objects to be missing from the local cache without
 halting a Git push. Default: false.
 
-==== Fetch settings
+=== Fetch settings
 
 * `lfs.fetchinclude`
 +
@@ -239,7 +243,7 @@ files. The default is 0 (no previous changes).
 Always operate as if --recent was included in a `git lfs fetch` call.
 Default false.
 
-==== Prune settings
+=== Prune settings
 
 * `lfs.pruneoffsetdays`
 +
@@ -256,7 +260,7 @@ called if --verify-remote is enabled.
 +
 Always run `git lfs prune` as if `--verify-remote` was provided.
 
-==== Extensions
+=== Extensions
 
 * `lfs.extension.<name>.<setting>`
 +
@@ -268,7 +272,7 @@ the settings are:
 copy
 ** `priority` The order of this extension compared to others
 
-==== Other settings
+=== Other settings
 
 * `lfs.<url>.access`
 +
@@ -384,7 +388,7 @@ include the TTL in the JSON response but still enforces it.
 Note that this is only necessary for larger repositories hosted on LFS
 servers that don't include the TTL.
 
-=== LFSCONFIG
+== LFSCONFIG
 
 The .lfsconfig file in a repository is read and interpreted in the same
 format as the file stored in .git/config. It allows a subset of keys to
@@ -403,13 +407,13 @@ be used, including and limited to:
 
 The set of keys allowed in this file is restricted for security reasons.
 
-=== EXAMPLES
+== EXAMPLES
 
 * Configure a custom LFS endpoint for your repository:
 
 `git config -f .lfsconfig lfs.url https://lfs.example.com/foo/bar/info/lfs`
 
-=== SEE ALSO
+== SEE ALSO
 
 git-config(1), git-lfs-install(1), gitattributes(5), gitignore(5).
 
diff --git a/docs/man/git-lfs-dedup.adoc b/docs/man/git-lfs-dedup.adoc
index 31146704f3..687d209ea3 100644
--- a/docs/man/git-lfs-dedup.adoc
+++ b/docs/man/git-lfs-dedup.adoc
@@ -1,10 +1,14 @@
-== git-lfs-dedup(1) - Deduplicate Git LFS files
+= git-lfs-dedup(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-dedup - Deduplicate Git LFS files
+
+== SYNOPSIS
 
 `git lfs dedup`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Deduplicates storage by re-creating working tree files as clones of the
 files in the Git LFS storage directory using the operating system's
@@ -19,6 +23,6 @@ contents before they are written to the Git LFS storage directory, and
 therefore the working tree files should not be copy-on-write clones of
 the LFS object files.
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-env.adoc b/docs/man/git-lfs-env.adoc
index 64565fa4a6..97e9b112cd 100644
--- a/docs/man/git-lfs-env.adoc
+++ b/docs/man/git-lfs-env.adoc
@@ -1,13 +1,17 @@
-== git-lfs-env(1) -- Display the Git LFS environment
+= git-lfs-env(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-env - Display the Git LFS environment
+
+== SYNOPSIS
 
 `git lfs env`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Display the current Git LFS environment.
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-ext.adoc b/docs/man/git-lfs-ext.adoc
index 5bba831fb8..6cc2b1b405 100644
--- a/docs/man/git-lfs-ext.adoc
+++ b/docs/man/git-lfs-ext.adoc
@@ -1,15 +1,19 @@
-== git-lfs-ext(1) - View extension details
+= git-lfs-ext(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-ext - View extension details
+
+== SYNOPSIS
 
 `git lfs ext list` [<name>...]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Git LFS extensions enable the manipulation of files streams during
 smudge and clean.
 
-=== EXAMPLES
+== EXAMPLES
 
 * List details for all extensions
 +
@@ -18,6 +22,6 @@ smudge and clean.
 +
 `git lfs ext list 'foo' 'bar'`
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index 49b19a19c1..df101024d8 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -1,10 +1,14 @@
-== git-lfs-fetch(1) -- Download all Git LFS files for a given ref
+= git-lfs-fetch(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-fetch - Download all Git LFS files for a given ref
+
+== SYNOPSIS
 
 `git lfs fetch` [options] [<remote> [<ref>...]]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Download Git LFS objects at the given refs from the specified remote.
 See [DEFAULT REMOTE] and [DEFAULT REFS] for what happens if you don't
@@ -12,7 +16,7 @@ specify.
 
 This does not update the working copy.
 
-=== OPTIONS
+== OPTIONS
 
 * `-I` `--include=`: Specify lfs.fetchinclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
@@ -31,7 +35,7 @@ all objects are downloaded.
 equivalent to running `git lfs prune` afterwards. See git-lfs-prune(1)
 for more details.
 
-=== INCLUDE AND EXCLUDE
+== INCLUDE AND EXCLUDE
 
 You can configure Git LFS to only fetch objects to satisfy references in
 certain paths of the repo, and/or to exclude certain paths of the repo,
@@ -49,7 +53,7 @@ Note that using the command-line options `-I` and `-X` override the
 respective configuration settings. Setting either option to an empty
 string clears the value.
 
-==== Examples
+=== Examples
 
 * `git config lfs.fetchinclude "textures,images/foo*"`
 +
@@ -68,19 +72,19 @@ media/reallybigfiles, but fetch everything else
 Only fetch LFS objects in the 'media' folder, but exclude those in one
 of its subfolders.
 
-=== DEFAULT REMOTE
+== DEFAULT REMOTE
 
 Without arguments, fetch downloads from the default remote. The default
 remote is the same as for `git fetch`, i.e. based on the remote branch
 you're tracking first, or origin otherwise.
 
-=== DEFAULT REFS
+== DEFAULT REFS
 
 If no refs are given as arguments, the currently checked out ref is
 used. In addition, if enabled, recently changed refs and commits are
 also included. See [RECENT CHANGES] for details.
 
-=== RECENT CHANGES
+== RECENT CHANGES
 
 If the `--recent` option is specified, or if the gitconfig option
 `lfs.fetchrecentalways` is true, then after the current ref (or those in
@@ -108,7 +112,7 @@ This is useful if you're often reviewing recent changes. The default is
 * `lfs.fetchrecentalways` Always operate as if --recent was provided on
 the command line.
 
-=== EXAMPLES
+== EXAMPLES
 
 * Fetch the LFS objects for the current ref from default remote
 +
@@ -132,7 +136,7 @@ by any commit in the `main` and `develop` branches
 +
 `git lfs fetch origin main mybranch e445b45c1c9c6282614f201b62778e4c0688b5c8`
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-checkout(1), git-lfs-pull(1), git-lfs-prune(1), gitconfig(5).
 
diff --git a/docs/man/git-lfs-filter-process.adoc b/docs/man/git-lfs-filter-process.adoc
index bb7f6c2d1a..cbfe808f82 100644
--- a/docs/man/git-lfs-filter-process.adoc
+++ b/docs/man/git-lfs-filter-process.adoc
@@ -1,11 +1,15 @@
-== git-lfs-filter-process(1) -- Git filter process that converts between pointer and actual content
+= git-lfs-filter-process(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-filter-process - Git filter process that converts between pointer and actual content
+
+== SYNOPSIS
 
 `git lfs filter-process` +
 `git lfs filter-process --skip`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Implement the Git process filter API, exchanging handshake messages and
 then accepting and responding to requests to either clean or smudge a
@@ -29,7 +33,7 @@ simply copied to standard output without change.
 The filter process uses Git's pkt-line protocol to communicate, and is
 documented in detail in gitattributes(5).
 
-=== OPTIONS
+== OPTIONS
 
 Without any options, filter-process accepts and responds to requests
 normally.
@@ -38,7 +42,7 @@ normally.
 * `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
 git-lfs-config(5).
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-clean(1), git-lfs-install(1), git-lfs-smudge(1),
 gitattributes(5), gitignore(5).
diff --git a/docs/man/git-lfs-fsck.adoc b/docs/man/git-lfs-fsck.adoc
index 75a517b1ec..dd3d9b5128 100644
--- a/docs/man/git-lfs-fsck.adoc
+++ b/docs/man/git-lfs-fsck.adoc
@@ -1,10 +1,14 @@
-== git-lfs-fsck(1) -- Check GIT LFS files for consistency
+= git-lfs-fsck(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-fsck - Check GIT LFS files for consistency
+
+== SYNOPSIS
 
 `git lfs fsck` [options] [revisions]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Checks all Git LFS files in the current HEAD for consistency.
 
@@ -24,14 +28,14 @@ In your Git configuration or in a `.lfsconfig` file, you may set
 one in that list will not be checked for consistency. Paths are matched
 using wildcard matching as per gitignore(5).
 
-=== OPTIONS
+== OPTIONS
 
 * `--objects`: Check that each object in HEAD matches its expected hash
 and that each object exists on disk.
 * `--pointers`: Check that each pointer is canonical and that each file
 which should be stored as a Git LFS file is so stored.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-ls-files(1), git-lfs-status(1), gitignore(5).
 
diff --git a/docs/man/git-lfs-install.adoc b/docs/man/git-lfs-install.adoc
index 913f14a83c..4e2c8804f7 100644
--- a/docs/man/git-lfs-install.adoc
+++ b/docs/man/git-lfs-install.adoc
@@ -1,10 +1,14 @@
-== git-lfs-install(1) -- Install Git LFS configuration.
+= git-lfs-install(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-install - Install Git LFS configuration.
+
+== SYNOPSIS
 
 `git lfs install` [options]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Perform the following actions to ensure that Git LFS is setup properly:
 
@@ -16,7 +20,7 @@ any Git configuration (and supported, i.e., the installed Git version is
 at least 2.9.0), then the pre-push hook will be installed to that
 directory instead.
 
-=== OPTIONS
+== OPTIONS
 
 Without any options, `git lfs install` will only setup the "lfs" smudge
 and clean filters if they are not already set.
@@ -47,7 +51,7 @@ checked out on your repository.
 * `--skip-repo`: Skips setup of the local repo; use if you want to
 install the global lfs filters but not make changes to the current repo.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-uninstall(1), git-worktree(1).
 
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
index c879c16a09..bc88595ec0 100644
--- a/docs/man/git-lfs-lock.adoc
+++ b/docs/man/git-lfs-lock.adoc
@@ -1,10 +1,14 @@
-== git-lfs-lock(1) -- Set a file as "locked" on the Git LFS server
+= git-lfs-lock(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-lock - Set a file as "locked" on the Git LFS server
+
+== SYNOPSIS
 
 `git lfs lock` [options] <path>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Sets the given file path as "locked" against the Git LFS server, with
 the intention of blocking attempts by other users to update the given
@@ -14,7 +18,7 @@ Once locked, LFS will verify that Git pushes do not modify files locked
 by other users. See the description of the `lfs.<url>.locksverify`
 config key in git-lfs-config(5) for details.
 
-=== OPTIONS
+== OPTIONS
 
 * `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
@@ -23,7 +27,7 @@ successfully. Intended for interoperation with external tools. If the
 command returns with a non-zero exit code, plain text messages will be
 sent to STDERR.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-unlock(1), git-lfs-locks(1).
 
diff --git a/docs/man/git-lfs-locks.adoc b/docs/man/git-lfs-locks.adoc
index 9f783e8366..48ed11ada2 100644
--- a/docs/man/git-lfs-locks.adoc
+++ b/docs/man/git-lfs-locks.adoc
@@ -1,14 +1,18 @@
-== git-lfs-locks(1) -- Lists currently locked files from the Git LFS server.
+= git-lfs-locks(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-locks - Lists currently locked files from the Git LFS server.
+
+== SYNOPSIS
 
 `git lfs locks` [options]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Lists current locks from the Git LFS server.
 
-=== OPTIONS
+== OPTIONS
 
 * `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
@@ -37,7 +41,7 @@ successfully. Intended for interoperation with external tools. If the
 command returns with a non-zero exit code, plain text messages will be
 sent to STDERR.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-lock(1), git-lfs-unlock(1).
 
diff --git a/docs/man/git-lfs-logs.adoc b/docs/man/git-lfs-logs.adoc
index 6290fb68f9..8a98b6b374 100644
--- a/docs/man/git-lfs-logs.adoc
+++ b/docs/man/git-lfs-logs.adoc
@@ -1,29 +1,33 @@
-== git-lfs-logs(1) - Show errors from the git-lfs command
+= git-lfs-logs(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-logs - Show errors from the git-lfs command
+
+== SYNOPSIS
 
 `git lfs logs` +
 `git lfs logs` <file> +
 `git lfs logs clear` +
 `git lfs logs boomtown`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Display errors from the git-lfs command. Any time it crashes, the
 details are saved to ".git/lfs/logs".
 
-=== COMMANDS
+== COMMANDS
 
 * `clear`: Clears all of the existing logged errors.
 * `boomtown`: Triggers a dummy exception.
 
-=== OPTIONS
+== OPTIONS
 
 Without any options, `git lfs logs` simply shows the list of error logs.
 
 * : Shows the specified error log. Use "last" to show the most recent
 error.
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index d9a44f1ed3..c7f5a517e5 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -1,11 +1,15 @@
-== git-lfs-ls-files(1) -- Show information about Git LFS files in the index and working tree
+= git-lfs-ls-files(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-ls-files - Show information about Git LFS files in the index and working tree
+
+== SYNOPSIS
 
 `git lfs ls-files` [<ref>] +
 `git lfs ls-files` <ref> <ref>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Display paths of Git LFS files that are found in the tree at the given
 reference. If no reference is given, scan the currently checked-out
@@ -15,7 +19,7 @@ between the two references are shown; deletions are not listed.
 An asterisk (*) after the OID indicates a full object, a minus (-)
 indicates an LFS pointer.
 
-=== OPTIONS
+== OPTIONS
 
 * `-l` `--long`: Show the entire 64 character OID, instead of just first
 10.
@@ -35,7 +39,7 @@ objects that have been deleted.
 [FETCH SETTINGS].
 * `-n` `--name-only`: Show only the lfs tracked file names.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-status(1), git-lfs-config(5).
 
diff --git a/docs/man/git-lfs-merge-driver.adoc b/docs/man/git-lfs-merge-driver.adoc
index 8a1a36490b..12b3c3698d 100644
--- a/docs/man/git-lfs-merge-driver.adoc
+++ b/docs/man/git-lfs-merge-driver.adoc
@@ -1,10 +1,14 @@
-== git-lfs-merge-driver(1) -- Merge text-based LFS files
+= git-lfs-merge-driver(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-merge-driver - Merge text-based LFS files
+
+== SYNOPSIS
 
 `git lfs merge-driver` [options]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Merge text files stored in Git LFS using the default Git merge
 machinery, or a custom merge driver if specified. Note that this, in
@@ -15,7 +19,7 @@ This program is intended to be invoked automatically by Git and not by
 users manually. See [CONFIGURATION] for details on the configuration
 required for that.
 
-=== OPTIONS
+== OPTIONS
 
 * `--ancestor` Specify the file containing the ancestor revision.
 * `--current` Specify the file containing the current revision.
@@ -28,7 +32,7 @@ merge of the file.
 +
 See [CONFIGURATION] for the sequences which are substituted here.
 
-=== CONFIGURATION
+== CONFIGURATION
 
 Git allows the use of a custom merge driver for files based on the
 `merge` attribute set in `.gitattributes`. By default, when using
@@ -80,7 +84,7 @@ attribute (as is the case by default with `merge=lfs`), then the default
 Git merge strategy is used. For LFS files, this means that Git will try
 to merge the pointer files, which usually is not useful.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-merge(1), git-merge-file(1), gitattributes(5)
 
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index 538078ec11..139eafc122 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -1,10 +1,14 @@
-== git-lfs-migrate(1) - Migrate history to or from Git LFS
+= git-lfs-migrate(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-migrate - Migrate history to or from Git LFS
+
+== SYNOPSIS
 
 `git lfs migrate` <mode> [options] [--] [branch ...]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Convert files in a Git repository to or from Git LFS pointers, or
 summarize Git file sizes by file type. The `import` mode converts Git
@@ -109,14 +113,14 @@ by `git remote`, but as noted above, after making changes to your local
 Git history while converting objects, it will never automatically push
 those changes to your remotes.
 
-=== MODES
+== MODES
 
 * `info` Show information about repository size. See [INFO].
 * `import` Convert Git objects to Git LFS pointers. See [IMPORT] and
 [IMPORT WITHOUT REWRITING HISTORY].
 * `export` Convert Git LFS pointers to Git objects. See [EXPORT].
 
-=== OPTIONS
+== OPTIONS
 
 * `-I` `--include=`: See [INCLUDE AND EXCLUDE].
 * `-X` `--exclude=`: See [INCLUDE AND EXCLUDE].
@@ -147,7 +151,7 @@ If any of `--include-ref` or `--exclude-ref` are given, the checked out
 branch will not be appended, but branches given explicitly will be
 appended.
 
-==== INFO
+=== INFO
 
 The `info` mode summarizes the sizes of file objects present in the Git
 history. It supports all the core `migrate` options and these additional
@@ -206,7 +210,7 @@ For example:
 By default only the top five entries are shown, but `--top` allows for
 more or fewer to be output as desired.
 
-==== IMPORT
+=== IMPORT
 
 The `import` mode migrates objects present in the Git history to pointer
 files tracked and stored with Git LFS. It supports all the core
@@ -242,7 +246,7 @@ If `--no-rewrite` is not provided and neither of those flags are given,
 the gitattributes will be incrementally modified to include new filepath
 extensions as they are rewritten in history.
 
-==== IMPORT WITHOUT REWRITING HISTORY
+=== IMPORT WITHOUT REWRITING HISTORY
 
 The `import` mode has a special sub-mode enabled by the `--no-rewrite`
 flag. This sub-mode will migrate objects to pointers as in the base
@@ -266,7 +270,7 @@ If `--message` is given, the new commit will be created with the
 provided message. If no message is given, a commit message will be
 generated based on the file arguments.
 
-==== EXPORT
+=== EXPORT
 
 The `export` mode migrates Git LFS pointer files present in the Git
 history out of Git LFS, converting them into their corresponding object
@@ -288,7 +292,7 @@ matching the `--exclude` patterns will retain their Git LFS status. The
 export command will modify the `.gitattributes` to set/unset any
 filepath patterns as given by those flags.
 
-=== INCLUDE AND EXCLUDE
+== INCLUDE AND EXCLUDE
 
 You can specify that `git lfs migrate` should only convert files whose
 pathspec matches the `--include` glob patterns and does not match the
@@ -308,7 +312,7 @@ among the suite of `git lfs` commands. Other commands which also take
 these options, such as `git lfs ls-files`, use the gitignore(5) form of
 pattern matching instead.
 
-=== INCLUDE AND EXCLUDE REFERENCES
+== INCLUDE AND EXCLUDE REFERENCES
 
 You can specify that `git lfs migrate` should only convert files added
 in commits reachable from certain references, namely those defined using
@@ -346,9 +350,9 @@ commits F, E, D, C, and B, but exclude commit A:
 The presence of flag `--everything` indicates that all local and remote
 references should be migrated.
 
-=== EXAMPLES
+== EXAMPLES
 
-==== Migrate unpushed commits
+=== Migrate unpushed commits
 
 A common use case for the migrate command is to convert large Git
 objects to LFS before pushing your commits. By default, it only scans
@@ -387,7 +391,7 @@ have been replaced with Git LFS pointers, this is normal, and the
 working copies of these files can be repopulated with their full
 expected contents by using `git lfs checkout`.
 
-==== Migrate local history
+=== Migrate local history
 
 You can also migrate the entire history of your repository:
 
@@ -421,7 +425,7 @@ the `--all` option when force-pushing may be convenient if many refs
 were updated, e.g., after importing to Git LFS with the `--everything`
 option.
 
-==== Migrate without rewriting local history
+=== Migrate without rewriting local history
 
 You can also migrate files without modifying the existing history of
 your repository. Note that in the examples below, files in
@@ -442,7 +446,7 @@ $ git lfs migrate import --no-rewrite \
 test.zip *.mp3 *.psd
 ....
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-checkout(1), git-lfs-ls-files(1), git-lfs-track(1),
 git-lfs-untrack(1), gitattributes(5), gitignore(5).
diff --git a/docs/man/git-lfs-pointer.adoc b/docs/man/git-lfs-pointer.adoc
index d86b86c968..e0895ef5e6 100644
--- a/docs/man/git-lfs-pointer.adoc
+++ b/docs/man/git-lfs-pointer.adoc
@@ -1,18 +1,22 @@
-== git-lfs-pointer(1) -- Build, compare, and check pointers
+= git-lfs-pointer(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-pointer - Build, compare, and check pointers
+
+== SYNOPSIS
 
 `git lfs pointer --file=path/to/file` +
 `git lfs pointer --file=path/to/file --pointer=path/to/pointer` +
 `git lfs pointer --file=path/to/file --stdin` +
 `git lfs pointer --check --file=path/to/file`
 
-=== Description
+== Description
 
 Builds and optionally compares generated pointer files to ensure
 consistency between different Git LFS implementations.
 
-=== OPTIONS
+== OPTIONS
 
 * `--file`: A local file to build the pointer from.
 * `--pointer`: A local file including the contents of a pointer
@@ -30,6 +34,6 @@ the pointer is canonical; that is, it would be the one created by Git
 LFS. If it is not, exits 2. The default, for backwards compatibility, is
 `--no-strict`, but this may change in a future version.
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-checkout.adoc b/docs/man/git-lfs-post-checkout.adoc
index 79f3905488..a494be454b 100644
--- a/docs/man/git-lfs-post-checkout.adoc
+++ b/docs/man/git-lfs-post-checkout.adoc
@@ -1,16 +1,20 @@
-== git-lfs-post-checkout(1) -- Git post-checkout hook implementation
+= git-lfs-post-checkout(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-post-checkout - Git post-checkout hook implementation
+
+== SYNOPSIS
 
 `git lfs post-checkout` <rev_before> <ref_after> <is_branch_checkout>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Responds to Git post-checkout events. It makes sure that any files which
 are marked as lockable by `git lfs track` are read-only in the working
 copy, if not currently locked by the local user.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-track(1)
 
diff --git a/docs/man/git-lfs-post-commit.adoc b/docs/man/git-lfs-post-commit.adoc
index 50a3bc19ca..4bdf21f130 100644
--- a/docs/man/git-lfs-post-commit.adoc
+++ b/docs/man/git-lfs-post-commit.adoc
@@ -1,10 +1,14 @@
-== git-lfs-post-commit(1) -- Git post-commit hook implementation
+= git-lfs-post-commit(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-post-commit - Git post-commit hook implementation
+
+== SYNOPSIS
 
 `git lfs post-commit`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Responds to Git post-commit events. It makes sure that any files which
 are marked as lockable by `git lfs track` are read-only in the working
@@ -16,7 +20,7 @@ limit itself checking only those files which have changed in `HEAD`. It
 primarily handles newly added lockable files which have not yet been
 made read-only.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-post-merge(1), git-lfs-track(1)
 
diff --git a/docs/man/git-lfs-post-merge.adoc b/docs/man/git-lfs-post-merge.adoc
index a7d4c37817..297fb9ca81 100644
--- a/docs/man/git-lfs-post-merge.adoc
+++ b/docs/man/git-lfs-post-merge.adoc
@@ -1,16 +1,20 @@
-== git-lfs-post-merge(1) -- Git post-merge hook implementation
+= git-lfs-post-merge(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-post-merge - Git post-merge hook implementation
+
+== SYNOPSIS
 
 `git lfs post-merge` <is_squash>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Responds to Git post-merge events. It makes sure that any files which
 are marked as lockable by `git lfs track` are read-only in the working
 copy, if not currently locked by the local user.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-track(1)
 
diff --git a/docs/man/git-lfs-pre-push.adoc b/docs/man/git-lfs-pre-push.adoc
index 12e20178f5..e5563ef9cf 100644
--- a/docs/man/git-lfs-pre-push.adoc
+++ b/docs/man/git-lfs-pre-push.adoc
@@ -1,10 +1,14 @@
-== git-lfs-pre-push(1) -- Git pre-push hook implementation
+= git-lfs-pre-push(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-pre-push - Git pre-push hook implementation
+
+== SYNOPSIS
 
 `git lfs pre-push` <remote> [remoteurl]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Responds to Git pre-hook events. It reads the range of commits from
 STDIN, in the following format:
@@ -24,12 +28,12 @@ of the Git objects in this branch.
 In the case of deleting a branch, no attempts to push Git LFS objects
 will be made.
 
-=== OPTIONS
+== OPTIONS
 
 * `GIT_LFS_SKIP_PUSH`: Do nothing on pre-push. For more, see:
 git-lfs-config(5).
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-clean(1), git-lfs-push(1).
 
diff --git a/docs/man/git-lfs-prune.adoc b/docs/man/git-lfs-prune.adoc
index e4c3ac0438..0a741c07a0 100644
--- a/docs/man/git-lfs-prune.adoc
+++ b/docs/man/git-lfs-prune.adoc
@@ -1,10 +1,14 @@
-== git-lfs-prune(1) -- Delete old LFS files from local storage
+= git-lfs-prune(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-prune - Delete old LFS files from local storage
+
+== SYNOPSIS
 
 `git lfs prune` [options]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Deletes local copies of LFS files which are old, thus freeing up disk
 space. Prune operates by enumerating all the locally stored objects, and
@@ -37,7 +41,7 @@ one in that list will be pruned unless they are referenced by a stash or
 an unpushed commit. Paths are matched using wildcard matching as per
 gitignore(5).
 
-=== OPTIONS
+== OPTIONS
 
 * `--dry-run` `-d` Don't actually delete anything, just report on what
 would have been done
@@ -53,7 +57,7 @@ lfs.pruneverifyremotealways was enabled in settings. See [VERIFY
 REMOTE].
 * `--verbose` `-v` Report the full detail of what is/would be deleted.
 
-=== RECENT FILES
+== RECENT FILES
 
 Prune won't delete LFS files referenced by 'recent' commits, in case you
 want to use them again without having to download. The definition of
@@ -77,7 +81,7 @@ the offset above. Anything which falls outside of this offsetted window
 is considered old enough to prune. If a day value is zero, that
 condition is not used at all to retain objects and they will be pruned.
 
-=== UNPUSHED LFS FILES
+== UNPUSHED LFS FILES
 
 When the only copy of an LFS file is local, and it is still reachable
 from any reference, that file can never be pruned, regardless of how old
@@ -92,7 +96,7 @@ that LFS files are pushed before the remote branch is updated.
 See [DEFAULT REMOTE], for which remote is considered 'pushed' for
 pruning purposes.
 
-=== VERIFY REMOTE
+== VERIFY REMOTE
 
 The `--verify-remote` option calls the remote to ensure that any LFS
 files to be deleted have copies on the remote before actually deleting
@@ -114,7 +118,7 @@ referenced only by orphaned commits), and files which are still
 referenced, but by commits which are prunable. This makes the prune
 process take longer.
 
-=== DEFAULT REMOTE
+== DEFAULT REMOTE
 
 When identifying [UNPUSHED LFS FILES] and performing [VERIFY REMOTE], a
 single remote, 'origin', is normally used as the reference. This one
@@ -128,7 +132,7 @@ will be pruned because everything is treated as 'unpushed'.
 You can alter the remote via git config: `lfs.pruneremotetocheck`. Set
 this to a different remote name to check that one instead of 'origin'.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-fetch(1), gitignore(5).
 
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index b839fd7bfb..357f0e41b5 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -1,10 +1,14 @@
-== git-lfs-pull(1) -- Download all Git LFS files for current ref & checkout
+= git-lfs-pull(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-pull - Download all Git LFS files for current ref & checkout
+
+== SYNOPSIS
 
 `git lfs pull` [options] [<remote>]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Download Git LFS objects for the currently checked out ref, and update
 the working copy with the downloaded content if required.
@@ -13,14 +17,14 @@ This is equivalent to running the following 2 commands:
 
 git lfs fetch [options] [] git lfs checkout
 
-=== OPTIONS
+== OPTIONS
 
 * `-I` `--include=`: Specify lfs.fetchinclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
 * `-X` `--exclude=`: Specify lfs.fetchexclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
 
-=== INCLUDE AND EXCLUDE
+== INCLUDE AND EXCLUDE
 
 You can configure Git LFS to only fetch objects to satisfy references in
 certain paths of the repo, and/or to exclude certain paths of the repo,
@@ -38,13 +42,13 @@ Note that using the command-line options `-I` and `-X` override the
 respective configuration settings. Setting either option to an empty
 string clears the value.
 
-=== DEFAULT REMOTE
+== DEFAULT REMOTE
 
 Without arguments, pull downloads from the default remote. The default
 remote is the same as for `git pull`, i.e. based on the remote branch
 you're tracking first, or origin otherwise.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-fetch(1), git-lfs-checkout(1), gitignore(5).
 
diff --git a/docs/man/git-lfs-push.adoc b/docs/man/git-lfs-push.adoc
index 1feadb4964..cbc7074609 100644
--- a/docs/man/git-lfs-push.adoc
+++ b/docs/man/git-lfs-push.adoc
@@ -1,18 +1,22 @@
-== git-lfs-push(1) -- Push queued large files to the Git LFS endpoint
+= git-lfs-push(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-push - Push queued large files to the Git LFS endpoint
+
+== SYNOPSIS
 
 `git lfs push` [options] <remote> [<ref>...] +
 `git lfs push` <remote> [<ref>...] +
 `git lfs push` --object-id <remote> [<oid>...]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Upload Git LFS files to the configured endpoint for the current Git
 remote. By default, it filters out objects that are already referenced
 by the local clone of the remote.
 
-=== OPTIONS
+== OPTIONS
 
 * `--dry-run`: Print the files that would be pushed, without actually
 pushing them.
@@ -28,7 +32,7 @@ refs.
 * `--object-id`: This pushes only the object OIDs listed at the end of
 the command, separated by spaces.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-fetch(1), git-lfs-pre-push(1).
 
diff --git a/docs/man/git-lfs-smudge.adoc b/docs/man/git-lfs-smudge.adoc
index 572abd2a8f..25d7d66fdb 100644
--- a/docs/man/git-lfs-smudge.adoc
+++ b/docs/man/git-lfs-smudge.adoc
@@ -1,11 +1,15 @@
-== git-lfs-smudge(1) -- Git smudge filter that converts pointer in blobs to the actual content
+= git-lfs-smudge(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-smudge - Git smudge filter that converts pointer in blobs to the actual content
+
+== SYNOPSIS
 
 `git lfs smudge` [<path>] +
 `git lfs smudge` --skip [<path>]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Read a Git LFS pointer file from standard input and write the contents
 of the corresponding large file to standard output. If needed, download
@@ -27,7 +31,7 @@ wildcard matching as per gitignore(5). Git LFS pointer files that are
 not replaced with the contents of their corresponding object files are
 simply copied to standard output without change.
 
-=== OPTIONS
+== OPTIONS
 
 Without any options, `git lfs smudge` outputs the raw Git LFS content to
 standard output.
@@ -36,13 +40,13 @@ standard output.
 * `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
 git-lfs-config(5).
 
-=== KNOWN BUGS
+== KNOWN BUGS
 
 On Windows, Git before 2.34.0 does not handle files in the working tree
 larger than 4 gigabytes. Newer versions of Git, as well as Unix
 versions, are unaffected.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-install(1), gitattributes(5), gitignore(5).
 
diff --git a/docs/man/git-lfs-standalone-file.adoc b/docs/man/git-lfs-standalone-file.adoc
index 5e1f4a25e0..3557724ada 100644
--- a/docs/man/git-lfs-standalone-file.adoc
+++ b/docs/man/git-lfs-standalone-file.adoc
@@ -1,10 +1,14 @@
-== git-lfs-standalone-file(1) -- Standalone transfer adapter for file URLs
+= git-lfs-standalone-file(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-standalone-file - Standalone transfer adapter for file URLs
+
+== SYNOPSIS
 
 `git lfs standalone-file`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Provides a standalone transfer adapter for file URLs (local paths).
 
@@ -16,6 +20,6 @@ Configuration is not necessary; Git LFS handles this internally.
 When invoked, this tool speaks JSON on input and output as a standalone
 transfer adapter. It is not intended for use by end users.
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-status.adoc b/docs/man/git-lfs-status.adoc
index 1d6a97e83c..62607aa3ee 100644
--- a/docs/man/git-lfs-status.adoc
+++ b/docs/man/git-lfs-status.adoc
@@ -1,10 +1,14 @@
-== git-lfs-status(1) -- Show the status of Git LFS files in the working tree
+= git-lfs-status(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-status - Show the status of Git LFS files in the working tree
+
+== SYNOPSIS
 
 `git lfs status` [<options>]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Display paths of Git LFS objects that
 
@@ -17,12 +21,12 @@ are files that could be staged using `git add`.
 
 This command must be run in a non-bare repository.
 
-=== OPTIONS
+== OPTIONS
 
 * `--porcelain`: Give the output in an easy-to-parse format for scripts.
 * `--json`: Give the output in a stable json format for scripts.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-ls-files(1).
 
diff --git a/docs/man/git-lfs-track.adoc b/docs/man/git-lfs-track.adoc
index 0734423ca0..b02e639e2d 100644
--- a/docs/man/git-lfs-track.adoc
+++ b/docs/man/git-lfs-track.adoc
@@ -1,10 +1,14 @@
-== git-lfs-track(1) - View or add Git LFS paths to Git attributes
+= git-lfs-track(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-track - View or add Git LFS paths to Git attributes
+
+== SYNOPSIS
 
 `git lfs track` [options] [<pattern>...]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Start tracking the given patterns(s) through Git LFS. The argument is
 written to .gitattributes. If no paths are provided, simply list the
@@ -18,7 +22,7 @@ mark (`?`), and the bracket characters (`[` and `]`) are treated
 specially; to disable this behavior and treat them literally instead,
 use `--filename` or escape the character with a backslash.
 
-=== OPTIONS
+== OPTIONS
 
 * `--verbose` `-v`: If enabled, have `git lfs track` log files which it
 will touch. Disabled by default.
@@ -45,7 +49,7 @@ only list patterns that are tracked.
 re-index files you wish to convert to LFS. Does not modify any
 `.gitattributes` file(s).
 
-=== EXAMPLES
+== EXAMPLES
 
 * List the patterns that Git LFS is currently tracking:
 +
@@ -61,7 +65,7 @@ locked:
 +
 `git lfs track --filename "project [1].psd"`
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-untrack(1), git-lfs-install(1), gitattributes(5), gitignore(5).
 
diff --git a/docs/man/git-lfs-uninstall.adoc b/docs/man/git-lfs-uninstall.adoc
index 80db81ae48..0e09720531 100644
--- a/docs/man/git-lfs-uninstall.adoc
+++ b/docs/man/git-lfs-uninstall.adoc
@@ -1,10 +1,14 @@
-== git-lfs-uninstall(1) -- Remove Git LFS configuration
+= git-lfs-uninstall(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-uninstall - Remove Git LFS configuration
+
+== SYNOPSIS
 
 `git lfs uninstall`
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Perform the following actions to remove the Git LFS configuration:
 
@@ -12,7 +16,7 @@ Perform the following actions to remove the Git LFS configuration:
 * Uninstall the Git LFS pre-push hook if run from inside a Git
 repository.
 
-=== OPTIONS
+== OPTIONS
 
 * --local: Removes the "lfs" smudge and clean filters from the local
 repository's git config, instead of the global git config
@@ -31,7 +35,7 @@ git config, instead of the global git config (~/.gitconfig).
 uninstall the global lfs filters but not make changes to the current
 repo.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-install(1), git-worktree(1).
 
diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
index bc9ecd1904..e441f3fa6b 100644
--- a/docs/man/git-lfs-unlock.adoc
+++ b/docs/man/git-lfs-unlock.adoc
@@ -1,16 +1,20 @@
-== git-lfs-unlock(1) -- Remove "locked" setting for a file on the Git LFS server
+= git-lfs-unlock(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-unlock - Remove "locked" setting for a file on the Git LFS server
+
+== SYNOPSIS
 
 `git lfs unlock` [OPTIONS] <path>
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Removes the given file path as "locked" on the Git LFS server. Files
 must exist and have a clean git status before they can be unlocked. The
 `--force` flag will skip these checks.
 
-=== OPTIONS
+== OPTIONS
 
 * `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
@@ -22,7 +26,7 @@ successfully. Intended for interoperation with external tools. If the
 command returns with a non-zero exit code, plain text messages will be
 sent to STDERR.
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-lock(1), git-lfs-locks(1).
 
diff --git a/docs/man/git-lfs-untrack.adoc b/docs/man/git-lfs-untrack.adoc
index 0cd6f170f1..345e3876f6 100644
--- a/docs/man/git-lfs-untrack.adoc
+++ b/docs/man/git-lfs-untrack.adoc
@@ -1,21 +1,25 @@
-== git-lfs-untrack(1) - Remove Git LFS paths from Git Attributes
+= git-lfs-untrack(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-untrack - Remove Git LFS paths from Git Attributes
+
+== SYNOPSIS
 
 `git lfs untrack` <path>...
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Stop tracking the given path(s) through Git LFS. The argument can be a
 glob pattern or a file path.
 
-=== EXAMPLES
+== EXAMPLES
 
 * Configure Git LFS to stop tracking GIF files:
 +
 `git lfs untrack "*.gif"`
 
-=== SEE ALSO
+== SEE ALSO
 
 git-lfs-track(1), git-lfs-install(1), gitattributes(5).
 
diff --git a/docs/man/git-lfs-update.adoc b/docs/man/git-lfs-update.adoc
index fbf700be95..bb77b8a6eb 100644
--- a/docs/man/git-lfs-update.adoc
+++ b/docs/man/git-lfs-update.adoc
@@ -1,16 +1,20 @@
-== git-lfs-update(1) -- Update Git hooks
+= git-lfs-update(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs-update - Update Git hooks
+
+== SYNOPSIS
 
 `git lfs update` [--manual | --force]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Updates the Git hooks used by Git LFS. Silently upgrades known hook
 contents. If you have your own custom hooks you may need to use one of
 the extended options below.
 
-=== OPTIONS
+== OPTIONS
 
 * `--manual` `-m` Print instructions for manually updating your hooks to
 include git-lfs functionality. Use this option if `git lfs update` fails
@@ -19,6 +23,6 @@ because of existing hooks and you want to retain their functionality.
 hooks. Use this option if `git lfs update` fails because of existing
 hooks but you don't care about their current contents.
 
-=== SEE ALSO
+== SEE ALSO
 
 Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs.adoc b/docs/man/git-lfs.adoc
index 79a9464a3b..2ad552380e 100644
--- a/docs/man/git-lfs.adoc
+++ b/docs/man/git-lfs.adoc
@@ -1,10 +1,14 @@
-== git-lfs(1) -- Work with large files in Git repositories
+= git-lfs(1)
 
-=== SYNOPSIS
+== NAME
+
+git-lfs - Work with large files in Git repositories
+
+== SYNOPSIS
 
 `git lfs` <command> [<args>]
 
-=== DESCRIPTION
+== DESCRIPTION
 
 Git LFS is a system for managing and versioning large files in
 association with a Git repository. Instead of storing the large files
@@ -21,12 +25,12 @@ also uses a `pre-push` hook to upload the large file contents to the Git
 LFS server whenever a commit containing a new large file version is
 about to be pushed to the corresponding Git server.
 
-=== COMMANDS
+== COMMANDS
 
 Like Git, Git LFS commands are separated into high level ("porcelain")
 commands and low level ("plumbing") commands.
 
-==== High level porcelain commands
+=== High level porcelain commands
 
 * git-lfs-checkout(1): Populate working copy with real content from Git
 LFS files.
@@ -58,7 +62,7 @@ server.
 * git-lfs-update(1): Update Git hooks for the current Git repository.
 * git-lfs-version(1): Report the version number.
 
-==== Low level plumbing commands
+=== Low level plumbing commands
 
 * git-lfs-clean(1): Git clean filter that converts large files to
 pointers.
@@ -75,7 +79,7 @@ the actual content.
 * git-lfs-standalone-file(1): Git LFS standalone transfer adapter for
 file URLs (local paths).
 
-=== EXAMPLES
+== EXAMPLES
 
 To get started with Git LFS, the following commands can be used.

From ecbfe2057f66635074c124f2cf8cde72e9040e54 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Tue, 7 Jun 2022 20:01:29 +0000
Subject: [PATCH 04/21] docs: turn options into description lists

Because Markdown lacks description lists, ronn converts bulleted lists
with options in them into an appropriate entry in the manual page.
However, AsciiDoc has description lists, so let's convert the values we
got from the ronn source to actual description lists.

Do this with the following one-liner:

ruby -pi -e '$_.gsub!(/^\* `(-.*)`\s+`(-.*)`(.*):(.*)$/, "\\1::\n\\2\\3::\n  \\4")' \
  -e '$_.gsub!(/^\* `(-.*)`(.*):$/, "\\1\\2::")' \
  -e '$_.gsub!(/^\* `(-.*)`(.*):\s+(.*)$/, "\\1\\2::\n  \\3")' \
  -e '$_.gsub!(/^\* (-.*):$/, "\\1\\2::")' \
  -e '$_.gsub!(/^\* (-.*):\s+(.*)$/, "\\1::\n  \\2")' *.adoc
---
 docs/man/git-lfs-checkout.adoc       | 12 +++++++----
 docs/man/git-lfs-clone.adoc          | 11 +++++++---
 docs/man/git-lfs-fetch.adoc          | 18 +++++++++++-----
 docs/man/git-lfs-filter-process.adoc |  3 ++-
 docs/man/git-lfs-fsck.adoc           |  6 ++++--
 docs/man/git-lfs-install.adoc        | 21 ++++++++++++-------
 docs/man/git-lfs-lock.adoc           |  7 +++++--
 docs/man/git-lfs-locks.adoc          | 28 ++++++++++++++++++-------
 docs/man/git-lfs-ls-files.adoc       | 31 +++++++++++++++++++++-------
 docs/man/git-lfs-migrate.adoc        | 23 ++++++++++++++-------
 docs/man/git-lfs-pointer.adoc        | 17 +++++++++------
 docs/man/git-lfs-pull.adoc           |  8 +++++--
 docs/man/git-lfs-push.adoc           |  9 +++++---
 docs/man/git-lfs-smudge.adoc         |  3 ++-
 docs/man/git-lfs-status.adoc         |  6 ++++--
 docs/man/git-lfs-track.adoc          |  8 +++++--
 docs/man/git-lfs-uninstall.adoc      | 12 +++++++----
 docs/man/git-lfs-unlock.adoc         | 15 ++++++++++----
 18 files changed, 167 insertions(+), 71 deletions(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index a0848060de..da149d7460 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -33,12 +33,16 @@ easier. A single Git LFS object's file path must be provided in .
 
 == OPTIONS
 
-* `--base`: Check out the merge base of the specified file.
-* `--ours`: Check out our side (that of the current branch) of the
+--base::
+ Check out the merge base of the specified file.
+--ours::
+ Check out our side (that of the current branch) of the
 conflict for the specified file.
-* `--theirs`: Check out their side (that of the other branch) of the
+--theirs::
+ Check out their side (that of the other branch) of the
 conflict for the specified file.
-* `--to` : If the working tree is in a conflicted state, check out the
+--to ::
+ If the working tree is in a conflicted state, check out the
 portion of the conflict specified by `--base`, `--ours`, or `--theirs`
 to the given path.
 
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index 278f19f8e7..1d1b0d704b 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -27,9 +27,14 @@ batch mode and parallel downloads performed by 'git lfs pull'.
 
 All options supported by 'git clone'
 
-* `-I` `--include=`: See [INCLUDE AND EXCLUDE]
-* `-X` `--exclude=`: See [INCLUDE AND EXCLUDE]
-* `--skip-repo`: Skip installing repo-level hooks (.git/hooks) that LFS
+-I::
+--include=::
+ See [INCLUDE AND EXCLUDE]
+-X::
+--exclude=::
+ See [INCLUDE AND EXCLUDE]
+--skip-repo::
+ Skip installing repo-level hooks (.git/hooks) that LFS
 requires. Disabled by default.
 
 == INCLUDE AND EXCLUDE
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index df101024d8..257398652f 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -18,20 +18,28 @@ This does not update the working copy.
 
 == OPTIONS
 
-* `-I` `--include=`: Specify lfs.fetchinclude just for this invocation;
+-I::
+--include=::
+ Specify lfs.fetchinclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
-* `-X` `--exclude=`: Specify lfs.fetchexclude just for this invocation;
+-X::
+--exclude=::
+ Specify lfs.fetchexclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
-* `--recent`: Download objects referenced by recent branches & commits
+--recent::
+ Download objects referenced by recent branches & commits
 in addition to those that would otherwise be downloaded. See [RECENT
 CHANGES]
-* `--all`: Download all objects that are referenced by any commit
+--all::
+ Download all objects that are referenced by any commit
 reachable from the refs provided as arguments. If no refs are provided,
 then all refs are fetched. This is primarily for backup and migration
 purposes. Cannot be combined with --recent or --include/--exclude.
 Ignores any globally configured include and exclude paths to ensure that
 all objects are downloaded.
-* `--prune` `-p`: Prune old and unreferenced objects after fetching,
+--prune::
+-p::
+ Prune old and unreferenced objects after fetching,
 equivalent to running `git lfs prune` afterwards. See git-lfs-prune(1)
 for more details.
 
diff --git a/docs/man/git-lfs-filter-process.adoc b/docs/man/git-lfs-filter-process.adoc
index cbfe808f82..3d0bb8cafe 100644
--- a/docs/man/git-lfs-filter-process.adoc
+++ b/docs/man/git-lfs-filter-process.adoc
@@ -38,7 +38,8 @@ documented in detail in gitattributes(5).
 Without any options, filter-process accepts and responds to requests
 normally.
 
-* `--skip`: Skip automatic downloading of objects on clone or pull.
+--skip::
+ Skip automatic downloading of objects on clone or pull.
 * `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
 git-lfs-config(5).
 
diff --git a/docs/man/git-lfs-fsck.adoc b/docs/man/git-lfs-fsck.adoc
index dd3d9b5128..6f44c70d16 100644
--- a/docs/man/git-lfs-fsck.adoc
+++ b/docs/man/git-lfs-fsck.adoc
@@ -30,9 +30,11 @@ using wildcard matching as per gitignore(5).
 
 == OPTIONS
 
-* `--objects`: Check that each object in HEAD matches its expected hash
+--objects::
+ Check that each object in HEAD matches its expected hash
 and that each object exists on disk.
-* `--pointers`: Check that each pointer is canonical and that each file
+--pointers::
+ Check that each pointer is canonical and that each file
 which should be stored as a Git LFS file is so stored.
 
 == SEE ALSO
diff --git a/docs/man/git-lfs-install.adoc b/docs/man/git-lfs-install.adoc
index 4e2c8804f7..f1bf80f8d6 100644
--- a/docs/man/git-lfs-install.adoc
+++ b/docs/man/git-lfs-install.adoc
@@ -25,12 +25,15 @@ directory instead.
 Without any options, `git lfs install` will only setup the "lfs" smudge
 and clean filters if they are not already set.
 
-* `--force`: Sets the "lfs" smudge and clean filters, overwriting
+--force::
+ Sets the "lfs" smudge and clean filters, overwriting
 existing values.
-* `--local`: Sets the "lfs" smudge and clean filters in the local
+--local::
+ Sets the "lfs" smudge and clean filters in the local
 repository's git config, instead of the global git config
 (~/.gitconfig).
-* `--worktree`: Sets the "lfs" smudge and clean filters in the current
+--worktree::
+ Sets the "lfs" smudge and clean filters in the current
 working tree's git config, instead of the global git config
 (~/.gitconfig) or local repository's git config ($GIT_DIR/config). If
 multiple working trees are in use, the Git config extension
@@ -38,17 +41,21 @@ multiple working trees are in use, the Git config extension
 tree is in use, `--worktree` has the same effect as `--local`. This
 option is only available if the installed Git version is at least 2.20.0
 and therefore supports the "worktreeConfig" extension.
-* `--manual`: Print instructions for manually updating your hooks to
+--manual::
+ Print instructions for manually updating your hooks to
 include git-lfs functionality. Use this option if `git lfs install`
 fails because of existing hooks and you want to retain their
 functionality.
-* `--system`: Sets the "lfs" smudge and clean filters in the system git
+--system::
+ Sets the "lfs" smudge and clean filters in the system git
 config, e.g. /etc/gitconfig instead of the global git config
 (~/.gitconfig).
-* `--skip-smudge`: Skips automatic downloading of objects on clone or
+--skip-smudge::
+ Skips automatic downloading of objects on clone or
 pull. This requires a manual "git lfs pull" every time a new commit is
 checked out on your repository.
-* `--skip-repo`: Skips setup of the local repo; use if you want to
+--skip-repo::
+ Skips setup of the local repo; use if you want to
 install the global lfs filters but not make changes to the current repo.
 
 == SEE ALSO
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
index bc88595ec0..fb2cc0013d 100644
--- a/docs/man/git-lfs-lock.adoc
+++ b/docs/man/git-lfs-lock.adoc
@@ -20,9 +20,12 @@ config key in git-lfs-config(5) for details.
 
 == OPTIONS
 
-* `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
+-r::
+--remote=::
+ Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
-* `--json`: Writes lock info as JSON to STDOUT if the command exits
+--json::
+ Writes lock info as JSON to STDOUT if the command exits
 successfully. Intended for interoperation with external tools. If the
 command returns with a non-zero exit code, plain text messages will be
 sent to STDERR.
diff --git a/docs/man/git-lfs-locks.adoc b/docs/man/git-lfs-locks.adoc
index 48ed11ada2..47026c8188 100644
--- a/docs/man/git-lfs-locks.adoc
+++ b/docs/man/git-lfs-locks.adoc
@@ -14,20 +14,29 @@ Lists current locks from the Git LFS server.
 
 == OPTIONS
 
-* `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
+-r::
+--remote=::
+ Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
-* `-i <id>` `--id=<id>`: Specifies a lock by its ID. Returns a single
+-i <id>::
+--id=<id>::
+ Specifies a lock by its ID. Returns a single
 result.
-* `-p <path>` `--path=<path>`: Specifies a lock by its path. Returns a
+-p <path>::
+--path=<path>::
+ Specifies a lock by its path. Returns a
 single result.
-* `--local`: Lists only our own locks which are cached locally. Skips a
+--local::
+ Lists only our own locks which are cached locally. Skips a
 remote call.
-* `--cached`: Lists cached locks from the last remote call. Contrary to
+--cached::
+ Lists cached locks from the last remote call. Contrary to
 --local, this will include locks of other users as well. This option is
 intended to display the last known locks in case you are offline. There
 is no guarantee that locks on the server have not changed in the
 meanwhile.
-* `--verify`: Verifies the lock owner on the server and marks our own
+--verify::
+ Verifies the lock owner on the server and marks our own
 locks by 'O'. Own locks are actually held by us and corresponding files
 can be updated for the next push. All other locks are held by someone
 else. Contrary to --local, this option will also detect locks which are
@@ -35,8 +44,11 @@ held by us despite no local lock information being available (e.g.
 because the file had been locked from a different clone); it will also
 detect 'broken' locks (e.g. if someone else has forcefully unlocked our
 files).
-* `-l <num>` `--limit=<num>`: Specifies number of results to return.
-* `--json`: Writes lock info as JSON to STDOUT if the command exits
+-l <num>::
+--limit=<num>::
+ Specifies number of results to return.
+--json::
+ Writes lock info as JSON to STDOUT if the command exits
 successfully. Intended for interoperation with external tools. If the
 command returns with a non-zero exit code, plain text messages will be
 sent to STDERR.
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index c7f5a517e5..322d236c4a 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -21,23 +21,38 @@ indicates an LFS pointer.
 
 == OPTIONS
 
-* `-l` `--long`: Show the entire 64 character OID, instead of just first
+-l::
+--long::
+ Show the entire 64 character OID, instead of just first
 10.
-* `-s` `--size`: Show the size of the LFS object between parenthesis at
+-s::
+--size::
+ Show the size of the LFS object between parenthesis at
 the end of a line.
-* `-d` `--debug`: Show as much information as possible about a LFS file.
+-d::
+--debug::
+ Show as much information as possible about a LFS file.
 This is intended for manual inspection; the exact format may change at
 any time.
-* `-a` `--all`: Inspects the full history of the repository, not the
+-a::
+--all::
+ Inspects the full history of the repository, not the
 current HEAD (or other provided reference). This will include previous
 versions of LFS objects that are no longer found in the current tree.
-* `--deleted`: Shows the full history of the given reference, including
+--deleted::
+ Shows the full history of the given reference, including
 objects that have been deleted.
-* `-I` `--include=`: Include paths matching only these patterns; see
+-I::
+--include=::
+ Include paths matching only these patterns; see
 [FETCH SETTINGS].
-* `-X` `--exclude=`: Exclude paths matching any of these patterns; see
+-X::
+--exclude=::
+ Exclude paths matching any of these patterns; see
 [FETCH SETTINGS].
-* `-n` `--name-only`: Show only the lfs tracked file names.
+-n::
+--name-only::
+ Show only the lfs tracked file names.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index 139eafc122..ffbd4fa27e 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -122,22 +122,31 @@ those changes to your remotes.
 
 == OPTIONS
 
-* `-I` `--include=`: See [INCLUDE AND EXCLUDE].
-* `-X` `--exclude=`: See [INCLUDE AND EXCLUDE].
-* `--include-ref`=: See [INCLUDE AND EXCLUDE REFERENCES].
-* `--exclude-ref`=: See [INCLUDE AND EXCLUDE REFERENCES].
-* `--skip-fetch`: Assumes that the known set of remote references is
+-I::
+--include=::
+ See [INCLUDE AND EXCLUDE].
+-X::
+--exclude=::
+ See [INCLUDE AND EXCLUDE].
+--include-ref=::
+ See [INCLUDE AND EXCLUDE REFERENCES].
+--exclude-ref=::
+ See [INCLUDE AND EXCLUDE REFERENCES].
+--skip-fetch::
+ Assumes that the known set of remote references is
 complete, and should not be refreshed when determining the set of
 "un-pushed" commits to migrate. Has no effect when combined with
 `--include-ref` or `--exclude-ref`.
-* `--everything`: See [INCLUDE AND EXCLUDE REFERENCES].
+--everything::
+ See [INCLUDE AND EXCLUDE REFERENCES].
 +
 Note: Git refs are "case-sensitive" on all platforms in "packed from"
 (see `git-pack-refs(1)`). On "case-insensitive" file systems, e.g. NTFS
 on Windows or default APFS on macOS, `git-lfs-migrate(1)` would only
 migrate the first ref if two or more refs are equal except for
 upper/lower case letters.
-* `--yes`: Assume a yes answer to any prompts, permitting noninteractive
+--yes::
+ Assume a yes answer to any prompts, permitting noninteractive
 use. Currently, the only such prompt is the one asking whether to
 overwrite (destroy) any working copy changes. Thus, specifying this
 option may cause data loss if you are not careful.
diff --git a/docs/man/git-lfs-pointer.adoc b/docs/man/git-lfs-pointer.adoc
index e0895ef5e6..e9bafb3317 100644
--- a/docs/man/git-lfs-pointer.adoc
+++ b/docs/man/git-lfs-pointer.adoc
@@ -18,18 +18,23 @@ consistency between different Git LFS implementations.
 
 == OPTIONS
 
-* `--file`: A local file to build the pointer from.
-* `--pointer`: A local file including the contents of a pointer
+--file::
+ A local file to build the pointer from.
+--pointer::
+ A local file including the contents of a pointer
 generated from another implementation. This is compared to the pointer
 generated from `--file`.
-* `--stdin`: Reads the pointer from STDIN to compare with the pointer
+--stdin::
+ Reads the pointer from STDIN to compare with the pointer
 generated from `--file`.
-* `--check`: Reads the pointer from STDIN (if `--stdin` is given) or the
+--check::
+ Reads the pointer from STDIN (if `--stdin` is given) or the
 filepath (if `--file`) is given. If neither or both of `--stdin` and
 `--file` are given, the invocation is invalid. Exits 0 if the data read
 is a valid Git LFS pointer. Exits 1 otherwise.
-* `--strict`:
-* `--no-strict`: In conjunction with `--check`, `--strict` verifies that
+--strict::
+--no-strict::
+ In conjunction with `--check`, `--strict` verifies that
 the pointer is canonical; that is, it would be the one created by Git
 LFS. If it is not, exits 2. The default, for backwards compatibility, is
 `--no-strict`, but this may change in a future version.
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index 357f0e41b5..2e013a0c82 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -19,9 +19,13 @@ git lfs fetch [options] [] git lfs checkout
 
 == OPTIONS
 
-* `-I` `--include=`: Specify lfs.fetchinclude just for this invocation;
+-I::
+--include=::
+ Specify lfs.fetchinclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
-* `-X` `--exclude=`: Specify lfs.fetchexclude just for this invocation;
+-X::
+--exclude=::
+ Specify lfs.fetchexclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
 
 == INCLUDE AND EXCLUDE
diff --git a/docs/man/git-lfs-push.adoc b/docs/man/git-lfs-push.adoc
index cbc7074609..361361a620 100644
--- a/docs/man/git-lfs-push.adoc
+++ b/docs/man/git-lfs-push.adoc
@@ -18,9 +18,11 @@ by the local clone of the remote.
 
 == OPTIONS
 
-* `--dry-run`: Print the files that would be pushed, without actually
+--dry-run::
+ Print the files that would be pushed, without actually
 pushing them.
-* `--all`: This pushes all objects to the remote that are referenced by
+--all::
+ This pushes all objects to the remote that are referenced by
 any commit reachable from the refs provided as arguments. If no refs are
 provided, then all local refs are pushed. Note that this behavior
 differs from that of git-lfs-fetch(1) when its `--all` option is used;
@@ -29,7 +31,8 @@ under `refs/heads` and `refs/tags`. If you are migrating a repository
 with these commands, make sure to run `git lfs push` for any additional
 remote refs that contain Git LFS objects not reachable from your local
 refs.
-* `--object-id`: This pushes only the object OIDs listed at the end of
+--object-id::
+ This pushes only the object OIDs listed at the end of
 the command, separated by spaces.
 
 == SEE ALSO
diff --git a/docs/man/git-lfs-smudge.adoc b/docs/man/git-lfs-smudge.adoc
index 25d7d66fdb..03c3b5b959 100644
--- a/docs/man/git-lfs-smudge.adoc
+++ b/docs/man/git-lfs-smudge.adoc
@@ -36,7 +36,8 @@ simply copied to standard output without change.
 Without any options, `git lfs smudge` outputs the raw Git LFS content to
 standard output.
 
-* `--skip`: Skip automatic downloading of objects on clone or pull.
+--skip::
+ Skip automatic downloading of objects on clone or pull.
 * `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
 git-lfs-config(5).
 
diff --git a/docs/man/git-lfs-status.adoc b/docs/man/git-lfs-status.adoc
index 62607aa3ee..04d84e6544 100644
--- a/docs/man/git-lfs-status.adoc
+++ b/docs/man/git-lfs-status.adoc
@@ -23,8 +23,10 @@ This command must be run in a non-bare repository.
 
 == OPTIONS
 
-* `--porcelain`: Give the output in an easy-to-parse format for scripts.
-* `--json`: Give the output in a stable json format for scripts.
+--porcelain::
+ Give the output in an easy-to-parse format for scripts.
+--json::
+ Give the output in a stable json format for scripts.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-track.adoc b/docs/man/git-lfs-track.adoc
index b02e639e2d..e5c44af7aa 100644
--- a/docs/man/git-lfs-track.adoc
+++ b/docs/man/git-lfs-track.adoc
@@ -24,9 +24,13 @@ use `--filename` or escape the character with a backslash.
 
 == OPTIONS
 
-* `--verbose` `-v`: If enabled, have `git lfs track` log files which it
+--verbose::
+-v::
+ If enabled, have `git lfs track` log files which it
 will touch. Disabled by default.
-* `--dry-run` `-d`: If enabled, have `git lfs track` log all actions it
+--dry-run::
+-d::
+ If enabled, have `git lfs track` log all actions it
 would normally take (adding entries to .gitattributes, touching files on
 disk, etc) without performing any mutative operations to the disk.
 +
diff --git a/docs/man/git-lfs-uninstall.adoc b/docs/man/git-lfs-uninstall.adoc
index 0e09720531..d12d4349a1 100644
--- a/docs/man/git-lfs-uninstall.adoc
+++ b/docs/man/git-lfs-uninstall.adoc
@@ -18,10 +18,12 @@ repository.
 
 == OPTIONS
 
-* --local: Removes the "lfs" smudge and clean filters from the local
+--local::
+ Removes the "lfs" smudge and clean filters from the local
 repository's git config, instead of the global git config
 (~/.gitconfig).
-* --worktree: Removes the "lfs" smudge and clean filters from the
+--worktree::
+ Removes the "lfs" smudge and clean filters from the
 current working tree's git config, instead of the global git config
 (~/.gitconfig) or local repository's git config ($GIT_DIR/config). If
 multiple working trees are in use, the Git config extension
@@ -29,9 +31,11 @@ multiple working trees are in use, the Git config extension
 tree is in use, `--worktree` has the same effect as `--local`. This
 option is only available if the installed Git version is at least 2.20.0
 and therefore supports the "worktreeConfig" extension.
-* --system: Removes the "lfs" smudge and clean filters from the system
+--system::
+ Removes the "lfs" smudge and clean filters from the system
 git config, instead of the global git config (~/.gitconfig).
-* --skip-repo: Skips cleanup of the local repo; use if you want to
+--skip-repo::
+ Skips cleanup of the local repo; use if you want to
 uninstall the global lfs filters but not make changes to the current
 repo.
 
diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
index e441f3fa6b..366604ae46 100644
--- a/docs/man/git-lfs-unlock.adoc
+++ b/docs/man/git-lfs-unlock.adoc
@@ -16,12 +16,19 @@ must exist and have a clean git status before they can be unlocked. The
 
 == OPTIONS
 
-* `-r` `--remote=`: Specify the Git LFS server to use. Ignored if the
+-r::
+--remote=::
+ Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
-* `-f` `--force`: Tells the server to remove the lock, even if it's
+-f::
+--force::
+ Tells the server to remove the lock, even if it's
 owned by another user.
-* `-i <id>` `--id=<id>`: Specifies a lock by its ID instead of path.
-* `--json`: Writes lock info as JSON to STDOUT if the command exits
+-i <id>::
+--id=<id>::
+ Specifies a lock by its ID instead of path.
+--json::
+ Writes lock info as JSON to STDOUT if the command exits
 successfully. Intended for interoperation with external tools. If the
 command returns with a non-zero exit code, plain text messages will be
 sent to STDERR.

From 96458393331e4fe0cc8daca8166e48e436a64573 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Tue, 21 Jun 2022 16:52:33 +0000
Subject: [PATCH 05/21] doc: switch git-lfs to use definition lists

In the git-lfs manual page, switch the AsciiDoc to use definition lists
instead of the bullets, since ronn converted these automatically into
definition lists.
---
 docs/man/git-lfs.adoc | 110 +++++++++++++++++++++++++-----------------
 1 file changed, 67 insertions(+), 43 deletions(-)

diff --git a/docs/man/git-lfs.adoc b/docs/man/git-lfs.adoc
index 2ad552380e..6e1d049f05 100644
--- a/docs/man/git-lfs.adoc
+++ b/docs/man/git-lfs.adoc
@@ -32,52 +32,76 @@ commands and low level ("plumbing") commands.
 
 === High level porcelain commands
 
-* git-lfs-checkout(1): Populate working copy with real content from Git
-LFS files.
-* git-lfs-dedup(1): De-duplicate Git LFS files.
-* git-lfs-env(1): Display the Git LFS environment.
-* git-lfs-ext(1): Display Git LFS extension details.
-* git-lfs-fetch(1): Download Git LFS files from a remote.
-* git-lfs-fsck(1): Check Git LFS files for consistency.
-* git-lfs-install(1): Install Git LFS configuration.
-* git-lfs-lock(1): Set a file as "locked" on the Git LFS server.
-* git-lfs-locks(1): List currently "locked" files from the Git LFS
-server.
-* git-lfs-logs(1): Show errors from the Git LFS command.
-* git-lfs-ls-files(1): Show information about Git LFS files in the index
-and working tree.
-* git-lfs-migrate(1): Migrate history to or from Git LFS
-* git-lfs-prune(1): Delete old Git LFS files from local storage
-* git-lfs-pull(1): Fetch Git LFS changes from the remote & checkout any
-required working tree files.
-* git-lfs-push(1): Push queued large files to the Git LFS endpoint.
-* git-lfs-status(1): Show the status of Git LFS files in the working
-tree.
-* git-lfs-track(1): View or add Git LFS paths to Git attributes.
-* git-lfs-uninstall(1): Uninstall Git LFS by removing hooks and
-smudge/clean filter configuration.
-* git-lfs-unlock(1): Remove "locked" setting for a file on the Git LFS
-server.
-* git-lfs-untrack(1): Remove Git LFS paths from Git Attributes.
-* git-lfs-update(1): Update Git hooks for the current Git repository.
-* git-lfs-version(1): Report the version number.
+git-lfs-checkout(1)::
+  Populate working copy with real content from Git LFS files.
+git-lfs-dedup(1)::
+  De-duplicate Git LFS files.
+git-lfs-env(1)::
+  Display the Git LFS environment.
+git-lfs-ext(1)::
+  Display Git LFS extension details.
+git-lfs-fetch(1)::
+  Download Git LFS files from a remote.
+git-lfs-fsck(1)::
+  Check Git LFS files for consistency.
+git-lfs-install(1)::
+  Install Git LFS configuration.
+git-lfs-lock(1)::
+  Set a file as "locked" on the Git LFS server.
+git-lfs-locks(1)::
+  List currently "locked" files from the Git LFS server.
+git-lfs-logs(1)::
+  Show errors from the Git LFS command.
+git-lfs-ls-files(1)::
+  Show information about Git LFS files in the index
+  and working tree.
+git-lfs-migrate(1)::
+  Migrate history to or from Git LFS
+git-lfs-prune(1)::
+  Delete old Git LFS files from local storage
+git-lfs-pull(1)::
+  Fetch Git LFS changes from the remote & checkout any required working tree
+  files.
+git-lfs-push(1)::
+  Push queued large files to the Git LFS endpoint.
+git-lfs-status(1)::
+  Show the status of Git LFS files in the working
+  tree.
+git-lfs-track(1)::
+  View or add Git LFS paths to Git attributes.
+git-lfs-uninstall(1)::
+  Uninstall Git LFS by removing hooks and smudge/clean filter configuration.
+git-lfs-unlock(1)::
+  Remove "locked" setting for a file on the Git LFS server.
+git-lfs-untrack(1)::
+  Remove Git LFS paths from Git Attributes.
+git-lfs-update(1)::
+  Update Git hooks for the current Git repository.
+git-lfs-version(1)::
+  Report the version number.
 
 === Low level plumbing commands
 
-* git-lfs-clean(1): Git clean filter that converts large files to
-pointers.
-* git-lfs-filter-process(1): Git process filter that converts between
-large files and pointers.
-* git-lfs-merge-driver(1): Merge text-based LFS files
-* git-lfs-pointer(1): Build and compare pointers.
-* git-lfs-post-checkout(1): Git post-checkout hook implementation.
-* git-lfs-post-commit(1): Git post-commit hook implementation.
-* git-lfs-post-merge(1): Git post-merge hook implementation.
-* git-lfs-pre-push(1): Git pre-push hook implementation.
-* git-lfs-smudge(1): Git smudge filter that converts pointer in blobs to
-the actual content.
-* git-lfs-standalone-file(1): Git LFS standalone transfer adapter for
-file URLs (local paths).
+git-lfs-clean(1)::
+  Git clean filter that converts large files to pointers.
+git-lfs-filter-process(1)::
+  Git process filter that converts between large files and pointers.
+git-lfs-merge-driver(1)::
+  Merge text-based LFS files
+git-lfs-pointer(1)::
+  Build and compare pointers.
+git-lfs-post-checkout(1)::
+  Git post-checkout hook implementation.
+git-lfs-post-commit(1)::
+  Git post-commit hook implementation.
+git-lfs-post-merge(1)::
+  Git post-merge hook implementation.
+git-lfs-pre-push(1)::
+  Git pre-push hook implementation.
+git-lfs-smudge(1)::
+  Git smudge filter that converts pointer in blobs to the actual content.
+git-lfs-standalone-file(1)::
+  Git LFS standalone transfer adapter for file URLs (local paths).
 
 == EXAMPLES

From ea770daf5c16860bd21202006c0b5027b8f539c2 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Tue, 21 Jun 2022 17:53:36 +0000
Subject: [PATCH 06/21] doc: fix excluded parameters in options

When we autoconverted the ronn source to AsciiDoc, we used the
CommonMark converter, since there isn't a ronn-specific one.  However,
that caused some problems because anything in angle brackets was assumed
to be an HTML tag and removed.

Fix all of the options descriptions that had a missing argument by
restoring the argument to what it was before.
---
 docs/man/git-lfs-checkout.adoc |  2 +-
 docs/man/git-lfs-clone.adoc    |  8 ++++----
 docs/man/git-lfs-fetch.adoc    |  4 ++--
 docs/man/git-lfs-lock.adoc     |  4 ++--
 docs/man/git-lfs-locks.adoc    |  4 ++--
 docs/man/git-lfs-ls-files.adoc |  8 ++++----
 docs/man/git-lfs-migrate.adoc  | 12 ++++++------
 docs/man/git-lfs-pull.adoc     |  8 ++++----
 8 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index da149d7460..05847eb6b5 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -41,7 +41,7 @@ conflict for the specified file.
 --theirs::
 Check out their side (that of the other branch) of the
 conflict for the specified file.
---to ::
+--to <path>::
 If the working tree is in a conflicted state, check out the
 portion of the conflict specified by `--base`, `--ours`, or `--theirs`
 to the given path.
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index 1d1b0d704b..096b9251e8 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -27,11 +27,11 @@ batch mode and parallel downloads performed by 'git lfs pull'.
 
 All options supported by 'git clone'
 
--I::
---include=::
+-I <paths>::
+--include=<paths>::
 See [INCLUDE AND EXCLUDE]
--X::
---exclude=::
+-X <paths>::
+--exclude=<paths>::
 See [INCLUDE AND EXCLUDE]
 --skip-repo::
 Skip installing repo-level hooks (.git/hooks) that LFS
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index 257398652f..f214c83a73 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -18,8 +18,8 @@ This does not update the working copy.
 
 == OPTIONS
 
--I::
---include=::
+-I <paths>::
+--include=<paths>::
 Specify lfs.fetchinclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
 -X::
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
index fb2cc0013d..1c7b2a0e4d 100644
--- a/docs/man/git-lfs-lock.adoc
+++ b/docs/man/git-lfs-lock.adoc
@@ -20,8 +20,8 @@ config key in git-lfs-config(5) for details.
 
 == OPTIONS
 
--r::
---remote=::
+-r <name>::
+--remote=<name>::
 Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
 --json::
diff --git a/docs/man/git-lfs-locks.adoc b/docs/man/git-lfs-locks.adoc
index 47026c8188..1dfe61e4b6 100644
--- a/docs/man/git-lfs-locks.adoc
+++ b/docs/man/git-lfs-locks.adoc
@@ -14,8 +14,8 @@ Lists current locks from the Git LFS server.
 
 == OPTIONS
 
--r::
---remote=::
+-r <name>::
+--remote=<name>::
 Specify the Git LFS server to use. Ignored if the
 `lfs.url` config key is set.
 -i <id>::
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index 322d236c4a..2167eff173 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -42,12 +42,12 @@ versions of LFS objects that are no longer found in the current tree.
 --deleted::
 Shows the full history of the given reference, including
 objects that have been deleted.
--I::
---include=::
+-I <paths>::
+--include=<paths>::
 Include paths matching only these patterns; see
 [FETCH SETTINGS].
--X::
---exclude=::
+-X <paths>::
+--exclude=<paths>::
 Exclude paths matching any of these patterns; see
 [FETCH SETTINGS].
 -n::
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index ffbd4fa27e..e49c7bfbc5 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -122,15 +122,15 @@ those changes to your remotes.
 
 == OPTIONS
 
--I::
---include=::
+-I <paths>::
+--include=<paths>::
 See [INCLUDE AND EXCLUDE].
--X::
---exclude=::
+-X <paths>::
+--exclude=<paths>::
 See [INCLUDE AND EXCLUDE].
---include-ref=::
+--include-ref=<refname>::
 See [INCLUDE AND EXCLUDE REFERENCES].
---exclude-ref=::
+--exclude-ref=<refname>::
 See [INCLUDE AND EXCLUDE REFERENCES].
 --skip-fetch::
 Assumes that the known set of remote references is
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index 2e013a0c82..edc5394c82 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -19,12 +19,12 @@ git lfs fetch [options] [] git lfs checkout
 
 == OPTIONS
 
--I::
---include=::
+-I <paths>::
+--include=<paths>::
 Specify lfs.fetchinclude just for this invocation;
 see [INCLUDE AND EXCLUDE]
--X::
---exclude=::
+-X <paths>::
+--exclude=<paths>::
 Specify lfs.fetchexclude just for this invocation;
 see [INCLUDE AND EXCLUDE]

From f9fd1af3d5ae68fd2001f0cbf7f0c79468371557 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Tue, 21 Jun 2022 20:50:59 +0000
Subject: [PATCH 07/21] doc: use consistent indentation in AsciiDoc

While Asciidoctor will accept inconsistent indentation for our
definition lists, this makes it hard to read in the plain text format.
Since the text we embed in the manual pages is the source, it would be
nice to have a consistent indentation for ease of reading by users.
Therefore, indent each of our definition lists such they are properly
indented to two spaces.

For some items which should have been definition lists, but, due to
syntactic anomalies, didn't get converted, convert those to definition
lists and properly indent them as well.
---
 docs/man/git-lfs-checkout.adoc       |   6 +-
 docs/man/git-lfs-clone.adoc          |   2 +-
 docs/man/git-lfs-fetch.adoc          |  64 +++++------
 docs/man/git-lfs-filter-process.adoc |   4 +-
 docs/man/git-lfs-fsck.adoc           |   4 +-
 docs/man/git-lfs-install.adoc        |  45 ++++----
 docs/man/git-lfs-lock.adoc           |  11 +-
 docs/man/git-lfs-locks.adoc          |  43 ++++---
 docs/man/git-lfs-logs.adoc           |   6 +-
 docs/man/git-lfs-ls-files.adoc       |  27 ++---
 docs/man/git-lfs-merge-driver.adoc   |  20 ++--
 docs/man/git-lfs-migrate.adoc        | 160 ++++++++++++++-------------
 docs/man/git-lfs-pointer.adoc        |  25 ++---
 docs/man/git-lfs-prune.adoc          |  33 +++---
 docs/man/git-lfs-pull.adoc           |   6 +-
 docs/man/git-lfs-push.adoc           |  24 ++--
 docs/man/git-lfs-smudge.adoc         |   4 +-
 docs/man/git-lfs-track.adoc          |  40 ++++---
 docs/man/git-lfs-uninstall.adoc      |  29 +++--
 docs/man/git-lfs-unlock.adoc         |  18 ++-
 docs/man/git-lfs-update.adoc         |  16 ++-
 21 files changed, 294 insertions(+), 293 deletions(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index 05847eb6b5..5d94af5dd3 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -37,14 +37,14 @@ easier. A single Git LFS object's file path must be provided in .
 Check out the merge base of the specified file.
 --ours::
 Check out our side (that of the current branch) of the
-conflict for the specified file.
+ conflict for the specified file.
 --theirs::
 Check out their side (that of the other branch) of the
 conflict for the specified file.
 --to <path>::
 If the working tree is in a conflicted state, check out the
-portion of the conflict specified by `--base`, `--ours`, or `--theirs`
-to the given path.
+ portion of the conflict specified by `--base`, `--ours`, or `--theirs`
+ to the given path.
 
 == EXAMPLES
 
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index 096b9251e8..c060b8adb9 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -35,7 +35,7 @@ All options supported by 'git clone'
 See [INCLUDE AND EXCLUDE]
 --skip-repo::
 Skip installing repo-level hooks (.git/hooks) that LFS
-requires. Disabled by default.
+ requires. Disabled by default.
 
 == INCLUDE AND EXCLUDE
 
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index f214c83a73..a0953d0889 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -20,28 +20,23 @@ This does not update the working copy.
 
 -I <paths>::
 --include=<paths>::
- Specify lfs.fetchinclude just for this invocation;
-see [INCLUDE AND EXCLUDE]
--X::
---exclude=::
- Specify lfs.fetchexclude just for this invocation;
-see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchinclude just for this invocation; see [INCLUDE AND EXCLUDE]
+-X <paths>::
+--exclude=<paths>::
+ Specify lfs.fetchexclude just for this invocation; see [INCLUDE AND EXCLUDE]
 --recent::
- Download objects referenced by recent branches & commits
-in addition to those that would otherwise be downloaded. See [RECENT
-CHANGES]
+ Download objects referenced by recent branches & commits in addition to those
+ that would otherwise be downloaded. See [RECENT CHANGES]
 --all::
- Download all objects that are referenced by any commit
-reachable from the refs provided as arguments. If no refs are provided,
-then all refs are fetched. This is primarily for backup and migration
-purposes. Cannot be combined with --recent or --include/--exclude.
-Ignores any globally configured include and exclude paths to ensure that
-all objects are downloaded.
+ Download all objects that are referenced by any commit reachable from the refs
+ provided as arguments. If no refs are provided, then all refs are fetched.
+ This is primarily for backup and migration purposes. Cannot be combined with
+ --recent or --include/--exclude. Ignores any globally configured include and
+ exclude paths to ensure that all objects are downloaded.
 --prune::
 -p::
- Prune old and unreferenced objects after fetching,
-equivalent to running `git lfs prune` afterwards. See git-lfs-prune(1)
-for more details.
+ Prune old and unreferenced objects after fetching, equivalent to running `git
+ lfs prune` afterwards. See git-lfs-prune(1) for more details.
 
 == INCLUDE AND EXCLUDE
 
@@ -103,22 +98,23 @@ commits without incurring further downloads.
 What changes are considered 'recent' is based on a number of gitconfig
 options:
 
-* `lfs.fetchrecentrefsdays` If non-zero, includes branches which have
-commits within N days of the current date. Only local refs are included
-unless lfs.fetchrecentremoterefs is true. The default is 7 days.
-* `lfs.fetchrecentremoterefs` If true, fetches remote refs (for the
-remote you're fetching) as well as local refs in the recent window. This
-is useful to fetch objects for remote branches you might want to check
-out later. The default is true; if you set this to false, fetching for
-those branches will only occur when you either check them out (losing
-the advantage of fetch --recent), or create a tracking local branch
-separately then fetch again.
-* `lfs.fetchrecentcommitsdays` In addition to fetching at branches, also
-fetches changes made within N days of the latest commit on the branch.
-This is useful if you're often reviewing recent changes. The default is
-0 (no previous changes).
-* `lfs.fetchrecentalways` Always operate as if --recent was provided on
-the command line.
+`lfs.fetchrecentrefsdays`::
+ If non-zero, includes branches which have
+ commits within N days of the current date. Only local refs are included
+ unless lfs.fetchrecentremoterefs is true. The default is 7 days.
+`lfs.fetchrecentremoterefs`::
+ If true, fetches remote refs (for the remote you're fetching) as well as local
+ refs in the recent window. This is useful to fetch objects for remote branches
+ you might want to check out later. The default is true; if you set this to
+ false, fetching for those branches will only occur when you either check them
+ out (losing the advantage of fetch --recent), or create a tracking local
+ branch separately then fetch again.
+`lfs.fetchrecentcommitsdays`::
+ In addition to fetching at branches, also fetches changes made within N days
+ of the latest commit on the branch. This is useful if you're often reviewing
+ recent changes. The default is 0 (no previous changes).
+`lfs.fetchrecentalways`::
+ Always operate as if --recent was provided on the command line.
 
 == EXAMPLES
 
diff --git a/docs/man/git-lfs-filter-process.adoc b/docs/man/git-lfs-filter-process.adoc
index 3d0bb8cafe..64c0ccdd10 100644
--- a/docs/man/git-lfs-filter-process.adoc
+++ b/docs/man/git-lfs-filter-process.adoc
@@ -40,8 +40,8 @@ normally.
 
 --skip::
 Skip automatic downloading of objects on clone or pull.
-* `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
-git-lfs-config(5).
+`GIT_LFS_SKIP_SMUDGE`::
+ Disables the smudging process. For more, see: git-lfs-config(5).
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-fsck.adoc b/docs/man/git-lfs-fsck.adoc
index 6f44c70d16..a77cec700b 100644
--- a/docs/man/git-lfs-fsck.adoc
+++ b/docs/man/git-lfs-fsck.adoc
@@ -32,10 +32,10 @@ using wildcard matching as per gitignore(5).
 
 --objects::
 Check that each object in HEAD matches its expected hash
-and that each object exists on disk.
+ and that each object exists on disk.
 --pointers::
 Check that each pointer is canonical and that each file
-which should be stored as a Git LFS file is so stored.
+ which should be stored as a Git LFS file is so stored.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-install.adoc b/docs/man/git-lfs-install.adoc
index f1bf80f8d6..c890c15e7c 100644
--- a/docs/man/git-lfs-install.adoc
+++ b/docs/man/git-lfs-install.adoc
@@ -26,37 +26,32 @@ Without any options, `git lfs install` will only setup the "lfs" smudge
 and clean filters if they are not already set.
 
 --force::
- Sets the "lfs" smudge and clean filters, overwriting
-existing values.
+ Sets the "lfs" smudge and clean filters, overwriting existing values.
 --local::
- Sets the "lfs" smudge and clean filters in the local
-repository's git config, instead of the global git config
-(~/.gitconfig).
+ Sets the "lfs" smudge and clean filters in the local repository's git config,
+ instead of the global git config (~/.gitconfig).
 --worktree::
- Sets the "lfs" smudge and clean filters in the current
-working tree's git config, instead of the global git config
-(~/.gitconfig) or local repository's git config ($GIT_DIR/config). If
-multiple working trees are in use, the Git config extension
-`worktreeConfig` must be enabled to use this option. If only one working
-tree is in use, `--worktree` has the same effect as `--local`. This
-option is only available if the installed Git version is at least 2.20.0
-and therefore supports the "worktreeConfig" extension.
+ Sets the "lfs" smudge and clean filters in the current working tree's git
+ config, instead of the global git config (~/.gitconfig) or local repository's
+ git config ($GIT_DIR/config). If multiple working trees are in use, the Git
+ config extension `worktreeConfig` must be enabled to use this option. If only
+ one working tree is in use, `--worktree` has the same effect as `--local`.
+ This option is only available if the installed Git version is at least 2.20.0
+ and therefore supports the "worktreeConfig" extension.
 --manual::
- Print instructions for manually updating your hooks to
-include git-lfs functionality. Use this option if `git lfs install`
-fails because of existing hooks and you want to retain their
-functionality.
+ Print instructions for manually updating your hooks to include git-lfs
+ functionality. Use this option if `git lfs install` fails because of existing
+ hooks and you want to retain their functionality.
 --system::
- Sets the "lfs" smudge and clean filters in the system git
-config, e.g. /etc/gitconfig instead of the global git config
-(~/.gitconfig).
+ Sets the "lfs" smudge and clean filters in the system git config, e.g.
+ /etc/gitconfig instead of the global git config (~/.gitconfig).
 --skip-smudge::
- Skips automatic downloading of objects on clone or
-pull. This requires a manual "git lfs pull" every time a new commit is
-checked out on your repository.
+ Skips automatic downloading of objects on clone or pull. This requires a
+ manual "git lfs pull" every time a new commit is checked out on your
+ repository.
 --skip-repo::
- Skips setup of the local repo; use if you want to
-install the global lfs filters but not make changes to the current repo.
+ Skips setup of the local repo; use if you want to install the global lfs
+ filters but not make changes to the current repo.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
index 1c7b2a0e4d..f8ba7196ea 100644
--- a/docs/man/git-lfs-lock.adoc
+++ b/docs/man/git-lfs-lock.adoc
@@ -22,13 +22,12 @@ config key in git-lfs-config(5) for details.
 
 -r <name>::
 --remote=<name>::
- Specify the Git LFS server to use. Ignored if the
-`lfs.url` config key is set.
+ Specify the Git LFS server to use. Ignored if the `lfs.url` config key is
+ set.
 --json::
- Writes lock info as JSON to STDOUT if the command exits
-successfully. Intended for interoperation with external tools. If the
-command returns with a non-zero exit code, plain text messages will be
-sent to STDERR.
+ Writes lock info as JSON to STDOUT if the command exits successfully. Intended
+ for interoperation with external tools. If the command returns with a non-zero
+ exit code, plain text messages will be sent to STDERR.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-locks.adoc b/docs/man/git-lfs-locks.adoc
index 1dfe61e4b6..559659d8a1 100644
--- a/docs/man/git-lfs-locks.adoc
+++ b/docs/man/git-lfs-locks.adoc
@@ -16,42 +16,37 @@ Lists current locks from the Git LFS server.
 
 -r <name>::
 --remote=<name>::
- Specify the Git LFS server to use. Ignored if the
-`lfs.url` config key is set.
+ Specify the Git LFS server to use. Ignored if the `lfs.url` config key is
+ set.
 -i <id>::
 --id=<id>::
- Specifies a lock by its ID. Returns a single
-result.
+ Specifies a lock by its ID. Returns a single result.
 -p <path>::
 --path=<path>::
- Specifies a lock by its path. Returns a
-single result.
+ Specifies a lock by its path. Returns a single result.
 --local::
- Lists only our own locks which are cached locally. Skips a
-remote call.
+ Lists only our own locks which are cached locally. Skips a remote call.
 --cached::
- Lists cached locks from the last remote call. Contrary to
---local, this will include locks of other users as well. This option is
-intended to display the last known locks in case you are offline. There
-is no guarantee that locks on the server have not changed in the
+ Lists cached locks from the last remote call. Contrary to `--local`, this will
+ include locks of other users as well. This option is intended to display the
+ last known locks in case you are offline. There is no guarantee that locks on
+ the server have not changed in the
 meanwhile.
 --verify::
- Verifies the lock owner on the server and marks our own
-locks by 'O'. Own locks are actually held by us and corresponding files
-can be updated for the next push. All other locks are held by someone
-else. Contrary to --local, this option will also detect locks which are
-held by us despite no local lock information being available (e.g.
-because the file had been locked from a different clone); it will also
-detect 'broken' locks (e.g. if someone else has forcefully unlocked our
-files).
+ Verifies the lock owner on the server and marks our own locks by 'O'. Own
+ locks are actually held by us and corresponding files can be updated for the
+ next push. All other locks are held by someone else. Contrary to --local, this
+ option will also detect locks which are held by us despite no local lock
+ information being available (e.g. because the file had been locked from a
+ different clone); it will also detect 'broken' locks (e.g. if someone else has
+ forcefully unlocked our files).
 -l <num>::
 --limit=<num>::
 Specifies number of results to return.
 --json::
- Writes lock info as JSON to STDOUT if the command exits
-successfully. Intended for interoperation with external tools. If the
-command returns with a non-zero exit code, plain text messages will be
-sent to STDERR.
+ Writes lock info as JSON to STDOUT if the command exits successfully. Intended
+ for interoperation with external tools. If the command returns with a non-zero
+ exit code, plain text messages will be sent to STDERR.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-logs.adoc b/docs/man/git-lfs-logs.adoc
index 8a98b6b374..6b8e8d8257 100644
--- a/docs/man/git-lfs-logs.adoc
+++ b/docs/man/git-lfs-logs.adoc
@@ -18,8 +18,10 @@ details are saved to ".git/lfs/logs".
 
 == COMMANDS
 
-* `clear`: Clears all of the existing logged errors.
-* `boomtown`: Triggers a dummy exception.
+`clear`::
+ Clears all of the existing logged errors.
+`boomtown`::
+ Triggers a dummy exception.
 
 == OPTIONS
 
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index 2167eff173..598d37e742 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -23,33 +23,28 @@ indicates an LFS pointer.
 
 -l::
 --long::
- Show the entire 64 character OID, instead of just first
-10.
+ Show the entire 64 character OID, instead of just first 10.
 -s::
 --size::
- Show the size of the LFS object between parenthesis at
-the end of a line.
+ Show the size of the LFS object between parenthesis at the end of a line.
 -d::
 --debug::
- Show as much information as possible about a LFS file.
-This is intended for manual inspection; the exact format may change at
-any time.
+ Show as much information as possible about a LFS file. This is intended for
+ manual inspection; the exact format may change at any time.
 -a::
 --all::
- Inspects the full history of the repository, not the
-current HEAD (or other provided reference). This will include previous
-versions of LFS objects that are no longer found in the current tree.
+ Inspects the full history of the repository, not the current HEAD (or other
+ provided reference). This will include previous versions of LFS objects that
+ are no longer found in the current tree.
 --deleted::
- Shows the full history of the given reference, including
-objects that have been deleted.
+ Shows the full history of the given reference, including objects that have
+ been deleted.
 -I <paths>::
 --include=<paths>::
- Include paths matching only these patterns; see
-[FETCH SETTINGS].
+ Include paths matching only these patterns; see [FETCH SETTINGS].
 -X <paths>::
 --exclude=<paths>::
- Exclude paths matching any of these patterns; see
-[FETCH SETTINGS].
+ Exclude paths matching any of these patterns; see [FETCH SETTINGS].
 -n::
 --name-only::
 Show only the lfs tracked file names.
diff --git a/docs/man/git-lfs-merge-driver.adoc b/docs/man/git-lfs-merge-driver.adoc
index 12b3c3698d..de2a12b143 100644
--- a/docs/man/git-lfs-merge-driver.adoc
+++ b/docs/man/git-lfs-merge-driver.adoc
@@ -21,14 +21,18 @@ required for that.
 
 == OPTIONS
 
-* `--ancestor` Specify the file containing the ancestor revision.
-* `--current` Specify the file containing the current revision.
-* `--marker-size` Specify the conflict marker size as an integer.
-* `--other` Specify the file containing the other revision.
-* `--program` Specify a command, which is passed to the shell after
-substitution, that performs the actual merge. If this is not specified,
-`git merge-file` is invoked with appropriate arguments to perform the
-merge of the file.
+--ancestor <path>::
+ Specify the file containing the ancestor revision.
+--current <path>::
+ Specify the file containing the current revision.
+--marker-size <num>::
+ Specify the conflict marker size as an integer.
+--other <path>::
+ Specify the file containing the other revision.
+--program <program>::
+ Specify a command, which is passed to the shell after substitution, that
+ performs the actual merge. If this is not specified, `git merge-file` is
+ invoked with appropriate arguments to perform the merge of the file.
 +
 See [CONFIGURATION] for the sequences which are substituted here.
 
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index e49c7bfbc5..2f55d66269 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -115,10 +115,13 @@ those changes to your remotes.
 
 == MODES
 
-* `info` Show information about repository size. See [INFO].
-* `import` Convert Git objects to Git LFS pointers. See [IMPORT] and
-[IMPORT WITHOUT REWRITING HISTORY].
-* `export` Convert Git LFS pointers to Git objects. See [EXPORT].
+info::
+ Show information about repository size. See [INFO].
+import::
+ Convert Git objects to Git LFS pointers. See [IMPORT] and
+ [IMPORT WITHOUT REWRITING HISTORY].
+export::
+ Convert Git LFS pointers to Git objects. See [EXPORT].
 
 == OPTIONS
 
@@ -133,9 +136,9 @@ those changes to your remotes.
 --exclude-ref=<refname>::
 See [INCLUDE AND EXCLUDE REFERENCES].
 --skip-fetch::
- Assumes that the known set of remote references is
-complete, and should not be refreshed when determining the set of
-"un-pushed" commits to migrate. Has no effect when combined with
+ Assumes that the known set of remote references is complete, and should not be
+ refreshed when determining the set of "un-pushed" commits to migrate. Has no
+ effect when combined with
 `--include-ref` or `--exclude-ref`.
 --everything::
 See [INCLUDE AND EXCLUDE REFERENCES].
@@ -146,12 +149,12 @@ on Windows or default APFS on macOS, `git-lfs-migrate(1)` would only
 migrate the first ref if two or more refs are equal except for
 upper/lower case letters.
 --yes::
- Assume a yes answer to any prompts, permitting noninteractive
-use. Currently, the only such prompt is the one asking whether to
-overwrite (destroy) any working copy changes. Thus, specifying this
-option may cause data loss if you are not careful.
+ Assume a yes answer to any prompts, permitting noninteractive use. Currently,
+ the only such prompt is the one asking whether to overwrite (destroy) any
+ working copy changes. Thus, specifying this option may cause data loss if you
+ are not careful.
 * [branch ...]: Migrate only the set of branches listed. If not given,
-`git-lfs-migrate(1)` will migrate the currently checked out branch.
+ `git-lfs-migrate(1)` will migrate the currently checked out branch.
 +
 References beginning with `^` will be excluded, whereas branches that do
 not begin with `^` will be included.
@@ -166,44 +169,46 @@ The `info` mode summarizes the sizes of file objects present in the Git
 history. It supports all the core `migrate` options and these additional
 ones:
 
-* `--above=<size>` Only count files whose individual filesize is above
-the given size. `size` may be specified as a number of bytes, or a
-number followed by a storage unit, e.g., "1b", "20 MB", "3 TiB", etc.
+--above=<size>::
+ Only count files whose individual filesize is above the given size. `size` may
+ be specified as a number of bytes, or a number followed by a storage unit,
+ e.g., "1b", "20 MB", "3 TiB", etc.
 +
 If a set of files sharing a common extension has no files in that set
 whose individual size is above the given `--above` no files no entry for
 that set will be shown.
-* `--top=<n>` Only display the top `n` entries, ordered by how many
-total files match the given pathspec. The default is to show only the
-top 5 entries. When existing Git LFS objects are found, an extra,
-separate "LFS Objects" line is output in addition to the top `n`
-entries, unless the `--pointers` option is used to change this behavior.
-* `--unit=<unit>` Format the number of bytes in each entry as a quantity
-of the storage unit provided. Valid units include: * b, kib, mib, gib,
-tib, pib - for IEC storage units * b, kb, mb, gb, tb, pb - for SI
-storage units
+--top=<n>::
+ Only display the top `n` entries, ordered by how many total files match the
+ given pathspec. The default is to show only the top 5 entries. When existing
+ Git LFS objects are found, an extra, separate "LFS Objects" line is output in
+ addition to the top `n` entries, unless the `--pointers` option is used to
+ change this behavior.
+--unit=<unit>::
+ Format the number of bytes in each entry as a quantity of the storage unit
+ provided. Valid units include: * b, kib, mib, gib, tib, pib - for IEC storage
+ units * b, kb, mb, gb, tb, pb - for SI storage units
 +
 If a `--unit` is not specified, the largest unit that can fit the number
 of counted bytes as a whole number quantity is chosen.
-* `--pointers=[follow|no-follow|ignore]` Treat existing Git LFS pointers
-in the history according to one of three alternatives. In the default
-`follow` case, if any pointers are found, an additional separate "LFS
-Objects" line item is output which summarizes the total number and size
-of the Git LFS objects referenced by pointers. In the `ignore` case, any
-pointers are simply ignored, while the `no-follow` case replicates the
-behavior of the `info` mode in older Git LFS versions and treats any
-pointers it finds as if they were regular files, so the output totals
-only include the contents of the pointers, not the contents of the
-objects to which they refer.
-* `--fixup` Infer `--include` and `--exclude` filters on a per-commit
-basis based on the `.gitattributes` files in a repository. In practice,
-this option counts any filepaths which should be tracked by Git LFS
-according to the repository's `.gitattributes` file(s), but aren't
-already pointers. The `.gitattributes` files are not reported, in
-contrast to the normal output of the `info` mode. This option is
-incompatible with explicitly given `--include`, `--exclude` filters and
-with any `--pointers` setting other than `ignore`, hence `--fixup`
-implies `--pointers=ignore` if it is not explicitly set.
+--pointers=[follow|no-follow|ignore]::
+ Treat existing Git LFS pointers in the history according to one of three
+ alternatives. In the default `follow` case, if any pointers are found, an
+ additional separate "LFS Objects" line item is output which summarizes the
+ total number and size of the Git LFS objects referenced by pointers. In the
+ `ignore` case, any pointers are simply ignored, while the `no-follow` case
+ replicates the behavior of the `info` mode in older Git LFS versions and
+ treats any pointers it finds as if they were regular files, so the output
+ totals only include the contents of the pointers, not the contents of the
+ objects to which they refer.
+--fixup::
+ Infer `--include` and `--exclude` filters on a per-commit basis based on the
+ `.gitattributes` files in a repository. In practice, this option counts any
+ filepaths which should be tracked by Git LFS according to the repository's
+ `.gitattributes` file(s), but aren't already pointers. The `.gitattributes`
+ files are not reported, in contrast to the normal output of the `info` mode.
+ This option is incompatible with explicitly given `--include`, `--exclude`
+ filters and with any `--pointers` setting other than `ignore`, hence `--fixup`
+ implies `--pointers=ignore` if it is not explicitly set.
 
 The format of the output shows the filename pattern, the total size of
 the file objects (excluding those below the `--above` threshold, if one
@@ -225,27 +230,28 @@ The `import` mode migrates objects present in the Git history to pointer
 files tracked and stored with Git LFS. It supports all the core
 `migrate` options and these additional ones:
 
-* `--verbose` Print the commit oid and filename of migrated files to
-STDOUT.
-* `--above=<size>` Only migrate files whose individual filesize is above
-the given size. `size` may be specified as a number of bytes, or a
-number followed by a storage unit, e.g., "1b", "20 MB", "3 TiB", etc.
-This option cannot be used with the `--include`, `--exclude`, and
-`--fixup` options.
-* `--object-map=<path>` Write to `path` a file with the mapping of each
-rewritten commits. The file format is CSV with this pattern:
-`OLD-SHA`,`NEW-SHA`
-* `--no-rewrite` Migrate objects to Git LFS in a new commit without
-rewriting Git history. Please note that when this option is used, the
-`migrate import` command will expect a different argument list,
-specialized options will become available, and the core `migrate`
-options will be ignored. See [IMPORT WITHOUT REWRITING HISTORY].
-* `--fixup` Infer `--include` and `--exclude` filters on a per-commit
-basis based on the `.gitattributes` files in a repository. In practice,
-this option imports any filepaths which should be tracked by Git LFS
-according to the repository's `.gitattributes` file(s), but aren't
-already pointers. This option is incompatible with explicitly given
-`--include`, `--exclude` filters.
+--verbose::
+ Print the commit oid and filename of migrated files to STDOUT.
+--above=<size>::
+ Only migrate files whose individual filesize is above the given size. `size`
+ may be specified as a number of bytes, or a number followed by a storage unit,
+ e.g., "1b", "20 MB", "3 TiB", etc. This option cannot be used with the
+ `--include`, `--exclude`, and `--fixup` options.
+--object-map=<path>::
+ Write to `path` a file with the mapping of each rewritten commits. The file
+ format is CSV with this pattern: `OLD-SHA`,`NEW-SHA`
+--no-rewrite::
+ Migrate objects to Git LFS in a new commit without rewriting Git history.
+ Please note that when this option is used, the `migrate import` command will
+ expect a different argument list, specialized options will become available,
+ and the core `migrate` options will be ignored. See [IMPORT WITHOUT REWRITING
+ HISTORY].
+--fixup::
+ Infer `--include` and `--exclude` filters on a per-commit basis based on the
+ `.gitattributes` files in a repository. In practice, this option imports any
+ filepaths which should be tracked by Git LFS according to the repository's
+ `.gitattributes` file(s), but aren't already pointers. This option is
+ incompatible with explicitly given `--include`, `--exclude` filters.
 
 If `--no-rewrite` is not provided and `--include` or `--exclude` (`-I`,
 `-X`, respectively) are given, the `.gitattributes` will be modified to
@@ -270,10 +276,12 @@ commit merged in.
 The `--no-rewrite` sub-mode supports the following options and
 arguments:
 
-* `-m <message> --message=<message>` Specifies a commit message for the
-newly created commit.
-* [file ...] The list of files to import. These files must be tracked by
-patterns specified in the gitattributes.
+-m <message>::
+--message=<message>::
+ Specifies a commit message for the newly created commit.
+[file ...]::
+ The list of files to import. These files must be tracked by
+ patterns specified in the gitattributes.
 
 If `--message` is given, the new commit will be created with the
 provided message. If no message is given, a commit message will be
@@ -286,13 +294,15 @@ history out of Git LFS, converting them into their corresponding object
 files. It supports all the core `migrate` options and these additional
 ones:
 
-* `--verbose` Print the commit oid and filename of migrated files to
-STDOUT.
-* `--object-map=<path>` Write to `path` a file with the mapping of each
-rewritten commit. The file format is CSV with this pattern:
-`OLD-SHA`,`NEW-SHA`
-* `--remote=<git-remote>` Download LFS objects from the provided
-`git-remote` during the export. If not provided, defaults to `origin`.
+--verbose::
+ Print the commit oid and filename of migrated files to
+ STDOUT.
+--object-map=<path>::
+ Write to `path` a file with the mapping of each rewritten commit. The file
+ format is CSV with this pattern: `OLD-SHA`,`NEW-SHA`
+--remote=<git-remote>::
+ Download LFS objects from the provided `git-remote` during the export. If not
+ provided, defaults to `origin`.
 
 The `export` mode requires at minimum a pattern provided with the
 `--include` argument to specify which files to export. Files matching
diff --git a/docs/man/git-lfs-pointer.adoc b/docs/man/git-lfs-pointer.adoc
index e9bafb3317..382c7b649a 100644
--- a/docs/man/git-lfs-pointer.adoc
+++ b/docs/man/git-lfs-pointer.adoc
@@ -21,23 +21,22 @@ consistency between different Git LFS implementations.
 --file::
 A local file to build the pointer from.
 --pointer::
- A local file including the contents of a pointer
-generated from another implementation. This is compared to the pointer
-generated from `--file`.
+ A local file including the contents of a pointer generated from another
+ implementation. This is compared to the pointer generated from `--file`.
 --stdin::
- Reads the pointer from STDIN to compare with the pointer
-generated from `--file`.
+ Reads the pointer from STDIN to compare with the pointer generated from
+ `--file`.
 --check::
- Reads the pointer from STDIN (if `--stdin` is given) or the
-filepath (if `--file`) is given. If neither or both of `--stdin` and
-`--file` are given, the invocation is invalid. Exits 0 if the data read
-is a valid Git LFS pointer. Exits 1 otherwise.
+ Reads the pointer from STDIN (if `--stdin` is given) or the filepath (if
+ `--file`) is given. If neither or both of `--stdin` and `--file` are given,
+ the invocation is invalid. Exits 0 if the data read is a valid Git LFS
+ pointer. Exits 1 otherwise.
 --strict::
 --no-strict::
- In conjunction with `--check`, `--strict` verifies that
-the pointer is canonical; that is, it would be the one created by Git
-LFS. If it is not, exits 2. The default, for backwards compatibility, is
-`--no-strict`, but this may change in a future version.
+ In conjunction with `--check`, `--strict` verifies that the pointer is
+ canonical; that is, it would be the one created by Git LFS. If it is not,
+ exits 2. The default, for backwards compatibility, is `--no-strict`, but this
+ may change in a future version.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-prune.adoc b/docs/man/git-lfs-prune.adoc
index 0a741c07a0..37ec942ca9 100644
--- a/docs/man/git-lfs-prune.adoc
+++ b/docs/man/git-lfs-prune.adoc
@@ -43,19 +43,26 @@ gitignore(5).
 
 == OPTIONS
 
-* `--dry-run` `-d` Don't actually delete anything, just report on what
-would have been done
-* `--force` `-f` Prune all objects except unpushed objects, including
-objects required for currently checked out refs. Implies `--recent`.
-* `--recent` Prune even objects that would normally be preserved by the
-configuration options specified below in [RECENT FILES].
-* `--verify-remote` `-c` Contact the remote and check that copies of the
-files we would delete definitely exist before deleting. See [VERIFY
-REMOTE].
-* `--no-verify-remote` Disables remote verification if
-lfs.pruneverifyremotealways was enabled in settings. See [VERIFY
-REMOTE].
-* `--verbose` `-v` Report the full detail of what is/would be deleted.
+--dry-run::
+-d::
+ Don't actually delete anything, just report on what would have been done
+--force::
+-f::
+ Prune all objects except unpushed objects, including objects required for
+ currently checked out refs. Implies `--recent`.
+--recent::
+ Prune even objects that would normally be preserved by the
+ configuration options specified below in [RECENT FILES].
+--verify-remote::
+-c::
+ Contact the remote and check that copies of the files we would delete
+ definitely exist before deleting. See [VERIFY REMOTE].
+--no-verify-remote::
+ Disables remote verification if lfs.pruneverifyremotealways was enabled in
+ settings. See [VERIFY REMOTE].
+--verbose::
+-v::
+ Report the full detail of what is/would be deleted.
 
 == RECENT FILES
 
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index edc5394c82..18c7c28504 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -21,12 +21,10 @@ git lfs fetch [options] [] git lfs checkout
 
 -I <paths>::
 --include=<paths>::
- Specify lfs.fetchinclude just for this invocation;
-see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchinclude just for this invocation; see [INCLUDE AND EXCLUDE]
 -X <paths>::
 --exclude=<paths>::
- Specify lfs.fetchexclude just for this invocation;
-see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchexclude just for this invocation; see [INCLUDE AND EXCLUDE]
 
 == INCLUDE AND EXCLUDE
 
diff --git a/docs/man/git-lfs-push.adoc b/docs/man/git-lfs-push.adoc
index 361361a620..dc1305212a 100644
--- a/docs/man/git-lfs-push.adoc
+++ b/docs/man/git-lfs-push.adoc
@@ -19,21 +19,19 @@ by the local clone of the remote.
 == OPTIONS
 
 --dry-run::
- Print the files that would be pushed, without actually
-pushing them.
+ Print the files that would be pushed, without actually pushing them.
 --all::
- This pushes all objects to the remote that are referenced by
-any commit reachable from the refs provided as arguments. If no refs are
-provided, then all local refs are pushed. Note that this behavior
-differs from that of git-lfs-fetch(1) when its `--all` option is used;
-in that case, all refs are fetched, including refs other than those
-under `refs/heads` and `refs/tags`. If you are migrating a repository
-with these commands, make sure to run `git lfs push` for any additional
-remote refs that contain Git LFS objects not reachable from your local
-refs.
+ This pushes all objects to the remote that are referenced by any commit
+ reachable from the refs provided as arguments. If no refs are provided, then
+ all local refs are pushed. Note that this behavior differs from that of
+ git-lfs-fetch(1) when its `--all` option is used; in that case, all refs are
+ fetched, including refs other than those under `refs/heads` and `refs/tags`.
+ If you are migrating a repository with these commands, make sure to run `git
+ lfs push` for any additional remote refs that contain Git LFS objects not
+ reachable from your local refs.
 --object-id::
- This pushes only the object OIDs listed at the end of
-the command, separated by spaces.
+ This pushes only the object OIDs listed at the end of the command, separated
+ by spaces.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-smudge.adoc b/docs/man/git-lfs-smudge.adoc
index 03c3b5b959..f79002b123 100644
--- a/docs/man/git-lfs-smudge.adoc
+++ b/docs/man/git-lfs-smudge.adoc
@@ -38,8 +38,8 @@ standard output.
 
 --skip::
 Skip automatic downloading of objects on clone or pull.
-* `GIT_LFS_SKIP_SMUDGE`: Disables the smudging process. For more, see:
-git-lfs-config(5).
+`GIT_LFS_SKIP_SMUDGE`::
+ Disables the smudging process. For more, see: git-lfs-config(5).
 
 == KNOWN BUGS
 
diff --git a/docs/man/git-lfs-track.adoc b/docs/man/git-lfs-track.adoc
index e5c44af7aa..abee3e778e 100644
--- a/docs/man/git-lfs-track.adoc
+++ b/docs/man/git-lfs-track.adoc
@@ -26,32 +26,36 @@ use `--filename` or escape the character with a backslash.
 
 --verbose::
 -v::
- If enabled, have `git lfs track` log files which it
-will touch. Disabled by default.
+ If enabled, have `git lfs track` log files which it will touch. Disabled by
+ default.
 --dry-run::
 -d::
- If enabled, have `git lfs track` log all actions it
-would normally take (adding entries to .gitattributes, touching files on
-disk, etc) without performing any mutative operations to the disk.
+ If enabled, have `git lfs track` log all actions it would normally take
+ (adding entries to .gitattributes, touching files on disk, etc) without
+ performing any mutative operations to the disk.
 +
 `git lfs track --dry-run [files]` also implicitly mocks the behavior of
 passing the `--verbose`, and will log in greater detail what it is
 doing.
 +
 Disabled by default.
-* `--filename` Treat the arguments as literal filenames, not as
-patterns. Any special glob characters in the filename will be escaped
-when writing the `.gitattributes` file.
-* `--lockable` `-l` Make the paths 'lockable', meaning they should be
-locked to edit them, and will be made read-only in the working copy when
-not locked.
-* `--not-lockable` Remove the lockable flag from the paths so they are
-no longer read-only unless locked.
-* `--no-excluded` Do not list patterns that are excluded in the output;
-only list patterns that are tracked.
-* `--no-modify-attrs` Makes matched entries stat-dirty so that Git can
-re-index files you wish to convert to LFS. Does not modify any
-`.gitattributes` file(s).
+--filename::
+ Treat the arguments as literal filenames, not as patterns. Any special glob
+ characters in the filename will be escaped when writing the `.gitattributes`
+ file.
+--lockable::
+-l::
+ Make the paths 'lockable', meaning they should be locked to edit them, and
+ will be made read-only in the working copy when not locked.
+--not-lockable::
+ Remove the lockable flag from the paths so they are no longer read-only unless
+ locked.
+--no-excluded::
+ Do not list patterns that are excluded in the output; only list patterns that
+ are tracked.
+--no-modify-attrs:
+ Makes matched entries stat-dirty so that Git can re-index files you wish to
+ convert to LFS. Does not modify any `.gitattributes` file(s).
 
 == EXAMPLES
 
diff --git a/docs/man/git-lfs-uninstall.adoc b/docs/man/git-lfs-uninstall.adoc
index d12d4349a1..6f6d80cadc 100644
--- a/docs/man/git-lfs-uninstall.adoc
+++ b/docs/man/git-lfs-uninstall.adoc
@@ -19,25 +19,22 @@ repository.
 == OPTIONS
 
 --local::
- Removes the "lfs" smudge and clean filters from the local
-repository's git config, instead of the global git config
-(~/.gitconfig).
+ Removes the "lfs" smudge and clean filters from the local repository's git
+ config, instead of the global git config (~/.gitconfig).
 --worktree::
- Removes the "lfs" smudge and clean filters from the
-current working tree's git config, instead of the global git config
-(~/.gitconfig) or local repository's git config ($GIT_DIR/config). If
-multiple working trees are in use, the Git config extension
-`worktreeConfig` must be enabled to use this option. If only one working
-tree is in use, `--worktree` has the same effect as `--local`. This
-option is only available if the installed Git version is at least 2.20.0
-and therefore supports the "worktreeConfig" extension.
+ Removes the "lfs" smudge and clean filters from the current working tree's git
+ config, instead of the global git config (~/.gitconfig) or local repository's
+ git config ($GIT_DIR/config). If multiple working trees are in use, the Git
+ config extension `worktreeConfig` must be enabled to use this option. If only
+ one working tree is in use, `--worktree` has the same effect as `--local`.
+ This option is only available if the installed Git version is at least 2.20.0
+ and therefore supports the "worktreeConfig" extension.
 --system::
- Removes the "lfs" smudge and clean filters from the system
-git config, instead of the global git config (~/.gitconfig).
+ Removes the "lfs" smudge and clean filters from the system git config, instead
+ of the global git config (~/.gitconfig).
 --skip-repo::
- Skips cleanup of the local repo; use if you want to
-uninstall the global lfs filters but not make changes to the current
-repo.
+ Skips cleanup of the local repo; use if you want to uninstall the global lfs
+ filters but not make changes to the current repo.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
index 366604ae46..f78adbca18 100644
--- a/docs/man/git-lfs-unlock.adoc
+++ b/docs/man/git-lfs-unlock.adoc
@@ -16,22 +16,20 @@ must exist and have a clean git status before they can be unlocked. The
 
 == OPTIONS
 
--r::
---remote=::
- Specify the Git LFS server to use. Ignored if the
-`lfs.url` config key is set.
+-r <name>::
+--remote=<name>::
+ Specify the Git LFS server to use. Ignored if the `lfs.url` config key is
+ set.
 -f::
 --force::
- Tells the server to remove the lock, even if it's
-owned by another user.
+ Tells the server to remove the lock, even if it's owned by another user.
 -i <id>::
 --id=<id>::
 Specifies a lock by its ID instead of path.
 --json::
- Writes lock info as JSON to STDOUT if the command exits
-successfully. Intended for interoperation with external tools. If the
-command returns with a non-zero exit code, plain text messages will be
-sent to STDERR.
+ Writes lock info as JSON to STDOUT if the command exits successfully. Intended
+ for interoperation with external tools. If the command returns with a non-zero
+ exit code, plain text messages will be sent to STDERR.
 
 == SEE ALSO
 
diff --git a/docs/man/git-lfs-update.adoc b/docs/man/git-lfs-update.adoc
index bb77b8a6eb..b4c162921b 100644
--- a/docs/man/git-lfs-update.adoc
+++ b/docs/man/git-lfs-update.adoc
@@ -16,12 +16,16 @@ the extended options below.
 
 == OPTIONS
 
-* `--manual` `-m` Print instructions for manually updating your hooks to
-include git-lfs functionality. Use this option if `git lfs update` fails
-because of existing hooks and you want to retain their functionality.
-* `--force` `-f` Forcibly overwrite any existing hooks with git-lfs
-hooks. Use this option if `git lfs update` fails because of existing
-hooks but you don't care about their current contents.
+--manual::
+-m::
+ Print instructions for manually updating your hooks to include git-lfs
+ functionality. Use this option if `git lfs update` fails because of existing
+ hooks and you want to retain their functionality.
+--force::
+-f::
+ Forcibly overwrite any existing hooks with git-lfs hooks. Use this option if
+ `git lfs update` fails because of existing hooks but you don't care about
+ their current contents.
 
 == SEE ALSO

From 748ad5ff412713efab76c9c9796550874275713c Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Wed, 22 Jun 2022 15:44:12 +0000
Subject: [PATCH 08/21] docs: regularize options parameters

We normally write options as lowercase text with angle brackets, so do
that here as well.
---
 docs/man/git-lfs-unlock.adoc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
index f78adbca18..9fa01e19a2 100644
--- a/docs/man/git-lfs-unlock.adoc
+++ b/docs/man/git-lfs-unlock.adoc
@@ -6,7 +6,7 @@ git-lfs-unlock - Remove "locked" setting for a file on the Git LFS server
 
 == SYNOPSIS
 
-`git lfs unlock` [OPTIONS] <path>
+`git lfs unlock` [<options>] <path>
 
 == DESCRIPTION

From e15937be627c683ef92e553b217b292bc81430cb Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Wed, 22 Jun 2022 15:45:04 +0000
Subject: [PATCH 09/21] doc: use source block for multiline text

In this case, the conversion to AsciiDoc has removed a line break which
we want.  Make this work properly by using a source block.
---
 docs/man/git-lfs-ext.adoc | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/docs/man/git-lfs-ext.adoc b/docs/man/git-lfs-ext.adoc
index 6cc2b1b405..0030e46e21 100644
--- a/docs/man/git-lfs-ext.adoc
+++ b/docs/man/git-lfs-ext.adoc
@@ -17,10 +17,15 @@ smudge and clean.
 
 * List details for all extensions
 +
-`git lfs ext` `git lfs ext list`
+....
+$ git lfs ext
+$ git lfs ext list
+....
 * List details for the specified extensions
 +
-`git lfs ext list 'foo' 'bar'`
+....
+$ git lfs ext list 'foo' 'bar'
+....
 
 == SEE ALSO

From 2b51ae31bce71e6af06cb9f0875ef3e510264f37 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Wed, 22 Jun 2022 15:50:05 +0000
Subject: [PATCH 10/21] doc: fix missing argument

Restore text that was removed by the conversion to AsciiDoc.
---
 docs/man/git-lfs-checkout.adoc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index 5d94af5dd3..a1943a4a7f 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -29,7 +29,8 @@ When used with `--to` and the working tree is in a conflicted state due
 to a merge, this option checks out one of the three stages a conflicting
 Git LFS object into a separate file (which can be outside of the work
 tree). This can make using diff tools to inspect and resolve merges
-easier. A single Git LFS object's file path must be provided in .
+easier. A single Git LFS object's file path must be provided in
+`<conflict-obj-path>`.
 
 == OPTIONS

From a9c8c0eadfb1e3b1b93470385afa9e8b78de90a4 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Wed, 22 Jun 2022 16:18:14 +0000
Subject: [PATCH 11/21] doc: convert ronn-style links to AsciiDoc
 cross-references

Asciidoctor provides autogenerated IDs for all section titles.  Use
these for our cross-references and replace the old ronn-style internal
links.

While we're at it, clean up a few small issues like indentation.
---
 docs/man/git-lfs-clone.adoc        |  4 +--
 docs/man/git-lfs-fetch.adoc        | 12 +++++----
 docs/man/git-lfs-ls-files.adoc     |  4 +--
 docs/man/git-lfs-merge-driver.adoc |  4 +--
 docs/man/git-lfs-migrate.adoc      | 43 ++++++++++++++++--------------
 docs/man/git-lfs-prune.adoc        | 20 +++++++-------
 docs/man/git-lfs-pull.adoc         |  4 +--
 7 files changed, 48 insertions(+), 43 deletions(-)

diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index c060b8adb9..3492cd4db9 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -29,10 +29,10 @@ All options supported by 'git clone'
 
 -I <paths>::
 --include=<paths>::
- See [INCLUDE AND EXCLUDE]
+ See <<_include_and_exclude>>.
 -X <paths>::
 --exclude=<paths>::
- See [INCLUDE AND EXCLUDE]
+ See <<_include_and_exclude>>.
 --skip-repo::
 Skip installing repo-level hooks (.git/hooks) that LFS
 requires. Disabled by default.
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index a0953d0889..a0c4cdff41 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -11,7 +11,7 @@ git-lfs-fetch - Download all Git LFS files for a given ref
 == DESCRIPTION
 
 Download Git LFS objects at the given refs from the specified remote.
-See [DEFAULT REMOTE] and [DEFAULT REFS] for what happens if you don't
+See <<_default_remote>> and <<_default_refs>> for what happens if you don't
 specify.
 
 This does not update the working copy.
@@ -20,13 +20,15 @@ This does not update the working copy.
 
 -I <paths>::
 --include=<paths>::
- Specify lfs.fetchinclude just for this invocation; see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchinclude just for this invocation; see
+ <<_include_and_exclude>>.
 -X <paths>::
 --exclude=<paths>::
- Specify lfs.fetchexclude just for this invocation; see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchexclude just for this invocation; see
+ <<_include_and_exclude>>.
 --recent::
 Download objects referenced by recent branches & commits in addition to those
- that would otherwise be downloaded. See [RECENT CHANGES]
+ that would otherwise be downloaded. See <<_recent_changes>>.
 --all::
 Download all objects that are referenced by any commit reachable from the refs
 provided as arguments. If no refs are provided, then all refs are fetched.
@@ -85,7 +87,7 @@ you're tracking first, or origin otherwise.
 
 If no refs are given as arguments, the currently checked out ref is
 used. In addition, if enabled, recently changed refs and commits are
-also included. See [RECENT CHANGES] for details.
+also included. See <<_recent_changes>> for details.
 
 == RECENT CHANGES
 
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index 598d37e742..0580e15037 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -41,10 +41,10 @@ indicates an LFS pointer.
 been deleted.
 -I <paths>::
 --include=<paths>::
- Include paths matching only these patterns; see [FETCH SETTINGS].
+ Include paths matching only these patterns; see <<_fetch_settings>>.
 -X <paths>::
 --exclude=<paths>::
- Exclude paths matching any of these patterns; see [FETCH SETTINGS].
+ Exclude paths matching any of these patterns; see <<_fetch_settings>>.
 -n::
 --name-only::
 Show only the lfs tracked file names.
diff --git a/docs/man/git-lfs-merge-driver.adoc b/docs/man/git-lfs-merge-driver.adoc
index de2a12b143..79f7593fa7 100644
--- a/docs/man/git-lfs-merge-driver.adoc
+++ b/docs/man/git-lfs-merge-driver.adoc
@@ -16,7 +16,7 @@ general, does not support partial renames or copies because Git does not
 support them in this case.
 
 This program is intended to be invoked automatically by Git and not by
-users manually. See [CONFIGURATION] for details on the configuration
+users manually. See <<_configuration>> for details on the configuration
 required for that.
 
 == OPTIONS
@@ -34,7 +34,7 @@ required for that.
 performs the actual merge. If this is not specified, `git merge-file` is
 invoked with appropriate arguments to perform the merge of the file.
 +
-See [CONFIGURATION] for the sequences which are substituted here.
+See <<_configuration>> for the sequences which are substituted here.
 
 == CONFIGURATION
 
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index 2f55d66269..6d445763da 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -26,7 +26,7 @@ will only make changes to your local repository and working copy, never
 any remotes. This is intentional as the `import` and `export` modes are
 generally "destructive" in the sense that they rewrite your Git history,
 changing commits and generating new commit SHAs. (The exception is the
-"no-rewrite" `import` sub-mode; see [IMPORT WITHOUT REWRITING HISTORY]
+"no-rewrite" `import` sub-mode; see <<_import_without_rewriting_history>>
 for details.)
 
 You should therefore always first commit or stash any uncommitted work
@@ -45,8 +45,8 @@ checked-out one, branch refs may be specified directly, or provided in
 one or more `--include-ref` options. They may also be excluded by
 prefixing them with `^` or providing them in `--exclude-ref` options.
 Use the `--everything` option to specify that all refs should be
-examined, including all remote refs. See [INCLUDE AND EXCLUDE
-REFERENCES] for details.
+examined, including all remote refs. See <<_include_and_exclude_references>>
+for details.
 
 For the `info` and `import` modes, all file types are considered by
 default; while useful in the `info` mode, this is often not desirable
@@ -54,7 +54,7 @@ when importing, so either filename patterns (pathspecs) or the `--fixup`
 option should normally be specified in that case. (At least one include
 pathspec is required for the `export` mode.) Pathspecs may be defined
 using the `--include` and `--exclude` options (`-I` and `-X` for short),
-as described in [INCLUDE AND EXCLUDE].
+as described in <<_include_and_exclude>>.
 
 As typical Git LFS usage depends on tracking specific file types using
 filename patterns defined in `.gitattributes` files, the
@@ -64,7 +64,7 @@ always be assigned the default read/write permissions mode (i.e.,
 without execute permissions). Any symbolic links with that name will
 cause the migration to halt prematurely.
 
-The `import` mode (see [IMPORT]) will convert Git objects of the file
+The `import` mode (see <<_import>>) will convert Git objects of the file
 types specified (e.g., with `--include`) to Git LFS pointers, and will
 add entries for those file types to `.gitattributes` files, creating
 those files if they do not exist. The result should be as if
@@ -75,7 +75,7 @@ exception is if the `--fixup` option is given, in which case the
 then convert Git objects which should be tracked by Git LFS but are not
 yet.
 
-The `export` mode (see [EXPORT]) works as the reverse operation to the
+The `export` mode (see <<_export>>) works as the reverse operation to the
 `import` mode, converting any Git LFS pointers that match the file types
 specified with `--include`, which must be given at least once. Note that
 `.gitattributes` entries will not be removed, nor will the files;
@@ -85,7 +85,7 @@ available in the `export` mode to specify the remote from which Git LFS
 objects should be fetched if they do not exist in the local Git LFS
 object cache; if not provided, `origin` is used by default.
 
-The `info` mode (see [INFO]) summarizes by file type (i.e., by filename
+The `info` mode (see <<_info>>) summarizes by file type (i.e., by filename
 extension) the total number and size of files in a repository. Note that
 like the other two modes, by default the `info` mode operates only on
 the currently checked-out branch and only on commits which do not exist
@@ -116,32 +116,34 @@ those changes to your remotes.
 == MODES
 
 info::
- Show information about repository size. See [INFO].
+ Show information about repository size. See <<_info>>.
 import::
- Convert Git objects to Git LFS pointers. See [IMPORT] and
- [IMPORT WITHOUT REWRITING HISTORY].
+ Convert Git objects to Git LFS pointers. See <<_import>> and
+ <<_import_without_rewriting_history>>
 export::
- Convert Git LFS pointers to Git objects. See [EXPORT].
+ Convert Git LFS pointers to Git objects. See <<_export>>.
 
 == OPTIONS
 
 -I <paths>::
 --include=<paths>::
- See [INCLUDE AND EXCLUDE].
+ See <<_include_and_exclude>>.
 -X <paths>::
 --exclude=<paths>::
- See [INCLUDE AND EXCLUDE].
+ See <<_include_and_exclude>>.
 --include-ref=<refname>::
- See [INCLUDE AND EXCLUDE REFERENCES].
+ See <<_include_and_exclude_references>>.
+--include-ref=<refname>::
+ See <<_include_and_exclude_references>>.
 --exclude-ref=<refname>::
- See [INCLUDE AND EXCLUDE REFERENCES].
+ See <<_include_and_exclude_references>>.
 --skip-fetch::
 Assumes that the known set of remote references is complete, and should not be
 refreshed when determining the set of "un-pushed" commits to migrate. Has no
 effect when combined with
 `--include-ref` or `--exclude-ref`.
 --everything::
- See [INCLUDE AND EXCLUDE REFERENCES].
+ See <<_include_and_exclude_references>>.
 +
 Note: Git refs are "case-sensitive" on all platforms in "packed from"
 (see `git-pack-refs(1)`). On "case-insensitive" file systems, e.g. NTFS
@@ -153,8 +155,9 @@ upper/lower case letters.
 the only such prompt is the one asking whether to overwrite (destroy) any
 working copy changes. Thus, specifying this option may cause data loss if you
 are not careful.
-* [branch ...]: Migrate only the set of branches listed. If not given,
- `git-lfs-migrate(1)` will migrate the currently checked out branch.
+`[branch ...]`::
+ Migrate only the set of branches listed. If not given, `git-lfs-migrate(1)`
+ will migrate the currently checked out branch.
 +
 References beginning with `^` will be excluded, whereas branches that do
 not begin with `^` will be included.
@@ -244,8 +247,8 @@ files tracked and stored with Git LFS. It supports all the core
 Migrate objects to Git LFS in a new commit without rewriting Git history.
 Please note that when this option is used, the `migrate import` command will
 expect a different argument list, specialized options will become available,
- and the core `migrate` options will be ignored. See [IMPORT WITHOUT REWRITING
- HISTORY].
+ and the core `migrate` options will be ignored.
+ See <<_import_without_rewriting_history>>.
 --fixup::
 Infer `--include` and `--exclude` filters on a per-commit basis based on the
 `.gitattributes` files in a repository. In practice, this option imports any
diff --git a/docs/man/git-lfs-prune.adoc b/docs/man/git-lfs-prune.adoc
index 37ec942ca9..5f9369c039 100644
--- a/docs/man/git-lfs-prune.adoc
+++ b/docs/man/git-lfs-prune.adoc
@@ -17,10 +17,10 @@ following:
 
 * the current checkout
 * all existing stashes
-* a 'recent branch'; see [RECENT FILES]
+* a 'recent branch'; see <<_recent_files>>
 * a 'recent commit' on the current branch or recent branches; see
-[RECENT FILES]
-* a commit which has not been pushed; see [UNPUSHED LFS FILES]
+<<_recent_files>>
+* a commit which has not been pushed; see <<_unpushed_lfs_files>>
 * any other worktree checkouts; see git-worktree(1)
 
 In general terms, prune will delete files you're not currently using and
@@ -52,14 +52,14 @@ gitignore(5).
 currently checked out refs. Implies `--recent`.
 --recent::
 Prune even objects that would normally be preserved by the
- configuration options specified below in [RECENT FILES].
+ configuration options specified below in <<_recent_files>>.
 --verify-remote::
 -c::
 Contact the remote and check that copies of the files we would delete
- definitely exist before deleting. See [VERIFY REMOTE].
+ definitely exist before deleting. See <<_verify_remote>>.
 --no-verify-remote::
 Disables remote verification if lfs.pruneverifyremotealways was enabled in
- settings. See [VERIFY REMOTE].
+ settings. See <<_verify_remote>>.
 --verbose::
 -v::
 Report the full detail of what is/would be deleted.
@@ -100,7 +100,7 @@ ahead, any LFS files referenced in those commits is unpushed and will
 not be deleted. This works because the LFS pre-push hook always ensures
 that LFS files are pushed before the remote branch is updated.
 
-See [DEFAULT REMOTE], for which remote is considered 'pushed' for
+See <<_default_remote>>, for which remote is considered 'pushed' for
 pruning purposes.
 
 == VERIFY REMOTE
@@ -109,11 +109,11 @@ The `--verify-remote` option calls the remote to ensure that any LFS
 files to be deleted have copies on the remote before actually deleting
 them.
 
-Usually the check performed by [UNPUSHED LFS FILES] is enough to
+Usually the check performed by <<_unpushed_lfs_files>> is enough to
 determine that files have been pushed, but if you want to be extra sure
 at the expense of extra overhead you can make prune actually call the
 remote API and verify the presence of the files you're about to delete
-locally. See [DEFAULT REMOTE] for which remote is checked.
+locally. See <<_default_remote>> for which remote is checked.
 
 You can make this behaviour the default by setting
 `lfs.pruneverifyremotealways` to true.
@@ -127,7 +127,7 @@ process take longer.
 
 == DEFAULT REMOTE
 
-When identifying [UNPUSHED LFS FILES] and performing [VERIFY REMOTE], a
+When identifying <<_unpushed_lfs_files>> and performing <<_verify_remote>>, a
 single remote, 'origin', is normally used as the reference. This one
 remote is considered canonical; even if you use multiple remotes, you
 probably want to retain your local copies until they've made it to that
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index 18c7c28504..aa39ab463d 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -21,10 +21,10 @@ git lfs fetch [options] [] git lfs checkout
 
 -I <paths>::
 --include=<paths>::
- Specify lfs.fetchinclude just for this invocation; see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchinclude just for this invocation; see <<_include_and_exclude>>
 -X <paths>::
 --exclude=<paths>::
- Specify lfs.fetchexclude just for this invocation; see [INCLUDE AND EXCLUDE]
+ Specify lfs.fetchexclude just for this invocation; see <<_include_and_exclude>>
 
 == INCLUDE AND EXCLUDE

From 0808c573d2add6869b7c7a219bfb6cf2b9e37b96 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 17:41:58 +0000
Subject: [PATCH 12/21] doc: place options in monospace

Our options should be in monospace since they're thing that people will
type at the command line.  Convert all of our AsciiDoc files with the
following one-liner:

ruby -pi -e '$_.gsub!(/^(-[-A-Za-z][^:]*)::$/, "`\\1`::")' *.adoc
---
 docs/man/git-lfs-checkout.adoc       |  8 ++---
 docs/man/git-lfs-clone.adoc          | 10 +++---
 docs/man/git-lfs-fetch.adoc          | 16 ++++-----
 docs/man/git-lfs-filter-process.adoc |  2 +-
 docs/man/git-lfs-fsck.adoc           |  4 +--
 docs/man/git-lfs-install.adoc        | 14 ++++----
 docs/man/git-lfs-lock.adoc           |  6 ++--
 docs/man/git-lfs-locks.adoc          | 24 ++++++-------
 docs/man/git-lfs-ls-files.adoc       | 30 ++++++++---------
 docs/man/git-lfs-merge-driver.adoc   | 10 +++---
 docs/man/git-lfs-migrate.adoc        | 50 ++++++++++++++--------------
 docs/man/git-lfs-pointer.adoc        | 12 +++----
 docs/man/git-lfs-prune.adoc          | 20 +++++------
 docs/man/git-lfs-pull.adoc           |  8 ++---
 docs/man/git-lfs-push.adoc           |  6 ++--
 docs/man/git-lfs-smudge.adoc         |  2 +-
 docs/man/git-lfs-status.adoc         |  4 +--
 docs/man/git-lfs-track.adoc          | 18 +++++-----
 docs/man/git-lfs-uninstall.adoc      |  8 ++---
 docs/man/git-lfs-unlock.adoc         | 14 ++++----
 docs/man/git-lfs-update.adoc         |  8 ++---
 21 files changed, 137 insertions(+), 137 deletions(-)

diff --git a/docs/man/git-lfs-checkout.adoc b/docs/man/git-lfs-checkout.adoc
index a1943a4a7f..214198b5a9 100644
--- a/docs/man/git-lfs-checkout.adoc
+++ b/docs/man/git-lfs-checkout.adoc
@@ -34,15 +34,15 @@ easier. A single Git LFS object's file path must be provided in
 
 == OPTIONS
 
---base::
+`--base`::
 Check out the merge base of the specified file.
---ours::
+`--ours`::
 Check out our side (that of the current branch) of the
 conflict for the specified file.
---theirs::
+`--theirs`::
 Check out their side (that of the other branch) of the
 conflict for the specified file.
---to <path>::
+`--to <path>`::
 If the working tree is in a conflicted state, check out the
 portion of the conflict specified by `--base`, `--ours`, or `--theirs`
 to the given path.
diff --git a/docs/man/git-lfs-clone.adoc b/docs/man/git-lfs-clone.adoc
index 3492cd4db9..e2b5bf9f72 100644
--- a/docs/man/git-lfs-clone.adoc
+++ b/docs/man/git-lfs-clone.adoc
@@ -27,13 +27,13 @@ batch mode and parallel downloads performed by 'git lfs pull'.
 
 All options supported by 'git clone'
 
--I <paths>::
---include=<paths>::
+`-I <paths>`::
+`--include=<paths>`::
 See <<_include_and_exclude>>.
--X <paths>::
---exclude=<paths>::
+`-X <paths>`::
+`--exclude=<paths>`::
 See <<_include_and_exclude>>.
---skip-repo::
+`--skip-repo`::
 Skip installing repo-level hooks (.git/hooks) that LFS
 requires. Disabled by default.
 
diff --git a/docs/man/git-lfs-fetch.adoc b/docs/man/git-lfs-fetch.adoc
index a0c4cdff41..40119ea9c1 100644
--- a/docs/man/git-lfs-fetch.adoc
+++ b/docs/man/git-lfs-fetch.adoc
@@ -18,25 +18,25 @@ This does not update the working copy.
 
 == OPTIONS
 
--I <paths>::
---include=<paths>::
+`-I <paths>`::
+`--include=<paths>`::
 Specify lfs.fetchinclude just for this invocation; see
 <<_include_and_exclude>>.
--X <paths>::
---exclude=<paths>::
+`-X <paths>`::
+`--exclude=<paths>`::
 Specify lfs.fetchexclude just for this invocation; see
 <<_include_and_exclude>>.
---recent::
+`--recent`::
 Download objects referenced by recent branches & commits in addition to those
 that would otherwise be downloaded. See <<_recent_changes>>.
---all::
+`--all`::
 Download all objects that are referenced by any commit reachable from the refs
 provided as arguments. If no refs are provided, then all refs are fetched.
 This is primarily for backup and migration purposes. Cannot be combined with
 --recent or --include/--exclude. Ignores any globally configured include and
 exclude paths to ensure that all objects are downloaded.
---prune::
--p::
+`--prune`::
+`-p`::
 Prune old and unreferenced objects after fetching, equivalent to running `git
 lfs prune` afterwards. See git-lfs-prune(1) for more details.
 
diff --git a/docs/man/git-lfs-filter-process.adoc b/docs/man/git-lfs-filter-process.adoc
index 64c0ccdd10..b03e2057b7 100644
--- a/docs/man/git-lfs-filter-process.adoc
+++ b/docs/man/git-lfs-filter-process.adoc
@@ -38,7 +38,7 @@ documented in detail in gitattributes(5).
 Without any options, filter-process accepts and responds to requests
 normally.
 
---skip::
+`--skip`::
 Skip automatic downloading of objects on clone or pull.
 `GIT_LFS_SKIP_SMUDGE`::
 Disables the smudging process. For more, see: git-lfs-config(5).
diff --git a/docs/man/git-lfs-fsck.adoc b/docs/man/git-lfs-fsck.adoc
index a77cec700b..581f8150bf 100644
--- a/docs/man/git-lfs-fsck.adoc
+++ b/docs/man/git-lfs-fsck.adoc
@@ -30,10 +30,10 @@ using wildcard matching as per gitignore(5).
 
 == OPTIONS
 
---objects::
+`--objects`::
 Check that each object in HEAD matches its expected hash
 and that each object exists on disk.
---pointers::
+`--pointers`::
 Check that each pointer is canonical and that each file
 which should be stored as a Git LFS file is so stored.
 
diff --git a/docs/man/git-lfs-install.adoc b/docs/man/git-lfs-install.adoc
index c890c15e7c..7d3e30b052 100644
--- a/docs/man/git-lfs-install.adoc
+++ b/docs/man/git-lfs-install.adoc
@@ -25,12 +25,12 @@ directory instead.
 Without any options, `git lfs install` will only setup the "lfs" smudge
 and clean filters if they are not already set.
 
---force::
+`--force`::
 Sets the "lfs" smudge and clean filters, overwriting existing values.
---local::
+`--local`::
 Sets the "lfs" smudge and clean filters in the local repository's git config,
 instead of the global git config (~/.gitconfig).
---worktree::
+`--worktree`::
 Sets the "lfs" smudge and clean filters in the current working tree's git
 config, instead of the global git config (~/.gitconfig) or local repository's
 git config ($GIT_DIR/config). If multiple working trees are in use, the Git
@@ -38,18 +38,18 @@ and clean filters if they are not already set.
 one working tree is in use, `--worktree` has the same effect as `--local`.
 This option is only available if the installed Git version is at least 2.20.0
 and therefore supports the "worktreeConfig" extension.
---manual::
+`--manual`::
 Print instructions for manually updating your hooks to include git-lfs
 functionality. Use this option if `git lfs install` fails because of existing
 hooks and you want to retain their functionality.
---system::
+`--system`::
 Sets the "lfs" smudge and clean filters in the system git config, e.g.
 /etc/gitconfig instead of the global git config (~/.gitconfig).
---skip-smudge::
+`--skip-smudge`::
 Skips automatic downloading of objects on clone or pull. This requires a
 manual "git lfs pull" every time a new commit is checked out on your
 repository.
---skip-repo::
+`--skip-repo`::
 Skips setup of the local repo; use if you want to install the global lfs
 filters but not make changes to the current repo.
 
diff --git a/docs/man/git-lfs-lock.adoc b/docs/man/git-lfs-lock.adoc
index f8ba7196ea..f66599466c 100644
--- a/docs/man/git-lfs-lock.adoc
+++ b/docs/man/git-lfs-lock.adoc
@@ -20,11 +20,11 @@ config key in git-lfs-config(5) for details.
 
 == OPTIONS
 
--r <name>::
---remote=<name>::
+`-r <name>`::
+`--remote=<name>`::
 Specify the Git LFS server to use. Ignored if the `lfs.url` config key is
 set.
---json::
+`--json`::
 Writes lock info as JSON to STDOUT if the command exits successfully. Intended
 for interoperation with external tools. If the command returns with a non-zero
 exit code, plain text messages will be sent to STDERR.
diff --git a/docs/man/git-lfs-locks.adoc b/docs/man/git-lfs-locks.adoc
index 559659d8a1..8310c981d6 100644
--- a/docs/man/git-lfs-locks.adoc
+++ b/docs/man/git-lfs-locks.adoc
@@ -14,25 +14,25 @@ Lists current locks from the Git LFS server.
 
 == OPTIONS
 
--r <name>::
---remote=<name>::
+`-r <name>`::
+`--remote=<name>`::
 Specify the Git LFS server to use. Ignored if the `lfs.url` config key is
 set.
--i <id>::
---id=<id>::
+`-i <id>`::
+`--id=<id>`::
 Specifies a lock by its ID. Returns a single result.
--p <path>::
---path=<path>::
+`-p <path>`::
+`--path=<path>`::
 Specifies a lock by its path. Returns a single result.
---local::
+`--local`::
 Lists only our own locks which are cached locally. Skips a remote call.
---cached::
+`--cached`::
 Lists cached locks from the last remote call. Contrary to `--local`, this will
 include locks of other users as well. This option is intended to display the
 last known locks in case you are offline. There is no guarantee that locks on
 the server have not changed in the
 meanwhile.
---verify::
+`--verify`::
 Verifies the lock owner on the server and marks our own locks by 'O'. Own
 locks are actually held by us and corresponding files can be updated for the
 next push. All other locks are held by someone else. Contrary to --local, this
@@ -40,10 +40,10 @@ meanwhile.
 information being available (e.g. because the file had been locked from a
 different clone); it will also detect 'broken' locks (e.g. if someone else has
 forcefully unlocked our files).
--l <num>::
---limit=<num>::
+`-l <num>`::
+`--limit=<num>`::
 Specifies number of results to return.
---json::
+`--json`::
 Writes lock info as JSON to STDOUT if the command exits successfully. Intended
 for interoperation with external tools. If the command returns with a non-zero
 exit code, plain text messages will be sent to STDERR.
diff --git a/docs/man/git-lfs-ls-files.adoc b/docs/man/git-lfs-ls-files.adoc
index 0580e15037..989bc2c643 100644
--- a/docs/man/git-lfs-ls-files.adoc
+++ b/docs/man/git-lfs-ls-files.adoc
@@ -21,32 +21,32 @@ indicates an LFS pointer.
 
 == OPTIONS
 
--l::
---long::
+`-l`::
+`--long`::
 Show the entire 64 character OID, instead of just first 10.
--s::
---size::
+`-s`::
+`--size`::
 Show the size of the LFS object between parenthesis at the end of a line.
--d::
---debug::
+`-d`::
+`--debug`::
 Show as much information as possible about a LFS file. This is intended for
 manual inspection; the exact format may change at any time.
--a::
---all::
+`-a`::
+`--all`::
 Inspects the full history of the repository, not the current HEAD (or other
 provided reference). This will include previous versions of LFS objects that
 are no longer found in the current tree.
---deleted::
+`--deleted`::
 Shows the full history of the given reference, including objects that have
 been deleted.
--I <paths>::
---include=<paths>::
+`-I <paths>`::
+`--include=<paths>`::
 Include paths matching only these patterns; see <<_fetch_settings>>.
--X <paths>::
---exclude=<paths>::
+`-X <paths>`::
+`--exclude=<paths>`::
 Exclude paths matching any of these patterns; see <<_fetch_settings>>.
--n::
---name-only::
+`-n`::
+`--name-only`::
 Show only the lfs tracked file names.
 
 == SEE ALSO
diff --git a/docs/man/git-lfs-merge-driver.adoc b/docs/man/git-lfs-merge-driver.adoc
index 79f7593fa7..b631b8f5c4 100644
--- a/docs/man/git-lfs-merge-driver.adoc
+++ b/docs/man/git-lfs-merge-driver.adoc
@@ -21,15 +21,15 @@ required for that.
 
 == OPTIONS
 
---ancestor <path>::
+`--ancestor <path>`::
 Specify the file containing the ancestor revision.
---current <path>::
+`--current <path>`::
 Specify the file containing the current revision.
---marker-size <num>::
+`--marker-size <num>`::
 Specify the conflict marker size as an integer.
---other <path>::
+`--other <path>`::
 Specify the file containing the other revision.
---program <program>::
+`--program <program>`::
 Specify a command, which is passed to the shell after substitution, that
 performs the actual merge. If this is not specified, `git merge-file` is
 invoked with appropriate arguments to perform the merge of the file.
diff --git a/docs/man/git-lfs-migrate.adoc b/docs/man/git-lfs-migrate.adoc
index 6d445763da..d8fc2996e2 100644
--- a/docs/man/git-lfs-migrate.adoc
+++ b/docs/man/git-lfs-migrate.adoc
@@ -125,24 +125,24 @@ export::
 
 == OPTIONS
 
--I <paths>::
---include=<paths>::
+`-I <paths>`::
+`--include=<paths>`::
 See <<_include_and_exclude>>.
--X <paths>::
---exclude=<paths>::
+`-X <paths>`::
+`--exclude=<paths>`::
 See <<_include_and_exclude>>.
---include-ref=<refname>::
+`--include-ref=<refname>`::
 See <<_include_and_exclude_references>>.
---include-ref=<refname>::
+`--include-ref=<refname>`::
 See <<_include_and_exclude_references>>.
---exclude-ref=<refname>::
+`--exclude-ref=<refname>`::
 See <<_include_and_exclude_references>>.
---skip-fetch::
+`--skip-fetch`::
 Assumes that the known set of remote references is complete, and should not be
 refreshed when determining the set of "un-pushed" commits to migrate. Has no
 effect when combined with
 `--include-ref` or `--exclude-ref`.
---everything::
+`--everything`::
 See <<_include_and_exclude_references>>.
 +
 Note: Git refs are "case-sensitive" on all platforms in "packed from"
@@ -150,7 +150,7 @@ Note: Git refs are "case-sensitive" on all platforms in "packed from"
 on Windows or default APFS on macOS, `git-lfs-migrate(1)` would only
 migrate the first ref if two or more refs are equal except for
 upper/lower case letters.
---yes::
+`--yes`::
 Assume a yes answer to any prompts, permitting noninteractive use. Currently,
 the only such prompt is the one asking whether to overwrite (destroy) any
 working copy changes. Thus, specifying this option may cause data loss if you
@@ -172,7 +172,7 @@ The `info` mode summarizes the sizes of file objects present in the Git
 history. It supports all the core `migrate` options and these additional
 ones:
 
---above=<size>::
+`--above=<size>`::
 Only count files whose individual filesize is above the given size. `size` may
 be specified as a number of bytes, or a number followed by a storage unit,
 e.g., "1b", "20 MB", "3 TiB", etc.
@@ -180,20 +180,20 @@ ones:
 If a set of files sharing a common extension has no files in that set
 whose individual size is above the given `--above` no files no entry for
 that set will be shown.
---top=<n>::
+`--top=<n>`::
 Only display the top `n` entries, ordered by how many total files match the
 given pathspec. The default is to show only the top 5 entries. When existing
 Git LFS objects are found, an extra, separate "LFS Objects" line is output in
 addition to the top `n` entries, unless the `--pointers` option is used to
 change this behavior.
---unit=<unit>::
+`--unit=<unit>`::
 Format the number of bytes in each entry as a quantity of the storage unit
 provided. Valid units include: * b, kib, mib, gib, tib, pib - for IEC storage
 units * b, kb, mb, gb, tb, pb - for SI storage units
 +
 If a `--unit` is not specified, the largest unit that can fit the number
 of counted bytes as a whole number quantity is chosen.
---pointers=[follow|no-follow|ignore]::
+`--pointers=[follow|no-follow|ignore]`::
 Treat existing Git LFS pointers in the history according to one of three
 alternatives. In the default `follow` case, if any pointers are found, an
 additional separate "LFS Objects" line item is output which summarizes the
@@ -203,7 +203,7 @@ of counted bytes as a whole number quantity is chosen.
 treats any pointers it finds as if they were regular files, so the output
 totals only include the contents of the pointers, not the contents of the
 objects to which they refer.
---fixup::
+`--fixup`::
 Infer `--include` and `--exclude` filters on a per-commit basis based on the
 `.gitattributes` files in a repository. In practice, this option counts any
 filepaths which should be tracked by Git LFS according to the repository's
@@ -233,23 +233,23 @@ The `import` mode migrates objects present in the Git history to pointer
 files tracked and stored with Git LFS. It supports all the core
 `migrate` options and these additional ones:
 
---verbose::
+`--verbose`::
 Print the commit oid and filename of migrated files to STDOUT.
---above=<size>::
+`--above=<size>`::
 Only migrate files whose individual filesize is above the given size. `size`
 may be specified as a number of bytes, or a number followed by a storage unit,
 e.g., "1b", "20 MB", "3 TiB", etc. This option cannot be used with the
 `--include`, `--exclude`, and `--fixup` options.
---object-map=<path>::
+`--object-map=<path>`::
 Write to `path` a file with the mapping of each rewritten commits. The file
 format is CSV with this pattern: `OLD-SHA`,`NEW-SHA`
---no-rewrite::
+`--no-rewrite`::
 Migrate objects to Git LFS in a new commit without rewriting Git history.
 Please note that when this option is used, the `migrate import` command will
 expect a different argument list, specialized options will become available,
 and the core `migrate` options will be ignored.
 See <<_import_without_rewriting_history>>.
---fixup::
+`--fixup`::
 Infer `--include` and `--exclude` filters on a per-commit basis based on the
 `.gitattributes` files in a repository. In practice, this option imports any
 filepaths which should be tracked by Git LFS according to the repository's
@@ -279,8 +279,8 @@ commit merged in.
 The `--no-rewrite` sub-mode supports the following options and
 arguments:
 
--m <message>::
---message=<message>::
+`-m <message>`::
+`--message=<message>`::
 Specifies a commit message for the newly created commit.
 [file ...]::
 The list of files to import. These files must be tracked by
@@ -297,13 +297,13 @@ history out of Git LFS, converting them into their corresponding object
 files. It supports all the core `migrate` options and these additional
 ones:
 
---verbose::
+`--verbose`::
 Print the commit oid and filename of migrated files to
 STDOUT.
---object-map=<path>::
+`--object-map=<path>`::
 Write to `path` a file with the mapping of each rewritten commit. The file
 format is CSV with this pattern: `OLD-SHA`,`NEW-SHA`
---remote=<git-remote>::
+`--remote=<git-remote>`::
 Download LFS objects from the provided `git-remote` during the export. If not
 provided, defaults to `origin`.
 
diff --git a/docs/man/git-lfs-pointer.adoc b/docs/man/git-lfs-pointer.adoc
index 382c7b649a..8b1de4a391 100644
--- a/docs/man/git-lfs-pointer.adoc
+++ b/docs/man/git-lfs-pointer.adoc
@@ -18,21 +18,21 @@ consistency between different Git LFS implementations.
 
 == OPTIONS
 
---file::
+`--file`::
 A local file to build the pointer from.
---pointer::
+`--pointer`::
 A local file including the contents of a pointer generated from another
 implementation. This is compared to the pointer generated from `--file`.
---stdin::
+`--stdin`::
 Reads the pointer from STDIN to compare with the pointer generated from
 `--file`.
---check::
+`--check`::
 Reads the pointer from STDIN (if `--stdin` is given) or the filepath (if
 `--file`) is given. If neither or both of `--stdin` and `--file` are given,
 the invocation is invalid. Exits 0 if the data read is a valid Git LFS
 pointer. Exits 1 otherwise.
---strict::
---no-strict::
+`--strict`::
+`--no-strict`::
 In conjunction with `--check`, `--strict` verifies that the pointer is
 canonical; that is, it would be the one created by Git LFS. If it is not,
 exits 2. The default, for backwards compatibility, is `--no-strict`, but this
diff --git a/docs/man/git-lfs-prune.adoc b/docs/man/git-lfs-prune.adoc
index 5f9369c039..4e26252c56 100644
--- a/docs/man/git-lfs-prune.adoc
+++ b/docs/man/git-lfs-prune.adoc
@@ -43,25 +43,25 @@ gitignore(5).
 
 == OPTIONS
 
---dry-run::
--d::
+`--dry-run`::
+`-d`::
 Don't actually delete anything, just report on what would have been done
---force::
--f::
+`--force`::
+`-f`::
 Prune all objects except unpushed objects, including objects required for
 currently checked out refs. Implies `--recent`.
---recent::
+`--recent`::
 Prune even objects that would normally be preserved by the
 configuration options specified below in <<_recent_files>>.
---verify-remote::
--c::
+`--verify-remote`::
+`-c`::
 Contact the remote and check that copies of the files we would delete
 definitely exist before deleting. See <<_verify_remote>>.
---no-verify-remote::
+`--no-verify-remote`::
 Disables remote verification if lfs.pruneverifyremotealways was enabled in
 settings. See <<_verify_remote>>.
---verbose::
--v::
+`--verbose`::
+`-v`::
 Report the full detail of what is/would be deleted.
 
 == RECENT FILES
diff --git a/docs/man/git-lfs-pull.adoc b/docs/man/git-lfs-pull.adoc
index aa39ab463d..7d4539de34 100644
--- a/docs/man/git-lfs-pull.adoc
+++ b/docs/man/git-lfs-pull.adoc
@@ -19,11 +19,11 @@ git lfs fetch [options] [] git lfs checkout
 
 == OPTIONS
 
--I <paths>::
---include=<paths>::
+`-I <paths>`::
+`--include=<paths>`::
 Specify lfs.fetchinclude just for this invocation; see <<_include_and_exclude>>
--X <paths>::
---exclude=<paths>::
+`-X <paths>`::
+`--exclude=<paths>`::
 Specify lfs.fetchexclude just for this invocation; see <<_include_and_exclude>>
 
 == INCLUDE AND EXCLUDE
diff --git a/docs/man/git-lfs-push.adoc b/docs/man/git-lfs-push.adoc
index dc1305212a..26eff85c4c 100644
--- a/docs/man/git-lfs-push.adoc
+++ b/docs/man/git-lfs-push.adoc
@@ -18,9 +18,9 @@ by the local clone of the remote.
 
 == OPTIONS
 
---dry-run::
+`--dry-run`::
 Print the files that would be pushed, without actually pushing them.
---all::
+`--all`::
 This pushes all objects to the remote that are referenced by any commit
 reachable from the refs provided as arguments. If no refs are provided, then
 all local refs are pushed. Note that this behavior differs from that of
@@ -29,7 +29,7 @@ by the local clone of the remote.
 If you are migrating a repository with these commands, make sure to run `git
 lfs push` for any additional remote refs that contain Git LFS objects not
 reachable from your local refs.
---object-id::
+`--object-id`::
 This pushes only the object OIDs listed at the end of the command, separated
 by spaces.
 
diff --git a/docs/man/git-lfs-smudge.adoc b/docs/man/git-lfs-smudge.adoc
index f79002b123..fc900488c6 100644
--- a/docs/man/git-lfs-smudge.adoc
+++ b/docs/man/git-lfs-smudge.adoc
@@ -36,7 +36,7 @@ simply copied to standard output without change.
 Without any options, `git lfs smudge` outputs the raw Git LFS content to
 standard output.
 
---skip::
+`--skip`::
 Skip automatic downloading of objects on clone or pull.
 `GIT_LFS_SKIP_SMUDGE`::
 Disables the smudging process. For more, see: git-lfs-config(5).
diff --git a/docs/man/git-lfs-status.adoc b/docs/man/git-lfs-status.adoc
index 04d84e6544..bf513ef519 100644
--- a/docs/man/git-lfs-status.adoc
+++ b/docs/man/git-lfs-status.adoc
@@ -23,9 +23,9 @@ This command must be run in a non-bare repository.
 
 == OPTIONS
 
---porcelain::
+`--porcelain`::
 Give the output in an easy-to-parse format for scripts.
---json::
+`--json`::
 Give the output in a stable json format for scripts.
 
 == SEE ALSO
diff --git a/docs/man/git-lfs-track.adoc b/docs/man/git-lfs-track.adoc
index abee3e778e..fd801dfe26 100644
--- a/docs/man/git-lfs-track.adoc
+++ b/docs/man/git-lfs-track.adoc
@@ -24,12 +24,12 @@ use `--filename` or escape the character with a backslash.
 
 == OPTIONS
 
---verbose::
--v::
+`--verbose`::
+`-v`::
 If enabled, have `git lfs track` log files which it will touch. Disabled by
 default.
---dry-run::
--d::
+`--dry-run`::
+`-d`::
 If enabled, have `git lfs track` log all actions it would normally take
 (adding entries to .gitattributes, touching files on disk, etc) without
 performing any mutative operations to the disk.
@@ -39,18 +39,18 @@ passing the `--verbose`, and will log in greater detail what it is
 doing.
 +
 Disabled by default.
---filename::
+`--filename`::
 Treat the arguments as literal filenames, not as patterns. Any special glob
 characters in the filename will be escaped when writing the `.gitattributes`
 file.
---lockable::
--l::
+`--lockable`::
+`-l`::
 Make the paths 'lockable', meaning they should be locked to edit them, and
 will be made read-only in the working copy when not locked.
---not-lockable::
+`--not-lockable`::
 Remove the lockable flag from the paths so they are no longer read-only unless
 locked.
---no-excluded::
+`--no-excluded`::
 Do not list patterns that are excluded in the output; only list patterns that
 are tracked.
 --no-modify-attrs:
diff --git a/docs/man/git-lfs-uninstall.adoc b/docs/man/git-lfs-uninstall.adoc
index 6f6d80cadc..4678e64396 100644
--- a/docs/man/git-lfs-uninstall.adoc
+++ b/docs/man/git-lfs-uninstall.adoc
@@ -18,10 +18,10 @@ repository.
 
 == OPTIONS
 
---local::
+`--local`::
 Removes the "lfs" smudge and clean filters from the local repository's git
 config, instead of the global git config (~/.gitconfig).
---worktree::
+`--worktree`::
 Removes the "lfs" smudge and clean filters from the current working tree's git
 config, instead of the global git config (~/.gitconfig) or local repository's
 git config ($GIT_DIR/config). If multiple working trees are in use, the Git
@@ -29,10 +29,10 @@ repository.
 one working tree is in use, `--worktree` has the same effect as `--local`.
 This option is only available if the installed Git version is at least 2.20.0
 and therefore supports the "worktreeConfig" extension.
---system::
+`--system`::
 Removes the "lfs" smudge and clean filters from the system git config, instead
 of the global git config (~/.gitconfig).
---skip-repo::
+`--skip-repo`::
 Skips cleanup of the local repo; use if you want to uninstall the global lfs
 filters but not make changes to the current repo.
 
diff --git a/docs/man/git-lfs-unlock.adoc b/docs/man/git-lfs-unlock.adoc
index 9fa01e19a2..5fb26fe501 100644
--- a/docs/man/git-lfs-unlock.adoc
+++ b/docs/man/git-lfs-unlock.adoc
@@ -16,17 +16,17 @@ must exist and have a clean git status before they can be unlocked. The
 
 == OPTIONS
 
--r <name>::
---remote=<name>::
+`-r <name>`::
+`--remote=<name>`::
 Specify the Git LFS server to use. Ignored if the `lfs.url` config key is
 set.
--f::
---force::
+`-f`::
+`--force`::
 Tells the server to remove the lock, even if it's owned by another user.
--i <id>::
---id=<id>::
+`-i <id>`::
+`--id=<id>`::
 Specifies a lock by its ID instead of path.
---json::
+`--json`::
 Writes lock info as JSON to STDOUT if the command exits successfully. Intended
 for interoperation with external tools. If the command returns with a non-zero
 exit code, plain text messages will be sent to STDERR.
diff --git a/docs/man/git-lfs-update.adoc b/docs/man/git-lfs-update.adoc
index b4c162921b..021979705c 100644
--- a/docs/man/git-lfs-update.adoc
+++ b/docs/man/git-lfs-update.adoc
@@ -16,13 +16,13 @@ the extended options below.
 
 == OPTIONS
 
---manual::
--m::
+`--manual`::
+`-m`::
 Print instructions for manually updating your hooks to include git-lfs
 functionality. Use this option if `git lfs update` fails because of existing
 hooks and you want to retain their functionality.
---force::
--f::
+`--force`::
+`-f`::
 Forcibly overwrite any existing hooks with git-lfs hooks. Use this option if
 `git lfs update` fails because of existing hooks but you don't care about
 their current contents.

From f11d3099ae27a6bea5ebc8beada9ac6978a50a0d Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Wed, 22 Jun 2022 20:25:05 +0000
Subject: [PATCH 13/21] mangen: convert to use AsciiDoc manual pages

Now that we're converting our manual pages to AsciiDoc, let's use these
versions as the input when generating our manual pages.  As a result,
there are some changes to the generator:

* Our links look different than before, so handle AsciiDoc
  cross-references.  If there's an actual description, use it;
  otherwise, take the link target generated by Asciidoctor and convert
  it to a string.  Don't try to parse the actual title since that would
  make our parser not one-pass.
* Use different header regexes since the headers are different.
* Since we now have two types of source blocks, those with dots and
  those with dashes and a header, convert both types of blocks.  If
  there is a header, remove it, and then strip off the delimiter lines.
* Since we now have definition lists, handle both bulleted lists and
  definition lists the same way for indenting.  Stop the indenting at a
  blank line, but do continue indenting when we receive the plus sign
  that indicates the continuation of the block.
* Clean up the extra colon at the end of definition lists.
* Clean up the space-plus that indicates a line break.
---
 docs/man/mangen.go | 71 +++++++++++++++++++++++++++++++++++-----------
 1 file changed, 54 insertions(+), 17 deletions(-)

diff --git a/docs/man/mangen.go b/docs/man/mangen.go
index 964e1fcb16..40b7230be3 100644
--- a/docs/man/mangen.go
+++ b/docs/man/mangen.go
@@ -42,11 +42,15 @@ func readManDir() (string, []os.FileInfo) {
 	return "", nil
 }
 
+func titleizeXref(s string) string {
+	return strings.Replace(strings.ToTitle(s[1:2])+s[2:], "_", " ", -1)
+}
+
 var (
 	verbose = flag.Bool("verbose", false, "Show verbose output.")
 )
 
-// Reads all .ronn files & and converts them to string literals
+// Reads all .adoc files & and converts them to string literals
 // triggered by "go generate" comment
 // Literals are inserted into a map using an init function, this means
 // that there are no compilation errors if 'go generate' hasn't been run, just
@@ -65,19 +69,21 @@ func main() {
 	out.WriteString("package commands\n\nfunc init() {\n")
 	out.WriteString("\t// THIS FILE IS GENERATED, DO NOT EDIT\n")
 	out.WriteString("\t// Use 'go generate ./commands' to update\n")
-	fileregex := regexp.MustCompile(`git-lfs(?:-([A-Za-z\-]+))?.\d.ronn`)
-	headerregex := regexp.MustCompile(`^###?\s+([A-Za-z0-9 ]+)`)
-	// only pick up caps in links to avoid matching optional args
-	linkregex := regexp.MustCompile(`\[([A-Z\- ]+)\]`)
+	fileregex := regexp.MustCompile(`git-lfs(?:-([A-Za-z\-]+))?.adoc`)
+	headerregex := regexp.MustCompile(`^==\s+([A-Za-z0-9 ]+)`)
+	// cross-references
+	linkregex := regexp.MustCompile(`<<([^,>]+)(?:,([^>]+))?>>`)
 	// man links
 	manlinkregex := regexp.MustCompile(`(git)(?:-(lfs))?-([a-z\-]+)$\d$`)
+	// source blocks
+	sourceblockregex := regexp.MustCompile(`\[source(,.*)?\]`)
 	count := 0
 	for _, f := range fs {
 		if match := fileregex.FindStringSubmatch(f.Name()); match != nil {
 			infof(os.Stderr, "%v\n", f.Name())
 			cmd := match[1]
 			if len(cmd) == 0 {
-				// This is git-lfs.1.ronn
+				// This is git-lfs.1.adoc
 				cmd = "git-lfs"
 			}
 			out.WriteString("\tManPages[\"" + cmd + "\"] = `")
@@ -86,18 +92,20 @@ func main() {
 				warnf(os.Stderr, "Failed to open %v: %v\n", f.Name(), err)
 				os.Exit(2)
 			}
-			// Process the ronn to make it nicer as help text
+			// Process the asciidoc to make it nicer as help text
 			scanner := bufio.NewScanner(contentf)
 			firstHeaderDone := false
 			skipNextLineIfBlank := false
-			lastLineWasBullet := false
+			lastLineWasList := false
+			isSourceBlock := false
+			sourceBlockLine := ""
 		scanloop:
 			for scanner.Scan() {
 				line := scanner.Text()
 				trimmedline := strings.TrimSpace(line)
 				if skipNextLineIfBlank && len(trimmedline) == 0 {
 					skipNextLineIfBlank = false
-					lastLineWasBullet = false
+					lastLineWasList = false
 					continue
 				}
 
@@ -105,6 +113,8 @@ func main() {
 				if hmatch := headerregex.FindStringSubmatch(line); hmatch != nil {
 					header := strings.ToLower(hmatch[1])
 					switch header {
+					case "name":
+						continue
 					case "synopsis":
 						// Ignore this, just go direct to command
 
@@ -121,14 +131,17 @@ func main() {
 						out.WriteString(strings.Repeat("-", len(header)) + "\n")
 					}
 					firstHeaderDone = true
-					lastLineWasBullet = false
+					lastLineWasList = false
 					continue
 				}
 
 				if lmatches := linkregex.FindAllStringSubmatch(line, -1); lmatches != nil {
 					for _, lmatch := range lmatches {
-						linktext := strings.ToLower(lmatch[1])
-						line = strings.Replace(line, lmatch[0], `"`+strings.ToUpper(linktext[:1])+linktext[1:]+`"`, 1)
+						if len(lmatch) > 2 && lmatch[2] != "" {
+							line = strings.Replace(line, lmatch[0], `"`+lmatch[2]+`"`, 1)
+						} else {
+							line = strings.Replace(line, lmatch[0], `"`+titleizeXref(lmatch[1])+`"`, 1)
+						}
 					}
 				}
 				if manmatches := manlinkregex.FindAllStringSubmatch(line, -1); manmatches != nil {
@@ -137,21 +150,45 @@ func main() {
 					}
 				}
 
+				if sourceblockmatches := sourceblockregex.FindStringIndex(line); sourceblockmatches != nil {
+					isSourceBlock = true
+					continue
+				}
+
 				// Skip content until after first header
 				if !firstHeaderDone {
 					continue
 				}
 				// OK, content here
 
-				// remove characters that markdown would render invisible in a text env.
-				for _, invis := range []string{"`", " "} {
+				// handle source block headers
+				if isSourceBlock {
+					sourceBlockLine = line
+					isSourceBlock = false
+					line = ""
+					continue
+				} else if sourceBlockLine != "" && line == sourceBlockLine {
+					line = ""
+					sourceBlockLine = ""
+				}
+
+				// remove characters that asciidoc would render invisible in a text env.
+				for _, invis := range []string{"`", "...."} {
 					line = strings.Replace(line, invis, "", -1)
 				}
+				line = strings.TrimSuffix(line, " +")
 
-				// indent bullets
+				// indent bullets and definition lists
 				if strings.HasPrefix(line, "*") {
-					lastLineWasBullet = true
-				} else if lastLineWasBullet && !strings.HasPrefix(line, " ") {
+					lastLineWasList = true
+				} else if strings.HasSuffix(line, "::") {
+					lastLineWasList = true
+					line = strings.TrimSuffix(line, ":")
+				} else if lastLineWasList && line == "+" {
+					line = ""
+				} else if lastLineWasList && line == "" {
+					lastLineWasList = false
+				} else if lastLineWasList && !strings.HasPrefix(line, " ") {
 					// indent paragraphs under bullets if not already done
 					line = " " + line
 				}

From 8945cbff81dd745edbecd888938aecde59cc5687 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Wed, 22 Jun 2022 20:33:21 +0000
Subject: [PATCH 14/21] Makefile: build man pages from AsciiDoc

Now that we have AsciiDoc manual pages, let's build our manual pages
from them.  Stop building the index.txt file and use Asciidoctor to
build the output instead.  Handle the difference in file names
gracefully.

Finally, use the attribute "reproducible" to avoid outputting dates in
our output and make them reproducible.  Packagers will appreciate this.
---
 Makefile | 45 ++++++++++-----------------------------------
 1 file changed, 10 insertions(+), 35 deletions(-)

diff --git a/Makefile b/Makefile
index 0b73d9e357..48a478e2af 100644
--- a/Makefile
+++ b/Makefile
@@ -53,6 +53,11 @@ RONN ?= ronn
 # RONN_EXTRA_ARGS are extra arguments given to the $(RONN) program when invoked.
 RONN_EXTRA_ARGS ?=
 
+# ASCIIDOCTOR is the name of the 'asciidoctor' program used to generate man pages.
+ASCIIDOCTOR ?= asciidoctor
+# ASCIIDOCTOR_EXTRA_ARGS are extra arguments given to the $(ASCIIDOCTOR) program when invoked.
+ASCIIDOCTOR_EXTRA_ARGS ?= -a reproducible
+
 # GREP is the name of the program used for regular expression matching, or
 # 'grep' if unset.
 GREP ?= grep
@@ -615,36 +620,6 @@ lint : $(SOURCES)
 	| $(GREP) -v "github.com/git-lfs/git-lfs" \
 	| $(GREP) "."
 
-# generate index.txt for ronn HTML man page link generation
-.PHONY : index.txt
-index.txt :
-	@echo "Generating index.txt for ronn"
-	@( \
-		printf "# internal\n" >index.txt; \
-		for f in $$(cd docs/man && ls git-lfs*.ronn); do \
-			l=$$(printf "$$f" | sed -E 's/\.([1-9])\.ronn$$/(\1)/'); \
-			printf "%s %s\n" "$$l $$f"; \
-		done >>index.txt; \
-		printf "\n# external\n" >>index.txt; \
-		for l in $$(awk 'p && FNR==1 {p=0}; \
-		 p && /^#/ {p=0}; \
-		 p && length; \
-		 /^## SEE ALSO/ {p=1};' \
-				docs/man/git-lfs*.ronn | \
-				sed 's/[^-a-z0-9()]/ /g' | tr -s ' ' '\n' | \
-				sort -u | grep '([1-9])' | grep -v ^git-lfs); do \
-			p=$$(printf "$$l" | head -c 3); \
-			if [ "$$p" = "git" ]; then \
-				f="git-scm.com/docs/%s"; \
-				u=$$(printf "$$l" | sed -E 's/^(.*)$[1-9]$$$/\1/'); \
-			else \
-				f="man7.org/linux/man-pages/man%s.html"; \
-				u=$$(printf "$$l" | sed -E 's/^(.*)$([1-9])$$$/\2\/\1.\2/'); \
-			fi; \
-			printf "%s https://$$f\n" "$$l" "$$u"; \
-		done >>index.txt; \
-	)
-
 # MAN_ROFF_TARGETS is a list of all ROFF-style targets in the man pages.
 MAN_ROFF_TARGETS = man/man1/git-lfs-checkout.1 \
 man/man1/git-lfs-clean.1 \
@@ -719,14 +694,14 @@ MAN_HTML_TARGETS = man/html/git-lfs-checkout.1.html \
 
 # man generates all ROFF- and HTML-style manpage targets.
 .PHONY : man
-man : index.txt $(MAN_ROFF_TARGETS) $(MAN_HTML_TARGETS)
+man : $(MAN_ROFF_TARGETS) $(MAN_HTML_TARGETS)
 
 # man/% generates ROFF-style man pages from the corresponding .ronn file.
-man/man1/% man/man5/% : docs/man/%.ronn
+man/man1/%.1 man/man5/%.5 : docs/man/%.adoc
 	@mkdir -p man/man1 man/man5
-	$(RONN) $(RONN_EXTRA_ARGS) -r --pipe < $^ > $@
+	$(ASCIIDOCTOR) $(ASCIIDOCTOR_EXTRA_ARGS) -b manpage -o $@ $^
 
 # man/%.html generates HTML-style man pages from the corresponding .ronn file.
-man/html/%.html : docs/man/%.ronn
+man/html/%.1.html man/html/%.5.html : docs/man/%.adoc
 	@mkdir -p man/html
-	$(RONN) $(RONN_EXTRA_ARGS) -5 --pipe < $^ > $@
+	$(ASCIIDOCTOR) $(ASCIIDOCTOR_EXTRA_ARGS) -b html5 -o $@ $^

From e93940960ee0e1749a2de6616150cd10061b18e2 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 17:46:12 +0000
Subject: [PATCH 15/21] rpm: set VERSION_ID to major version

The version ID set right now is a value like "8.5" on Rocky Linux 8.  In
such a situation, it's hard to compare, and this prevents rubygems-devel
from being installed properly in such a situation.  To make things work
properly, strip off the decimal point and decimal value from the end of
the string.
---
 rpm/build_rpms.bsh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rpm/build_rpms.bsh b/rpm/build_rpms.bsh
index b5123d55e3..a0d8e693ee 100755
--- a/rpm/build_rpms.bsh
+++ b/rpm/build_rpms.bsh
@@ -4,7 +4,7 @@ set -eu
 
 CURDIR=$(cd $(dirname ${BASH_SOURCE[0]}); pwd)
 if [ -e /etc/os-release ]; then
-  VERSION_ID=$(source /etc/os-release; echo ${VERSION_ID})
+  VERSION_ID=$(source /etc/os-release; echo ${VERSION_ID%%.*})
   OS_NAME=$(source /etc/os-release; echo ${NAME})
   OS_NAME=${OS_NAME,,}
 else #Basically Centos 5/6

From 31c9cf59ae9c55a67fe0f4434b0144ff4fa7de05 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 17:49:11 +0000
Subject: [PATCH 16/21] debian/control: depend on asciidoctor

Since we're now generating our manual pages with Asciidoctor, let's
depend on it instead of ronn.
---
 debian/control | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/debian/control b/debian/control
index 80e23380b4..a8b0fdfd48 100644
--- a/debian/control
+++ b/debian/control
@@ -2,7 +2,7 @@ Source: git-lfs
 Section: vcs
 Priority: optional
 Maintainer: Stephen Gelman <gelman@getbraintree.com>
-Build-Depends: debhelper (>= 9), dh-golang, golang-go:native (>= 1.12.0), git (>= 1.8.2), ruby-ronn, ronn | ruby-ronn (<< 0.8.0-1)
+Build-Depends: debhelper (>= 9), dh-golang, golang-go:native (>= 1.12.0), git (>= 1.8.2), asciidoctor
 Standards-Version: 3.9.6
 
 Package: git-lfs

From db9a82132a2bb066876d8ddf06c5255da2f199a4 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 17:51:19 +0000
Subject: [PATCH 17/21] rpm: build Asciidoctor if not present

If Asciidoctor is not already present, build the gem as an RPM.
---
 rpm/SPECS/rubygem-asciidoctor.spec | 71 ++++++++++++++++++++++++++++++
 rpm/build_rpms.bsh                 | 12 ++---
 2 files changed, 74 insertions(+), 9 deletions(-)
 create mode 100644 rpm/SPECS/rubygem-asciidoctor.spec

diff --git a/rpm/SPECS/rubygem-asciidoctor.spec b/rpm/SPECS/rubygem-asciidoctor.spec
new file mode 100644
index 0000000000..8a4d21125e
--- /dev/null
+++ b/rpm/SPECS/rubygem-asciidoctor.spec
@@ -0,0 +1,71 @@
+#global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
+%global gemdir %(IFS=: R=($(gem env gempath)); echo ${R[${#R[@]}-1]})
+%define gem_name asciidoctor
+
+Name:           rubygem-%{gem_name}
+Version:        2.0.17
+Release:        1%{?dist}
+Summary:        Builds manuals
+
+Group:          Applications/Programming
+License:        N/A
+URL:            https://rubygems.org/gems/%{gem_name}
+Source0:        https://rubygems.org/downloads/%{gem_name}-%{version}.gem
+BuildRoot:      %(echo %{_topdir}/BUILDROOT/%{gem_name}-%{version})
+%if 0%{?el7}
+BuildRequires:  rh-ruby30-ruby, rh-ruby30-build
+Requires:       rh-ruby30-ruby
+%else
+BuildRequires:  gem
+Requires:       ruby
+%endif
+BuildArch:      noarch
+
+%description
+Builds Manuals
+
+%prep
+%if 0%{?el7}
+%setup -q -c -T
+%else
+%setup -q -n %{gem_name}-%{version}
+%endif
+%if 0%{?el7}
+mkdir -p ./usr/local
+gem install -V --local --force --install-dir ./%{gemdir} --wrappers --bindir ./usr/local/bin %{SOURCE0}
+%endif
+
+%build
+%if 0%{?el8}
+gem build ../%{gem_name}-%{version}.gemspec
+gem install -V --local --build-root . --force --no-document %{gem_name}-%{version}.gem
+%endif
+
+%install
+mkdir -p ${RPM_BUILD_ROOT}
+cp -a ./usr ${RPM_BUILD_ROOT}/usr
+%if 0%{?el7}
+cp -a ./opt ${RPM_BUILD_ROOT}/opt
+%endif
+
+%clean
+rm -rf %{buildroot}
+
+%files
+%defattr(-,root,root,-)
+%if 0%{?el8}
+%dir %{gem_instdir}
+%{gem_libdir}
+%exclude %{gem_cache}
+%{gem_spec}
+/usr/share/gems
+/usr/bin/%{gem_name}
+%else
+%{gemdir}/gems/%{gem_name}-%{version}
+/opt/rh/rh-ruby30/root/usr/local/share/gems/cache/%{gem_name}-%{version}.gem
+/opt/rh/rh-ruby30/root/usr/local/share/gems/doc/%{gem_name}-%{version}
+/opt/rh/rh-ruby30/root/usr/local/share/gems/specifications/%{gem_name}-%{version}.gemspec
+/usr/local/bin
+%endif
+
+%changelog
diff --git a/rpm/build_rpms.bsh b/rpm/build_rpms.bsh
index a0d8e693ee..6285ba485c 100755
--- a/rpm/build_rpms.bsh
+++ b/rpm/build_rpms.bsh
@@ -124,20 +124,14 @@ if [[ ${VERSION_ID[0]} == 8 ]]; then
   $SUDO yum install -y rubygems-devel
 fi
 
-if ! command -v ronn; then
+if ! command -v asciidoctor; then
   echo "Downloading some ruby gems..."
   pushd ${CURDIR}/SOURCES
-    curl -L -O https://rubygems.org/downloads/rdiscount-2.1.8.gem
-    curl -L -O https://rubygems.org/downloads/hpricot-0.8.6.gem
-    curl -L -O https://rubygems.org/downloads/mustache-1.0.1.gem
-    curl -L -O https://rubygems.org/downloads/ronn-0.7.3.gem
+    curl -L -O https://rubygems.org/downloads/asciidoctor-2.0.17.gem
   popd
 
   echo "Building ruby gems..."
-  "${RPMBUILD[@]}" -ba ${CURDIR}/SPECS/rubygem-rdiscount.spec
-  "${RPMBUILD[@]}" -ba ${CURDIR}/SPECS/rubygem-mustache.spec
-  "${RPMBUILD[@]}" -ba ${CURDIR}/SPECS/rubygem-hpricot.spec
-  "${RPMBUILD[@]}" -ba ${CURDIR}/SPECS/rubygem-ronn.spec
+  "${RPMBUILD[@]}" -ba ${CURDIR}/SPECS/rubygem-asciidoctor.spec
 
   echo "Installing ruby gems..."
   $SUDO yum install -y --nogpgcheck $(ls ${CURDIR}/RPMS/noarch/rubygem-*.rpm ${CURDIR}/RPMS/x86_64/rubygem-*.rpm | grep -v debuginfo)

From 9576d07463ac0e33d8acfd986041d5b55abdf935 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 17:57:31 +0000
Subject: [PATCH 18/21] rpm: switch completely from ronn to Asciidoctor

Update all the dependencies to refer to Asciidoctor instead and remove
the remaining ronn-related instructions and specs.
---
 rpm/INSTALL.md                   |  6 +--
 rpm/SPECS/git-lfs.spec           |  2 +-
 rpm/SPECS/rubygem-hpricot.spec   | 59 -----------------------------
 rpm/SPECS/rubygem-mustache.spec  | 61 ------------------------------
 rpm/SPECS/rubygem-rdiscount.spec | 61 ------------------------------
 rpm/SPECS/rubygem-ronn.spec      | 65 --------------------------------
 6 files changed, 4 insertions(+), 250 deletions(-)
 delete mode 100644 rpm/SPECS/rubygem-hpricot.spec
 delete mode 100644 rpm/SPECS/rubygem-mustache.spec
 delete mode 100644 rpm/SPECS/rubygem-rdiscount.spec
 delete mode 100644 rpm/SPECS/rubygem-ronn.spec

diff --git a/rpm/INSTALL.md b/rpm/INSTALL.md
index 9fe3e21315..8c90818415 100644
--- a/rpm/INSTALL.md
+++ b/rpm/INSTALL.md
@@ -5,7 +5,7 @@ source code tarball needs to be put in a SOURCES directory. The BUILD and
 BUILDROOT directories are used during the build process. The final RPM ends up
 in the RPMS directory and a source-rpm in SRPMS.
 
-In order to expedite installing all dependencies (mainly ruby-ronn and golang)
+In order to expedite installing all dependencies (mainly asciidoctor and golang)
 and download any needed files a build_rpms.bsh script is included. This is the
 **RECOMMENDED** way to build the rpms. It will install all yum packages in
 order to build the rpm. This can be especially difficult in CentOS 5 and 6,
@@ -38,7 +38,7 @@ yum install RPMS/x86_64/git-lfs*.rpm
 
 If you want to use your own ruby/golang without using the version from
 build_rpms.bsh, you will have to disable dependencies on the rpms. It's pretty
-easy, just make sure ronn and go are in the path, and run
+easy, just make sure asciidoctor and go are in the path, and run
 
 ```
 NODEPS=1 ./build_rpms.bsh
@@ -47,7 +47,7 @@ NODEPS=1 ./build_rpms.bsh
 ### Manual build method ###
 
 If you want to use your own ruby/golang without using build_rpms.bsh, it's a
-little more complicated. You have to make sure ronn and go are in the path,
+little more complicated. You have to make sure asciidoctor and go are in the path,
 and create the build structure, and download/create the tar.gz file used. This
 is not recommended, but it is possible.
 
diff --git a/rpm/SPECS/git-lfs.spec b/rpm/SPECS/git-lfs.spec
index 8ff505093b..e0a8525359 100644
--- a/rpm/SPECS/git-lfs.spec
+++ b/rpm/SPECS/git-lfs.spec
@@ -9,7 +9,7 @@ URL: https://git-lfs.github.com/
 Source0: https://github.com/git-lfs/git-lfs/archive/v%{version}/%{name}-%{version}.tar.gz
 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
 BuildRequires: perl-Digest-SHA
-BuildRequires: golang, tar, rubygem-ronn, which, git >= 1.8.2, gettext-devel
+BuildRequires: golang, tar, rubygem-asciidoctor, which, git >= 1.8.2, gettext-devel
 
 Requires: git >= 1.8.2
 
diff --git a/rpm/SPECS/rubygem-hpricot.spec b/rpm/SPECS/rubygem-hpricot.spec
deleted file mode 100644
index afbde3dec8..0000000000
--- a/rpm/SPECS/rubygem-hpricot.spec
+++ /dev/null
@@ -1,59 +0,0 @@
-#global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
-%global gemdir %(IFS=: R=($(gem env gempath)); echo ${R[${#R[@]}-1]})
-%define gem_name hpricot
-Name: rubygem-%{gem_name}
-Version: 0.8.6
-Release:	1%{?dist}
-Summary: a swift, liberal HTML parser with a fantastic library
-
-Group: Applications/Programming
-License: N/A
-URL:		https://rubygems.org/gems/%{gem_name}
-Source0:	https://rubygems.org/downloads/%{gem_name}-%{version}.gem
-BuildRoot: %(echo %{_topdir}/BUILDROOT/%{gem_name}-%{version})
-BuildRequires:	gem
-Requires: ruby
-
-%description
-a swift, liberal HTML parser with a fantastic library
-
-%prep
-%if 0%{?el6}%{?el7}
-%setup -q -c -T
-%else
-%setup -q -n %{gem_name}-%{version}
-%endif
-%if ! 0%{?el8}
-gem install -V --local --force --install-dir ./%{gemdir} %{SOURCE0}
-%endif
-#mv ./%{gemdir}/bin ./usr/local
-
-%build
-%if 0%{?el8}
-gem build ../%{gem_name}-%{version}.gemspec
-%gem_install
-%endif
-
-%install
-mkdir -p ${RPM_BUILD_ROOT}
-cp -a ./usr ${RPM_BUILD_ROOT}/usr
-
-%clean
-rm -rf %{buildroot}
-
-%files
-%defattr(-,root,root,-)
-%if 0%{?el8}
-%dir %{gem_instdir}
-%{gem_extdir_mri}
-%{gem_libdir}
-%exclude %{gem_cache}
-%{gem_spec}
-/usr/share/gems
-%else
-%{gemdir}
-%endif
-
-%changelog
-* Wed May 20 2015 Andrew Neff <andyneff@users.noreply.github.com> - 2.1.8
-- Initial Spec
diff --git a/rpm/SPECS/rubygem-mustache.spec b/rpm/SPECS/rubygem-mustache.spec
deleted file mode 100644
index 4e15f94ddb..0000000000
--- a/rpm/SPECS/rubygem-mustache.spec
+++ /dev/null
@@ -1,61 +0,0 @@
-#global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
-%global gemdir %(IFS=: R=($(gem env gempath)); echo ${R[${#R[@]}-1]})
-%define gem_name mustache
-
-Name: rubygem-%{gem_name}
-Version: 1.0.1
-Release:	1%{?dist}
-Summary: A framework-agnostic way to render logic-free views
-
-Group: Applications/Programming
-License: MIT
-URL:		https://rubygems.org/gems/%{gem_name}
-Source0:	https://rubygems.org/downloads/%{gem_name}-%{version}.gem
-BuildRoot: %(echo %{_topdir}/BUILDROOT/%{gem_name}-%{version})
-BuildRequires:	gem > 2.0
-Requires: ruby > 2.0
-BuildArch: noarch
-
-%description
-Inspired by ctemplate, Mustache is a framework-agnostic way to render logic-free views. As ctemplates says, "It emphasizes separating logic from presentation: it is impossible to embed application logic in this template language. Think of Mustache as a replacement for your views. Instead of views consisting of ERB or HAML with random helpers and arbitrary logic, your views are broken into two parts: a Ruby class and an HTML template.
-
-%prep
-%if 0%{?el6}%{?el7}
-%setup -q -c -T
-%else
-%setup -q -n %{gem_name}-%{version}
-%endif
-%if ! 0%{?el8}
-gem install -V --local --force --install-dir ./%{gemdir} %{SOURCE0}
-mv ./%{gemdir}/bin ./usr/local
-%endif
-
-%build
-%if 0%{?el8}
-gem build ../%{gem_name}-%{version}.gemspec
-%gem_install
-%endif
-
-%install
-mkdir -p ${RPM_BUILD_ROOT}
-cp -a ./usr ${RPM_BUILD_ROOT}/usr
-
-%clean
-rm -rf %{buildroot}
-
-%files
-%defattr(-,root,root,-)
-%if 0%{?el8}
-%dir %{gem_instdir}
-%{gem_libdir}
-%exclude %{gem_cache}
-/usr/share/gems
-/usr/bin/%{gem_name}
-%else
-%{gemdir}
-/usr/local/bin/%{gem_name}
-%endif
-
-%changelog
-* Wed May 20 2015 Andrew Neff <andyneff@users.noreply.github.com> - 2.1.8
-- Initial Spec
diff --git a/rpm/SPECS/rubygem-rdiscount.spec b/rpm/SPECS/rubygem-rdiscount.spec
deleted file mode 100644
index 76cecaadaa..0000000000
--- a/rpm/SPECS/rubygem-rdiscount.spec
+++ /dev/null
@@ -1,61 +0,0 @@
-#global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
-%global gemdir %(IFS=: R=($(gem env gempath)); echo ${R[${#R[@]}-1]})
-%define gem_name rdiscount
-Name: rubygem-%{gem_name}
-Version: 2.1.8
-Release:	1%{?dist}
-Summary: Fast Implementation of Gruber's Markdown in C
-
-Group: Applications/Programming
-License: BSD
-URL:		https://rubygems.org/gems/%{gem_name}
-Source0:	https://rubygems.org/downloads/%{gem_name}-%{version}.gem
-BuildRoot: %(echo %{_topdir}/BUILDROOT/%{gem_name}-%{version})
-BuildRequires:	gem > 1.9.2
-Requires: ruby > 1.9.2
-
-%description
-Fast Implementation of Gruber's Markdown in C
-
-%prep
-%if 0%{?el6}%{?el7}
-%setup -q -c -T
-%else
-%setup -q -n %{gem_name}-%{version}
-%endif
-%if ! 0%{?el8}
-gem install -V --local --force --install-dir ./%{gemdir} %{SOURCE0}
-mv ./%{gemdir}/bin ./usr/local
-%endif
-
-%build
-%if 0%{?el8}
-gem build ../%{gem_name}-%{version}.gemspec
-%gem_install
-%endif
-
-%install
-mkdir -p ${RPM_BUILD_ROOT}
-cp -a ./usr ${RPM_BUILD_ROOT}/usr
-
-%clean
-rm -rf %{buildroot}
-
-%files
-%defattr(-,root,root,-)
-%if 0%{?el8}
-%dir %{gem_instdir}
-%{gem_extdir_mri}
-%{gem_libdir}
-%exclude %{gem_cache}
-/usr/share/gems
-/usr/bin/%{gem_name}
-%{gem_spec}
-%else
-%{gemdir}
-/usr/local/bin/%{gem_name}
-%endif
-
-%changelog
-* Wed May 20 2015 Andrew Neff <andyneff@users.noreply.github.com> - 2.1.8
-- Initial Spec
diff --git a/rpm/SPECS/rubygem-ronn.spec b/rpm/SPECS/rubygem-ronn.spec
deleted file mode 100644
index 2160e42484..0000000000
--- a/rpm/SPECS/rubygem-ronn.spec
+++ /dev/null
@@ -1,65 +0,0 @@
-#global gemdir %(ruby -rubygems -e 'puts Gem::dir' 2>/dev/null)
-%global gemdir %(IFS=: R=($(gem env gempath)); echo ${R[${#R[@]}-1]})
-%define gem_name ronn
-
-Name: rubygem-%{gem_name}
-Version: 0.7.3
-Release:	1%{?dist}
-Summary: Builds manuals
-
-Group: Applications/Programming
-License: N/A
-URL:		https://rubygems.org/gems/%{gem_name}
-Source0:	https://rubygems.org/downloads/%{gem_name}-%{version}.gem
-BuildRoot: %(echo %{_topdir}/BUILDROOT/%{gem_name}-%{version})
-BuildRequires:	gem
-Requires: ruby
-Requires: rubygem-hpricot >= 0.8.2
-Requires: rubygem-mustache >= 0.7.0
-Requires: rubygem-rdiscount >= 1.5.8
-BuildArch: noarch
-
-%description
-Builds Manuals
-
-%prep
-%if 0%{?el6}%{?el7}
-%setup -q -c -T
-%else
-%setup -q -n %{gem_name}-%{version}
-%endif
-%if ! 0%{?el8}
-gem install -V --local --force --install-dir ./%{gemdir} %{SOURCE0}
-mv ./%{gemdir}/bin ./usr/local
-%endif
-
-%build
-%if 0%{?el8}
-gem build ../%{gem_name}-%{version}.gemspec
-%gem_install
-%endif
-
-%install
-mkdir -p ${RPM_BUILD_ROOT}
-cp -a ./usr ${RPM_BUILD_ROOT}/usr
-
-%clean
-rm -rf %{buildroot}
-
-%files
-%defattr(-,root,root,-)
-%if 0%{?el8}
-%dir %{gem_instdir}
-%{gem_libdir}
-%exclude %{gem_cache}
-%{gem_spec}
-/usr/share/gems
-/usr/bin/%{gem_name}
-%else
-%{gemdir}
-/usr/local/bin/%{gem_name}
-%endif
-
-%changelog
-* Wed May 20 2015 Andrew Neff <andyneff@users.noreply.github.com> - 2.1.8
-- Initial Spec

From 370b8d8f1932d47bca1f84a82c1d79bed84ec893 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 17:58:51 +0000
Subject: [PATCH 19/21] workflows: use Asciidoctor

Use Asciidoctor instead of ronn to build docs.
---
 .github/workflows/ci.yml      | 4 ++--
 .github/workflows/release.yml | 6 +++---
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c4834f4007..8b01b8d47a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -21,7 +21,7 @@ jobs:
       if: ${{ startsWith(matrix.os, 'ubuntu-') }}
       env:
           DEBIAN_FRONTEND: noninteractive
-    - run: gem install ronn-ng
+    - run: gem install asciidoctor
     - run: script/cibuild
       env:
           FORCE_LOCALIZE: true
@@ -61,7 +61,7 @@ jobs:
     - run: cinst InnoSetup -y
     - run: cinst strawberryperl -y
     - run: refreshenv
-    - run: gem install ronn-ng
+    - run: gem install asciidoctor
       shell: bash
     - run: make man
       shell: bash
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 9c3a3b9616..2523a3ce81 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,7 +23,7 @@ jobs:
     - run: cinst strawberryperl -y
     - run: cinst zip -y
     - run: cinst jq -y
-    - run: gem install ronn-ng
+    - run: gem install asciidoctor
     - run: refreshenv
     - run: GOPATH="$HOME/go" PATH="$HOME/go/bin:$PATH" go install github.com/josephspurrier/goversioninfo/cmd/goversioninfo@latest
       shell: bash
@@ -70,7 +70,7 @@ jobs:
         go-version: ${{ matrix.go }}
     - run: brew install gettext
     - run: brew install mitchellh/gon/gon
-    - run: gem install ronn-ng
+    - run: gem install asciidoctor
     - run: make release
       env:
           FORCE_LOCALIZE: true
@@ -113,7 +113,7 @@ jobs:
     - uses: actions/download-artifact@v1
       with:
         name: macos-assets
-    - run: gem install ronn-ng
+    - run: gem install asciidoctor
     - run: CGO_ENABLED=0 make release
     - run: rm -f bin/releases/*windows* bin/releases/*darwin*
     - run: 'find windows-assets -name "*windows*" -type f | xargs -L1 -I{} mv {} bin/releases'

From cbab711c15bd521d26954020f0a5208700e75390 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Thu, 23 Jun 2022 18:10:09 +0000
Subject: [PATCH 20/21] docs: remove ronn files

These are no longer needed, so let's remove them.
---
 docs/man/git-lfs-checkout.1.ronn        |  87 -----
 docs/man/git-lfs-clean.1.ronn           |  24 --
 docs/man/git-lfs-clone.1.ronn           |  57 ---
 docs/man/git-lfs-config.5.ronn          | 443 ----------------------
 docs/man/git-lfs-dedup.1.ronn           |  23 --
 docs/man/git-lfs-env.1.ronn             |  14 -
 docs/man/git-lfs-ext.1.ronn             |  26 --
 docs/man/git-lfs-fetch.1.ronn           | 153 --------
 docs/man/git-lfs-filter-process.1.ronn  |  45 ---
 docs/man/git-lfs-fsck.1.ronn            |  40 --
 docs/man/git-lfs-install.1.ronn         |  58 ---
 docs/man/git-lfs-lock.1.ronn            |  32 --
 docs/man/git-lfs-locks.1.ronn           |  54 ---
 docs/man/git-lfs-logs.1.ronn            |  33 --
 docs/man/git-lfs-ls-files.1.ronn        |  52 ---
 docs/man/git-lfs-merge-driver.1.ronn    |  91 -----
 docs/man/git-lfs-migrate.1.ronn         | 467 ------------------------
 docs/man/git-lfs-pointer.1.ronn         |  44 ---
 docs/man/git-lfs-post-checkout.1.ronn   |  18 -
 docs/man/git-lfs-post-commit.1.ronn     |  23 --
 docs/man/git-lfs-post-merge.1.ronn      |  18 -
 docs/man/git-lfs-pre-push.1.ronn        |  35 --
 docs/man/git-lfs-prune.1.ronn           | 140 -------
 docs/man/git-lfs-pull.1.ronn            |  53 ---
 docs/man/git-lfs-push.1.ronn            |  39 --
 docs/man/git-lfs-smudge.1.ronn          |  51 ---
 docs/man/git-lfs-standalone-file.1.ronn |  22 --
 docs/man/git-lfs-status.1.ronn          |  34 --
 docs/man/git-lfs-track.1.ronn           |  80 ----
 docs/man/git-lfs-uninstall.1.ronn       |  41 ---
 docs/man/git-lfs-unlock.1.ronn          |  34 --
 docs/man/git-lfs-untrack.1.ronn         |  23 --
 docs/man/git-lfs-update.1.ronn          |  28 --
 docs/man/git-lfs.1.ronn                 | 124 -------
 34 files changed, 2506 deletions(-)
 delete mode 100644 docs/man/git-lfs-checkout.1.ronn
 delete mode 100644 docs/man/git-lfs-clean.1.ronn
 delete mode 100644 docs/man/git-lfs-clone.1.ronn
 delete mode 100644 docs/man/git-lfs-config.5.ronn
 delete mode 100644 docs/man/git-lfs-dedup.1.ronn
 delete mode 100644 docs/man/git-lfs-env.1.ronn
 delete mode 100644 docs/man/git-lfs-ext.1.ronn
 delete mode 100644 docs/man/git-lfs-fetch.1.ronn
 delete mode 100644 docs/man/git-lfs-filter-process.1.ronn
 delete mode 100644 docs/man/git-lfs-fsck.1.ronn
 delete mode 100644 docs/man/git-lfs-install.1.ronn
 delete mode 100644 docs/man/git-lfs-lock.1.ronn
 delete mode 100644 docs/man/git-lfs-locks.1.ronn
 delete mode 100644 docs/man/git-lfs-logs.1.ronn
 delete mode 100644 docs/man/git-lfs-ls-files.1.ronn
 delete mode 100644 docs/man/git-lfs-merge-driver.1.ronn
 delete mode 100644 docs/man/git-lfs-migrate.1.ronn
 delete mode 100644 docs/man/git-lfs-pointer.1.ronn
 delete mode 100644 docs/man/git-lfs-post-checkout.1.ronn
 delete mode 100644 docs/man/git-lfs-post-commit.1.ronn
 delete mode 100644 docs/man/git-lfs-post-merge.1.ronn
 delete mode 100644 docs/man/git-lfs-pre-push.1.ronn
 delete mode 100644 docs/man/git-lfs-prune.1.ronn
 delete mode 100644 docs/man/git-lfs-pull.1.ronn
 delete mode 100644 docs/man/git-lfs-push.1.ronn
 delete mode 100644 docs/man/git-lfs-smudge.1.ronn
 delete mode 100644 docs/man/git-lfs-standalone-file.1.ronn
 delete mode 100644 docs/man/git-lfs-status.1.ronn
 delete mode 100644 docs/man/git-lfs-track.1.ronn
 delete mode 100644 docs/man/git-lfs-uninstall.1.ronn
 delete mode 100644 docs/man/git-lfs-unlock.1.ronn
 delete mode 100644 docs/man/git-lfs-untrack.1.ronn
 delete mode 100644 docs/man/git-lfs-update.1.ronn
 delete mode 100644 docs/man/git-lfs.1.ronn

diff --git a/docs/man/git-lfs-checkout.1.ronn b/docs/man/git-lfs-checkout.1.ronn
deleted file mode 100644
index 3df823fb9a..0000000000
--- a/docs/man/git-lfs-checkout.1.ronn
+++ /dev/null
@@ -1,87 +0,0 @@
-git-lfs-checkout(1) -- Update working copy with file content if available
-=========================================================================
-
-## SYNOPSIS
-
-`git lfs checkout` [<glob-pattern>...] 
-`git lfs checkout` --to <file> {--base|--ours|--theirs} <conflict-obj-path>
-
-## DESCRIPTION
-
-Try to ensure that the working copy contains file content for Git LFS objects
-for the current ref, if the object data is available. Does not download any
-content; see git-lfs-fetch(1) for that.
-
-Checkout scans the current ref for all LFS objects that would be required, then
-where a file is either missing in the working copy, or contains placeholder
-pointer content with the same SHA, the real file content is written, provided
-we have it in the local store. Modified files are never overwritten.
-
-One or more <glob-pattern>s may be provided as arguments to restrict the
-set of files that are updated. Glob patterns are matched as per the format
-described in gitignore(5).
-
-When used with `--to` and the working tree is in a conflicted state due to a
-merge, this option checks out one of the three stages a conflicting Git LFS
-object into a separate file (which can be outside of the work tree).
-This can make using diff tools to inspect and resolve merges easier.
-A single Git LFS object's file path must be provided in <conflict-obj-path>.
-
-## OPTIONS
-
-* `--base`:
- Check out the merge base of the specified file.
-
-* `--ours`:
- Check out our side (that of the current branch) of the conflict for the
- specified file.
-
-* `--theirs`:
- Check out their side (that of the other branch) of the conflict for the
- specified file.
-
-* `--to` <path>:
- If the working tree is in a conflicted state, check out the portion of the
- conflict specified by `--base`, `--ours`, or `--theirs` to the given path.
-
-## EXAMPLES
-
-* Checkout all files that are missing or placeholders:
-
-```
-$ git lfs checkout
-```
-
-* Checkout a specific couple of files:
-
-```
-$ git lfs checkout path/to/file1.png path/to.file2.png
-```
-
-* Checkout a path with a merge conflict into separate files:
-
-```
-# Attempt merge with a branch that has a merge conflict
-$ git merge conflicting-branch
-CONFLICT (content): Merge conflict in path/to/conflicting/file.dat
-
-# Checkout versions of the conflicting file into temp files
-$ git lfs checkout ours.dat --ours path/to/conflicting/file.dat
-$ git lfs checkout theirs.dat --theirs path/to/conflicting/file.dat
-
-# Compare conflicting versions in ours.dat and theirs.dat,
-# then resolve conflict (e.g., by choosing one version over
-# the other, or creating a new version)
-
-# Cleanup and continue with merge
-$ rm ours.dat theirs.dat
-$ git add path/to/conflicting/file.dat
-$ git merge --continue
-```
-
-## SEE ALSO
-
-git-lfs-fetch(1), git-lfs-pull(1), gitignore(5).
-
-Part of the git-lfs(1) suite.
-
diff --git a/docs/man/git-lfs-clean.1.ronn b/docs/man/git-lfs-clean.1.ronn
deleted file mode 100644
index 0789088f0e..0000000000
--- a/docs/man/git-lfs-clean.1.ronn
+++ /dev/null
@@ -1,24 +0,0 @@
-git-lfs-clean(1) -- Git clean filter that converts large files to pointers
-==========================================================================
-
-## SYNOPSIS
-
-`git lfs clean` <path>
-
-## DESCRIPTION
-
-Read the contents of a large file from standard input, and write a Git
-LFS pointer file for that file to standard output.
-
-Clean is typically run by Git's clean filter, configured by the repository's
-Git attributes.
-
-Clean is not part of the user-facing Git plumbing commands. To preview the
-pointer of a large file as it would be generated, see the git-lfs-pointer(1)
-command.
-
-## SEE ALSO
-
-git-lfs-install(1), git-lfs-push(1), git-lfs-pointer(1), gitattributes(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-clone.1.ronn b/docs/man/git-lfs-clone.1.ronn
deleted file mode 100644
index e74c18cd08..0000000000
--- a/docs/man/git-lfs-clone.1.ronn
+++ /dev/null
@@ -1,57 +0,0 @@
-git-lfs-clone(1) -- Efficiently clone a LFS-enabled repository
-========================================================================
-
-## SYNOPSIS
-
-`git lfs clone` [git clone options] <repository> [<directory>]
-
-## DESCRIPTION
-
-Clone an LFS enabled Git repository more efficiently by disabling LFS during the
-git clone, then performing a 'git lfs pull' directly afterwards.
-
-'git lfs clone' also installs all of the repo-level hooks (.git/hooks) that LFS
-requires to operate. If `--separate-git-dir` is given, the hooks will be
-installed there.
-
-This is faster than a regular 'git clone' because that will download LFS content
-using the smudge filter, which is executed individually per file in the working
-copy. This is relatively inefficient compared to the batch mode and parallel
-downloads performed by 'git lfs pull'.
-
-## OPTIONS
-
-All options supported by 'git clone'
-
-* `-I` <paths> `--include=`<paths>:
- See [INCLUDE AND EXCLUDE]
-
-* `-X` <paths> `--exclude=`<paths>:
- See [INCLUDE AND EXCLUDE]
-
-* `--skip-repo`:
- Skip installing repo-level hooks (.git/hooks) that LFS requires. Disabled by
- default.
-
-## INCLUDE AND EXCLUDE
-
-You can configure Git LFS to only fetch objects to satisfy references in certain
-paths of the repo, and/or to exclude certain paths of the repo, to reduce the
-time you spend downloading things you do not use.
-
-In your Git configuration or in a `.lfsconfig` file, you may set either or
-both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated lists of
-paths. If `lfs.fetchinclude` is defined, Git LFS objects will only be fetched
-if their path matches one in that list, and if `lfs.fetchexclude` is defined,
-Git LFS objects will only be fetched if their path does not match one
-in that list. Paths are matched using wildcard matching as per gitignore(5).
-
-Note that using the command-line options `-I` and `-X` override the respective
-configuration settings. Setting either option to an empty string clears the
-value.
-
-## SEE ALSO
-
-git-clone(1), git-lfs-pull(1), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-config.5.ronn b/docs/man/git-lfs-config.5.ronn
deleted file mode 100644
index 90e550df0d..0000000000
--- a/docs/man/git-lfs-config.5.ronn
+++ /dev/null
@@ -1,443 +0,0 @@
-git-lfs-config(5) -- Configuration options for git-lfs
-======================================================
-
-## CONFIGURATION FILES
-
-git-lfs reads its configuration from any file supported by `git config -l`,
-including all per-repository, per-user, and per-system Git configuration files.
-
-Additionally, a small number of settings can be specified in a file called
-`.lfsconfig` at the root of the repository; see the "LFSCONFIG" section for more
-details. This configuration file is useful for setting options such as the LFS
-URL or access type for all users of a repository, especially when these differ
-from the default. The `.lfsconfig` file uses the same format as `.gitconfig`.
-
-If the `.lfsconfig` file is missing, the index is checked for a version of the
-file, and that is used instead. If both are missing, `HEAD` is checked for the
-file. If the repository is bare, only `HEAD` is checked. This order may change
-for checkouts in the future to better match Git's behavior.
-
-Settings from Git configuration files override the `.lfsconfig` file. This
-allows you to override settings like `lfs.url` in your local environment without
-having to modify the `.lfsconfig` file.
-
-Most options regarding git-lfs are contained in the `[lfs]` section, meaning
-they are all named `lfs.foo` or similar, although occasionally an lfs option can
-be scoped inside the configuration for a remote.
-
-
-## LIST OF OPTIONS
-
-### General settings
-
-* `lfs.url` / `remote.<remote>.lfsurl`
-
- The url used to call the Git LFS remote API. Default blank (derive from clone
- URL).
-
-* `lfs.pushurl` / `remote.<remote>.lfspushurl`
-
- The url used to call the Git LFS remote API when pushing. Default blank (derive
- from either LFS non-push urls or clone url).
-
-* `remote.lfsdefault`
-
- The remote used to find the Git LFS remote API. `lfs.url` and
- `branch.*.remote` for the current branch override this setting. If this
- setting is not specified and there is exactly one remote, that remote is
- picked; otherwise, the default is `origin`.
-
-* `remote.lfspushdefault`
-
- The remote used to find the Git LFS remote API when pushing. `lfs.url` and
- `branch.*.pushremote` for the current branch override this setting. If this
- setting is not set, `remote.pushdefault` is used, or if that is not set, the
- order of selection is used as specified in the `remote.lfsdefault` above.
-
-* `lfs.dialtimeout`
-
- Sets the maximum time, in seconds, that the HTTP client will wait to initiate
- a connection. This does not include the time to send a request and wait for a
- response. Default: 30 seconds
-
-* `lfs.tlstimeout`
-
- Sets the maximum time, in seconds, that the HTTP client will wait for a TLS
- handshake. Default: 30 seconds.
-
-* `lfs.activitytimeout` / `lfs.https://<host>.activitytimeout`
-
- Sets the maximum time, in seconds, that the HTTP client will wait for the
- next tcp read or write. If < 1, no activity timeout is used at all.
- Default: 30 seconds
-
-* `lfs.keepalive`
-
- Sets the maximum time, in seconds, for the HTTP client to maintain keepalive
- connections. Default: 30 minutes.
-
-* `lfs.ssh.automultiplex`
-
- When using the pure SSH-based protocol, whether to multiplex requests over a
- single connection when possible. This option requires the use of OpenSSH or a
- compatible SSH client. Default: true.
-
-* `lfs.ssh.retries`
-
- Specifies the number of times Git LFS will attempt to obtain authorization via
- SSH before aborting. Default: 5.
-
-* `core.askpass`, GIT_ASKPASS
-
- Given as a program and its arguments, this is invoked when authentication is
- needed against the LFS API. The contents of stdout are interpreted as the
- password.
-
-* `lfs.cachecredentials`
-
- Enables in-memory SSH and Git Credential caching for a single 'git lfs'
- command. Default: enabled.
-
-* `lfs.storage`
-
- Allow override LFS storage directory. Non-absolute path is relativized to
- inside of Git repository directory (usually `.git`).
-
- Note: you should not run `git lfs prune` if you have different repositories
- sharing the same storage directory.
-
- Default: `lfs` in Git repository directory (usually `.git/lfs`).
-
-* `lfs.largefilewarning`
-
- Warn when a file is 4 GiB or larger. Such files will be corrupted when using
- Windows (unless smudging is disabled) with a Git for Windows version less than
- 2.34.0 due to a limitation in Git. Default: true if the version is less than
- 2.34.0, false otherwise.
-
-### Upload and download transfer settings
-
- These settings control how the upload and download of LFS content occurs.
-
-* `lfs.concurrenttransfers`
-
- The number of concurrent uploads/downloads. Default 8.
-
-* `lfs.basictransfersonly`
-
- If set to true, only basic HTTP upload/download transfers will be used,
- ignoring any more advanced transfers that the client/server may support.
- This is primarily to work around bugs or incompatibilities.
-
- The git-lfs client supports basic HTTP downloads, resumable HTTP downloads
- (using `Range` headers), and resumable uploads via tus.io protocol. Custom
- transfer methods can be added via `lfs.customtransfer` (see next section).
- However setting this value to true limits the client to simple HTTP.
-
-* `lfs.tustransfers`
-
- If set to true, this enables resumable uploads of LFS objects through the
- tus.io API. Once this feature is finalized, this setting will be removed,
- and tus.io uploads will be available for all clients.
-
-* `lfs.standalonetransferagent`
-
- Allows the specified custom transfer agent to be used directly
- for transferring files, without asking the server how the transfers
- should be made. The custom transfer agent has to be defined in a
- `lfs.customtransfer.<name>` settings group.
-
-* `lfs.customtransfer.<name>.path`
-
- `lfs.customtransfer.<name>` is a settings group which defines a custom
- transfer hook which allows you to upload/download via an intermediate process,
- using any mechanism you like (rather than just HTTP). `path` should point to
- the process you wish to invoke. The protocol between the git-lfs client and
- the custom transfer process is documented at
- https://github.com/git-lfs/git-lfs/blob/main/docs/custom-transfers.md
-
- <name> must be a unique identifier that the LFS server understands. When
- calling the LFS API the client will include a list of supported transfer
- types. If the server also supports this named transfer type, it will select it
- and actions returned from the API will be in relation to that transfer type
- (may not be traditional URLs for example). Only if the server accepts <name>
- as a transfer it supports will this custom transfer process be invoked.
-
-* `lfs.customtransfer.<name>.args`
-
- If the custom transfer process requires any arguments, these can be provided
- here. This string will be expanded by the shell.
-
-* `lfs.customtransfer.<name>.concurrent`
-
- If true (the default), git-lfs will invoke the custom transfer process
- multiple times in parallel, according to `lfs.concurrenttransfers`, splitting
- the transfer workload between the processes.
-
-* `lfs.customtransfer.<name>.direction`
-
- Specifies which direction the custom transfer process supports, either
- "download", "upload", or "both". The default if unspecified is "both".
-
-* `lfs.transfer.maxretries`
-
- Specifies how many retries LFS will attempt per OID before marking the
- transfer as failed. Must be an integer which is at least one. If the value is
- not an integer, is less than one, or is not given, a value of eight will be
- used instead.
-
-* `lfs.transfer.maxretrydelay`
-
- Specifies the maximum time in seconds LFS will wait between each retry
- attempt. LFS uses exponential backoff for retries, doubling the time between
- each retry until reaching this limit. If a server requests a delay using the
- `Retry-After` header, the header value overrides the exponential delay for
- that attempt and is not limited by this option.
-
- Must be an integer which is not negative. Use zero to disable delays between
- retries unless requested by a server. If the value is not an integer, is
- negative, or is not given, a value of ten will be used instead.
-
-* `lfs.transfer.maxverifies`
-
- Specifies how many verification requests LFS will attempt per OID before
- marking the transfer as failed, if the object has a verification action
- associated with it. Must be an integer which is at least one. If the value is
- not an integer, is less than one, or is not given, a default value of three
- will be used instead.
-
-* `lfs.transfer.enablehrefrewrite`
-
- If set to true, this enables rewriting href of LFS objects using
- `url.*.insteadof/pushinsteadof` config. `pushinsteadof` is used only for
- uploading, and `insteadof` is used for downloading and for uploading when
- `pushinsteadof` is not set.
-
-### Push settings
-
-* `lfs.allowincompletepush`
-
- When pushing, allow objects to be missing from the local cache without halting
- a Git push. Default: false.
-
-### Fetch settings
-
-* `lfs.fetchinclude`
-
- When fetching, only download objects which match any entry on this
- comma-separated list of paths/filenames. Wildcard matching is as per
- gitignore(5). See git-lfs-fetch(1) for examples.
-
-* `lfs.fetchexclude`
-
- When fetching, do not download objects which match any item on this
- comma-separated list of paths/filenames. Wildcard matching is as per
- gitignore(5). See git-lfs-fetch(1) for examples.
-
-* `lfs.fetchrecentrefsdays`
-
- If non-zero, fetches refs which have commits within N days of the current
- date. Only local refs are included unless lfs.fetchrecentremoterefs is true.
- Also used as a basis for pruning old files.
- The default is 7 days.
-
-* `lfs.fetchrecentremoterefs`
-
- If true, fetches remote refs (for the remote you're fetching) as well as local
- refs in the recent window. This is useful to fetch objects for remote branches
- you might want to check out later. The default is true; if you set this to
- false, fetching for those branches will only occur when you either check them
- out (losing the advantage of fetch --recent), or create a tracking local
- branch separately then fetch again.
-
-* `lfs.fetchrecentcommitsdays`
-
- In addition to fetching at refs, also fetches previous changes made within N
- days of the latest commit on the ref. This is useful if you're often reviewing
- recent changes. Also used as a basis for pruning old files.
- The default is 0 (no previous changes).
-
-* `lfs.fetchrecentalways`
-
- Always operate as if --recent was included in a `git lfs fetch` call. Default
- false.
-
-### Prune settings
-
-* `lfs.pruneoffsetdays`
-
- The number of days added to the `lfs.fetchrecent*` settings to determine what
- can be pruned. Default is 3 days, i.e. that anything fetched at the very
- oldest edge of the 'recent window' is eligible for pruning 3 days later.
-
-* `lfs.pruneremotetocheck`
-
- Set the remote that LFS files must have been pushed to in order for them to
- be considered eligible for local pruning. Also the remote which is called if
- --verify-remote is enabled.
-
-* `lfs.pruneverifyremotealways`
-
- Always run `git lfs prune` as if `--verify-remote` was provided.
-
-### Extensions
-
-* `lfs.extension.<name>.<setting>`
-
- Git LFS extensions enable the manipulation of files streams during smudge and
- clean. `name` groups the settings for a single extension, and the settings
- are:
- * `clean` The command which runs when files are added to the index
- * `smudge` The command which runs when files are written to the working copy
- * `priority` The order of this extension compared to others
-
-### Other settings
-
-* `lfs.<url>.access`
-
- Note: this setting is normally set by LFS itself on receiving a 401 response
- (authentication required), you don't normally need to set it manually.
-
- If set to "basic" then credentials will be requested before making batch
- requests to this url, otherwise a public request will initially be attempted.
-
-* `lfs.<url>.locksverify`
-
- Determines whether locks are checked before Git pushes. This prevents you from
- pushing changes to files that other users have locked. The Git LFS pre-push
- hook varies its behavior based on the value of this config key.
-
- * `null` - In the absence of a value, Git LFS will attempt the call, and warn
- if it returns an error. If the response is valid, Git LFS will set the value
- to `true`, and will halt the push if the user attempts to update a file locked
- by another user. If the server returns a `501 Not Implemented` response, Git
- LFS will set the value to `false.`
- * `true` - Git LFS will attempt to verify locks, halting the Git push if there
- are any server issues, or if the user attempts to update a file locked by
- another user.
- * `false` - Git LFS will completely skip the lock check in the pre-push hook.
- You should set this if you're not using File Locking, or your Git server
- verifies locked files on pushes automatically.
-
- Supports URL config lookup as described in:
- https://git-scm.com/docs/git-config#git-config-httplturlgt. To set this value
- per-host: `git config --global lfs.https://github.com/.locksverify [true|false]`.
-
-* `lfs.<url>.contenttype`
-
- Determines whether Git LFS should attempt to detect an appropriate HTTP
- `Content-Type` header when uploading using the 'basic' upload adapter. If set
- to false, the default header of `Content-Type: application/octet-stream` is
- chosen instead. Default: 'true'.
-
-* `lfs.skipdownloaderrors`
-
- Causes Git LFS not to abort the smudge filter when a download error is
- encountered, which allows actions such as checkout to work when you are unable
- to download the LFS content. LFS files which could not download will contain
- pointer content instead.
-
- Note that this will result in git commands which call the smudge filter to
- report success even in cases when LFS downloads fail, which may affect
- scripts.
-
- You can also set the environment variable GIT_LFS_SKIP_DOWNLOAD_ERRORS=1 to
- get the same effect.
-
-* `GIT_LFS_PROGRESS`
-
- This environment variable causes Git LFS to emit progress updates to an
- absolute file-path on disk when cleaning, smudging, or fetching.
-
- Progress is reported periodically in the form of a new line being appended to
- the end of the file. Each new line will take the following format:
-
- `<direction> <current>/<total files> <downloaded>/<total> <name>`
-
- Each field is described below:
- * `direction`: The direction of transfer, either "checkout", "download", or
- "upload".
- * `current` The index of the currently transferring file.
- * `total files` The estimated count of all files to be transferred.
- * `downloaded` The number of bytes already downloaded.
- * `total` The entire size of the file, in bytes.
- * `name` The name of the file.
-
-* `GIT_LFS_FORCE_PROGRESS`
- `lfs.forceprogress`
-
- Controls whether Git LFS will suppress progress status when the standard
- output stream is not attached to a terminal. The default is `false` which
- makes Git LFS detect whether stdout is a terminal and suppress progress when
- it's not; you can disable this behaviour and force progress status even when
- standard output stream is not a terminal by setting either variable to 1,
- 'yes' or 'true'.
-
-* `GIT_LFS_SKIP_SMUDGE`
-
- Sets whether or not Git LFS will skip attempting to convert pointers of files
- tracked into their corresponding objects when checked out into a working copy.
- If 'true', '1', 'on', or similar, Git LFS will skip the smudge process in both
- `git lfs smudge` and `git lfs filter-process`. If unset, or set to 'false',
- '0', 'off', or similar, Git LFS will smudge files as normal.
-
-* `GIT_LFS_SKIP_PUSH`
-
- Sets whether or not Git LFS will attempt to upload new Git LFS object in a
- pre-push hook. If 'true', '1', 'on', or similar, Git LFS will skip the
- pre-push hook, so no new Git LFS objects will be uploaded. If unset, or set to
- 'false', '0', 'off', or similar, Git LFS will proceed as normal.
-
-* `GIT_LFS_SET_LOCKABLE_READONLY`
- `lfs.setlockablereadonly`
-
- These settings, the first an environment variable and the second a gitconfig
- setting, control whether files marked as 'lockable' in `git lfs track` are
- made read-only in the working copy when not locked by the current user.
- The default is `true`; you can disable this behaviour and have all files
- writeable by setting either variable to 0, 'no' or 'false'.
-
-* `lfs.lockignoredfiles`
-
- This setting controls whether Git LFS will set ignored files that match the
- lockable pattern read only as well as tracked files. The default is `false`;
- you can enable this behavior by setting the variable to 1, 'yes', or 'true'.
-
-* `lfs.defaulttokenttl`
-
- This setting sets a default token TTL when git-lfs-authenticate does not
- include the TTL in the JSON response but still enforces it.
-
- Note that this is only necessary for larger repositories hosted on LFS
- servers that don't include the TTL.
-
-## LFSCONFIG
-
-The .lfsconfig file in a repository is read and interpreted in the same format
-as the file stored in .git/config. It allows a subset of keys to be used,
-including and limited to:
-
-- lfs.allowincompletepush
-- lfs.fetchexclude
-- lfs.fetchinclude
-- lfs.gitprotocol
-- lfs.locksverify
-- lfs.pushurl
-- lfs.skipdownloaderrors
-- lfs.url
-- lfs.{*}.access
-- remote.{name}.lfsurl
-
-The set of keys allowed in this file is restricted for security reasons.
-
-## EXAMPLES
-
-* Configure a custom LFS endpoint for your repository:
-
- `git config -f .lfsconfig lfs.url https://lfs.example.com/foo/bar/info/lfs`
-
-## SEE ALSO
-
-git-config(1), git-lfs-install(1), gitattributes(5), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-dedup.1.ronn b/docs/man/git-lfs-dedup.1.ronn
deleted file mode 100644
index cb8ff7280f..0000000000
--- a/docs/man/git-lfs-dedup.1.ronn
+++ /dev/null
@@ -1,23 +0,0 @@
-git-lfs-dedup(1) - Deduplicate Git LFS files
-======================================================
-
-## SYNOPSIS
-
-`git lfs dedup`
-
-## DESCRIPTION
-
-Deduplicates storage by re-creating working tree files as clones of the files in the Git LFS storage directory
-using the operating system's copy-on-write file creation functionality.
-
-If the operating system or file system don't support copy-on-write file creation, this command exits unsuccessfully.
-
-This command will also exit without success if any Git LFS extensions are
-configured, as these will typically be used to alter the file contents
-before they are written to the Git LFS storage directory, and therefore the
-working tree files should not be copy-on-write clones of the LFS object files.
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
-
diff --git a/docs/man/git-lfs-env.1.ronn b/docs/man/git-lfs-env.1.ronn
deleted file mode 100644
index d2dce2e9cd..0000000000
--- a/docs/man/git-lfs-env.1.ronn
+++ /dev/null
@@ -1,14 +0,0 @@
-git-lfs-env(1) -- Display the Git LFS environment
-=================================================
-
-## SYNOPSIS
-
-`git lfs env`
-
-## DESCRIPTION
-
-Display the current Git LFS environment.
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-ext.1.ronn b/docs/man/git-lfs-ext.1.ronn
deleted file mode 100644
index c8bde96a69..0000000000
--- a/docs/man/git-lfs-ext.1.ronn
+++ /dev/null
@@ -1,26 +0,0 @@
-git-lfs-ext(1) - View extension details
-==============================================================
-
-## SYNOPSIS
-
-`git lfs ext list` [<name>...]
-
-## DESCRIPTION
-
-Git LFS extensions enable the manipulation of files streams
-during smudge and clean.
-
-## EXAMPLES
-
-* List details for all extensions
-
- `git lfs ext`
- `git lfs ext list`
-
-* List details for the specified extensions
-
- `git lfs ext list 'foo' 'bar'`
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-fetch.1.ronn b/docs/man/git-lfs-fetch.1.ronn
deleted file mode 100644
index f8db346374..0000000000
--- a/docs/man/git-lfs-fetch.1.ronn
+++ /dev/null
@@ -1,153 +0,0 @@
-git-lfs-fetch(1) -- Download all Git LFS files for a given ref
-==============================================================
-
-## SYNOPSIS
-
-`git lfs fetch` [options] [<remote> [<ref>...]]
-
-## DESCRIPTION
-
-Download Git LFS objects at the given refs from the specified remote. See
-[DEFAULT REMOTE] and [DEFAULT REFS] for what happens if you don't specify.
-
-This does not update the working copy.
-
-## OPTIONS
-
-* `-I` <paths> `--include=`<paths>:
- Specify lfs.fetchinclude just for this invocation; see [INCLUDE AND EXCLUDE]
-
-* `-X` <paths> `--exclude=`<paths>:
- Specify lfs.fetchexclude just for this invocation; see [INCLUDE AND EXCLUDE]
-
-* `--recent`:
- Download objects referenced by recent branches & commits in addition to those
- that would otherwise be downloaded. See [RECENT CHANGES]
-
-* `--all`:
- Download all objects that are referenced by any commit reachable from the refs
- provided as arguments. If no refs are provided, then all refs are fetched.
- This is primarily for backup and migration purposes. Cannot be combined with
- --recent or --include/--exclude. Ignores any globally configured include and
- exclude paths to ensure that all objects are downloaded.
-
-* `--prune` `-p`:
- Prune old and unreferenced objects after fetching, equivalent to running
- `git lfs prune` afterwards. See git-lfs-prune(1) for more details.
-
-## INCLUDE AND EXCLUDE
-
-You can configure Git LFS to only fetch objects to satisfy references in certain
-paths of the repo, and/or to exclude certain paths of the repo, to reduce the
-time you spend downloading things you do not use.
-
-In your Git configuration or in a `.lfsconfig` file, you may set either or
-both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated lists of
-paths. If `lfs.fetchinclude` is defined, Git LFS objects will only be fetched
-if their path matches one in that list, and if `lfs.fetchexclude` is defined,
-Git LFS objects will only be fetched if their path does not match one
-in that list. Paths are matched using wildcard matching as per gitignore(5).
-
-Note that using the command-line options `-I` and `-X` override the respective
-configuration settings. Setting either option to an empty string clears the
-value.
-
-### Examples
-
-* `git config lfs.fetchinclude "textures,images/foo*"`
-
- This will only fetch objects referenced in paths in the textures folder, and
- files called foo* in the images folder
-
-* `git config lfs.fetchinclude "*.jpg,*.png,*.tga"`
-
- Only fetch JPG/PNG/TGA files, wherever they are in the repository
-
-* `git config lfs.fetchexclude "media/reallybigfiles"`
-
- Don't fetch any LFS objects referenced in the folder media/reallybigfiles, but
- fetch everything else
-
-* `git config lfs.fetchinclude "media"` 
- `git config lfs.fetchexclude "media/excessive"`
-
- Only fetch LFS objects in the 'media' folder, but exclude those in one of its
- subfolders.
-
-## DEFAULT REMOTE
-
-Without arguments, fetch downloads from the default remote. The default remote
-is the same as for `git fetch`, i.e. based on the remote branch you're tracking
-first, or origin otherwise.
-
-## DEFAULT REFS
-
-If no refs are given as arguments, the currently checked out ref is used. In
-addition, if enabled, recently changed refs and commits are also
-included. See [RECENT CHANGES] for details.
-
-## RECENT CHANGES
-
-If the `--recent` option is specified, or if the gitconfig option
-`lfs.fetchrecentalways` is true, then after the current ref (or those in the
-arguments) is fetched, we also search for 'recent' changes to fetch
-objects for, so that it's more convenient to checkout or diff those commits
-without incurring further downloads.
-
-What changes are considered 'recent' is based on a number of gitconfig options:
-
-* `lfs.fetchrecentrefsdays`
- If non-zero, includes branches which have commits within N days of the current
- date. Only local refs are included unless lfs.fetchrecentremoterefs is true.
- The default is 7 days.
-
-* `lfs.fetchrecentremoterefs`
- If true, fetches remote refs (for the remote you're fetching) as well as local
- refs in the recent window. This is useful to fetch objects for remote branches
- you might want to check out later. The default is true; if you set this to
- false, fetching for those branches will only occur when you either check them
- out (losing the advantage of fetch --recent), or create a tracking local
- branch separately then fetch again.
-
-* `lfs.fetchrecentcommitsdays`
- In addition to fetching at branches, also fetches changes made within N
- days of the latest commit on the branch. This is useful if you're often
- reviewing recent changes. The default is 0 (no previous changes).
-
-* `lfs.fetchrecentalways`
- Always operate as if --recent was provided on the command line.
-
-
-## EXAMPLES
-
-* Fetch the LFS objects for the current ref from default remote
-
- `git lfs fetch`
-
-* Fetch the LFS objects for the current ref AND recent changes from default
- remote
-
- `git lfs fetch --recent`
-
-* Fetch the LFS objects for the current ref from a secondary remote 'upstream'
-
- `git lfs fetch upstream`
-
-* Fetch all the LFS objects from the default remote that are referenced by any
- commit in the `main` and `develop` branches
-
- `git lfs fetch --all origin main develop`
-
-* Fetch the LFS objects for a branch from origin
-
- `git lfs fetch origin mybranch`
-
-* Fetch the LFS objects for 2 branches and a commit from origin
-
- `git lfs fetch origin main mybranch e445b45c1c9c6282614f201b62778e4c0688b5c8`
-
-## SEE ALSO
-
-git-lfs-checkout(1), git-lfs-pull(1), git-lfs-prune(1), gitconfig(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-filter-process.1.ronn b/docs/man/git-lfs-filter-process.1.ronn
deleted file mode 100644
index c6c356e18f..0000000000
--- a/docs/man/git-lfs-filter-process.1.ronn
+++ /dev/null
@@ -1,45 +0,0 @@
-git-lfs-filter-process(1) -- Git filter process that converts between pointer and actual content
-===========================================================================================
-
-## SYNOPSIS
-
-`git lfs filter-process`
-`git lfs filter-process --skip`
-
-## DESCRIPTION
-
-Implement the Git process filter API, exchanging handshake messages and then
-accepting and responding to requests to either clean or smudge a file.
-
-filter-process is always run by Git's filter process, and is configured by the
-repository's Git attributes.
-
-In your Git configuration or in a `.lfsconfig` file, you may set either or
-both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated lists of
-paths. If `lfs.fetchinclude` is defined, Git LFS pointer files will only be
-replaced with the contents of the corresponding Git LFS object file if their
-path matches one in that list, and if `lfs.fetchexclude` is defined, Git LFS
-pointer files will only be replaced with the contents of the corresponding
-Git LFS object file if their path does not match one in that list. Paths are
-matched using wildcard matching as per gitignore(5). Git LFS pointer files
-that are not replaced with the contents of their corresponding object files
-are simply copied to standard output without change.
-
-The filter process uses Git's pkt-line protocol to communicate, and is
-documented in detail in gitattributes(5).
-
-## OPTIONS
-
-Without any options, filter-process accepts and responds to requests normally.
-
-* `--skip`:
- Skip automatic downloading of objects on clone or pull.
-
-* `GIT_LFS_SKIP_SMUDGE`:
- Disables the smudging process. For more, see: git-lfs-config(5).
-
-## SEE ALSO
-
-git-lfs-clean(1), git-lfs-install(1), git-lfs-smudge(1), gitattributes(5), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-fsck.1.ronn b/docs/man/git-lfs-fsck.1.ronn
deleted file mode 100644
index 9b10fd81bd..0000000000
--- a/docs/man/git-lfs-fsck.1.ronn
+++ /dev/null
@@ -1,40 +0,0 @@
-git-lfs-fsck(1) -- Check GIT LFS files for consistency
-======================================================
-
-## SYNOPSIS
-
-`git lfs fsck` [options] [revisions]
-
-## DESCRIPTION
-
-Checks all Git LFS files in the current HEAD for consistency.
-
-Corrupted files are moved to ".git/lfs/bad".
-
-The revisions may be specified as either a single committish, in which case only
-that commit is inspected; specified as a range of the form `A..B` (and only this
-form), in which case that range is inspected; or omitted entirely, in which case
-HEAD (and, for --objects, the index) is examined.
-
-The default is to perform all checks.
-
-In your Git configuration or in a `.lfsconfig` file, you may set
-`lfs.fetchexclude` to a comma-separated list of paths. If `lfs.fetchexclude`
-is defined, then any Git LFS files whose paths match one in that list will
-not be checked for consistency. Paths are matched using wildcard matching as
-per gitignore(5).
-
-## OPTIONS
-
-* `--objects`:
- Check that each object in HEAD matches its expected hash and that each object
- exists on disk.
-* `--pointers`:
- Check that each pointer is canonical and that each file which should be stored
- as a Git LFS file is so stored.
-
-## SEE ALSO
-
-git-lfs-ls-files(1), git-lfs-status(1), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-install.1.ronn b/docs/man/git-lfs-install.1.ronn
deleted file mode 100644
index ece848fc19..0000000000
--- a/docs/man/git-lfs-install.1.ronn
+++ /dev/null
@@ -1,58 +0,0 @@
-git-lfs-install(1) -- Install Git LFS configuration.
-========================================================
-
-## SYNOPSIS
-
-`git lfs install` [options]
-
-## DESCRIPTION
-
-Perform the following actions to ensure that Git LFS is setup properly:
-
-* Set up the clean and smudge filters under the name "lfs" in the global Git
- config.
-* Install a pre-push hook to run git-lfs-pre-push(1) for the current repository,
- if run from inside one. If "core.hooksPath" is configured in any Git
- configuration (and supported, i.e., the installed Git version is at least
- 2.9.0), then the pre-push hook will be installed to that directory instead.
-
-## OPTIONS
-
-Without any options, `git lfs install` will only setup the "lfs" smudge and clean
-filters if they are not already set.
-
-* `--force`:
- Sets the "lfs" smudge and clean filters, overwriting existing values.
-* `--local`:
- Sets the "lfs" smudge and clean filters in the local repository's git
- config, instead of the global git config (~/.gitconfig).
-* `--worktree`:
- Sets the "lfs" smudge and clean filters in the current working tree's
- git config, instead of the global git config (~/.gitconfig) or local
- repository's git config ($GIT_DIR/config).
- If multiple working trees are in use, the Git config extension
- `worktreeConfig` must be enabled to use this option.
- If only one working tree is in use, `--worktree` has the same effect
- as `--local`.
- This option is only available if the installed Git version is at least
- 2.20.0 and therefore supports the "worktreeConfig" extension.
-* `--manual`:
- Print instructions for manually updating your hooks to include git-lfs
- functionality. Use this option if `git lfs install` fails because of existing
- hooks and you want to retain their functionality.
-* `--system`:
- Sets the "lfs" smudge and clean filters in the system git config, e.g. /etc/gitconfig
- instead of the global git config (~/.gitconfig).
-* `--skip-smudge`:
- Skips automatic downloading of objects on clone or pull. This requires a
- manual "git lfs pull" every time a new commit is checked out on your
- repository.
-* `--skip-repo`:
- Skips setup of the local repo; use if you want to install the global lfs
- filters but not make changes to the current repo.
-
-## SEE ALSO
-
-git-lfs-uninstall(1), git-worktree(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-lock.1.ronn b/docs/man/git-lfs-lock.1.ronn
deleted file mode 100644
index ed7d702157..0000000000
--- a/docs/man/git-lfs-lock.1.ronn
+++ /dev/null
@@ -1,32 +0,0 @@
-git-lfs-lock(1) -- Set a file as "locked" on the Git LFS server
-===============================================================
-
-## SYNOPSIS
-
-`git lfs lock` [options] <path>
-
-## DESCRIPTION
-
-Sets the given file path as "locked" against the Git LFS server, with the
-intention of blocking attempts by other users to update the given path. Locking
-a file requires the file to exist in the working copy.
-
-Once locked, LFS will verify that Git pushes do not modify files locked by
-other users. See the description of the `lfs.<url>.locksverify` config key in
-git-lfs-config(5) for details.
-
-## OPTIONS
-
-* `-r` <name> `--remote=`<name>:
- Specify the Git LFS server to use. Ignored if the `lfs.url` config key is set.
-
-* `--json`:
- Writes lock info as JSON to STDOUT if the command exits successfully. Intended
- for interoperation with external tools. If the command returns with a non-zero
- exit code, plain text messages will be sent to STDERR.
-
-## SEE ALSO
-
-git-lfs-unlock(1), git-lfs-locks(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-locks.1.ronn b/docs/man/git-lfs-locks.1.ronn
deleted file mode 100644
index 99ffd6d9eb..0000000000
--- a/docs/man/git-lfs-locks.1.ronn
+++ /dev/null
@@ -1,54 +0,0 @@
-git-lfs-locks(1) -- Lists currently locked files from the Git LFS server.
-=============================================================================
-
-## SYNOPSIS
-
-`git lfs locks` [options]
-
-## DESCRIPTION
-
-Lists current locks from the Git LFS server.
-
-## OPTIONS
-
-* `-r` <name> `--remote=`<name>:
- Specify the Git LFS server to use. Ignored if the `lfs.url` config key is set.
-
-* `-i <id>` `--id=<id>`:
- Specifies a lock by its ID. Returns a single result.
-
-* `-p <path>` `--path=<path>`:
- Specifies a lock by its path. Returns a single result.
-
-* `--local`:
- Lists only our own locks which are cached locally. Skips a remote call.
-
-* `--cached`:
- Lists cached locks from the last remote call. Contrary to --local, this will
- include locks of other users as well. This option is intended to display the
- last known locks in case you are offline. There is no guarantee that locks
- on the server have not changed in the meanwhile.
-
-* `--verify`:
- Verifies the lock owner on the server and marks our own locks by 'O'.
- Own locks are actually held by us and corresponding files can be updated for
- the next push. All other locks are held by someone else.
- Contrary to --local, this option will also detect locks which are held by us
- despite no local lock information being available (e.g. because the file had
- been locked from a different clone);
- it will also detect 'broken' locks (e.g. if someone else has forcefully
- unlocked our files).
-
-* `-l <num>` `--limit=<num>`:
- Specifies number of results to return.
-
-* `--json`:
- Writes lock info as JSON to STDOUT if the command exits successfully. Intended
- for interoperation with external tools. If the command returns with a non-zero
- exit code, plain text messages will be sent to STDERR.
-
-## SEE ALSO
-
-git-lfs-lock(1), git-lfs-unlock(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-logs.1.ronn b/docs/man/git-lfs-logs.1.ronn
deleted file mode 100644
index 7102bf6f6f..0000000000
--- a/docs/man/git-lfs-logs.1.ronn
+++ /dev/null
@@ -1,33 +0,0 @@
-git-lfs-logs(1) - Show errors from the git-lfs command
-======================================================
-
-## SYNOPSIS
-
-`git lfs logs` 
-`git lfs logs` <file> 
-`git lfs logs clear` 
-`git lfs logs boomtown` 
-
-## DESCRIPTION
-
-Display errors from the git-lfs command. Any time it crashes, the details are
-saved to ".git/lfs/logs".
-
-## COMMANDS
-
-* `clear`:
- Clears all of the existing logged errors.
-
-* `boomtown`:
- Triggers a dummy exception.
-
-## OPTIONS
-
-Without any options, `git lfs logs` simply shows the list of error logs.
-
-* <file>:
- Shows the specified error log. Use "last" to show the most recent error.
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-ls-files.1.ronn b/docs/man/git-lfs-ls-files.1.ronn
deleted file mode 100644
index d2d34ecc2c..0000000000
--- a/docs/man/git-lfs-ls-files.1.ronn
+++ /dev/null
@@ -1,52 +0,0 @@
-git-lfs-ls-files(1) -- Show information about Git LFS files in the index and working tree
-=========================================================================================
-
-## SYNOPSIS
-
-`git lfs ls-files` [<ref>] 
-`git lfs ls-files` <ref> <ref>
-
-## DESCRIPTION
-
-Display paths of Git LFS files that are found in the tree at the given
-reference. If no reference is given, scan the currently checked-out branch.
-If two references are given, the LFS files that are modified between the two
-references are shown; deletions are not listed.
-
-An asterisk (*) after the OID indicates a full object, a minus (-) indicates an
-LFS pointer.
-
-## OPTIONS
-
-* `-l` `--long`:
- Show the entire 64 character OID, instead of just first 10.
-
-* `-s` `--size`:
- Show the size of the LFS object between parenthesis at the end of a line.
-
-* `-d` `--debug`:
- Show as much information as possible about a LFS file. This is intended
- for manual inspection; the exact format may change at any time.
-
-* `-a` `--all`:
- Inspects the full history of the repository, not the current HEAD (or other
- provided reference). This will include previous versions of LFS objects that
- are no longer found in the current tree.
-
-* `--deleted`:
- Shows the full history of the given reference, including objects that have
- been deleted.
-
-* `-I` <paths> `--include=`<paths>:
- Include paths matching only these patterns; see [FETCH SETTINGS].
-
-* `-X` <paths> `--exclude=`<paths>:
- Exclude paths matching any of these patterns; see [FETCH SETTINGS].
-
-* `-n` `--name-only`:
- Show only the lfs tracked file names.
-## SEE ALSO
-
-git-lfs-status(1), git-lfs-config(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-merge-driver.1.ronn b/docs/man/git-lfs-merge-driver.1.ronn
deleted file mode 100644
index d515cd4e42..0000000000
--- a/docs/man/git-lfs-merge-driver.1.ronn
+++ /dev/null
@@ -1,91 +0,0 @@
-git-lfs-merge-driver(1) -- Merge text-based LFS files
-==============================================================
-
-## SYNOPSIS
-
-`git lfs merge-driver` [options]
-
-## DESCRIPTION
-
-Merge text files stored in Git LFS using the default Git merge machinery, or a
-custom merge driver if specified. Note that this, in general, does not support
-partial renames or copies because Git does not support them in this case.
-
-This program is intended to be invoked automatically by Git and not by users
-manually. See [CONFIGURATION] for details on the configuration required for
-that.
-
-## OPTIONS
-
-* `--ancestor` <path>
- Specify the file containing the ancestor revision.
-
-* `--current` <path>
- Specify the file containing the current revision.
-
-* `--marker-size` <num>
- Specify the conflict marker size as an integer.
-
-* `--other` <path>
- Specify the file containing the other revision.
-
-* `--program` <program>
- Specify a command, which is passed to the shell after substitution, that
- performs the actual merge. If this is not specified, `git merge-file` is
- invoked with appropriate arguments to perform the merge of the file.
-
- See [CONFIGURATION] for the sequences which are substituted here.
-
-## CONFIGURATION
-
-Git allows the use of a custom merge driver for files based on the `merge`
-attribute set in `.gitattributes`. By default, when using `git lfs track`, this
-value is set to `lfs`.
-
-Because Git LFS can be used to store both text and binary files and it isn't
-always clear which behavior should be used, Git LFS does not enable this merge
-driver by default. However, if you know that some or all of your files are text
-files, then you can set the `merge` attribute for those files to `lfs-text` and
-use `git config` to set the merge driver like so:
-
-```console
-$ git config merge.lfs-text.driver 'git lfs merge-driver --ancestor %O --current %A --other %B --marker-size %L --output %A'
-```
-
-This tells Git to invoke the custom Git LFS merge driver, which in turn uses
-Git's merge machinery, to merge files where the `merge` attribute is set to
-`lfs-text`. Note that `lfs-text` here is an example and any syntactically valid
-value can be used.
-
-If you are using a special type of file that needs rules different from Git's
-standard merge machinery, you can also specify the `--program` option, which
-is passed to `sh` after substituting its own percent-encoded escapes:
-
-* `%A`: the current version
-* `%B`: the other version
-* `%D`: the destination version
-* `%O`: the ancestor version
-* `%L`: the conflict marker size
-
-Note that the percent sign must typically be doubled to prevent Git from
-substituting its own values here. Therefore, specifying the default behavior
-explicitly looks like this:
-
-```console
-$ git config merge.lfs-text.driver \
- 'git lfs merge-driver --ancestor %O --current %A --other %B --marker-size %L --output %A --program '\''git merge-file --stdout --marker-size=%%L %%A %%O %%B >%%D'\'''
-```
-
-The exit status from the custom command should be zero on success or non-zero on
-conflicts or other failure.
-
-Note that if no merge driver is specified for the value of the `merge` attribute
-(as is the case by default with `merge=lfs`), then the default Git merge
-strategy is used. For LFS files, this means that Git will try to merge the
-pointer files, which usually is not useful.
-
-## SEE ALSO
-
-git-merge(1), git-merge-file(1), gitattributes(5)
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-migrate.1.ronn b/docs/man/git-lfs-migrate.1.ronn
deleted file mode 100644
index 53875f010c..0000000000
--- a/docs/man/git-lfs-migrate.1.ronn
+++ /dev/null
@@ -1,467 +0,0 @@
-git-lfs-migrate(1) - Migrate history to or from Git LFS
-=======================================================
-
-## SYNOPSIS
-
-`git lfs migrate` <mode> [options] [--] [branch ...]
-
-## DESCRIPTION
-
-Convert files in a Git repository to or from Git LFS pointers, or
-summarize Git file sizes by file type. The `import` mode converts Git
-files (i.e., blobs) to Git LFS, while the `export` mode does the reverse,
-and the `info` mode provides an informational summary which may be useful
-in deciding which files to import or export.
-
-In all modes, by default `git lfs migrate` operates only on the currently
-checked-out branch, and only on files (of any size and type) added in
-commits which do not exist on any remote. Multiple options are available
-to override these defaults.
-
-When converting files to or from Git LFS, the `git lfs migrate` command will
-only make changes to your local repository and working copy, never any
-remotes. This is intentional as the `import` and `export` modes are
-generally "destructive" in the sense that they rewrite your Git history,
-changing commits and generating new commit SHAs. (The exception is the
-"no-rewrite" `import` sub-mode; see [IMPORT WITHOUT REWRITING HISTORY]
-for details.)
-
-You should therefore always first commit or stash any uncommitted work
-before using the `import` or `export` modes, and then validate the result of
-the migration before pushing the changes to your remotes, for instance by
-running the `info` mode and by examining your rewritten commit history.
-
-Once you are satisfied with the changes, you will need to force-push the
-new Git history of any rewritten branches to all your remotes. This is
-a step which should be taken with care, since you will be altering the
-Git history on your remotes.
-
-To examine or modify files in branches other than the currently checked-out
-one, branch refs may be specified directly, or provided in one or more
-`--include-ref` options. They may also be excluded by prefixing them
-with `^` or providing them in `--exclude-ref` options. Use the `--everything`
-option to specify that all refs should be examined, including all remote refs.
-See [INCLUDE AND EXCLUDE REFERENCES] for details.
-
-For the `info` and `import` modes, all file types are considered by default;
-while useful in the `info` mode, this is often not desirable when importing,
-so either filename patterns (pathspecs) or the `--fixup` option should
-normally be specified in that case. (At least one include pathspec is
-required for the `export` mode.) Pathspecs may be defined using the
-`--include` and `--exclude` options (`-I` and `-X` for short), as described
-in [INCLUDE AND EXCLUDE].
-
-As typical Git LFS usage depends on tracking specific file types using
-filename patterns defined in `.gitattributes` files, the `git lfs migrate`
-command will examine, create, and modify `.gitattributes` files as
-necessary. The `.gitattributes` files will always be assigned the default
-read/write permissions mode (i.e., without execute permissions). Any
-symbolic links with that name will cause the migration to halt prematurely.
-
-The `import` mode (see [IMPORT]) will convert Git objects of the file types
-specified (e.g., with `--include`) to Git LFS pointers, and will add entries
-for those file types to `.gitattributes` files, creating those files if they
-do not exist. The result should be as if `git lfs track` commands had been
-run at the points in your Git history corresponding to where each type of
-converted file first appears. The exception is if the `--fixup` option is
-given, in which case the `import` mode will only examine any existing
-`.gitattributes` files and then convert Git objects which should be tracked
-by Git LFS but are not yet.
-
-The `export` mode (see [EXPORT]) works as the reverse operation to the
-`import` mode, converting any Git LFS pointers that match the file types
-specified with `--include`, which must be given at least once. Note that
-`.gitattributes` entries will not be removed, nor will the files; instead,
-the `export` mode inserts "do not track" entries similar to those created
-by the `git lfs untrack` command. The `--remote` option is available in
-the `export` mode to specify the remote from which Git LFS objects should
-be fetched if they do not exist in the local Git LFS object cache; if not
-provided, `origin` is used by default.
-
-The `info` mode (see [INFO]) summarizes by file type (i.e., by filename
-extension) the total number and size of files in a repository. Note that
-like the other two modes, by default the `info` mode operates only on
-the currently checked-out branch and only on commits which do not exist on
-any remote, so to get a summary of the entire repository across all branches,
-use the `--everything` option. If objects have already been converted to
-Git LFS pointers, then by default the size of the referenced objects is
-totaled and reported separately. You may also choose to ignore them by
-using `--pointers=ignore` or to treat the pointers as files by using
-`--pointers=no-follow`. (The latter option is akin to how existing Git LFS
-pointers were handled by the `info` mode in prior versions of Git LFS).
-
-When using the `--everything` option, take note that it means all refs
-(local and remote) will be considered, but not necessarily all file types.
-The `import` and `info` modes consider all file types by default, although
-the `--include` and `--exclude` options constrain this behavior. Also
-note that after importing across all branches with the `--everything` option
-(and then checking to ensure the results are satisfactory!) it may be
-convenient to update multiple branches on your remotes by using the `--all`
-option to `git push`.
-
-Unless the `--skip-fetch` option is given, `git lfs migrate` always begins by
-fetching updated lists of refs from all the remotes returned by `git remote`,
-but as noted above, after making changes to your local Git history while
-converting objects, it will never automatically push those changes to your
-remotes.
-
-## MODES
-
-* `info`
- Show information about repository size. See [INFO].
-
-* `import`
- Convert Git objects to Git LFS pointers. See [IMPORT] and
- [IMPORT WITHOUT REWRITING HISTORY].
-
-* `export`
- Convert Git LFS pointers to Git objects. See [EXPORT].
-
-## OPTIONS
-
-* `-I` <paths> `--include=`<paths>:
- See [INCLUDE AND EXCLUDE].
-
-* `-X` <paths> `--exclude=`<paths>:
- See [INCLUDE AND EXCLUDE].
-
-* `--include-ref`=<refname>:
- See [INCLUDE AND EXCLUDE REFERENCES].
-
-* `--exclude-ref`=<refname>:
- See [INCLUDE AND EXCLUDE REFERENCES].
-
-* `--skip-fetch`:
- Assumes that the known set of remote references is complete, and should not
- be refreshed when determining the set of "un-pushed" commits to migrate. Has
- no effect when combined with `--include-ref` or `--exclude-ref`.
-
-* `--everything`:
- See [INCLUDE AND EXCLUDE REFERENCES].
-
- Note: Git refs are "case-sensitive" on all platforms in "packed from" (see
- `git-pack-refs(1)`). On "case-insensitive" file systems, e.g. NTFS on Windows
- or default APFS on macOS, `git-lfs-migrate(1)` would only migrate the first
- ref if two or more refs are equal except for upper/lower case letters.
-
-* `--yes`:
- Assume a yes answer to any prompts, permitting noninteractive use.
- Currently, the only such prompt is the one asking whether to overwrite
- (destroy) any working copy changes. Thus, specifying this option may cause
- data loss if you are not careful.
-
-* [branch ...]:
- Migrate only the set of branches listed. If not given, `git-lfs-migrate(1)`
- will migrate the currently checked out branch.
-
- References beginning with `^` will be excluded, whereas branches that do not
- begin with `^` will be included.
-
- If any of `--include-ref` or `--exclude-ref` are given, the checked out
- branch will not be appended, but branches given explicitly will be appended.
-
-### INFO
-
-The `info` mode summarizes the sizes of file objects present in the Git history.
-It supports all the core `migrate` options and these additional ones:
-
-* `--above=<size>`
- Only count files whose individual filesize is above the given size. `size`
- may be specified as a number of bytes, or a number followed by a storage
- unit, e.g., "1b", "20 MB", "3 TiB", etc.
-
- If a set of files sharing a common extension has no files in that set whose
- individual size is above the given `--above` no files no entry for that set
- will be shown.
-
-* `--top=<n>`
- Only display the top `n` entries, ordered by how many total files match the
- given pathspec. The default is to show only the top 5 entries. When
- existing Git LFS objects are found, an extra, separate "LFS Objects" line
- is output in addition to the top `n` entries, unless the `--pointers`
- option is used to change this behavior.
-
-* `--unit=<unit>`
- Format the number of bytes in each entry as a quantity of the storage unit
- provided. Valid units include:
- * b, kib, mib, gib, tib, pib - for IEC storage units
- * b, kb, mb, gb, tb, pb - for SI storage units
-
- If a `--unit` is not specified, the largest unit that can fit the number of
- counted bytes as a whole number quantity is chosen.
-
-* `--pointers=[follow|no-follow|ignore]`
- Treat existing Git LFS pointers in the history according to one of three
- alternatives. In the default `follow` case, if any pointers are found,
- an additional separate "LFS Objects" line item is output which summarizes
- the total number and size of the Git LFS objects referenced by pointers.
- In the `ignore` case, any pointers are simply ignored, while the `no-follow`
- case replicates the behavior of the `info` mode in older Git LFS versions
- and treats any pointers it finds as if they were regular files, so the
- output totals only include the contents of the pointers, not the contents
- of the objects to which they refer.
-
-* `--fixup`
- Infer `--include` and `--exclude` filters on a per-commit basis based on the
- `.gitattributes` files in a repository. In practice, this option counts any
- filepaths which should be tracked by Git LFS according to the repository's
- `.gitattributes` file(s), but aren't already pointers. The `.gitattributes`
- files are not reported, in contrast to the normal output of the `info` mode.
- This option is incompatible with explicitly given `--include`, `--exclude`
- filters and with any `--pointers` setting other than `ignore`, hence
- `--fixup` implies `--pointers=ignore` if it is not explicitly set.
-
-The format of the output shows the filename pattern, the total size of the
-file objects (excluding those below the `--above` threshold, if one was
-defined), and the ratio of the number of files above the threshold to the
-total number of files; this ratio is also shown as a percentage. For example:
-
-```
-*.gif 	93 MB 	9480/10504 files(s)	 90%
-*.png 	14 MB 	 1732/1877 files(s)	 92%
-```
-
-By default only the top five entries are shown, but `--top` allows for
-more or fewer to be output as desired.
-
-### IMPORT
-
-The `import` mode migrates objects present in the Git history to pointer
-files tracked and stored with Git LFS. It supports all the core `migrate`
-options and these additional ones:
-
-* `--verbose`
- Print the commit oid and filename of migrated files to STDOUT.
-
-* `--above=<size>`
- Only migrate files whose individual filesize is above the given size. `size`
- may be specified as a number of bytes, or a number followed by a storage
- unit, e.g., "1b", "20 MB", "3 TiB", etc. This option cannot be used with
- the `--include`, `--exclude`, and `--fixup` options.
-
-* `--object-map=<path>`
- Write to `path` a file with the mapping of each rewritten commits. The file
- format is CSV with this pattern: `OLD-SHA`,`NEW-SHA`
-
-* `--no-rewrite`
- Migrate objects to Git LFS in a new commit without rewriting Git
- history. Please note that when this option is used, the `migrate import`
- command will expect a different argument list, specialized options will
- become available, and the core `migrate` options will be ignored. See
- [IMPORT WITHOUT REWRITING HISTORY].
-
-* `--fixup`
- Infer `--include` and `--exclude` filters on a per-commit basis based on the
- `.gitattributes` files in a repository. In practice, this option imports any
- filepaths which should be tracked by Git LFS according to the repository's
- `.gitattributes` file(s), but aren't already pointers. This option is
- incompatible with explicitly given `--include`, `--exclude` filters.
-
-If `--no-rewrite` is not provided and `--include` or `--exclude` (`-I`, `-X`,
-respectively) are given, the `.gitattributes` will be modified to include any
-new filepath patterns as given by those flags.
-
-If `--no-rewrite` is not provided and neither of those flags are given, the
-gitattributes will be incrementally modified to include new filepath extensions
-as they are rewritten in history.
-
-### IMPORT WITHOUT REWRITING HISTORY
-
-The `import` mode has a special sub-mode enabled by the `--no-rewrite` flag.
-This sub-mode will migrate objects to pointers as in the base `import`
-mode, but will do so in a new commit without rewriting Git history. When using
-this sub-mode, the base `migrate` options, such as `--include-ref`, will be
-ignored, as will those for the base `import` mode. The `migrate` command will
-also take a different argument list. As a result of these changes,
-`--no-rewrite` will only operate on the current branch - any other interested
-branches must have the generated commit merged in.
-
-The `--no-rewrite` sub-mode supports the following options and arguments:
-
-* `-m <message> --message=<message>`
- Specifies a commit message for the newly created commit.
-
-* [file ...]
- The list of files to import. These files must be tracked by patterns
- specified in the gitattributes.
-
-If `--message` is given, the new commit will be created with the provided
-message. If no message is given, a commit message will be generated based on the
-file arguments.
-
-### EXPORT
-
-The `export` mode migrates Git LFS pointer files present in the Git history out
-of Git LFS, converting them into their corresponding object files. It supports
-all the core `migrate` options and these additional ones:
-
-* `--verbose`
- Print the commit oid and filename of migrated files to STDOUT.
-
-* `--object-map=<path>`
- Write to `path` a file with the mapping of each rewritten commit. The file
- format is CSV with this pattern: `OLD-SHA`,`NEW-SHA`
-
-* `--remote=<git-remote>`
- Download LFS objects from the provided `git-remote` during the export. If
- not provided, defaults to `origin`.
-
-The `export` mode requires at minimum a pattern provided with the `--include`
-argument to specify which files to export. Files matching the `--include`
-patterns will be removed from Git LFS, while files matching the `--exclude`
-patterns will retain their Git LFS status. The export command will modify the
-`.gitattributes` to set/unset any filepath patterns as given by those flags.
-
-## INCLUDE AND EXCLUDE
-
-You can specify that `git lfs migrate` should only convert files whose
-pathspec matches the `--include` glob patterns and does not match the
-`--exclude` glob patterns, either to reduce total migration time or to only
-migrate part of your repo. Multiple patterns may be given using commas
-as delimiters.
-
-Pattern matching is done so as to be functionally equivalent to the pattern
-matching format of `.gitattributes`. In addition to simple file extension
-matches (e.g., `*.gif`) patterns may also specify directory paths, in which
-case the `path/**` format may be used to match recursively.
-
-Note that this form of pattern matching for the `--include` and `--exclude`
-options used by the `git lfs migrate` command is unique among the suite of
-`git lfs` commands. Other commands which also take these options, such as
-`git lfs ls-files`, use the gitignore(5) form of pattern matching instead.
-
-## INCLUDE AND EXCLUDE REFERENCES
-
-You can specify that `git lfs migrate` should only convert files added
-in commits reachable from certain references, namely those defined using one
-or more `--include-ref` options, and should ignore files in commits reachable
-from references defined in `--exclude-ref` options.
-
-```
- D---E---F
- / \
- A---B------C refs/heads/my-feature
- \ \
- \ refs/heads/main
- \
- refs/remotes/origin/main
-```
-
-In the above configuration, the following commits are reachable by each ref:
-
-```
-refs/heads/main: C, B, A
-refs/heads/my-feature: F, E, D, B, A
-refs/remote/origin/main: A
-```
-
-The following `git lfs migrate` options would, therefore, include commits
-F, E, D, C, and B, but exclude commit A:
-
-```
- --include-ref=refs/heads/my-feature
- --include-ref=refs/heads/main
- --exclude-ref=refs/remotes/origin/main
-```
-
-The presence of flag `--everything` indicates that all local and remote
-references should be migrated.
-
-## EXAMPLES
-
-### Migrate unpushed commits
-
-A common use case for the migrate command is to convert large Git objects to
-LFS before pushing your commits. By default, it only scans commits that don't
-exist on any remote, so long as the repository is non-bare.
-
-First, run `git lfs migrate info` to list the file types taking up the most
-space in your repository:
-
-```
-$ git lfs migrate info
-migrate: Fetching remote refs: ..., done
-migrate: Sorting commits: ..., done
-migrate: Examining commits: 100% (1/1), done
-*.mp3 	284 MB	 1/1 files(s)	100%
-*.pdf 	42 MB 	 8/8 files(s)	100%
-*.psd 	9.8 MB	15/15 files(s)	100%
-*.ipynb	6.9 MB	 6/6 files(s)	100%
-*.csv 	5.8 MB	 2/2 files(s)	100%
-```
-
-Now, you can run `git lfs migrate import` to convert some file types to LFS:
-
-```
-$ git lfs migrate import --include="*.mp3,*.psd"
-migrate: Fetching remote refs: ..., done
-migrate: Sorting commits: ..., done
-migrate: Rewriting commits: 100% (1/1), done
- main	d2b959babd099fe70da1c1512e2475e8a24de163 -> 136e706bf1ae79643915c134e17a6c933fd53c61
-migrate: Updating refs: ..., done
-```
-
-If after conversion you find that some files in your working directory have
-been replaced with Git LFS pointers, this is normal, and the working copies
-of these files can be repopulated with their full expected contents by using
-`git lfs checkout`.
-
-### Migrate local history
-
-You can also migrate the entire history of your repository:
-
-```
-# Check for large files and existing Git LFS objects in your local main branch
-$ git lfs migrate info --include-ref=main
-
-# Check for large files and existing Git LFS objects in every branch
-$ git lfs migrate info --everything
-
-# Check for large files in every branch, ignoring any existing Git LFS objects,
-# and listing the top 100 or fewer results
-$ git lfs migrate info --everything --pointers=ignore --top=100
-```
-
-The same flags will work in `import` mode:
-
-```
-# Convert all zip files in your main branch
-$ git lfs migrate import --include-ref=main --include="*.zip"
-
-# Convert all zip files in every local branch
-$ git lfs migrate import --everything --include="*.zip"
-
-# Convert all files over 100K in every local branch
-$ git lfs migrate import --everything --above=100Kb
-```
-
-Note: This will require a force-push to any existing Git remotes. Using
-the `--all` option when force-pushing may be convenient if many refs were
-updated, e.g., after importing to Git LFS with the `--everything` option.
-
-### Migrate without rewriting local history
-
-You can also migrate files without modifying the existing history of your
-repository. Note that in the examples below, files in subdirectories are not
-included because they are not explicitly specified.
-
-Without a specified commit message:
-
-```
-$ git lfs migrate import --no-rewrite test.zip *.mp3 *.psd
-```
-
-With a specified commit message:
-
-```
-$ git lfs migrate import --no-rewrite \
- -m "Import test.zip, .mp3, .psd files in root of repo" \
- test.zip *.mp3 *.psd
-```
-
-## SEE ALSO
-
-git-lfs-checkout(1), git-lfs-ls-files(1), git-lfs-track(1),
-git-lfs-untrack(1), gitattributes(5), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-pointer.1.ronn b/docs/man/git-lfs-pointer.1.ronn
deleted file mode 100644
index b37999a816..0000000000
--- a/docs/man/git-lfs-pointer.1.ronn
+++ /dev/null
@@ -1,44 +0,0 @@
-git-lfs-pointer(1) -- Build, compare, and check pointers
-========================================================
-
-## SYNOPSIS
-
-`git lfs pointer --file=path/to/file` 
-`git lfs pointer --file=path/to/file --pointer=path/to/pointer` 
-`git lfs pointer --file=path/to/file --stdin`
-`git lfs pointer --check --file=path/to/file`
-
-## Description
-
-Builds and optionally compares generated pointer files to ensure consistency
-between different Git LFS implementations.
-
-## OPTIONS
-
-* `--file`:
- A local file to build the pointer from.
-
-* `--pointer`:
- A local file including the contents of a pointer generated from another
- implementation. This is compared to the pointer generated from `--file`.
-
-* `--stdin`:
- Reads the pointer from STDIN to compare with the pointer generated from
- `--file`.
-
-* `--check`:
- Reads the pointer from STDIN (if `--stdin` is given) or the filepath (if
- `--file`) is given. If neither or both of `--stdin` and `--file` are given,
- the invocation is invalid. Exits 0 if the data read is a valid Git LFS
- pointer. Exits 1 otherwise.
-
-* `--strict`:
-* `--no-strict`:
- In conjunction with `--check`, `--strict` verifies that the pointer is
- canonical; that is, it would be the one created by Git LFS. If it is not,
- exits 2. The default, for backwards compatibility, is `--no-strict`, but
- this may change in a future version.
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-checkout.1.ronn b/docs/man/git-lfs-post-checkout.1.ronn
deleted file mode 100644
index 03ac55424b..0000000000
--- a/docs/man/git-lfs-post-checkout.1.ronn
+++ /dev/null
@@ -1,18 +0,0 @@
-git-lfs-post-checkout(1) -- Git post-checkout hook implementation
-=================================================================
-
-## SYNOPSIS
-
-`git lfs post-checkout` <rev_before> <ref_after> <is_branch_checkout>
-
-## DESCRIPTION
-
-Responds to Git post-checkout events. It makes sure that any files which are
-marked as lockable by `git lfs track` are read-only in the working copy, if
-not currently locked by the local user.
-
-## SEE ALSO
-
-git-lfs-track(1)
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-commit.1.ronn b/docs/man/git-lfs-post-commit.1.ronn
deleted file mode 100644
index 5e75d76aaa..0000000000
--- a/docs/man/git-lfs-post-commit.1.ronn
+++ /dev/null
@@ -1,23 +0,0 @@
-git-lfs-post-commit(1) -- Git post-commit hook implementation
-=================================================================
-
-## SYNOPSIS
-
-`git lfs post-commit`
-
-## DESCRIPTION
-
-Responds to Git post-commit events. It makes sure that any files which are
-marked as lockable by `git lfs track` are read-only in the working copy, if
-not currently locked by the local user.
-
-Where the `git lfs post-merge` command, which has a similar purpose, must
-examine all files in the working copy, `git lfs post-commit` can limit
-itself checking only those files which have changed in `HEAD`. It primarily
-handles newly added lockable files which have not yet been made read-only.
-
-## SEE ALSO
-
-git-lfs-post-merge(1), git-lfs-track(1)
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-post-merge.1.ronn b/docs/man/git-lfs-post-merge.1.ronn
deleted file mode 100644
index d1d976c53c..0000000000
--- a/docs/man/git-lfs-post-merge.1.ronn
+++ /dev/null
@@ -1,18 +0,0 @@
-git-lfs-post-merge(1) -- Git post-merge hook implementation
-=================================================================
-
-## SYNOPSIS
-
-`git lfs post-merge` <is_squash>
-
-## DESCRIPTION
-
-Responds to Git post-merge events. It makes sure that any files which are
-marked as lockable by `git lfs track` are read-only in the working copy, if
-not currently locked by the local user.
-
-## SEE ALSO
-
-git-lfs-track(1)
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-pre-push.1.ronn b/docs/man/git-lfs-pre-push.1.ronn
deleted file mode 100644
index 1a86e6f558..0000000000
--- a/docs/man/git-lfs-pre-push.1.ronn
+++ /dev/null
@@ -1,35 +0,0 @@
-git-lfs-pre-push(1) -- Git pre-push hook implementation
-=======================================================
-
-## SYNOPSIS
-
-`git lfs pre-push` <remote> [remoteurl]
-
-## DESCRIPTION
-
-Responds to Git pre-hook events. It reads the range of commits from STDIN, in
-the following format:
-
- <local-ref> SP <local-sha1> SP <remote-ref> SP <remote-sha1> \n
-
-It also takes the remote name and URL as arguments.
-
-If any of those Git objects are associated with Git LFS objects, those
-objects will be pushed to the Git LFS API.
-
-In the case of pushing a new branch, the list of Git objects will be all of
-the Git objects in this branch.
-
-In the case of deleting a branch, no attempts to push Git LFS objects will be
-made.
-
-## OPTIONS
-
-* `GIT_LFS_SKIP_PUSH`:
- Do nothing on pre-push. For more, see: git-lfs-config(5).
-
-## SEE ALSO
-
-git-lfs-clean(1), git-lfs-push(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-prune.1.ronn b/docs/man/git-lfs-prune.1.ronn
deleted file mode 100644
index fd70fee373..0000000000
--- a/docs/man/git-lfs-prune.1.ronn
+++ /dev/null
@@ -1,140 +0,0 @@
-git-lfs-prune(1) -- Delete old LFS files from local storage
-===========================================================
-
-## SYNOPSIS
-
-`git lfs prune` [options]
-
-## DESCRIPTION
-
-Deletes local copies of LFS files which are old, thus freeing up disk space.
-Prune operates by enumerating all the locally stored objects, and then deleting
-any which are not referenced by at least ONE of the following:
-
-* the current checkout
-* all existing stashes
-* a 'recent branch'; see [RECENT FILES]
-* a 'recent commit' on the current branch or recent branches; see [RECENT FILES]
-* a commit which has not been pushed; see [UNPUSHED LFS FILES]
-* any other worktree checkouts; see git-worktree(1)
-
-In general terms, prune will delete files you're not currently using and which
-are not 'recent', so long as they've been pushed i.e. the local copy is not the
-only one.
-
-The reflog is not considered, only commits. Therefore LFS objects that are
-only referenced by orphaned commits are always deleted.
-
-Note: you should not run `git lfs prune` if you have different repositories
-sharing the same custom storage directory; see git-lfs-config(5) for more
-details about `lfs.storage` option.
-
-In your Git configuration or in a `.lfsconfig` file, you may set
-`lfs.fetchexclude` to a comma-separated list of paths. If `lfs.fetchexclude`
-is defined, then any Git LFS files whose paths match one in that list will
-be pruned unless they are referenced by a stash or an unpushed commit.
-Paths are matched using wildcard matching as per gitignore(5).
-
-## OPTIONS
-
-* `--dry-run` `-d`
- Don't actually delete anything, just report on what would have been done
-
-* `--force` `-f`
- Prune all objects except unpushed objects, including objects required for
- currently checked out refs. Implies `--recent`.
-
-* `--recent`
- Prune even objects that would normally be preserved by the configuration
- options specified below in [RECENT FILES].
-
-* `--verify-remote` `-c`
- Contact the remote and check that copies of the files we would delete
- definitely exist before deleting. See [VERIFY REMOTE].
-
-* `--no-verify-remote`
- Disables remote verification if lfs.pruneverifyremotealways was enabled in
- settings. See [VERIFY REMOTE].
-
-* `--verbose` `-v`
- Report the full detail of what is/would be deleted.
-
-## RECENT FILES
-
-Prune won't delete LFS files referenced by 'recent' commits, in case you want
-to use them again without having to download. The definition of 'recent' is
-derived from the one used by git-lfs-fetch(1) to download recent objects with
-the `--recent` option, with an offset of a number of days (default 3) to ensure
-that we always keep files you download for a few days.
-
-Here are the git-config(1) settings that control this behaviour:
-
-* `lfs.pruneoffsetdays` 
- The number of extra days added to the fetch recent settings when using them
- to decide when to prune. So for a reference to be considered old enough to
- prune, it has to be this many days older than the oldest reference that would
- be downloaded via `git lfs fetch --recent`. Only used if the relevant
- fetch recent 'days' setting is non-zero. Default 3 days.
-
-* `lfs.fetchrecentrefsdays` 
- `lfs.fetchrecentremoterefs` 
- `lfs.fetchrecentcommitsdays` 
- These have the same meaning as git-lfs-fetch(1) with the `--recent` option,
- they are used as a base for the offset above. Anything which falls outside
- of this offsetted window is considered old enough to prune. If a day value is
- zero, that condition is not used at all to retain objects and they will be
- pruned.
-
-## UNPUSHED LFS FILES
-
-When the only copy of an LFS file is local, and it is still reachable from any
-reference, that file can never be pruned, regardless of how old it is.
-
-To determine whether an LFS file has been pushed, we check the difference
-between local refs and remote refs; where the local ref is ahead, any LFS files
-referenced in those commits is unpushed and will not be deleted. This works
-because the LFS pre-push hook always ensures that LFS files are pushed before
-the remote branch is updated.
-
-See [DEFAULT REMOTE], for which remote is considered 'pushed' for pruning
-purposes.
-
-## VERIFY REMOTE
-
-The `--verify-remote` option calls the remote to ensure that any LFS files to be
-deleted have copies on the remote before actually deleting them.
-
-Usually the check performed by [UNPUSHED LFS FILES] is enough to determine that
-files have been pushed, but if you want to be extra sure at the expense of extra
-overhead you can make prune actually call the remote API and verify the
-presence of the files you're about to delete locally. See [DEFAULT REMOTE] for
-which remote is checked.
-
-You can make this behaviour the default by setting `lfs.pruneverifyremotealways`
-to true.
-
-In addition to the overhead of calling the remote, using this option also
-requires prune to distinguish between totally unreachable files (e.g. those that
-were added to the index but never committed, or referenced only by orphaned
-commits), and files which are still referenced, but by commits which are
-prunable. This makes the prune process take longer.
-
-## DEFAULT REMOTE
-
-When identifying [UNPUSHED LFS FILES] and performing [VERIFY REMOTE], a single
-remote, 'origin', is normally used as the reference. This one remote is
-considered canonical; even if you use multiple remotes, you probably want to
-retain your local copies until they've made it to that remote. 'origin' is used
-by default because that will usually be a main central repo, or your fork of
-it - in both cases that's a valid remote backup of your work. If origin doesn't
-exist then by default nothing will be pruned because everything is treated as
-'unpushed'.
-
-You can alter the remote via git config: `lfs.pruneremotetocheck`. Set this
-to a different remote name to check that one instead of 'origin'.
-
-## SEE ALSO
-
-git-lfs-fetch(1), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-pull.1.ronn b/docs/man/git-lfs-pull.1.ronn
deleted file mode 100644
index ec4b1a363a..0000000000
--- a/docs/man/git-lfs-pull.1.ronn
+++ /dev/null
@@ -1,53 +0,0 @@
-git-lfs-pull(1) -- Download all Git LFS files for current ref & checkout
-========================================================================
-
-## SYNOPSIS
-
-`git lfs pull` [options] [<remote>]
-
-## DESCRIPTION
-
-Download Git LFS objects for the currently checked out ref, and update
-the working copy with the downloaded content if required.
-
-This is equivalent to running the following 2 commands:
-
-git lfs fetch [options] [<remote>]
-git lfs checkout
-
-## OPTIONS
-
-* `-I` <paths> `--include=`<paths>:
- Specify lfs.fetchinclude just for this invocation; see [INCLUDE AND EXCLUDE]
-
-* `-X` <paths> `--exclude=`<paths>:
- Specify lfs.fetchexclude just for this invocation; see [INCLUDE AND EXCLUDE]
-
-## INCLUDE AND EXCLUDE
-
-You can configure Git LFS to only fetch objects to satisfy references in certain
-paths of the repo, and/or to exclude certain paths of the repo, to reduce the
-time you spend downloading things you do not use.
-
-In your Git configuration or in a `.lfsconfig` file, you may set either or
-both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated lists of
-paths. If `lfs.fetchinclude` is defined, Git LFS objects will only be fetched
-if their path matches one in that list, and if `lfs.fetchexclude` is defined,
-Git LFS objects will only be fetched if their path does not match one
-in that list. Paths are matched using wildcard matching as per gitignore(5).
-
-Note that using the command-line options `-I` and `-X` override the respective
-configuration settings. Setting either option to an empty string clears the
-value.
-
-## DEFAULT REMOTE
-
-Without arguments, pull downloads from the default remote. The default remote is
-the same as for `git pull`, i.e. based on the remote branch you're tracking
-first, or origin otherwise.
-
-## SEE ALSO
-
-git-lfs-fetch(1), git-lfs-checkout(1), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-push.1.ronn b/docs/man/git-lfs-push.1.ronn
deleted file mode 100644
index 21c52f957a..0000000000
--- a/docs/man/git-lfs-push.1.ronn
+++ /dev/null
@@ -1,39 +0,0 @@
-git-lfs-push(1) -- Push queued large files to the Git LFS endpoint
-==================================================================
-
-## SYNOPSIS
-
-`git lfs push` [options] <remote> [<ref>...] 
-`git lfs push` <remote> [<ref>...] 
-`git lfs push` --object-id <remote> [<oid>...]
-
-## DESCRIPTION
-
-Upload Git LFS files to the configured endpoint for the current Git remote. By
-default, it filters out objects that are already referenced by the local clone
-of the remote.
-
-## OPTIONS
-
-* `--dry-run`:
- Print the files that would be pushed, without actually pushing them.
-
-* `--all`:
- This pushes all objects to the remote that are referenced by any commit
- reachable from the refs provided as arguments. If no refs are provided, then
- all local refs are pushed. Note that this behavior differs from that of
- git-lfs-fetch(1) when its `--all` option is used; in that case, all refs
- are fetched, including refs other than those under `refs/heads` and
- `refs/tags`. If you are migrating a repository with these commands, make
- sure to run `git lfs push` for any additional remote refs that contain
- Git LFS objects not reachable from your local refs.
-
-* `--object-id`:
- This pushes only the object OIDs listed at the end of the command, separated
- by spaces.
-
-## SEE ALSO
-
-git-lfs-fetch(1), git-lfs-pre-push(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-smudge.1.ronn b/docs/man/git-lfs-smudge.1.ronn
deleted file mode 100644
index 1cdc28014e..0000000000
--- a/docs/man/git-lfs-smudge.1.ronn
+++ /dev/null
@@ -1,51 +0,0 @@
-git-lfs-smudge(1) -- Git smudge filter that converts pointer in blobs to the actual content
-===========================================================================================
-
-## SYNOPSIS
-
-`git lfs smudge` [<path>]
-`git lfs smudge` --skip [<path>]
-
-## DESCRIPTION
-
-Read a Git LFS pointer file from standard input and write the contents
-of the corresponding large file to standard output. If needed,
-download the file's contents from the Git LFS endpoint. The <path>
-argument, if provided, is only used for a progress bar.
-
-Smudge is typically run by Git's smudge filter, configured by the repository's
-Git attributes.
-
-In your Git configuration or in a `.lfsconfig` file, you may set either or
-both of `lfs.fetchinclude` and `lfs.fetchexclude` to comma-separated lists of
-paths. If `lfs.fetchinclude` is defined, Git LFS pointer files will only be
-replaced with the contents of the corresponding Git LFS object file if their
-path matches one in that list, and if `lfs.fetchexclude` is defined, Git LFS
-pointer files will only be replaced with the contents of the corresponding
-Git LFS object file if their path does not match one in that list. Paths are
-matched using wildcard matching as per gitignore(5). Git LFS pointer files
-that are not replaced with the contents of their corresponding object files
-are simply copied to standard output without change.
-
-## OPTIONS
-
-Without any options, `git lfs smudge` outputs the raw Git LFS content to
-standard output.
-
-* `--skip`:
- Skip automatic downloading of objects on clone or pull.
-
-* `GIT_LFS_SKIP_SMUDGE`:
- Disables the smudging process. For more, see: git-lfs-config(5).
-
-## KNOWN BUGS
-
-On Windows, Git before 2.34.0 does not handle files in the working tree larger
-than 4 gigabytes. Newer versions of Git, as well as Unix versions, are
-unaffected.
-
-## SEE ALSO
-
-git-lfs-install(1), gitattributes(5), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-standalone-file.1.ronn b/docs/man/git-lfs-standalone-file.1.ronn
deleted file mode 100644
index f30fdd41b8..0000000000
--- a/docs/man/git-lfs-standalone-file.1.ronn
+++ /dev/null
@@ -1,22 +0,0 @@
-git-lfs-standalone-file(1) -- Standalone transfer adapter for file URLs
-=======================================================================
-
-## SYNOPSIS
-
-`git lfs standalone-file`
-
-## DESCRIPTION
-
-Provides a standalone transfer adapter for file URLs (local paths).
-
-By default, Git LFS requires the support of an HTTP server to implement the Git
-LFS protocol. However, this tool allows the use of URLs starting with `file:///`
-(that is, those representing local paths) in addition. Configuration is not
-necessary; Git LFS handles this internally.
-
-When invoked, this tool speaks JSON on input and output as a standalone transfer
-adapter. It is not intended for use by end users.
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-status.1.ronn b/docs/man/git-lfs-status.1.ronn
deleted file mode 100644
index 8a37e723d7..0000000000
--- a/docs/man/git-lfs-status.1.ronn
+++ /dev/null
@@ -1,34 +0,0 @@
-git-lfs-status(1) -- Show the status of Git LFS files in the working tree
-=========================================================================
-
-## SYNOPSIS
-
-`git lfs status` [<options>]
-
-## DESCRIPTION
-
-Display paths of Git LFS objects that
-
-* have not been pushed to the Git LFS server. These are large files
- that would be uploaded by `git push`.
-
-* have differences between the index file and the current HEAD commit.
- These are large files that would be committed by `git commit`.
-
-* have differences between the working tree and the index file. These
- are files that could be staged using `git add`.
-
-This command must be run in a non-bare repository.
-
-## OPTIONS
-
-* `--porcelain`:
- Give the output in an easy-to-parse format for scripts.
-* `--json`:
- Give the output in a stable json format for scripts.
-
-## SEE ALSO
-
-git-lfs-ls-files(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-track.1.ronn b/docs/man/git-lfs-track.1.ronn
deleted file mode 100644
index 814843c348..0000000000
--- a/docs/man/git-lfs-track.1.ronn
+++ /dev/null
@@ -1,80 +0,0 @@
-git-lfs-track(1) - View or add Git LFS paths to Git attributes
-==============================================================
-
-## SYNOPSIS
-
-`git lfs track` [options] [<pattern>...]
-
-## DESCRIPTION
-
-Start tracking the given patterns(s) through Git LFS. The <pattern> argument
-is written to .gitattributes. If no paths are provided, simply list the
-currently-tracked paths.
-
-The [gitattributes documentation](https://git-scm.com/docs/gitattributes) states
-that patterns use the [gitignore pattern rules](https://git-scm.com/docs/gitignore)
-to match paths. This means that patterns which contain asterisk (`*`), question
-mark (`?`), and the bracket characters (`[` and `]`) are treated specially; to
-disable this behavior and treat them literally instead, use `--filename` or
-escape the character with a backslash.
-
-## OPTIONS
-
-* `--verbose` `-v`:
- If enabled, have `git lfs track` log files which it will touch. Disabled by
- default.
-
-* `--dry-run` `-d`:
- If enabled, have `git lfs track` log all actions it would normally take
- (adding entries to .gitattributes, touching files on disk, etc) without
- performing any mutative operations to the disk.
-
- `git lfs track --dry-run [files]` also implicitly mocks the behavior of
- passing the `--verbose`, and will log in greater detail what it is doing.
-
- Disabled by default.
-
-* `--filename`
- Treat the arguments as literal filenames, not as patterns. Any special glob
- characters in the filename will be escaped when writing the `.gitattributes`
- file.
-
-* `--lockable` `-l`
- Make the paths 'lockable', meaning they should be locked to edit them, and
- will be made read-only in the working copy when not locked.
-
-* `--not-lockable`
- Remove the lockable flag from the paths so they are no longer read-only unless
- locked.
-
-* `--no-excluded`
- Do not list patterns that are excluded in the output; only list patterns that
- are tracked.
-
-* `--no-modify-attrs`
- Makes matched entries stat-dirty so that Git can re-index files you wish to
- convert to LFS. Does not modify any `.gitattributes` file(s).
-
-## EXAMPLES
-
-* List the patterns that Git LFS is currently tracking:
-
- `git lfs track`
-
-* Configure Git LFS to track GIF files:
-
- `git lfs track "*.gif"`
-
-* Configure Git LFS to track PSD files and make them read-only unless locked:
-
- `git lfs track --lockable "*.psd"`
-
-* Configure Git LFS to track the file named `project [1].psd`:
-
- `git lfs track --filename "project [1].psd"`
-
-## SEE ALSO
-
-git-lfs-untrack(1), git-lfs-install(1), gitattributes(5), gitignore(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-uninstall.1.ronn b/docs/man/git-lfs-uninstall.1.ronn
deleted file mode 100644
index 853676d020..0000000000
--- a/docs/man/git-lfs-uninstall.1.ronn
+++ /dev/null
@@ -1,41 +0,0 @@
-git-lfs-uninstall(1) -- Remove Git LFS configuration
-=================================================
-
-## SYNOPSIS
-
-`git lfs uninstall`
-
-## DESCRIPTION
-
-Perform the following actions to remove the Git LFS configuration:
-
-* Remove the "lfs" clean and smudge filters from the global Git config.
-* Uninstall the Git LFS pre-push hook if run from inside a Git repository.
-
-## OPTIONS
-
-* --local:
- Removes the "lfs" smudge and clean filters from the local repository's git
- config, instead of the global git config (~/.gitconfig).
-* --worktree:
- Removes the "lfs" smudge and clean filters from the current working tree's
- git config, instead of the global git config (~/.gitconfig) or local
- repository's git config ($GIT_DIR/config).
- If multiple working trees are in use, the Git config extension
- `worktreeConfig` must be enabled to use this option.
- If only one working tree is in use, `--worktree` has the same effect
- as `--local`.
- This option is only available if the installed Git version is at least
- 2.20.0 and therefore supports the "worktreeConfig" extension.
-* --system:
- Removes the "lfs" smudge and clean filters from the system git config,
- instead of the global git config (~/.gitconfig).
-* --skip-repo:
- Skips cleanup of the local repo; use if you want to uninstall the global lfs
- filters but not make changes to the current repo.
-
-## SEE ALSO
-
-git-lfs-install(1), git-worktree(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-unlock.1.ronn b/docs/man/git-lfs-unlock.1.ronn
deleted file mode 100644
index 04d044bee9..0000000000
--- a/docs/man/git-lfs-unlock.1.ronn
+++ /dev/null
@@ -1,34 +0,0 @@
-git-lfs-unlock(1) -- Remove "locked" setting for a file on the Git LFS server
-=============================================================================
-
-## SYNOPSIS
-
-`git lfs unlock` [OPTIONS] <path>
-
-## DESCRIPTION
-
-Removes the given file path as "locked" on the Git LFS server. Files must exist
-and have a clean git status before they can be unlocked. The `--force` flag will
-skip these checks.
-
-## OPTIONS
-
-* `-r` <name> `--remote=`<name>:
- Specify the Git LFS server to use. Ignored if the `lfs.url` config key is set.
-
-* `-f` `--force`:
- Tells the server to remove the lock, even if it's owned by another user.
-
-* `-i <id>` `--id=<id>`:
- Specifies a lock by its ID instead of path.
-
-* `--json`:
- Writes lock info as JSON to STDOUT if the command exits successfully. Intended
- for interoperation with external tools. If the command returns with a non-zero
- exit code, plain text messages will be sent to STDERR.
-
-## SEE ALSO
-
-git-lfs-lock(1), git-lfs-locks(1).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-untrack.1.ronn b/docs/man/git-lfs-untrack.1.ronn
deleted file mode 100644
index 138e65b2e2..0000000000
--- a/docs/man/git-lfs-untrack.1.ronn
+++ /dev/null
@@ -1,23 +0,0 @@
-git-lfs-untrack(1) - Remove Git LFS paths from Git Attributes
-=============================================================
-
-## SYNOPSIS
-
-`git lfs untrack` <path>...
-
-## DESCRIPTION
-
-Stop tracking the given path(s) through Git LFS. The <path> argument
-can be a glob pattern or a file path.
-
-## EXAMPLES
-
-* Configure Git LFS to stop tracking GIF files:
-
- `git lfs untrack "*.gif"`
-
-## SEE ALSO
-
-git-lfs-track(1), git-lfs-install(1), gitattributes(5).
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs-update.1.ronn b/docs/man/git-lfs-update.1.ronn
deleted file mode 100644
index 891692af62..0000000000
--- a/docs/man/git-lfs-update.1.ronn
+++ /dev/null
@@ -1,28 +0,0 @@
-git-lfs-update(1) -- Update Git hooks
-=====================================
-
-## SYNOPSIS
-
-`git lfs update` [--manual | --force]
-
-## DESCRIPTION
-
-Updates the Git hooks used by Git LFS. Silently upgrades known hook contents.
-If you have your own custom hooks you may need to use one of the extended
-options below.
-
-## OPTIONS
-
-* `--manual` `-m`
- Print instructions for manually updating your hooks to include git-lfs
- functionality. Use this option if `git lfs update` fails because of existing
- hooks and you want to retain their functionality.
-
-* `--force` `-f`
- Forcibly overwrite any existing hooks with git-lfs hooks. Use this option
- if `git lfs update` fails because of existing hooks but you don't care
- about their current contents.
-
-## SEE ALSO
-
-Part of the git-lfs(1) suite.
diff --git a/docs/man/git-lfs.1.ronn b/docs/man/git-lfs.1.ronn
deleted file mode 100644
index 0dc1377087..0000000000
--- a/docs/man/git-lfs.1.ronn
+++ /dev/null
@@ -1,124 +0,0 @@
-git-lfs(1) -- Work with large files in Git repositories
-=======================================================
-
-## SYNOPSIS
-
-`git lfs` <command> [<args>]
-
-## DESCRIPTION
-
-Git LFS is a system for managing and versioning large files in
-association with a Git repository. Instead of storing the large files
-within the Git repository as blobs, Git LFS stores special "pointer
-files" in the repository, while storing the actual file contents on a
-Git LFS server. The contents of the large file are downloaded
-automatically when needed, for example when a Git branch containing
-the large file is checked out.
-
-Git LFS works by using a "smudge" filter to look up the large file
-contents based on the pointer file, and a "clean" filter to create a
-new version of the pointer file when the large file's contents change.
-It also uses a `pre-push` hook to upload the large file contents to
-the Git LFS server whenever a commit containing a new large file
-version is about to be pushed to the corresponding Git server.
-
-## COMMANDS
-
-Like Git, Git LFS commands are separated into high level ("porcelain")
-commands and low level ("plumbing") commands.
-
-### High level porcelain commands
-
-* git-lfs-checkout(1):
- Populate working copy with real content from Git LFS files.
-* git-lfs-dedup(1):
- De-duplicate Git LFS files.
-* git-lfs-env(1):
- Display the Git LFS environment.
-* git-lfs-ext(1):
- Display Git LFS extension details.
-* git-lfs-fetch(1):
- Download Git LFS files from a remote.
-* git-lfs-fsck(1):
- Check Git LFS files for consistency.
-* git-lfs-install(1):
- Install Git LFS configuration.
-* git-lfs-lock(1):
- Set a file as "locked" on the Git LFS server.
-* git-lfs-locks(1):
- List currently "locked" files from the Git LFS server.
-* git-lfs-logs(1):
- Show errors from the Git LFS command.
-* git-lfs-ls-files(1):
- Show information about Git LFS files in the index and working tree.
-* git-lfs-migrate(1):
- Migrate history to or from Git LFS
-* git-lfs-prune(1):
- Delete old Git LFS files from local storage
-* git-lfs-pull(1):
- Fetch Git LFS changes from the remote & checkout any required working tree
- files.
-* git-lfs-push(1):
- Push queued large files to the Git LFS endpoint.
-* git-lfs-status(1):
- Show the status of Git LFS files in the working tree.
-* git-lfs-track(1):
- View or add Git LFS paths to Git attributes.
-* git-lfs-uninstall(1):
- Uninstall Git LFS by removing hooks and smudge/clean filter configuration.
-* git-lfs-unlock(1):
- Remove "locked" setting for a file on the Git LFS server.
-* git-lfs-untrack(1):
- Remove Git LFS paths from Git Attributes.
-* git-lfs-update(1):
- Update Git hooks for the current Git repository.
-* git-lfs-version(1):
- Report the version number.
-
-### Low level plumbing commands
-
-* git-lfs-clean(1):
- Git clean filter that converts large files to pointers.
-* git-lfs-filter-process(1):
- Git process filter that converts between large files and pointers.
-* git-lfs-merge-driver(1):
- Merge text-based LFS files
-* git-lfs-pointer(1):
- Build and compare pointers.
-* git-lfs-post-checkout(1):
- Git post-checkout hook implementation.
-* git-lfs-post-commit(1):
- Git post-commit hook implementation.
-* git-lfs-post-merge(1):
- Git post-merge hook implementation.
-* git-lfs-pre-push(1):
- Git pre-push hook implementation.
-* git-lfs-smudge(1):
- Git smudge filter that converts pointer in blobs to the actual content.
-* git-lfs-standalone-file(1):
- Git LFS standalone transfer adapter for file URLs (local paths).
-
-## EXAMPLES
-
-To get started with Git LFS, the following commands can be used.
-
- 1. Setup Git LFS on your system. You only have to do this once per
- repository per machine:
-
- git lfs install
-
- 2. Choose the type of files you want to track, for examples all `ISO`
- images, with git-lfs-track(1):
-
- git lfs track "*.iso"
-
- 3. The above stores this information in gitattributes(5) files, so
- that file needs to be added to the repository:
-
- git add .gitattributes
-
- 4. Commit, push and work with the files normally:
-
- git add file.iso
- git commit -m "Add disk image"
- git push

From e670c008335b197c047ae0fc49ac7d24b3107227 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <bk2204@github.com>
Date: Mon, 11 Jul 2022 15:15:53 +0000
Subject: [PATCH 21/21] gitignore: remove lines for ronn

Since we're no longer using ronn, let's remove the patterns and comments
for it in `.gitignore`.
---
 .gitignore | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 3405589d43..6c04e4ba86 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,9 +3,7 @@ benchmark/
 out/
 resource.syso
 
-# only allow man/*.\d.ronn files
 man/*
-index.txt
 
 *.test
 tmp

Places

File 5054.patch of Package git-lfs (Revision 18efc91c28176d5063fa85b6b4d89645)

Places