git-ls-tree(1)
==============

NAME
----
git-ls-tree - List the contents of a tree object


SYNOPSIS
--------
[verse]
'git-ls-tree' [-d] [-r] [-t] [-l] [-z]
	    [--name-only] [--name-status] [--full-name] [--abbrev=[<n>]]
	    <tree-ish> [paths...]

DESCRIPTION
-----------
Lists the contents of a given tree object, like what "/bin/ls -a" does
in the current working directory. Note that the usage is subtly different,
though - 'paths' denote just a list of patterns to match, e.g. so specifying
directory name (without '-r') will behave differently, and order of the
arguments does not matter.

OPTIONS
-------
<tree-ish>::
	Id of a tree-ish.

-d::
	Show only the named tree entry itself, not its children.

-r::
	Recurse into sub-trees.

-t::
	Show tree entries even when going to recurse them. Has no effect
	if '-r' was not passed. '-d' implies '-t'.

-l::
--long::
	Show object size of blob (file) entries.

-z::
	\0 line termination on output.

--name-only::
--name-status::
	List only filenames (instead of the "long" output), one per line.

--abbrev[=<n>]::
	Instead of showing the full 40-byte hexadecimal object
	lines, show only handful hexdigits prefix.
	Non default number of digits can be specified with --abbrev=<n>.

--full-name::
	Instead of showing the path names relative to the current working
	directory, show the full path names.

paths::
	When paths are given, show them (note that this isn't really raw
	pathnames, but rather a list of patterns to match).  Otherwise
	implicitly uses the root level of the tree as the sole path argument.


Output Format
-------------
        <mode> SP <type> SP <object> TAB <file>

When the `-z` option is not used, TAB, LF, and backslash characters
in pathnames are represented as `\t`, `\n`, and `\\`, respectively.

When the `-l` option is used, format changes to

        <mode> SP <type> SP <object> SP <object size> TAB <file>

Object size identified by <object> is given in bytes, and right-justified
with minimum width of 7 characters.  Object size is given only for blobs
(file) entries; for other entries `-` character is used in place of size.


Author
------
Written by Petr Baudis <pasky@suse.cz>
Completely rewritten from scratch by Junio C Hamano <junkio@cox.net>,
another major rewrite by Linus Torvalds <torvalds@osdl.org>

Documentation
--------------
Documentation by David Greaves, Junio C Hamano and the git-list
<git@vger.kernel.org>.

GIT
---
Part of the linkgit:git[7] suite
