Convert absolute path into relative path given a current directory using Bash

Question

Example   absolute   foo bar  current   foo baz foo     Magic  relative        bar    How do I create the magic  hopefully not too complicated code

User · Answer

I needed something like this but which resolved symbolic links too  I discovered that pwd has a -P flag for that purpose  A fragment of my script is appended  It s within a function in a shell script  hence the  1 and  2  The result value  which is the relative path from START ABS to END ABS  is in the UPDIRS variable  The script cd s into each parameter directory in order to execute the pwd -P and this also means that relative path parameters are handled  Cheers  Jim  SAVE DIR   PWD  cd   1  START ABS  pwd -P  cd   SAVE DIR  cd   2  END ABS  pwd -P   START WORK   START ABS  UPDIRS     while test -n    START WORK   -a    END ABS    START WORK           END ABS   do     START WORK  dirname   START WORK          UPDIRS   UPDIRS       done UPDIRS   UPDIRS  END ABS    START WORK    cd   SAVE DIR

User · Answer

Using realpath from GNU coreutils 8 23 is the simplest  I think     realpath --relative-to   file1    file2    For example     realpath --relative-to  usr bin nmap  tmp testing          tmp testing

User · Answer

This script works only on the path names  It does not require any of the files to exist  If the paths passed are not absolute  the behavior is a bit unusual  but it should work as expected if both paths are relative   I only tested it on OS nbsp X  so it might not be portable      bin bash set -e declare SCRIPT NAME    basename  0   function usage       echo  Usage   SCRIPT NAME  lt base path gt   lt target file gt       echo         Outputs  lt target file gt  relative to  lt base path gt       exit 1    if      -lt 2    then usage  fi  declare base  1 declare target  2 declare -a base part    declare -a target part      Split path elements  amp  canonicalize OFS   IFS   IFS     bpl 0  for bp in  base  do     case   bp  in                              let  bpl  bpl-1                base part   bpl     bp    let  bpl  bpl 1        esac done tpl 0  for tp in  target  do     case   tp  in                              let  tpl  tpl-1                target part   tpl     tp    let  tpl  tpl 1        esac done IFS   OFS    Count common prefix common 0 for    i 0   i lt  bpl   i       do     if      base part  i         target part  common        then         let  common  common 1      else         break     fi done   Compute number of directories up let  updir  bpl- common     updir 0  if the expression is zero   let  fails   trivial case  after canonical decomposition  if    updir -eq 0    then     echo       exit fi   Print updirs for    i 0   i lt  updir   i       do     echo -n     done   Print remaining path for    i  common   i lt  tpl   i       do     if    i -ne  common    then         echo -n         fi     if            target part  i        then         echo -n    target part  i        fi done  One last newline echo

User · Answer

test sh      bin bash                                                                   cd  home ubuntu touch blah TEST  home ubuntu    blah echo TEST  TEST TMP   readlink -e   TEST   echo TMP  TMP REL   TMP   pwd    echo REL  REL   Testing       test sh  TEST  home ubuntu    blah TMP  home ubuntu blah REL blah

User · Answer

Here s a shell script that does it without calling other programs       bin env bash    bash script to find the relative path between two directories  mydir   0    mydir   0     creadlink   mydir creadlink   shopt -s extglob  relpath               path1     creadlink    1           path2     creadlink    2           orig1  path1         path1   path1             path2   path2              while    do                 if test     path1   then                         break                 fi                 part1   path2  path1                  if test    part1         part1   then                         path1   path1                             continue                 fi                 if test    path2  path1       path2   then                         path1   path1                             continue                 fi                 break         done         part1  path1         path1   orig1  part1          depth   path1                       path1   path2  path1          path1   depth   path2  part1          path1   path1                 path1   path1            if test     path1   then                 path1           fi         printf   path1      relpath test              res   relpath   path1 to dir1  path1 to dir2           expected     dir2          test results   res    expected           res   relpath     path1 to dir2           expected  path1 to dir2          test results   res    expected           res   relpath   path1 to dir2             expected                    test results   res    expected           res   relpath                expected             test results   res    expected           res   relpath   path to dir2 dir3  path to dir1 dir4 dir4a           expected        dir1 dir4 dir4a          test results   res    expected           res   relpath   path to dir1 dir4 dir4a  path to dir2 dir3           expected           dir2 dir3          test results   res    expected            res   relpath     path to dir2 dir3            expected           dir2 dir3           test results   res    expected     test results              if test     1      2   then                 printf  failed  nresult  nX sX nexpected  nX sX n n               fi     relpath test   source   http   www ynform org w Pub Relpath

User · Answer

This script gives correct results only for inputs that are absolute paths or relative paths without   or         bin bash    usage  relpath from to  if      1       2     then     echo         exit fi  IFS      current   1  absolute   2   abssize    absolute     cursize    current      while      absolute level        current level      do        level          if    level  gt  abssize    level  gt  cursize        then         break     fi done  for   i   level  i  lt  cursize  i     do     if   i  gt  level       then         newpath  newpath        fi     newpath  newpath     done  for   i   level  i  lt  abssize  i     do     if    -n  newpath        then         newpath  newpath        fi     newpath  newpath  absolute i   done  echo   newpath

User · Answer

