Rework clone

Instead of doing work to find the default branch just to be able to
set up the repository before doing a fetch, do a "git clone" and let
git handle it.

Use -c core.sharedrepository=0600 to get the same result as
--shared=0600 passed to init.

Use --separate-git-dir to get the git directory in $YADM_REPO and do a
checkout in a temporary dir that's removed right after the clone is
done.

When the clone is done, iterate over all missing files in $YADM_WORK
and perform a checkout. If local files exists that differ compared
with the cloned ones the local files are left intact and the user is
instructed to deal with the conflicts.

test/test_clone.py

@@ -59,7 +59,7 @@ def test_clone(
         # clone should fail
         assert run.failure
         assert run.err != ''
-        assert 'Unable to fetch origin' in run.out
+        assert 'Unable to clone the repository' in run.out
         assert not paths.repo.exists()
     elif repo_exists and not force:
         # can't overwrite data
@@ -76,8 +76,7 @@ def test_clone(
         # ensure conflicts are handled properly
         if conflicts:
             assert 'NOTE' in run.out
-            assert 'Merging origin/master failed' in run.out
-            assert 'Conflicts preserved' in run.out
+            assert 'Local files with content that differs' in run.out
 
         # confirm correct Git origin
         run = runner(
@@ -89,23 +88,16 @@ def test_clone(
 
         # ensure conflicts are really preserved
         if conflicts:
-            # test to see if the work tree is actually "clean"
+            # test that the conflicts are preserved in the work tree
             run = runner(
                 command=yadm_cmd('status', '-uno', '--porcelain'),
                 cwd=paths.work)
             assert run.success
             assert run.err == ''
-            assert run.out == '', 'worktree has unexpected changes'
+            assert str(ds1.tracked[0].path) in run.out
 
-            # test to see if the conflicts are stashed
-            run = runner(command=yadm_cmd('stash', 'list'), cwd=paths.work)
-            assert run.success
-            assert run.err == ''
-            assert 'Conflicts preserved' in run.out, 'conflicts not stashed'
-
-            # verify content of the stashed conflicts
-            run = runner(
-                command=yadm_cmd('stash', 'show', '-p'), cwd=paths.work)
+            # verify content of the conflicts
+            run = runner(command=yadm_cmd('diff'), cwd=paths.work)
             assert run.success
             assert run.err == ''
             assert '\n+conflict' in run.out, 'conflicts not stashed'
@@ -242,20 +234,20 @@ def test_clone_perms(
             f'initial private dir perms drwxrwxrwx.+.{private_type}',
             run.out)
         assert re.search(
-            f'pre-merge private dir perms drwxrwxrwx.+.{private_type}',
+            f'pre-checkout private dir perms drwxrwxrwx.+.{private_type}',
             run.out)
         assert re.search(
-            f'post-merge private dir perms drwxrwxrwx.+.{private_type}',
+            f'post-checkout private dir perms drwxrwxrwx.+.{private_type}',
             run.out)
     else:
         # private directories which are created, should be done prior to
-        # merging, and with secure permissions.
+        # checkout, and with secure permissions.
         assert 'initial private dir perms' not in run.out
         assert re.search(
-            f'pre-merge private dir perms drwx------.+.{private_type}',
+            f'pre-checkout private dir perms drwx------.+.{private_type}',
             run.out)
         assert re.search(
-            f'post-merge private dir perms drwx------.+.{private_type}',
+            f'post-checkout private dir perms drwx------.+.{private_type}',
             run.out)
 
     # standard perms still apply afterwards unless disabled with auto.perms
@@ -297,8 +289,8 @@ def test_alternate_branch(runner, paths, yadm_cmd, repo_config, branch):
 
     if branch == 'invalid':
         assert run.failure
-        assert 'ERROR: Clone failed' in run.out
-        assert f"'origin/{branch}' does not exist in {remote_url}" in run.out
+        assert 'ERROR: Unable to clone the repository' in run.out
+        assert f"Remote branch {branch} not found in upstream" in run.err
     else:
         assert successful_clone(run, paths, repo_config)
 
@@ -321,7 +313,6 @@ def test_alternate_branch(runner, paths, yadm_cmd, repo_config, branch):
 def successful_clone(run, paths, repo_config, expected_code=0):
     """Assert clone is successful"""
     assert run.code == expected_code
-    assert 'Initialized' in run.out
     assert oct(paths.repo.stat().mode).endswith('00'), 'Repo is not secured'
     assert repo_config('core.bare') == 'false'
     assert repo_config('status.showUntrackedFiles') == 'no'

yadm

@@ -705,134 +705,111 @@ function clean() {
 
 }
 
-function _default_remote_branch() {
-  local ls_remote
-  ls_remote=$("$GIT_PROGRAM" ls-remote -q --symref "$1" 2>/dev/null)
-  match="^ref:[[:blank:]]+refs/heads/([^[:blank:]]+)"
-  if [[ "$ls_remote" =~ $match ]] ; then
-    echo "${BASH_REMATCH[1]}"
-  else
-    echo master
-  fi
-}
-
 function clone() {
 
   DO_BOOTSTRAP=1
-  local branch=
-
-  local repo_url=
+  local -a args
+  local -i do_checkout=1
   while [[ $# -gt 0 ]] ; do
-    key="$1"
-    case $key in
-      -b)
-        if ! is_valid_branch_name "$2"; then
-          error_out "You must provide a branch name when using '-b'"
-        fi
-        branch="$2"
-        shift
-      ;;
+    case "$1" in
       --bootstrap) # force bootstrap, without prompt
         DO_BOOTSTRAP=2
       ;;
       --no-bootstrap) # prevent bootstrap, without prompt
         DO_BOOTSTRAP=3
       ;;
-      *) # use first found argument as the URL
-        [ -z "$repo_url" ] && repo_url="$1"
+      --checkout)
+        do_checkout=1
+      ;;
+      -n|--no-checkout)
+        do_checkout=0
+      ;;
+      --bare|--separate-git-dir=*)
+        # ignore arguments without separate parameter
+      ;;
+      --separate-git-dir)
+        # ignore arguments with separate parameter
+        shift
+      ;;
+      *)
+        args+=("$1")
       ;;
     esac
     shift
   done
 
