encontre a pesquisa nos diretórios pai em vez de subdiretórios

Estou aninhado em uma árvore de arquivos e gostaria de descobrir qual diretório pai contém um arquivo.

Por exemplo, estou em um conjunto de repositórios Git aninhados e quero encontrar o diretório .git que controla os arquivos em que estou atualmente. Eu espero por algo como find -searchup -iname ".git"

Uma versão ainda mais geral que permite o uso de findopções:

#!/bin/bash
set -e
path="$1"
shift 1
while [[ $path != / ]];
do
    find "$path" -maxdepth 1 -mindepth 1 "$@"
    # Note: if you want to ignore symlinks, use "$(realpath -s "$path"/..)"
    path="$(readlink -f "$path"/..)"
done

Por exemplo (supondo que o script seja salvo como find_up.sh)

find_up.sh some_dir -iname "foo*bar" -execdir pwd \;

... imprimirá os nomes de todos some_diros ancestrais (incluindo ele próprio) até os /quais um arquivo com o padrão seja encontrado.

Ao usar readlink -fo script acima, siga os links simbólicos no caminho, conforme observado nos comentários. Em realpath -svez disso, você pode usar se desejar seguir os caminhos pelo nome ("/ foo / bar" aumentará para "foo" mesmo que "bar" seja um link simbólico) - no entanto, isso requer instalação realpathque não é instalada por padrão em maioria das plataformas.

git rev-parse --show-toplevel

imprimirá o diretório de nível superior do repositório atual, se você estiver em um.

Outras opções relacionadas:

# `pwd` is inside a git-controlled repository
git rev-parse --is-inside-work-tree
# `pwd` is inside the .git directory
git rev-parse --is-inside-git-dir

# path to the .git directory (may be relative or absolute)
git rev-parse --git-dir

# inverses of each other:
# `pwd` relative to root of repository
git rev-parse --show-prefix
# root of repository relative to `pwd`
git rev-parse --show-cdup

Uma versão generalizada da resposta de Gilles, primeiro parâmetro usado para encontrar correspondência:

find-up () {
  path=$(pwd)
  while [[ "$path" != "" && ! -e "$path/$1" ]]; do
    path=${path%/*}
  done
  echo "$path"
}

Mantém o uso de links simbólicos.

Encontrar não pode fazer isso. Não consigo pensar em nada mais simples do que um loop de shell. (Não testado, assume que não há /.git)

git_root=$(pwd -P 2>/dev/null || command pwd)
while [ ! -e "$git_root/.git" ]; do
  git_root=${git_root%/*}
  if [ "$git_root" = "" ]; then break; fi
done

Para o caso específico de um repositório git, você pode deixar o git fazer o trabalho por você.

git_root=$(GIT_EDITOR=echo git config -e)
git_root=${git_root%/*}

Se você estiver usando o zsh com o globbing estendido ativado, poderá fazê-lo com um oneliner:

(../)#.git(:h)   # relative path to containing directory, eg. '../../..', '.'
(../)#.git(:a)   # absolute path to actual file, eg. '/home/you/src/prj1/.git'
(../)#.git(:a:h) # absolute path to containing directory, eg. '/home/you/src/prj1'

Explicação (citada em man zshexpn):

Globbing Recursivo

Um componente de nome de caminho do formulário (foo/)#corresponde a um caminho que consiste em zero ou mais diretórios correspondentes ao padrão foo. Como abreviação, **/é equivalente a (*/)#.

Modificadores

Após o designador opcional da palavra, você pode adicionar uma sequência de um ou mais dos seguintes modificadores, cada um precedido por um ':'. Esses modificadores também funcionam no resultado da geração do nome do arquivo e da expansão dos parâmetros, exceto onde indicado.

• uma
  • Transforme um nome de arquivo em um caminho absoluto: acrescenta o diretório atual, se necessário, e resolve qualquer uso de '..' e '.'
• UMA
  • Como ' a ', mas também resolva o uso de links simbólicos sempre que possível. Observe que a resolução de '..' ocorre antes da resolução dos links simbólicos. Essa chamada é equivalente a a menos que o seu sistema tenha a realpathchamada do sistema (os sistemas modernos têm).
• h
  • Remova um componente de nome de caminho à direita, deixando a cabeça. Isso funciona como ' dirname'.

Créditos: Fauxon #zshpara a sugestão inicial de usar (../)#.git(:h).

Esta versão do findup suporta a sintaxe "find", como a resposta do @ sinelaw, mas também suporta links simbólicos sem precisar de caminho real. Ele também suporta um recurso "parar em" opcional, portanto, isso funciona: findup .:~ -name foo... procura por foo sem passar o diretório inicial.

#!/bin/bash

set -e

# get optional root dir
IFS=":" && arg=($1)
shift 1
path=${arg[0]}
root=${arg[1]}
[[ $root ]] || root=/
# resolve home dir
eval root=$root

# use "cd" to prevent symlinks from resolving
cd $path
while [[ "$cur" != "$root" && "$cur" != "/" ]];
do
    cur="$(pwd)"
    find  "$cur/"  -maxdepth 1 -mindepth 1 "$@"
    cd ..
done

Descobri que trabalhar com links simbólicos mata algumas das outras opções. Especialmente as respostas específicas do git. Na metade, criei meu próprio favorito a partir dessa resposta original, que é bastante eficaz.

#!/usr/bin/env bash

# usage: upsearch .git

function upsearch () {
    origdir=${2-`pwd`}
    test / == "$PWD" && cd "$origdir" && return || \
    test -e "$1" && echo "$PWD" && cd "$origdir" && return || \
    cd .. && upsearch "$1" "$origdir"
}

Estou usando links simbólicos para meus projetos go porque go quer código fonte em um determinado local e eu gosto de manter meus projetos em ~ / projects. Crio o projeto em $ GOPATH / src e os vinculo a ~ / projects. Portanto, a execução git rev-parse --show-toplevelimprime o diretório $ GOPATH, não o diretório ~ / projects. Esta solução resolve esse problema.

Sei que é uma situação muito específica, mas acho que a solução é valiosa.

A solução de Vincent Scheib não funciona para arquivos que residem no diretório raiz.

A versão a seguir faz e também permite passar o diretório inicial como o 1º argumento.

find-up() {
    path="$(realpath -s "$1")"

    while ! [ -e "$path"/"$2" ] && [ -n "$path" ]; do
        path="${path%/*}"
    done

    [ -e "$path"/"$2" ] && echo "$path"/"$2"
}

Eu modifiquei a solução do sinelaw para ser POSIX. Ele não segue links simbólicos e inclui a pesquisa no diretório raiz usando um loop do while.

find-up:

#!/usr/bin/env sh

set -e # exit on error
# Use cd and pwd to not follow symlinks.
# Unlike find, default to current directory if no arguments given.
directory="$(cd "${1:-.}"; pwd)"

shift 1 # shift off the first argument, so only options remain

while :; do
  # POSIX, but gets "Permission denied" on private directories.
  # Use || true to allow errors without exiting on error.
  find "$directory" -path "${directory%/}/*/*" -prune -o ! -path "$directory" "$@" -print || true

  # Equivalent, but -mindepth and -maxdepth aren't POSIX.
  # find "$directory" -mindepth 1 -maxdepth 1 "$@"

  if [ "$directory" = '/' ]; then
    break # End do while loop
  else
    directory=$(dirname "$directory")
  fi
done