Guess this one shall do the trick too     comes with built-in tests      OK  some overhead expected  but we re doing Bourne shell here          bin sh      Finding the relative path to a certain file   2   given the absolute path   1     available here too http   pastebin com tWWqA8aB    relpath        local  FROM   1    local    TO   dirname   2     local  FILE   basename  2     local  DEBUG   3     local FROMREL      local FROMUP   FROM    while     FROMUP            do     local TOUP   TO      local TOREL        while     TOUP            do         -z   DEBUG       echo 1 gt  amp 2   DEBUG FROMUP      TOUP        if     FROMUP      TOUP     then         echo    FROMREL -    TOREL  TOREL     FILE          return 0       fi       TOREL   basename  TOUP   TOREL     TOREL        TOUP   dirname  TOUP       done     FROMREL      FROMREL     FROMREL      FROMUP   dirname  FROMUP     done   echo    FROMREL -    TOREL     TOREL  FILE    return 0    relpathshow        echo   - target  2    echo     from    1    echo     ------    echo       gt   relpath  1  2              echo         If given 2 arguments  do as said    if   -n   2     then   relpath  1  2    If only one given  then assume current directory elif   -n   1     then   relpath  pwd   1    Otherwise perform a set of built-in tests to confirm the validity of the method     else    relpathshow  usr share emacs22 site-lisp emacs-goodies-el                  usr share emacs22 site-lisp emacs-goodies-el filladapt el    relpathshow  usr share emacs23 site-lisp emacs-goodies-el                  usr share emacs22 site-lisp emacs-goodies-el filladapt el    relpathshow  usr bin                  usr share emacs22 site-lisp emacs-goodies-el filladapt el    relpathshow  usr bin                  usr share emacs22 site-lisp emacs-goodies-el filladapt el    relpathshow  usr bin share emacs22 site-lisp emacs-goodies-el                  etc motd    relpathshow                    initrd img fi

User · Answer

This is a corrected  fully functional improvement of the currently best rated solution from  pini  which sadly handle only a few cases   Reminder    -z  test if the string is zero-length   empty  and  -n  test if the string is not empty     both  1 and  2 are absolute paths beginning with     returns relative path to  2  target from  1  source source  1 target  2  common part  source   for now result      for now  while       target  common part         target       do       no match  means that candidate common part is not correct       go up one level  reduce common part      common part    dirname  common part         and record that we went back  with correct   handling     if    -z  result     then         result          else         result      result      fi done  if     common part            then       special case for root  no common path      result   result   fi    since we now have identified the common part    compute the non-common part forward part    target  common part      and now stick all parts together if    -n  result     amp  amp     -n  forward part     then     result   result forward part  elif    -n  forward part     then       extra slash removal     result    forward part 1   fi  echo  result   Test cases    compute relative sh   A B C    A            -- gt           compute relative sh   A B C    A B          -- gt        compute relative sh   A B C    A B C        -- gt      compute relative sh   A B C    A B C D      -- gt    D  compute relative sh   A B C    A B C D E    -- gt    D E  compute relative sh   A B C    A B D        -- gt       D  compute relative sh   A B C    A B D E      -- gt       D E  compute relative sh   A B C    A D          -- gt          D  compute relative sh   A B C    A D E        -- gt          D E  compute relative sh   A B C    D E F        -- gt             D E F

User · Answer