-  [ -z "$repo_url" ] && error_out "No repository provided"
+  [ ${#args[@]} -eq 0 ] && error_out "No repository provided"
 
-  [ -z "$branch" ] && branch=$(_default_remote_branch "$repo_url")
+  # The last argument should be the source repository. Inject -- to make sure it is.
+  if [[ ${#args[@]} -eq 1 || "${args[-2]}" != "--" ]]; then
+      args+=("${args[-1]}")
+      args[-2]="--"
+  fi
 
   [ -n "$DEBUG" ] && display_private_perms "initial"
 
-  # shellcheck disable=SC2119
-  # clone will begin with a bare repo
-  init
-
-  # configure local HEAD with the correct branch
-  printf 'ref: refs/heads/%s\n' "$branch" > "${YADM_REPO}/HEAD"
-
-  # add the specified remote, and configure the repo to track origin/$branch
-  debug "Adding remote to new repo"
-  "$GIT_PROGRAM" remote add origin "$repo_url"
-  debug "Configuring new repo to track origin/${branch}"
-  "$GIT_PROGRAM" config "branch.${branch}.remote" origin
-  "$GIT_PROGRAM" config "branch.${branch}.merge" "refs/heads/${branch}"
+  # safety check, don't attempt to clone when the repo is already present
+  [ -d "$YADM_REPO" ] && [ -z "$FORCE" ] &&
+    error_out "Git repo already exists. [$YADM_REPO]\nUse '-f' if you want to force it to be overwritten."
 
-  # fetch / merge (and possibly fallback to reset)
-  debug "Doing an initial fetch of the origin"
-  "$GIT_PROGRAM" fetch origin || {
-    debug "Removing repo after failed clone"
+  # remove existing if forcing the clone to happen anyway
+  [ -d "$YADM_REPO" ] && {
+    debug "Removing existing repo prior to clone"
     rm -rf "$YADM_REPO"
-    error_out "Unable to fetch origin $repo_url"
   }
-  debug "Verifying '${branch}' is a valid branch to merge"
-  [ -f "${YADM_REPO}/refs/remotes/origin/${branch}" ] || {
-    debug "Removing repo after failed clone"
-    rm -rf "$YADM_REPO"
-    error_out "Clone failed, 'origin/${branch}' does not exist in $repo_url"
+
+  local wc
+  wc="$(mktemp -d)" || error_out "Unable to create temporary directory"
+
+  # first clone without checkout
+  debug "Doing an initial clone of the repository"
+  (cd "$wc" &&
+       "$GIT_PROGRAM" -c core.sharedrepository=0600 clone --no-checkout \
+                      --separate-git-dir="$YADM_REPO" "${args[@]}" repo.git) || {
+      debug "Removing repo after failed clone"
+      rm -rf "$YADM_REPO" "$wc"
+      error_out "Unable to clone the repository"
   }
+  rm -rf "$wc"
+  configure_repo
+
+  # then reset the index as the --no-checkout flag makes the index empty
+  "$GIT_PROGRAM" reset --quiet .
 
   if [ "$YADM_WORK" = "$HOME" ]; then
     debug "Determining if repo tracks private directories"
     for private_dir in $(private_dirs all); do
-      found_log=$("$GIT_PROGRAM" log -n 1 "origin/${branch}" -- "$private_dir" 2>/dev/null)
+      found_log=$("$GIT_PROGRAM" log -n 1 -- "$private_dir" 2>/dev/null)
       if [ -n "$found_log" ]; then
         debug "Private directory $private_dir is tracked by repo"
         assert_private_dirs "$private_dir"
       fi
     done
   fi
 
-  [ -n "$DEBUG" ] && display_private_perms "pre-merge"
-  debug "Doing an initial merge of origin/${branch}"
-  "$GIT_PROGRAM" merge "origin/${branch}" || {
-    debug "Merge failed, doing a reset and stashing conflicts."
-    "$GIT_PROGRAM" reset "origin/${branch}"
-    if cd "$YADM_WORK"; then # necessary because of a bug in Git
-      "$GIT_PROGRAM" -c user.name='yadm clone' -c user.email='yadm' stash save Conflicts preserved from yadm clone command 2>&1
-      cat <<EOF
-**NOTE**
-  Merging origin/${branch} failed.
-
-  As a result, yadm did 'reset origin/${branch}', and then
-  stashed the conflicting data.
+  # finally check out (unless instructed not to) all files that don't exist in $YADM_WORK
+  if [[ $do_checkout -ne 0 ]]; then
+      [ -n "$DEBUG" ] && display_private_perms "pre-checkout"
 
-  This likely happened because you had files in \$HOME
-  which conflicted with files tracked by origin/${branch}.
+      "$GIT_PROGRAM" ls-files --deleted | while IFS= read -r file; do
+          "$GIT_PROGRAM" checkout -- ":/$file"
+      done
 
-  You can review the stashed conflicts with the
-  command 'yadm stash show -p' from within your
-  \$HOME directory. If you want to restore the
-  stashed data, you can run 'yadm stash apply' or
-  'yadm stash pop' and then handle the conflicts
-  in another way.
-EOF
-    else
-      # skip auto_bootstrap if conflicts could not be stashed
-      DO_BOOTSTRAP=0
-      cat <<EOF
+      if [ -n "$("$GIT_PROGRAM" ls-files --modified)" ]; then
+          cat <<EOF
 **NOTE**
-  Merging origin/${branch} failed.
-  yadm did 'reset origin/${branch}' instead.
-
-  yadm did not stash these conflicts beacuse it was unable
-  to change to the $YADM_WORK directory.
+  Local files with content that differs from the ones just
+  cloned were found in $YADM_WORK. They have been left
+  unmodified.
 
-  Please review and resolve any differences appropriately
+  Please review and resolve any differences appropriately.
   If you know what you're doing, and want to overwrite the
-  tracked files, consider 'yadm reset --hard origin/${branch}'
+  tracked files, consider 'yadm checkout "$YADM_WORK"'.
 EOF
-    fi
-  }
+      fi
 
-  [ -n "$DEBUG" ] && display_private_perms "post-merge"
+      [ -n "$DEBUG" ] && display_private_perms "post-checkout"
+  fi
 
   CHANGES_POSSIBLE=1
 
@@ -1441,18 +1418,6 @@ function exclude_encrypted() {
 
 }
 
-function is_valid_branch_name() {
-  # Git branches do not allow:
-  #  * path component that begins with "."
-  #  * double dot
-  #  * "~", "^", ":", "\", space
-  #  * end with a "/"
-  #  * end with ".lock"
-  pattern='(\/\.|\.\.|[~^:\\ ]|\/$|\.lock$)'
-  [[ "$1" =~ $pattern ]] && return 1
-  return 0
-}
-
 function query_distro() {
   distro=""
   if command -v "$LSB_RELEASE_PROGRAM" &> /dev/null; then