Recursively list all files and sub-directories

Question

Is there a way, possibly using a package, to recursively list all the files (with paths) and sub-directories (or at least the empty sub-directories, since the paths to the non-empty ones can be gleaned from the paths of the files contained therein) of the current directory?

The closest I could find is the projectile-find-file function of the projectile package (alternatively, the helm-projectile-find-file function of the helm-projectile package), but it doesn't seem to be able to list empty folders. Additionally, it seems to work only with Git and other version control repositories, but there may be a workaround for this limitation.

Answer 1

Assuming you use ivy you can use this function

    (defun fhd/counsel-everything ()
      "list everything recursively"
      (interactive)
      (let* ((cands (split-string
                     (shell-command-to-string "find .") "\n" t)))
        (ivy-read "File: " cands
                  :action #'find-file
                  :caller 'fhd/counsel-everything)))

Answer 2

directory-files-recursively

(I think this was added in Emacs 25)

here's the link to the manual: https://www.gnu.org/software/emacs/manual/html_node/elisp/Contents-of-Directories.html

Return all files under directory whose names match regexp. This function searches the specified directory and its sub-directories, recursively, for files whose basenames (i.e., without the leading directories) match the specified regexp, and returns a list of the absolute file names of the matching files (see absolute file names). The file names are returned in depth-first order, meaning that files in some sub-directory are returned before the files in its parent directory. In addition, matching files found in each subdirectory are sorted alphabetically by their basenames. By default, directories whose names match regexp are omitted from the list, but if the optional argument include-directories is non-nil, they are included.

Example

(directory-files-recursively default-directory "")

Answer 3

This answer assumes that you want to display a listing of the file and dir names, instead of obtaining a Lisp list of them.

Use standard Emacs commands find-dired , find-name-dired, or find-grep-dired. The found file and dir names are displayed in a Dired-mode buffer. (You can put all the power of Dired to work on the results.)

If you use library find-dired+.el then you have enhanced versions of those standard Emacs commands, plush you have a command find-time-dired, which find files that are newer or older than a given timestamp.

Answer 4

This answer assumes that you want to obtain a Lisp list of the file and dir names, instead of displaying a listing of them.

If you use library Dired+ then you can use function diredp-files-within. (You need not be in a Dired buffer to use it.)

This works with any Emacs version, and it is more general than directory-files-recursively.

• You can pass it a list of files and dirs, and it acts recursively in each of them.

• Or you can pass it a function that returns such a list.

  • If there is a Dired buffer for a directory that gets processed then the function is invoked in that buffer to return the list of files to include.

    For example, if the function is dired-get-marked-files then only the marked files and subdirectories are included.

• You can pass it a predicate that each each file or directory must satisfy. Regexp matching is of course one kind of predicate.

• You can tell it not to follow symbolic links.

Answer 5

See https://github.com/technomancy/find-file-in-project

There are commands to either find file or find directories. But not both.

If you just want to list all sub-directories and files recursively in one buffer, there are two commands built in Emacs for ages:

1. M-x find-dired. It's dependent on CLI tool find. At Windows, you need install Cygwin or MYSYS which has find

2. M-x find-lisp-find-dired. Same as find-dired but written in Lisp. So there is no third party dependency. Besides, it can recognize locale out of box. But it's slower than find-dired

Answer 6

My answer is similar to using find-dired:

(shell-command (concat "find " my-directory " -name foo.txt"))

Then, switch to buffer *Shell Command Output*, and you'll have a buffer with a list of files, and/or directories, one per line.

Answer 7

This is independent of Emacs, but if all you want to do is list all files and sub-directories As in you don't require any hyperlinks to go to the file in Emacs, but simply want to list the directories, files, and subdirectories in an Emacs buffer, you can simply use the shell command ls -R > nameOfFile.txt. And then open the resulting file in Emacs.

You can, of course, run this within eshell M-x eshell to the same effect, if you are on Windows and don't have an ls command.

This command will revert the output of ls -R to the specified file name. I usually like to name it the name of the directory. ls -R is the command to recursively run ls. This will include directories and sub-directories that have no files in them.

I like to use this command to compare the contents of directory structures within Emacs quite often. Simply run the command on two different directories, open the resulting files in two different Emacs buffers and run M-x compare-windows to compare the two.

Answer 8

To get all files and sub-directories in Emacs:

C-u 2 ESC x dired RET R

That is, type C-u 2, then M-x, then d i r e d, then RET.

The value of dired-listing-switches appears in the minibuffer. Type R, to append R to those ls switches (e.g., change -al to -alR). When you hit RET those switches take effect. Switch R lists subdirs, recursively.

Answer 9

(defun my-dir-list (source)
  ;;
  ;; Print list files in current buffer
  ;;
  ;; Not tested, system-type: gnu
  ;; Tested,     system-type: windows-nt
  ;;
  (interactive "sDirectory: ")
  (let ((n 0)
    (l-file-dir (and (cd source) (directory-files-and-attributes "./")))
    (dir-list '())
    (file-list '())
    )
    (princ (format "%s\n" default-directory) (current-buffer))
    (while l-file-dir
      (if (nth 1 (car l-file-dir))
      (setq n (1+ n)
        dir-list (cons ((lambda (source)
                  (and (not (string-prefix-p "." (car source))) source))
                (car l-file-dir)) dir-list)
        )
    (princ (format "%s\n" (concat default-directory
                      (and (string-match "\\.[0-9|A-z]" (caar l-file-dir))
                       (caar l-file-dir)))) (current-buffer))
    )
      (setq l-file-dir (cdr l-file-dir))
      )
    (while (caar dir-list)
      (setq dir-list (cdr dir-list))
      (cd "..")
      )
    )
  'ok
  )