Yet another solution  pure bash   GNU readlink for easy use in following context  ln -s  quot   relpath  quot  A quot   quot  B quot   quot   quot  B quot    Edit  Make sure that  quot  B quot  is either not existing or no softlink in that case  else relpath follows this link which is not what you want   This works in nearly all current Linux   If readlink -m does not work at your side  try readlink -f instead   See also https   gist github com hilbix 1ec361d00a8178ae8ea0 for possible updates    relpath A B   Calculate relative path from A to B  returns true on success   Example  ln -s  quot   relpath  quot  A quot   quot  B quot   quot   quot  B quot  relpath     local X Y A   We can create dangling softlinks X  quot   readlink -m --  quot  1 quot   quot     return Y  quot   readlink -m --  quot  2 quot   quot     return X  quot   X     quot  A  quot  quot  while   Y  quot   Y     quot             quot    X  quot  Y quot    quot     quot   X quot    do         A  quot     A quot  done X  quot  A  X  quot  Y quot    quot  X  quot   X    quot  echo  quot   X -   quot     Notes   Care was taken that it is safe against unwanted shell meta character expansion  in case filenames contain   or    The output is meant to be usable as the first argument to ln -s   relpath     gives   and not the empty string relpath a a gives a  even if a happens to be a directory   Most common cases were tested to give reasonable results  too  This solution uses string prefix matching  hence readlink is required to canonicalize paths  Thanks to readlink -m it works for not yet existing paths  too   On old systems  where readlink -m is not available  readlink -f fails if the file does not exist   So you probably need some workaround like this  untested    readlink missing     readlink -m --  quot  1 quot   amp  amp  return readlink -f --  quot  1 quot   amp  amp  return   -e      amp  amp  echo  quot   readlink missing  quot   dirname  quot  1 quot   quot     basename  quot  1 quot   quot     This is not really quite correct in case  1 includes   or    for nonexisting paths  like in  doesnotexist   a   but it should cover most cases   Replace readlink -m -- above by readlink missing   Edit because of the downvote follows Here is a test  that this function  indeed  is correct  check     res  quot   relpath  quot  2 quot   quot  1 quot   quot     quot   res quot     quot   3 quot     amp  amp  return printf   WRONG   -10q  -10q gives  q nCORRECT  -10q  -10q gives  q n   quot  1 quot   quot  2 quot   quot  res quot   quot    quot           TARGET   SOURCE         RESULT check  quot  A B C quot   quot  A quot             quot    quot  check  quot  A B C quot   quot  A x quot           quot       A x quot  check  quot  A B C quot   quot  A B quot           quot   quot  check  quot  A B C quot   quot  A B C quot         quot C quot  check  quot  A B C quot   quot  A B C D quot       quot C D quot  check  quot  A B C quot   quot  A B C D E quot     quot C D E quot  check  quot  A B C quot   quot  A B D quot         quot D quot  check  quot  A B C quot   quot  A B D E quot       quot D E quot  check  quot  A B C quot   quot  A D quot           quot    D quot  check  quot  A B C quot   quot  A D E quot         quot    D E quot  check  quot  A B C quot   quot  D E F quot         quot       D E F quot   check  quot  foo baz moo quot   quot  foo bar quot   quot    bar quot   Puzzled   Well  these are the correct results   Even if you think it does not fit the question  here is the proof this is correct  check  quot http   example com foo baz moo quot   quot http   example com foo bar quot   quot    bar quot   Without any doubt     bar is the exact and only correct relative path of the page bar seen from the page moo   Everything else would be plain wrong  It is trivial to adopt the output to the question which apparently assumes  that current is a directory  absolute  quot  foo bar quot  current  quot  foo baz foo quot  relative  quot      relpath  quot  absolute quot   quot  current quot   quot   This returns exactly  what was asked for  And before you raise an eyebrow  here is a bit more complex variant of relpath  spot the small difference   which should work for URL-Syntax  too  so a trailing   survives  thanks to some bash-magic     Calculate relative PATH to the given DEST from the given BASE   In the URL case  both URLs must be absolute and have the same Scheme    The  SCHEME   must not be present in the FS either    This way this routine works for file paths an   relpathurl DEST BASE relpathurl     local X Y A   We can create dangling softlinks X  quot   readlink -m --  quot  1 quot   quot     return Y  quot   readlink -m --  quot  2 quot   quot     return X  quot   X      1  quot   1    quot   quot  Y  quot   Y     2  quot   2    quot   quot  A  quot  quot  while   Y  quot   Y     quot             quot    X  quot  Y quot    quot     quot   X quot    do         A  quot     A quot  done X  quot  A  X  quot  Y quot    quot  X  quot   X    quot  echo  quot   X -   quot     And here are the checks just to make clear  It really works as told  check     res  quot   relpathurl  quot  2 quot   quot  1 quot   quot     quot   res quot     quot   3 quot     amp  amp  return printf   WRONG   -10q  -10q gives  q nCORRECT  -10q  -10q gives  q n   quot  1 quot   quot  2 quot   quot  res quot   quot    quot           TARGET   SOURCE         RESULT check  quot  A B C quot   quot  A quot             quot    quot  check  quot  A B C quot   quot  A x quot           quot       A x quot  check  quot  A B C quot   quot  A B quot           quot   quot  check  quot  A B C quot   quot  A B C quot         quot C quot  check  quot  A B C quot   quot  A B C D quot       quot C D quot  check  quot  A B C quot   quot  A B C D E quot     quot C D E quot  check  quot  A B C quot   quot  A B D quot         quot D quot  check  quot  A B C quot   quot  A B D E quot       quot D E quot  check  quot  A B C quot   quot  A D quot           quot    D quot  check  quot  A B C quot   quot  A D E quot         quot    D E quot  check  quot  A B C quot   quot  D E F quot         quot       D E F quot   check  quot  foo baz moo quot   quot  foo bar quot   quot    bar quot  check  quot http   example com foo baz moo quot   quot http   example com foo bar quot   quot    bar quot   check  quot http   example com foo baz moo  quot   quot http   example com foo bar quot   quot       bar quot  check  quot http   example com foo baz moo quot    quot http   example com foo bar  quot   quot    bar  quot  check  quot http   example com foo baz moo  quot    quot http   example com foo bar  quot   quot       bar  quot   And here is how this can be used to give the wanted result from the question  absolute  quot  foo bar quot  current  quot  foo baz foo quot  relative  quot   relpathurl  quot  absolute quot   quot  current  quot   quot  echo  quot  relative quot   If you find something which does not work  please let me know in the comments below   Thanks  PS  Why are the arguments of relpath  quot reversed quot  in contrast to all the other answers here  If you change Y  quot   readlink -m --  quot  2 quot   quot     return  to Y  quot   readlink -m --  quot   2 - quot  PWD quot   quot   quot     return  then you can leave the 2nd parameter away  such that the BASE is the current directory URL whatever   That s only the Unix principle  as usual

User · Answer

I took your question as a challenge to write this in  portable  shell code  i e    with a POSIX shell in mind no bashisms such as arrays avoid calling externals like the plague  There s not a single fork in the script  That makes it blazingly fast  especially on systems with significant fork overhead  like cygwin  Must deal with glob characters in pathnames                It runs on any POSIX conformant shell  zsh  bash  ksh  ash  busybox        It even contains a testsuite to verify its operation  Canonicalization of pathnames is left as an exercise   -      bin sh    Find common parent directory path for a pair of paths    Call with two pathnames as args  e g    commondirpart foo bar foo baz bat - gt  result  foo     The result is either empty or ends with      commondirpart         result       while test    1  -gt 0 -a    2  -gt 0  do       if test    1   1            2   2       then     First characters the same           break                                         No  we re done comparing        fi       result   result  1   1                           Yes  append to result        set --    1        2                             Chop first char off both strings     done    case   result  in                          result    result            esac      Turn foo bar baz into            dir2dotdot         OLDIFS   IFS  IFS     result       for dir in  1  do       result   result        done    result    result        IFS   OLDIFS       Call with FROM TO args  relativepath         case   1  in                                           printf   s n     1  not canonical   exit 1                 from    1                    printf   s n     1  not absolute   exit 1      esac    case   2  in                                           printf   s n     2  not canonical   exit 1                 to    2                    printf   s n     2  not absolute   exit 1      esac     case   to  in       from       Identical directories        result             from       From  x to  x foo bar - gt  foo bar       result    to   from                       From  foo bar to   - gt              dir2dotdot   from                 case   from  in          to             From  x foo bar to  x - gt                 dir2dotdot    from   to                              Everything else           commondirpart   from    to           common   result           dir2dotdot    from  common            result   result   to  common         esac             esac    set -f   noglob  set -x cat  lt  lt EOF          -  -                                                                                                                                   a-z     0-9       0-9    foo  foo    foo       foo bar          foo bar  foo     foo bar  foo baz    baz  foo bar  bar foo        bar foo  foo bar baz  gnarf blurfl blubb          gnarf blurfl blubb  foo bar baz  gnarf          gnarf  foo bar baz  foo baz       baz  foo   bar     bar  EOF while read FROM TO VIA  do    relativepath   FROM    TO     printf   s n   FROM   FROM   TO     TO   VIA    result     if test   result       VIA   then       printf   s n   OOOPS  Expected   VIA  but got   result      fi done    vi  set tabstop 3 shiftwidth 3 expandtab fileformat unix

User · Answer

Sadly  Mark Rushakoff s answer  now deleted - it referenced the code from here  does not seem to work correctly when adapted to   source  home part2 part3 part4 target  work proj1 proj2   The thinking outlined in the commentary can be refined to make it work correctly for most cases   I m about to assume that the script takes a source argument  where you are  and a target argument  where you want to get to   and that either both are absolute pathnames or both are relative   If one is absolute and the other relative  the easiest thing is to prefix the relative name with the current working directory - but the code below does not do that     Beware  The code below is close to working correctly  but is not quite right    There is the problem addressed in the comments from Dennis Williamson  There is also a problem that this purely textual processing of pathnames and you can be seriously messed up by weird symlinks  The code does not handle stray  dots  in paths like  xyz   pqr   The code does not handle stray  double dots  in paths like  xyz    pqr   Trivially  the code does not remove leading      from paths    Dennis s code is better because it fixes 1 and 5 - but has the same issues 2  3  4  Use Dennis s code  and up-vote it ahead of this  because of that    NB  POSIX provides a system call realpath   that resolves pathnames so that there are no symlinks left in them   Applying that to the input names  and then using Dennis s code would give the correct answer each time   It is trivial to write the C code that wraps realpath   - I ve done it - but I don t know of a standard utility that does so      For this  I find Perl easier to use than shell  though bash has decent support for arrays and could probably do this too - exercise for the reader   So  given two compatible names  split them each into components    Set the relative path to empty  While the components are the same  skip to the next  When corresponding components are different or there are no more components for one path  If there are no remaining source components and the relative path is empty  add     to the start  For each remaining source component  prefix the relative path with        If there are no remaining target components and the relative path is empty  add     to the start  For each remaining target component  add the component to the end of the path after a slash    Thus      bin perl -w  use strict     Should fettle the arguments if one is absolute and one relative    Oops - missing functionality     Split  my  source    split       ARGV 0   my  target    split       ARGV 1    my  count   scalar  source       count   scalar  target  if  scalar  target   lt   count   my  relpath        my  i  for   i   0   i  lt   count   i          last if  source  i  ne  target  i       relpath       if   i  gt   scalar  source   amp  amp   relpath eq      for  my  s    i   s  lt  scalar  source    s           relpath        relpath      relpath       if   i  gt   scalar  target   amp  amp   relpath eq      for  my  t    i   t  lt  scalar  target    t           relpath       target  t         Clean up result  remove double slash  trailing slash  trailing slash-dot    relpath    s         relpath    s        relpath    s          print  source     ARGV 0  n   print  target     ARGV 1  n   print  relpath    relpath n     Test script  the square brackets contain a blank and a tab    sed  s                  d   lt  lt       home part1 part2  home part1 part3  home part1 part2  home part4 part5  home part1 part2  work part6 part7  home part1        work part1 part2 part3 part4  home              work part2 part3                    work part2 part3 part4   home part1 part2  home part1 part2 part3 part4  home part1 part2  home part1 part2 part3  home part1 part2  home part1 part2  home part1 part2  home part1  home part1 part2  home  home part1 part2     home part1 part2  work  home part1 part2  work part1  home part1 part2  work part1 part2  home part1 part2  work part1 part2 part3  home part1 part2  work part1 part2 part3 part4  home part1 part2 home part1 part3 home part1 part2 home part4 part5 home part1 part2 work part6 part7 home part1       work part1 part2 part3 part4 home             work part2 part3                  work part2 part3  home part1 part2 home part1 part2 part3 part4 home part1 part2 home part1 part2 part3 home part1 part2 home part1 part2 home part1 part2 home part1 home part1 part2 home home part1 part2    home part1 part2 work home part1 part2 work part1 home part1 part2 work part1 part2 home part1 part2 work part1 part2 part3 home part1 part2 work part1 part2 part3 part4     while read source target do     perl relpath pl  source  target     echo done   Output from the test script   source     home part1 part2 target     home part1 part3 relpath      part3  source     home part1 part2 target     home part4 part5 relpath         part4 part5  source     home part1 part2 target     work part6 part7 relpath            work part6 part7  source     home part1 target     work part1 part2 part3 part4 relpath         work part1 part2 part3 part4  source     home target     work part2 part3 relpath      work part2 part3  source      target     work part2 part3 part4 relpath     work part2 part3 part4  source     home part1 part2 target     home part1 part2 part3 part4 relpath     part3 part4  source     home part1 part2 target     home part1 part2 part3 relpath     part3  source     home part1 part2 target     home part1 part2 relpath      source     home part1 part2 target     home part1 relpath       source     home part1 part2 target     home relpath          source     home part1 part2 target      relpath                source     home part1 part2 target     work relpath            work  source     home part1 part2 target     work part1 relpath            work part1  source     home part1 part2 target     work part1 part2 relpath            work part1 part2  source     home part1 part2 target     work part1 part2 part3 relpath            work part1 part2 part3  source     home part1 part2 target     work part1 part2 part3 part4 relpath            work part1 part2 part3 part4  source    home part1 part2 target    home part1 part3 relpath      part3  source    home part1 part2 target    home part4 part5 relpath         part4 part5  source    home part1 part2 target    work part6 part7 relpath            work part6 part7  source    home part1 target    work part1 part2 part3 part4 relpath         work part1 part2 part3 part4  source    home target    work part2 part3 relpath      work part2 part3  source      target    work part2 part3 relpath      work part2 part3  source    home part1 part2 target    home part1 part2 part3 part4 relpath     part3 part4  source    home part1 part2 target    home part1 part2 part3 relpath     part3  source    home part1 part2 target    home part1 part2 relpath      source    home part1 part2 target    home part1 relpath       source    home part1 part2 target    home relpath          source    home part1 part2 target      relpath             source    home part1 part2 target    work relpath            work  source    home part1 part2 target    work part1 relpath            work part1  source    home part1 part2 target    work part1 part2 relpath            work part1 part2  source    home part1 part2 target    work part1 part2 part3 relpath            work part1 part2 part3  source    home part1 part2 target    work part1 part2 part3 part4 relpath            work part1 part2 part3 part4     This Perl script works fairly thoroughly on Unix  it does not take into account all the complexities of Windows path names  in the face of weird inputs   It uses the module Cwd and its function realpath to resolve the real path of names that exist  and does a textual analysis for paths that don t exist   In all cases except one  it produces the same output as Dennis s script   The deviant case is   source     home part1 part2 target       relpath1            relpath2                The two results are equivalent - just not identical    The output is from a mildly modified version of the test script - the Perl script below simply prints the answer  rather than the inputs and the answer as in the script above    Now  should I eliminate the non-working answer   Maybe        bin perl -w   Based loosely on code from  http   unix derkeiler com Newsgroups comp unix shell 2005-10 1256 html   Via  http   stackoverflow com questions 2564634  use strict   die  Usage   0 from to n  if scalar  ARGV    2   use Cwd qw realpath getcwd    my  pwd  my  verbose   0     Fettle filename so it is absolute    Deals with             and        notations  plus symlinks    The realpath   function does the hard work if the path exists    For non-existent paths  the code does a purely textual hack  sub resolve       my  name            my  path    realpath  name       if   defined  path                  Path does not exist - do the best we can with lexical analysis           Assume Unix - not dealing with Windows           path    name          if   name    m                             pwd   getcwd if  defined  pwd               path     pwd  path                      path    s       g        Not UNC paths           path    s                No trailing            path    s        g       No embedded               Try to eliminate     abc           path    s                       1 g           path    s                No trailing             path    s                No leading              What happens with   and   as inputs            return  path      sub print result       my  source   target   relpath            if   verbose                print  source     ARGV 0  n           print  target     ARGV 1  n           print  relpath    relpath n             else               print   relpath n             exit 0     my  source    resolve  ARGV 0    my  target    resolve  ARGV 1    print result  source   target       if   source eq  target      Split  my  source    split       source  my  target    split       target   my  count   scalar  source       count   scalar  target  if  scalar  target   lt   count   my  relpath       my  i     Both paths are absolute  Perl splits an empty field 0  for   i   1   i  lt   count   i          last if  source  i  ne  target  i      for  my  s    i   s  lt  scalar  source    s           relpath     relpath   if   s  gt   i        relpath     relpath       for  my  t    i   t  lt  scalar  target    t           relpath     relpath   if   relpath ne           relpath     relpath target  t       print result  source   target   relpath

User · Answer

python -c  import os path  print os path relpath   foo bar     foo baz foo      gives         bar

User · Answer

This answer does not address the Bash part of the question  but because I tried to use the answers in this question to implement this functionality in Emacs I ll throw it out there   Emacs actually has a function for this out of the box   ELISP gt   file-relative-name   a b c    a b c       ELISP gt   file-relative-name   a b c    a b    c  ELISP gt   file-relative-name   a b c    c b          a b c

User · Answer

bin bash   both  1 and  2 are absolute paths   returns  2 relative to  1  source  1 target  2  common part  source back  while      target  common part        target      do   common part   dirname  common part    back       back   done  echo   back   target  common part

User · Answer

My Solution   computeRelativePath           Source   readlink -f   1       Target   readlink -f   2        local OLDIFS  IFS     IFS          local SourceDirectoryArray   Source      local TargetDirectoryArray   Target       local SourceArrayLength   echo   SourceDirectoryArray       wc -w      local TargetArrayLength   echo   TargetDirectoryArray       wc -w       local Length     test  SourceArrayLength -gt  TargetArrayLength  amp  amp  Length  SourceArrayLength    Length  TargetArrayLength       local Result        local AppendToEnd         IFS  OLDIFS      local i      for   i   0  i  lt    Length   1   i          do             if      SourceDirectoryArray  i         TargetDirectoryArray  i                  then                 continue                 elif      SourceDirectoryArray  i             amp  amp       TargetDirectoryArray  i                         then                 AppendToEnd    AppendToEnd   TargetDirectoryArray   i                      Result    Result                                  elif      SourceDirectoryArray  i                       then                 Result    Result   TargetDirectoryArray   i                  else                 Result    Result                  fi     done      Result    Result   AppendToEnd        echo  Result

User · Answer

Here is my version  It s based on the answer by  Offirmo  I made it Dash-compatible and fixed the following testcase failure     compute-relative sh   a b c de f g    a b c def g     --          f g    Now   CT FindRelativePath   a b c de f g    a b c def g     --              def g    See the code     both  1 and  2 are absolute paths beginning with     returns relative path to  2  target from  1  source CT FindRelativePath         local insource  1     local intarget  2        Ensure both source and target end with         This simplifies the inner loop       echo  insource      insource         echo  intarget      intarget        case   insource  in                           source   insource          esac      case   intarget  in                           target   intarget          esac       echo  source      source         echo  target      target         local common part  source   for now      local result          echo  common part is now      common part         echo  result is now           result         echo  target common part       target  common part         while      target  common part        target   -a    common part              do           no match  means that candidate common part is not correct           go up one level  reduce common part          common part   dirname   common part              and record that we went back         if   -z    result      then             result               else             result      result          fi          echo   w  common part is now      common part             echo   w  result is now           result             echo   w  target common part       target  common part         done       echo   f  common part is          common part         if      common part             then           special case for root  no common path          common part         fi        since we now have identified the common part        compute the non-common part     forward part    target  common part        echo  forward part      forward part         if   -n    result   -a -n    forward part      then          echo   simple concat           result   result forward part      elif   -n    forward part      then         result   forward part      fi      echo  result      result           if a   was added to target and result ends in   then remove it now      if     intarget       target     then         case   result  in                 result   echo   result    awk    string substr  0  1  length  0 -1   print string                  esac     fi      echo  result      return 0

User · Answer

Python s os path relpath as a shell function  The goal of this relpath exercise is to mimic Python 2 7 s os path relpath function  available from Python version 2 6 but only working properly in 2 7   as proposed by xni  As a consequence  some of the results may differ from functions provided in other answers    I have not tested with newlines in paths simply because it breaks the validation based on calling python -c from ZSH  It would certainly be possible with some effort    Regarding    magic    in Bash  I have given up looking for magic in Bash long ago  but I have since found all the magic I need  and then some  in ZSH   Consequently  I propose two implementations   The first implementation aims to be fully POSIX-compliant  I have tested it with   bin dash on Debian 6 0 6    Squeeze     It also works perfectly with  bin sh on OS X 10 8 3  which is actually Bash version 3 2 pretending to be a POSIX shell   The second implementation is a ZSH shell function that is robust against multiple slashes and other nuisances in paths  If you have ZSH available  this is the recommended version  even if you are calling it in the script form presented below  i e  with a shebang of    usr bin env zsh  from another shell   Finally  I have written a ZSH script that verifies the output of the relpath command found in  PATH given the test cases provided in other answers  I added some spice to those tests by adding some spaces  tabs  and punctuation such as       here and there and also threw in yet another test with exotic UTF-8 characters found in vim-powerline   POSIX shell function  First  the POSIX-compliant shell function  It works with a variety of paths  but does not clean multiple slashes or resolve symlinks      bin sh relpath               -ge 1    amp  amp       -le 2      return 1     current    2    1        target    2 -  1            target            target       target     target              current            current       current    current            current     current          appendix    target          relative        while appendix    target   current                 current            amp  amp      appendix      target     do         if     current      appendix     then             relative    relative -                echo    relative                 return 0         fi         current    current              relative   relative  relative            done     relative   relative  relative    appendix       appendix         echo   relative    relpath        ZSH shell function  Now  the more robust zsh version  If you would like it to resolve the arguments to real paths    la realpath -f  available in the Linux coreutils package   replace the  a on lines 3 and 4 with  A   To use this in zsh  remove the first and last line and put it in a directory that is in your  FPATH variable      usr bin env zsh relpath                -ge 1     amp  amp        -le 2       return 1     local target     2 - 1  a    replace   a  by   A  to resolve symlinks     local current       2   1  - PWD  a    replace   a  by   A  to resolve symlinks     local appendix   target        local relative        while appendix   target  current               current            amp  amp      appendix    target     do         if     current    appendix     then             relative   relative -               print   relative                return 0         fi         current   current             relative   relative  relative            done     relative    relative    appendix       appendix        print  relative   relpath        Test script  Finally  the test script  It accepts one option  namely -v to enable verbose output      usr bin env zsh set -eu VERBOSE false script name   basename  0   usage          print   n    Usage   script name SRC PATH DESTINATION PATH n   gt  amp 2     exit   1  1    vrb       VERBOSE  amp  amp  print -P            return 0     relpath check                -ge 1     amp  amp        -le 2       return 1     target     2 - 1       prefix       2   1  - PWD       result   relpath  prefix  target        Compare with python s os path relpath function     py result   python -c  import os path  print os path relpath   target     prefix         col   F green       if     result     py result     amp  amp  col   F red       VERBOSE  then         print -P    col Source    prefix  nDestination    target  f          print -P    col relpath     qq result  f          print -P    col python      qq py result  f n      fi    run checks          print  Running checks          relpath check       a   b                a   b      x             relpath check        A      relpath check   A           relpath check      amp            E          relpath check          amp            E      relpath check      amp            E       amp            E F      relpath check   X Y       amp       C    E F      relpath check      amp       C    A      relpath check   A      C    A  B      relpath check          C           C      relpath check      amp   B   C       amp   B   C D      relpath check      amp       C       amp       C            relpath check          C           D      relpath check    A   B C     A   B    E      relpath check      amp       C       amp   D      relpath check      amp       C       amp      E      relpath check      amp       C       E F       relpath check  home part1 part2  home part1 part3     relpath check  home part1 part2  home part4 part5     relpath check  home part1 part2  work part6 part7     relpath check  home part1        work part1 part2 part3 part4     relpath check  home              work part2 part3     relpath check                    work part2 part3 part4     relpath check  home part1 part2  home part1 part2 part3 part4     relpath check  home part1 part2  home part1 part2 part3     relpath check  home part1 part2  home part1 part2     relpath check  home part1 part2  home part1     relpath check  home part1 part2  home     relpath check  home part1 part2       relpath check  home part1 part2  work     relpath check  home part1 part2  work part1     relpath check  home part1 part2  work part1 part2     relpath check  home part1 part2  work part1 part2 part3     relpath check  home part1 part2  work part1 part2 part3 part4      relpath check home part1 part2 home part1 part3     relpath check home part1 part2 home part4 part5     relpath check home part1 part2 work part6 part7     relpath check home part1       work part1 part2 part3 part4     relpath check home             work part2 part3     relpath check                  work part2 part3     relpath check home part1 part2 home part1 part2 part3 part4     relpath check home part1 part2 home part1 part2 part3     relpath check home part1 part2 home part1 part2     relpath check home part1 part2 home part1     relpath check home part1 part2 home     relpath check home part1 part2       relpath check home part1 part2 work     relpath check home part1 part2 work part1     relpath check home part1 part2 work part1 part2     relpath check home part1 part2 work part1 part2 part3     relpath check home part1 part2 work part1 part2 part3 part4      print  Done with checks     if       -gt 0     amp  amp      1    -v      then     VERBOSE true     shift fi if       -eq 0     then     run checks else     VERBOSE true     relpath check      fi

User · Answer

bin sh    Return relative path from canonical absolute dir path  1 to canonical   absolute dir path  2   1 and or  2 may end with one or no         Does only need POSIX shell builtins  no external command  relPath          local common path up     common   1    path   2         while test    path   common         path   do         common   common     up     up     done     path  up  path   common     path   path     printf  s    path -         Return relative path from dir  1 to dir  2  Does not impose any   restrictions on  1 and  2 but requires GNU Core Utility  readlink    HINT  busybox s  readlink  does not support option  -m   only  -f          which requires that all but the last path component must exist  relpath      relPath    readlink -m   1       readlink -m   2         Above shell script was inspired by pini s  Thanks    It triggers a bug in the syntax highlighting module of Stack Overflow  at least in my preview frame   So please ignore if highlighting is incorrect   Some notes     Removed errors and improved code without significantly increasing code length and complexity Put functionality into functions for easiness of use  Kept functions POSIX compatible so that they  should  work with all POSIX shells  tested with dash  bash  and zsh in Ubuntu Linux 12 04  Used local variables only to avoid clobbering global variables and polluting the global name space Both directory paths DO NOT need to exist  requirement for my application  Pathnames may contain spaces  special characters  control characters  backslashes  tabs                    etc  Core function  relPath  uses POSIX shell builtins only but requires canonical absolute directory paths as parameters Extended function  relpath  can handle arbitrary directory paths  also relative  non-canonical  but requires external GNU core utility  readlink  Avoided builtin  echo  and used builtin  printf  instead for two reasons    Due to conflicting historical implementations of builtin  echo  it behaves differently in different shells -  POSIX recommends that printf is preferred over echo  Builtin  echo  of some POSIX shells will interpret some backslash sequences and thus corrupt pathnames containing such sequences   To avoid unnecessary conversions  pathnames are used as they are returned and expected by shell and OS utilities  e g  cd  ln  ls  find  mkdir  unlike python s  os path relpath  which will interpret some backslash sequences  Except for the mentioned backslash sequences the last line of function  relPath  outputs pathnames compatible to python   path  up  path   common     path   path     printf  s    path -      Last line can be replaced  and simplified  by line  printf  s   up  path   common       I prefer the latter because   Filenames can be directly appended to dir paths obtained by relPath  e g    ln -s    relpath   lt fromDir gt     lt toDir gt    lt file gt     lt fromDir gt    Symbolic links in the same dir created with this method do not have the ugly      prepended to the filename   If you find an error please contact linuxball  at  gmail com and I ll try to fix it  Added regression test suite  also POSIX shell compatible    Code listing for regression tests  simply append it to the shell script                                                                                    If called with 2 arguments assume they are dir paths and print rel  path                                                                                 test        2  amp  amp        printf   s n   Rel  path from   1  to   2  is    relpath   1    2          exit 0                                                              If NOT called with 2 arguments run regression tests                                                            format   t -19s  -22s  -27s  -8s  -8s  -8s n  printf     n n    Testing own and python s function with canonical absolute dirs n n  printf   format n         From Directory   To Directory   Rel  Path   relPath   relpath   python  IFS  while read -r p  do     eval set --  p     case  1 in          continue   esac   Skip comments and empty lines       q stores quoting character  use   if   is used in path name     q      case  1 2 in        q       esac     rPOk passed rP   relPath   1    2    test   rP      3     rPOk  rP     rpOk passed rp   relpath   1    2    test   rp      3     rpOk  rp     RPOk passed     RP   python -c  import os path  print os path relpath  q 2 q   q 1 q        test   RP      3     RPOk  RP     printf         format    q 1 q    q 2 q    q 3 q    q rPOk q    q rpOk q    q RPOk q  done  lt  lt - EOF        From directory    To directory           Expected relative path                                                           usr                                                 usr                                                                     usr                   usr                            usr                   usr        usr                 usr                            usr                 usr                            usr                 usr                            usr                 usr                            u                   usr                      usr        usr                 u                        u        u  dir              u  dir                         u                   u  dir                dir        u  dir              u                                                   u  dir                u  dir        u  dir                                                 u                   u                                                  u                     u         u                                                   u  dir              u  dir                         u                   u  dir                dir        u  dir              u                                                   u  dir                u  dir        u  dir                                                 u                   u                                                  u                     u         u                                                   u  dir              u  dir                         u                   u  dir                dir        u  dir              u                                                   u  dir                u  dir        u  dir                                                 u                   u                                                  u                     u         u                                                   u n dir             u n dir                        u n                 u n dir               dir        u n dir             u n                                                 u n dir               u n dir        u n dir                                                u n                 u n                                                u n                   u n        u n                                                      a   b                a   b      x                 x                                  A                     A        A                                                      amp            E                                                                        amp            E          amp            E           amp            E        amp            E F                   E F        X Y                    amp       C    E F              amp       C    E F           amp       C          A                              A        A      C            A  B                        B               C                    C                           amp   B   C             amp   B   C D          D           amp       C             amp       C                                 C                    D                  D         A   B C             A   B    E                 E           amp       C             amp   D                      D           amp       C             amp      E                      E           amp       C             E F                            E F        home p1 p2          home p1 p3               p3        home p1 p2          home p4 p5                  p4 p5        home p1 p2          work p6 p7                     work p6 p7        home p1             work p1 p2 p3 p4            work p1 p2 p3 p4        home                work p2 p3               work p2 p3                            work p2 p3 p4         work p2 p3 p4        home p1 p2          home p1 p2 p3 p4      p3 p4        home p1 p2          home p1 p2 p3         p3        home p1 p2          home p1 p2                     home p1 p2          home p1                         home p1 p2          home                               home p1 p2                                                home p1 p2          work                           work        home p1 p2          work p1                        work p1        home p1 p2          work p1 p2                     work p1 p2        home p1 p2          work p1 p2 p3                  work p1 p2 p3        home p1 p2          work p1 p2 p3 p4               work p1 p2 p3 p4         -                   -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  a-z                 0-9                      0-9    EOF   format   t -19s  -22s  -27s  -8s  -8s n  printf   n n    Testing own and python s function with arbitrary dirs n n  printf   format n         From Directory   To Directory   Rel  Path   relpath   python  IFS  while read -r p  do     eval set --  p     case  1 in          continue   esac   Skip comments and empty lines       q stores quoting character  use   if   is used in path name     q      case  1 2 in        q       esac     rpOk passed rp   relpath   1    2    test   rp      3     rpOk  rp     RPOk passed     RP   python -c  import os path  print os path relpath  q 2 q   q 1 q        test   RP      3     RPOk  RP     printf   format    q 1 q    q 2 q    q 3 q    q rpOk q    q RPOk q  done  lt  lt - EOF        From directory    To directory           Expected relative path       usr p1       p4     p3    p1 p6       p2         p1 p2         home       work              dir               dir        home p1 p2          home p1 p3                p3       home p1 p2          home p4 p5                   p4 p5       home p1 p2          work p6 p7                      work p6 p7       home p1             work p1 p2 p3 p4             work p1 p2 p3 p4       home                work p2 p3                work p2 p3                           work p2 p3             work p2 p3       home p1 p2          home p1 p2 p3 p4       p3 p4       home p1 p2          home p1 p2 p3          p3       home p1 p2          home p1 p2                     home p1 p2          home p1                         home p1 p2          home                               home p1 p2                                                home p1 p2          work                            work       home p1 p2          work p1                         work p1       home p1 p2          work p1 p2                      work p1 p2       home p1 p2          work p1 p2 p3                   work p1 p2 p3       home p1 p2          work p1 p2 p3 p4                work p1 p2 p3 p4  EOF

User · Answer

I would just use Perl for this not-so-trivial task   absolute   foo bar  current   foo baz foo     Perl is magic relative   perl -MFile  Spec -e  print File  Spec- gt abs2rel    absolute      current

User · Answer

It is built in to Perl since 2001  so it works on nearly every system you can imagine  even VMS   perl -e  use File  Spec  print File  Spec- gt abs2rel  ARGV      n   FILE BASE   Also  the solution is easy to understand   So for your example   perl -e  use File  Spec  print File  Spec- gt abs2rel  ARGV      n    absolute  current      would work fine

User · Answer

A slight improvement on kasku s and Pini s answers  which plays nicer with spaces and allows passing relative paths      bin bash   both  1 and  2 are paths   returns  2 relative to  1 absolute  readlink -f   2   current  readlink -f   1     Perl is magic   Quoting horror     spaces cause problems  that s why we need the extra   in here  relative   perl -MFile  Spec -e  print File  Spec- gt abs2rel q  absolute  q  current      echo  relative

User · Answer

Not a lot of the answers here are practical for every day use    Since it is very difficult to do this properly in pure bash  I suggest the following  reliable solution  similar to one suggestion buried in a comment    function relpath        python -c  import os sys print os path relpath   sys argv 1                 Then  you can get the relative path based upon the current directory   echo   relpath somepath    or you can specify that the path be relative to a given directory   echo   relpath somepath  etc     relative to  etc   The one disadvantage is this requires python  but    It works identically in any python    2 6 It does not require that the files or directories exist  Filenames may contain a wider range of special characters   For example  many other solutions do not work if filenames contain  spaces or other special characters  It is a one-line function that doesn t clutter scripts    Note that solutions which include basename or dirname may not necessarily be better  as they require that coreutils be installed    If somebody has a pure bash solution that is reliable and simple  rather than a convoluted curiosity   I d be surprised

User · Answer

Presuming that you have installed  bash  pwd  dirname  echo  then relpath is     bin bash s   cd   1     pwd   d   cd  2 pwd   b   while      d  s          d     do s   dirname  s  b       b    done  echo   b   d  s     I ve golfed the answer from pini and a few other ideas  Note  This requires both paths to be existing folders  Files will not work

[bash] Convert absolute path into relative path given a current directory using Bash

Examples related to bash

Examples related to shell

Examples related to path

Examples related to relative-path

Examples related to absolute-path