2017-06-07 17:47:58 +00:00
|
|
|
package commands
|
|
|
|
|
|
|
|
import (
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
"bufio"
|
2017-11-16 23:44:20 +00:00
|
|
|
"fmt"
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
"io"
|
2017-06-09 23:38:59 +00:00
|
|
|
"strings"
|
2017-06-09 23:37:15 +00:00
|
|
|
|
2021-09-01 19:41:10 +00:00
|
|
|
"github.com/git-lfs/git-lfs/v3/errors"
|
commands,t: gitattributes migrate filepath parsing
The --include and --exclude (-I and -X) options to the
"git lfs migrate" command allow the user to specify filepath
filters which select matching files to migrate and which are
also used to populate any .gitattributes files written by the
import or export operations.
This latter functionality implies that we need to parse
any filepath patterns supplied by these options using
gitattributes(5) rules, since the patterns will be copied
directly into .gitattributes files. (See the use of the
trackedFromFilter() and trackedFromExportFilter() functions
in particular.)
However, all other Git LFS commands which parse --include
and --exclude options, such as "git lfs fetch" and
"git lfs ls-files", expect to treat any supplied patterns
according to gitignore(5) rules. (This aligns with, for
instance, how the -x option to "git ls-files" works.)
We therefore introduce a buildFilepathFilterWithPatternType()
function which the "git lfs migrate" command can use to
specify the filepathfilter.GitAttributes parsing mode for
its filter, while the other commands continue to use the
filepathfilter.GitIgnore mode.
Note that this change change will have several consequences.
On one hand, patterns such as "*.bin" will only match against
files, not directories, which will restore the behaviour of
"git lfs migrate" in this regard prior to v3.0.0 and the
changes from PR #4556.
On the other hand, patterns such as "foo" will no longer
recursively match everything inside a directory, and "foo/**"
must be used instead. This is in line with how Git's native
gitattributes(5) matching works.
We therefore adjust one existing test to use a directory
match of the form "foo/**" instead of "foo", and add one new
test which confirms that only files named "*.txt" match a
pattern of that form, instead of all files in any directory
whose name has that form, such as a file like "foo.txt/bar.md".
This new test fails without the changes to the "git lfs migrate"
command introduced in this commit.
2021-12-03 00:09:35 +00:00
|
|
|
"github.com/git-lfs/git-lfs/v3/filepathfilter"
|
2021-09-01 19:41:10 +00:00
|
|
|
"github.com/git-lfs/git-lfs/v3/git"
|
|
|
|
"github.com/git-lfs/git-lfs/v3/git/githistory"
|
|
|
|
"github.com/git-lfs/git-lfs/v3/tasklog"
|
2021-12-13 18:53:50 +00:00
|
|
|
"github.com/git-lfs/git-lfs/v3/tr"
|
2020-06-30 16:21:08 +00:00
|
|
|
"github.com/git-lfs/gitobj/v2"
|
2017-06-07 17:47:58 +00:00
|
|
|
"github.com/spf13/cobra"
|
|
|
|
)
|
|
|
|
|
2017-06-09 23:35:11 +00:00
|
|
|
var (
|
|
|
|
// migrateIncludeRefs is a set of Git references to explicitly include
|
|
|
|
// in the migration.
|
|
|
|
migrateIncludeRefs []string
|
|
|
|
// migrateExcludeRefs is a set of Git references to explicitly exclude
|
|
|
|
// in the migration.
|
|
|
|
migrateExcludeRefs []string
|
2017-09-07 17:47:17 +00:00
|
|
|
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
// migrateYes indicates that an answer of 'yes' should be presumed
|
|
|
|
// whenever 'git lfs migrate' asks for user input.
|
|
|
|
migrateYes bool
|
|
|
|
|
2017-11-20 17:48:50 +00:00
|
|
|
// migrateSkipFetch assumes that the client has the latest copy of
|
|
|
|
// remote references, and thus should not contact the remote for a set
|
|
|
|
// of updated references.
|
|
|
|
migrateSkipFetch bool
|
2017-11-17 16:45:30 +00:00
|
|
|
|
2020-10-09 00:50:34 +00:00
|
|
|
// migrateImportAboveFmt indicates the presence of the --above=<size>
|
|
|
|
// flag and instructs 'git lfs migrate import' to import all files
|
|
|
|
// above the provided size.
|
|
|
|
migrateImportAboveFmt string
|
|
|
|
|
2017-09-07 17:47:17 +00:00
|
|
|
// migrateEverything indicates the presence of the --everything flag,
|
|
|
|
// and instructs 'git lfs migrate' to migrate all local references.
|
|
|
|
migrateEverything bool
|
2017-09-22 18:43:04 +00:00
|
|
|
|
|
|
|
// migrateVerbose enables verbose logging
|
|
|
|
migrateVerbose bool
|
2018-03-19 13:41:35 +00:00
|
|
|
|
|
|
|
// objectMapFile is the path to the map of old sha1 to new sha1
|
|
|
|
// commits
|
|
|
|
objectMapFilePath string
|
2018-05-22 18:12:40 +00:00
|
|
|
|
|
|
|
// migrateNoRewrite is the flag indicating whether or not the
|
|
|
|
// command should rewrite git history
|
|
|
|
migrateNoRewrite bool
|
2018-05-23 16:36:36 +00:00
|
|
|
// migrateCommitMessage is the message to use with the commit generated
|
|
|
|
// by the migrate command
|
|
|
|
migrateCommitMessage string
|
2018-06-27 18:03:23 +00:00
|
|
|
|
|
|
|
// exportRemote is the remote from which to download objects when
|
|
|
|
// performing an export
|
|
|
|
exportRemote string
|
commands/command_migrate.go: introduce '--fixup' flag on 'import'
A common invocation of the 'git lfs migrate import' command is with
'--include' and/or '--exclude' flag(s), which specify wildmatch
pattern(s) for which paths to migrate and/or not migrate.
This is useful for retroactively importing a set of files into Git LFS's
care, or fixing up a file that should have been tracked by Git LFS but
was accidentally committed as a large object instead.
In the later case, it is often the reality that a user will run 'git lfs
migrate --import' with an '--include' path that they believe will gather
the file (and the file alone). This approach is brittle because it
requires the user to infer not only the applicable pattern but the
meaning of that pattern. It also requires the user to run more than one
migration when fixing multiple types of files.
The .gitattributes file(s) contained within a repository provide an
authoritative source on what file(s) are considered by Git to be tracked
in Git LFS. We can use this information to infer the correct patterns to
``fix up'' a broken repository.
In the simplest case, if a repository's .gitattributes file contains the
following:
*.txt filter=lfs merge=lfs diff=lfs -text
But a .txt file matched by that pattern is not parse-able as an LFS
pointer, it will appear as unable to checkout.
Running 'git lfs migrate import --fixup --everything' will correctly
traverse history and find the affected .txt file, read it, create an
object file for it, and store it as an LFS pointer in history.
Thus, a user can run one command which will recognize arbitrarily
complex problems where a file should be tracked by Git LFS, but isn't.
Later, this feature could be combined with the new 'git lfs migrate
export' functionality to also clean files _out_ of Git LFS to object
files when they are not supposed to be tracked as Git LFS objects.
2018-07-06 19:20:02 +00:00
|
|
|
|
|
|
|
// migrateFixup is the flag indicating whether or not to infer the
|
|
|
|
// included and excluded filepath patterns.
|
|
|
|
migrateFixup bool
|
2017-06-09 23:35:11 +00:00
|
|
|
)
|
2017-06-07 17:47:58 +00:00
|
|
|
|
2018-07-05 16:49:10 +00:00
|
|
|
// migrate takes the given command and arguments, *gitobj.ObjectDatabase, as well
|
2017-06-15 19:52:55 +00:00
|
|
|
// as a BlobRewriteFn to apply, and performs a migration.
|
2017-11-22 22:07:24 +00:00
|
|
|
func migrate(args []string, r *githistory.Rewriter, l *tasklog.Logger, opts *githistory.RewriteOptions) {
|
commands: make sure we're in the working tree
In the normal case, Git commands perform repository autodiscovery based
on the current working directory. However, in some cases, it's possible
to specify a Git working tree unrelated to the current working directory
by using GIT_WORK_TREE. In such a case, we want to make sure that we
change into the working tree such that our working directory is always
within the working tree, if one exists. This is what Git does, and it
means that when we write files into the repository, such as a
.gitattributes file, we write them into the proper place.
Note also that we adjust the code to require that the working directory
be non-empty when we require a working copy instead of that the
repository be non-bare. That's because we don't want people to be
working inside of the Git directory in such situations, where the
repository would be non-bare but would not have a working tree.
We add tests for this case for track and untrack, which require a
working tree, and for checkout, which requires only a repository. This
means that we can verify the behavior of the functions we've added
without needing to add tests for this case to each of the subcommands.
2020-10-02 19:03:55 +00:00
|
|
|
setupRepository()
|
2017-06-09 23:41:41 +00:00
|
|
|
|
2017-08-29 21:06:35 +00:00
|
|
|
opts, err := rewriteOptions(args, opts, l)
|
2017-06-09 23:41:41 +00:00
|
|
|
if err != nil {
|
|
|
|
ExitWithError(err)
|
|
|
|
}
|
|
|
|
|
2017-06-21 16:42:36 +00:00
|
|
|
_, err = r.Rewrite(opts)
|
2017-06-09 23:41:41 +00:00
|
|
|
if err != nil {
|
|
|
|
ExitWithError(err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:37:15 +00:00
|
|
|
// getObjectDatabase creates a *git.ObjectDatabase from the filesystem pointed
|
|
|
|
// at the .git directory of the currently checked-out repository.
|
2018-07-05 16:49:10 +00:00
|
|
|
func getObjectDatabase() (*gitobj.ObjectDatabase, error) {
|
2018-09-05 15:50:46 +00:00
|
|
|
dir, err := git.GitCommonDir()
|
2017-06-09 23:37:15 +00:00
|
|
|
if err != nil {
|
2022-01-28 05:49:32 +00:00
|
|
|
return nil, errors.Wrap(err, tr.Tr.Get("cannot open root"))
|
2017-06-09 23:37:15 +00:00
|
|
|
}
|
2020-06-29 21:56:37 +00:00
|
|
|
|
|
|
|
return git.ObjectDatabase(cfg.OSEnv(), cfg.GitEnv(), dir, cfg.TempDir())
|
2017-06-09 23:37:15 +00:00
|
|
|
}
|
|
|
|
|
2017-06-09 23:40:42 +00:00
|
|
|
// rewriteOptions returns *githistory.RewriteOptions able to be passed to a
|
|
|
|
// *githistory.Rewriter that reflect the current arguments and flags passed to
|
2017-06-21 16:54:55 +00:00
|
|
|
// an invocation of git-lfs-migrate(1).
|
2017-06-09 23:40:42 +00:00
|
|
|
//
|
2017-06-21 16:54:55 +00:00
|
|
|
// It is merged with the given "opts". In other words, an identical "opts" is
|
|
|
|
// returned, where the Include and Exclude fields have been filled based on the
|
|
|
|
// following rules:
|
2017-06-09 23:40:42 +00:00
|
|
|
//
|
|
|
|
// The included and excluded references are determined based on the output of
|
|
|
|
// includeExcludeRefs (see below for documentation and detail).
|
|
|
|
//
|
|
|
|
// If any of the above could not be determined without error, that error will be
|
|
|
|
// returned immediately.
|
2017-11-22 22:07:24 +00:00
|
|
|
func rewriteOptions(args []string, opts *githistory.RewriteOptions, l *tasklog.Logger) (*githistory.RewriteOptions, error) {
|
2017-08-29 21:06:35 +00:00
|
|
|
include, exclude, err := includeExcludeRefs(l, args)
|
2017-06-09 23:40:42 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return &githistory.RewriteOptions{
|
|
|
|
Include: include,
|
|
|
|
Exclude: exclude,
|
|
|
|
|
2018-03-19 13:41:35 +00:00
|
|
|
UpdateRefs: opts.UpdateRefs,
|
|
|
|
Verbose: opts.Verbose,
|
|
|
|
ObjectMapFilePath: opts.ObjectMapFilePath,
|
2017-06-22 00:26:24 +00:00
|
|
|
|
2018-07-06 19:14:31 +00:00
|
|
|
BlobFn: opts.BlobFn,
|
|
|
|
TreePreCallbackFn: opts.TreePreCallbackFn,
|
|
|
|
TreeCallbackFn: opts.TreeCallbackFn,
|
2017-06-09 23:40:42 +00:00
|
|
|
}, nil
|
|
|
|
}
|
|
|
|
|
2022-06-11 19:33:12 +00:00
|
|
|
// isSpecialGitRef checks if a ref spec is a special git ref to exclude from
|
|
|
|
// --everything
|
|
|
|
func isSpecialGitRef(refspec string) bool {
|
2022-06-15 03:36:19 +00:00
|
|
|
// Special refspecs.
|
|
|
|
switch refspec {
|
|
|
|
case "refs/stash":
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Special refspecs from namespaces.
|
2022-06-11 19:33:12 +00:00
|
|
|
parts := strings.SplitN(refspec, "/", 3)
|
|
|
|
if len(parts) < 3 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
prefix := strings.Join(parts[:2], "/")
|
|
|
|
switch prefix {
|
|
|
|
case "refs/notes", "refs/bisect", "refs/replace":
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:40:08 +00:00
|
|
|
// includeExcludeRefs returns fully-qualified sets of references to include, and
|
|
|
|
// exclude, or an error if those could not be determined.
|
|
|
|
//
|
|
|
|
// They are determined based on the following rules:
|
|
|
|
//
|
|
|
|
// - Include all local refs/heads/<branch> references for each branch
|
|
|
|
// specified as an argument.
|
|
|
|
// - Include the currently checked out branch if no branches are given as
|
|
|
|
// arguments and the --include-ref= or --exclude-ref= flag(s) aren't given.
|
|
|
|
// - Include all references given in --include-ref=<ref>.
|
|
|
|
// - Exclude all references given in --exclude-ref=<ref>.
|
2017-11-22 22:07:24 +00:00
|
|
|
func includeExcludeRefs(l *tasklog.Logger, args []string) (include, exclude []string, err error) {
|
2017-06-09 23:40:08 +00:00
|
|
|
hardcore := len(migrateIncludeRefs) > 0 || len(migrateExcludeRefs) > 0
|
|
|
|
|
2017-09-07 17:47:17 +00:00
|
|
|
if len(args) == 0 && !hardcore && !migrateEverything {
|
2017-06-09 23:40:08 +00:00
|
|
|
// If no branches were given explicitly AND neither
|
|
|
|
// --include-ref or --exclude-ref flags were given, then add the
|
|
|
|
// currently checked out reference.
|
|
|
|
current, err := currentRefToMigrate()
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
args = append(args, current.Name)
|
|
|
|
}
|
|
|
|
|
2017-09-07 17:47:17 +00:00
|
|
|
if migrateEverything && len(args) > 0 {
|
2021-12-13 18:53:50 +00:00
|
|
|
return nil, nil, errors.New(tr.Tr.Get("Cannot use --everything with explicit reference arguments"))
|
2017-09-07 17:47:17 +00:00
|
|
|
}
|
|
|
|
|
2017-06-09 23:40:08 +00:00
|
|
|
for _, name := range args {
|
2017-12-13 19:13:11 +00:00
|
|
|
var excluded bool
|
|
|
|
if strings.HasPrefix("^", name) {
|
|
|
|
name = name[1:]
|
|
|
|
excluded = true
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:40:08 +00:00
|
|
|
// Then, loop through each branch given, resolve that reference,
|
|
|
|
// and include it.
|
|
|
|
ref, err := git.ResolveRef(name)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
2017-12-13 19:13:11 +00:00
|
|
|
if excluded {
|
|
|
|
exclude = append(exclude, ref.Refspec())
|
|
|
|
} else {
|
|
|
|
include = append(include, ref.Refspec())
|
|
|
|
}
|
2017-06-09 23:40:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if hardcore {
|
2017-09-07 17:47:17 +00:00
|
|
|
if migrateEverything {
|
2021-12-13 18:53:50 +00:00
|
|
|
return nil, nil, errors.New(tr.Tr.Get("Cannot use --everything with --include-ref or --exclude-ref"))
|
2017-09-07 17:47:17 +00:00
|
|
|
}
|
|
|
|
|
2017-06-09 23:40:08 +00:00
|
|
|
// If either --include-ref=<ref> or --exclude-ref=<ref> were
|
|
|
|
// given, append those to the include and excluded reference
|
|
|
|
// set, respectively.
|
|
|
|
include = append(include, migrateIncludeRefs...)
|
|
|
|
exclude = append(exclude, migrateExcludeRefs...)
|
2017-09-07 17:47:17 +00:00
|
|
|
} else if migrateEverything {
|
2018-07-09 19:43:26 +00:00
|
|
|
refs, err := git.AllRefsIn("")
|
2017-09-07 17:47:17 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
2018-07-09 19:43:26 +00:00
|
|
|
for _, ref := range refs {
|
|
|
|
switch ref.Type {
|
|
|
|
case git.RefTypeLocalBranch, git.RefTypeLocalTag,
|
2018-09-25 21:15:04 +00:00
|
|
|
git.RefTypeRemoteBranch:
|
2018-07-09 19:43:26 +00:00
|
|
|
|
|
|
|
include = append(include, ref.Refspec())
|
|
|
|
case git.RefTypeOther:
|
2022-06-11 19:33:12 +00:00
|
|
|
if isSpecialGitRef(ref.Refspec()) {
|
2018-07-09 19:43:26 +00:00
|
|
|
continue
|
|
|
|
}
|
2022-06-11 19:33:12 +00:00
|
|
|
include = append(include, ref.Refspec())
|
2018-07-09 19:43:26 +00:00
|
|
|
}
|
2017-09-07 17:47:17 +00:00
|
|
|
}
|
2017-06-09 23:40:08 +00:00
|
|
|
} else {
|
2017-12-05 02:53:08 +00:00
|
|
|
bare, err := git.IsBare()
|
2017-06-09 23:40:08 +00:00
|
|
|
if err != nil {
|
2021-12-13 18:53:50 +00:00
|
|
|
return nil, nil, errors.Wrap(err, tr.Tr.Get("Unable to determine bareness"))
|
2017-06-09 23:40:08 +00:00
|
|
|
}
|
|
|
|
|
2017-12-05 02:53:08 +00:00
|
|
|
if !bare {
|
|
|
|
// Otherwise, if neither --include-ref=<ref> or
|
|
|
|
// --exclude-ref=<ref> were given, include no additional
|
|
|
|
// references, and exclude all remote references that
|
|
|
|
// are remote branches or remote tags.
|
|
|
|
remoteRefs, err := getRemoteRefs(l)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, err
|
|
|
|
}
|
|
|
|
|
2018-09-25 21:36:14 +00:00
|
|
|
for remote, refs := range remoteRefs {
|
2018-09-25 21:15:04 +00:00
|
|
|
for _, ref := range refs {
|
2018-09-25 21:36:14 +00:00
|
|
|
exclude = append(exclude,
|
|
|
|
formatRefName(ref, remote))
|
commands/command_migrate.go: return all references by remote
We have used the getRemoteRefs since [1] to return a slice of all remote
references, without distinguishing which remote they came from.
The reason for doing so was that we had had modified each reference's
"name" (i.e., the last element of splitting the full reference name by
'/').
This was OK to do, since we modified the reference's name (i.e., the
last component of the fully qualified reference name as read from Git
when splitting on the '/' character) to include the remote name. This
allowed us to call '(*git.Ref).Refspec()', which would theoretically
format us a correctly printed reference name, for all kinds of
references.
This is broken in practice, so to prepare for a future commit that will
fix it, let's return a map of remote name to all references present on
that remote, such that we can format each based on its remote and full
name individually.
[1]: ce89eb35 (commands/command_migrate: teach how to find all remote
refs, 2017-06-09)
2018-09-25 03:47:35 +00:00
|
|
|
}
|
2017-12-05 02:53:08 +00:00
|
|
|
}
|
2017-11-16 23:44:20 +00:00
|
|
|
}
|
2017-06-09 23:40:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return include, exclude, nil
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:39:34 +00:00
|
|
|
// getRemoteRefs returns a fully qualified set of references belonging to all
|
|
|
|
// remotes known by the currently checked-out repository, or an error if those
|
|
|
|
// references could not be determined.
|
commands/command_migrate.go: return all references by remote
We have used the getRemoteRefs since [1] to return a slice of all remote
references, without distinguishing which remote they came from.
The reason for doing so was that we had had modified each reference's
"name" (i.e., the last element of splitting the full reference name by
'/').
This was OK to do, since we modified the reference's name (i.e., the
last component of the fully qualified reference name as read from Git
when splitting on the '/' character) to include the remote name. This
allowed us to call '(*git.Ref).Refspec()', which would theoretically
format us a correctly printed reference name, for all kinds of
references.
This is broken in practice, so to prepare for a future commit that will
fix it, let's return a map of remote name to all references present on
that remote, such that we can format each based on its remote and full
name individually.
[1]: ce89eb35 (commands/command_migrate: teach how to find all remote
refs, 2017-06-09)
2018-09-25 03:47:35 +00:00
|
|
|
func getRemoteRefs(l *tasklog.Logger) (map[string][]*git.Ref, error) {
|
|
|
|
refs := make(map[string][]*git.Ref)
|
2017-06-09 23:39:34 +00:00
|
|
|
|
|
|
|
remotes, err := git.RemoteList()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2017-11-20 17:48:50 +00:00
|
|
|
if !migrateSkipFetch {
|
2021-12-13 18:53:50 +00:00
|
|
|
w := l.Waiter(fmt.Sprintf("migrate: %s", tr.Tr.Get("Fetching remote refs")))
|
2017-11-17 16:45:30 +00:00
|
|
|
if err := git.Fetch(remotes...); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
w.Complete()
|
2017-08-29 21:06:20 +00:00
|
|
|
}
|
|
|
|
|
2017-06-09 23:39:34 +00:00
|
|
|
for _, remote := range remotes {
|
2017-11-17 16:45:30 +00:00
|
|
|
var refsForRemote []*git.Ref
|
2017-11-20 17:48:50 +00:00
|
|
|
if migrateSkipFetch {
|
2017-11-17 16:45:30 +00:00
|
|
|
refsForRemote, err = git.CachedRemoteRefs(remote)
|
|
|
|
} else {
|
|
|
|
refsForRemote, err = git.RemoteRefs(remote)
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:39:34 +00:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
commands/command_migrate.go: return all references by remote
We have used the getRemoteRefs since [1] to return a slice of all remote
references, without distinguishing which remote they came from.
The reason for doing so was that we had had modified each reference's
"name" (i.e., the last element of splitting the full reference name by
'/').
This was OK to do, since we modified the reference's name (i.e., the
last component of the fully qualified reference name as read from Git
when splitting on the '/' character) to include the remote name. This
allowed us to call '(*git.Ref).Refspec()', which would theoretically
format us a correctly printed reference name, for all kinds of
references.
This is broken in practice, so to prepare for a future commit that will
fix it, let's return a map of remote name to all references present on
that remote, such that we can format each based on its remote and full
name individually.
[1]: ce89eb35 (commands/command_migrate: teach how to find all remote
refs, 2017-06-09)
2018-09-25 03:47:35 +00:00
|
|
|
refs[remote] = refsForRemote
|
2017-06-09 23:39:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return refs, nil
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:38:59 +00:00
|
|
|
// formatRefName returns the fully-qualified name for the given Git reference
|
|
|
|
// "ref".
|
|
|
|
func formatRefName(ref *git.Ref, remote string) string {
|
2018-09-25 21:31:36 +00:00
|
|
|
if ref.Type == git.RefTypeRemoteBranch {
|
|
|
|
return strings.Join([]string{
|
|
|
|
"refs", "remotes", remote, ref.Name}, "/")
|
2017-06-09 23:38:59 +00:00
|
|
|
}
|
2018-09-25 21:31:36 +00:00
|
|
|
return ref.Refspec()
|
2017-06-09 23:38:59 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:38:16 +00:00
|
|
|
// currentRefToMigrate returns the fully-qualified name of the currently
|
|
|
|
// checked-out reference, or an error if the reference's type was not a local
|
|
|
|
// branch.
|
|
|
|
func currentRefToMigrate() (*git.Ref, error) {
|
|
|
|
current, err := git.CurrentRef()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if current.Type == git.RefTypeOther ||
|
2018-09-25 21:15:04 +00:00
|
|
|
current.Type == git.RefTypeRemoteBranch {
|
2017-06-09 23:38:16 +00:00
|
|
|
|
2021-12-13 18:53:50 +00:00
|
|
|
return nil, errors.Errorf(tr.Tr.Get("Cannot migrate non-local ref: %s", current.Name))
|
2017-06-09 23:38:16 +00:00
|
|
|
}
|
|
|
|
return current, nil
|
|
|
|
}
|
|
|
|
|
2017-06-09 23:41:15 +00:00
|
|
|
// getHistoryRewriter returns a history rewriter that includes the filepath
|
2018-07-09 17:20:43 +00:00
|
|
|
// filter given by the --include and --exclude arguments.
|
2018-07-05 16:49:10 +00:00
|
|
|
func getHistoryRewriter(cmd *cobra.Command, db *gitobj.ObjectDatabase, l *tasklog.Logger) *githistory.Rewriter {
|
2017-06-09 23:41:15 +00:00
|
|
|
include, exclude := getIncludeExcludeArgs(cmd)
|
commands,t: gitattributes migrate filepath parsing
The --include and --exclude (-I and -X) options to the
"git lfs migrate" command allow the user to specify filepath
filters which select matching files to migrate and which are
also used to populate any .gitattributes files written by the
import or export operations.
This latter functionality implies that we need to parse
any filepath patterns supplied by these options using
gitattributes(5) rules, since the patterns will be copied
directly into .gitattributes files. (See the use of the
trackedFromFilter() and trackedFromExportFilter() functions
in particular.)
However, all other Git LFS commands which parse --include
and --exclude options, such as "git lfs fetch" and
"git lfs ls-files", expect to treat any supplied patterns
according to gitignore(5) rules. (This aligns with, for
instance, how the -x option to "git ls-files" works.)
We therefore introduce a buildFilepathFilterWithPatternType()
function which the "git lfs migrate" command can use to
specify the filepathfilter.GitAttributes parsing mode for
its filter, while the other commands continue to use the
filepathfilter.GitIgnore mode.
Note that this change change will have several consequences.
On one hand, patterns such as "*.bin" will only match against
files, not directories, which will restore the behaviour of
"git lfs migrate" in this regard prior to v3.0.0 and the
changes from PR #4556.
On the other hand, patterns such as "foo" will no longer
recursively match everything inside a directory, and "foo/**"
must be used instead. This is in line with how Git's native
gitattributes(5) matching works.
We therefore adjust one existing test to use a directory
match of the form "foo/**" instead of "foo", and add one new
test which confirms that only files named "*.txt" match a
pattern of that form, instead of all files in any directory
whose name has that form, such as a file like "foo.txt/bar.md".
This new test fails without the changes to the "git lfs migrate"
command introduced in this commit.
2021-12-03 00:09:35 +00:00
|
|
|
filter := buildFilepathFilterWithPatternType(cfg, include, exclude, false, filepathfilter.GitAttributes)
|
2017-06-09 23:41:15 +00:00
|
|
|
|
2017-06-14 22:10:42 +00:00
|
|
|
return githistory.NewRewriter(db,
|
2017-08-29 21:05:11 +00:00
|
|
|
githistory.WithFilter(filter), githistory.WithLogger(l))
|
2017-06-09 23:41:15 +00:00
|
|
|
}
|
|
|
|
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
func ensureWorkingCopyClean(in io.Reader, out io.Writer) {
|
|
|
|
dirty, err := git.IsWorkingCopyDirty()
|
|
|
|
if err != nil {
|
|
|
|
ExitWithError(errors.Wrap(err,
|
2021-12-13 18:53:50 +00:00
|
|
|
tr.Tr.Get("Could not determine if working copy is dirty")))
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if !dirty {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
var proceed bool
|
|
|
|
if migrateYes {
|
|
|
|
proceed = true
|
|
|
|
} else {
|
|
|
|
answer := bufio.NewReader(in)
|
|
|
|
L:
|
|
|
|
for {
|
2021-12-13 18:53:50 +00:00
|
|
|
fmt.Fprintf(out, "migrate: %s", tr.Tr.Get("override changes in your working copy? All uncommitted changes will be lost! [y/N] "))
|
commands/command_migrate.go: print newline conditionally
Sometimes when invoking 'git lfs migrate import', mysterious output like
the following can be seen:
$ git lfs migrate import
migrate: override changes in your working copy? [Y/n] y
migrate: changes in your working copy will be overridden ...
migrate: Fetching remote refs: ..., done
Where an extra newline is printed between the answer, 'y', and the next
line of output from the migrator.
Instead, let's only print that secondary newline when one isn't given in
the answer. This should never be the case (c.f., ReadString()), but will
harden the code to changes like opening /dev/tty in raw mode and reading
character-by-character.
To do so, ensure that the answer doesn't satisfy:
strings.HasSuffix(answer, '\n')
...and print a newline iff it doesn't.
In a related sense, ignore io.EOF errors.
2018-07-16 18:14:20 +00:00
|
|
|
s, err := answer.ReadString('\n')
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
if err != nil {
|
commands/command_migrate.go: print newline conditionally
Sometimes when invoking 'git lfs migrate import', mysterious output like
the following can be seen:
$ git lfs migrate import
migrate: override changes in your working copy? [Y/n] y
migrate: changes in your working copy will be overridden ...
migrate: Fetching remote refs: ..., done
Where an extra newline is printed between the answer, 'y', and the next
line of output from the migrator.
Instead, let's only print that secondary newline when one isn't given in
the answer. This should never be the case (c.f., ReadString()), but will
harden the code to changes like opening /dev/tty in raw mode and reading
character-by-character.
To do so, ensure that the answer doesn't satisfy:
strings.HasSuffix(answer, '\n')
...and print a newline iff it doesn't.
In a related sense, ignore io.EOF errors.
2018-07-16 18:14:20 +00:00
|
|
|
if err == io.EOF {
|
|
|
|
break L
|
|
|
|
}
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
ExitWithError(errors.Wrap(err,
|
2021-12-13 18:53:50 +00:00
|
|
|
tr.Tr.Get("Could not read answer")))
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
}
|
|
|
|
|
commands/command_migrate.go: print newline conditionally
Sometimes when invoking 'git lfs migrate import', mysterious output like
the following can be seen:
$ git lfs migrate import
migrate: override changes in your working copy? [Y/n] y
migrate: changes in your working copy will be overridden ...
migrate: Fetching remote refs: ..., done
Where an extra newline is printed between the answer, 'y', and the next
line of output from the migrator.
Instead, let's only print that secondary newline when one isn't given in
the answer. This should never be the case (c.f., ReadString()), but will
harden the code to changes like opening /dev/tty in raw mode and reading
character-by-character.
To do so, ensure that the answer doesn't satisfy:
strings.HasSuffix(answer, '\n')
...and print a newline iff it doesn't.
In a related sense, ignore io.EOF errors.
2018-07-16 18:14:20 +00:00
|
|
|
switch strings.TrimSpace(s) {
|
2021-12-13 18:53:50 +00:00
|
|
|
// TRANSLATORS: these are negative (no) responses.
|
|
|
|
case tr.Tr.Get("n"), tr.Tr.Get("N"), "":
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
proceed = false
|
|
|
|
break L
|
2021-12-13 18:53:50 +00:00
|
|
|
// TRANSLATORS: these are positive (yes) responses.
|
|
|
|
case tr.Tr.Get("y"), tr.Tr.Get("Y"):
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
proceed = true
|
|
|
|
break L
|
|
|
|
}
|
commands/command_migrate.go: print newline conditionally
Sometimes when invoking 'git lfs migrate import', mysterious output like
the following can be seen:
$ git lfs migrate import
migrate: override changes in your working copy? [Y/n] y
migrate: changes in your working copy will be overridden ...
migrate: Fetching remote refs: ..., done
Where an extra newline is printed between the answer, 'y', and the next
line of output from the migrator.
Instead, let's only print that secondary newline when one isn't given in
the answer. This should never be the case (c.f., ReadString()), but will
harden the code to changes like opening /dev/tty in raw mode and reading
character-by-character.
To do so, ensure that the answer doesn't satisfy:
strings.HasSuffix(answer, '\n')
...and print a newline iff it doesn't.
In a related sense, ignore io.EOF errors.
2018-07-16 18:14:20 +00:00
|
|
|
|
|
|
|
if !strings.HasSuffix(s, "\n") {
|
|
|
|
fmt.Fprintf(out, "\n")
|
|
|
|
}
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if proceed {
|
2022-01-26 00:34:01 +00:00
|
|
|
fmt.Fprintf(out, "migrate: %s\n", tr.Tr.Get("changes in your working copy will be overridden ..."))
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
} else {
|
2022-01-26 00:34:01 +00:00
|
|
|
Exit("migrate: %s", tr.Tr.Get("working copy must not be dirty"))
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-07 17:47:58 +00:00
|
|
|
func init() {
|
2017-06-12 21:22:49 +00:00
|
|
|
info := NewCommand("info", migrateInfoCommand)
|
|
|
|
info.Flags().IntVar(&migrateInfoTopN, "top", 5, "--top=<n>")
|
2017-07-31 17:47:13 +00:00
|
|
|
info.Flags().StringVar(&migrateInfoAboveFmt, "above", "", "--above=<n>")
|
2017-06-15 21:08:15 +00:00
|
|
|
info.Flags().StringVar(&migrateInfoUnitFmt, "unit", "", "--unit=<unit>")
|
2021-05-02 02:31:32 +00:00
|
|
|
info.Flags().StringVar(&migrateInfoPointers, "pointers", "", "Ignore, dereference, or include LFS pointer files")
|
2021-05-17 05:34:47 +00:00
|
|
|
info.Flags().BoolVar(&migrateFixup, "fixup", false, "Infer filepaths based on .gitattributes")
|
2017-06-12 21:22:49 +00:00
|
|
|
|
2017-06-21 16:43:56 +00:00
|
|
|
importCmd := NewCommand("import", migrateImportCommand)
|
2020-10-09 00:50:34 +00:00
|
|
|
importCmd.Flags().StringVar(&migrateImportAboveFmt, "above", "", "--above=<n>")
|
2017-09-22 18:43:04 +00:00
|
|
|
importCmd.Flags().BoolVar(&migrateVerbose, "verbose", false, "Verbose logging")
|
2018-03-19 13:41:35 +00:00
|
|
|
importCmd.Flags().StringVar(&objectMapFilePath, "object-map", "", "Object map file")
|
2018-05-22 18:12:40 +00:00
|
|
|
importCmd.Flags().BoolVar(&migrateNoRewrite, "no-rewrite", false, "Add new history without rewriting previous")
|
2018-05-23 16:36:36 +00:00
|
|
|
importCmd.Flags().StringVarP(&migrateCommitMessage, "message", "m", "", "With --no-rewrite, an optional commit message")
|
commands/command_migrate.go: introduce '--fixup' flag on 'import'
A common invocation of the 'git lfs migrate import' command is with
'--include' and/or '--exclude' flag(s), which specify wildmatch
pattern(s) for which paths to migrate and/or not migrate.
This is useful for retroactively importing a set of files into Git LFS's
care, or fixing up a file that should have been tracked by Git LFS but
was accidentally committed as a large object instead.
In the later case, it is often the reality that a user will run 'git lfs
migrate --import' with an '--include' path that they believe will gather
the file (and the file alone). This approach is brittle because it
requires the user to infer not only the applicable pattern but the
meaning of that pattern. It also requires the user to run more than one
migration when fixing multiple types of files.
The .gitattributes file(s) contained within a repository provide an
authoritative source on what file(s) are considered by Git to be tracked
in Git LFS. We can use this information to infer the correct patterns to
``fix up'' a broken repository.
In the simplest case, if a repository's .gitattributes file contains the
following:
*.txt filter=lfs merge=lfs diff=lfs -text
But a .txt file matched by that pattern is not parse-able as an LFS
pointer, it will appear as unable to checkout.
Running 'git lfs migrate import --fixup --everything' will correctly
traverse history and find the affected .txt file, read it, create an
object file for it, and store it as an LFS pointer in history.
Thus, a user can run one command which will recognize arbitrarily
complex problems where a file should be tracked by Git LFS, but isn't.
Later, this feature could be combined with the new 'git lfs migrate
export' functionality to also clean files _out_ of Git LFS to object
files when they are not supposed to be tracked as Git LFS objects.
2018-07-06 19:20:02 +00:00
|
|
|
importCmd.Flags().BoolVar(&migrateFixup, "fixup", false, "Infer filepaths based on .gitattributes")
|
2017-06-21 16:43:56 +00:00
|
|
|
|
2018-06-13 21:10:32 +00:00
|
|
|
exportCmd := NewCommand("export", migrateExportCommand)
|
2018-06-25 20:06:43 +00:00
|
|
|
exportCmd.Flags().BoolVar(&migrateVerbose, "verbose", false, "Verbose logging")
|
|
|
|
exportCmd.Flags().StringVar(&objectMapFilePath, "object-map", "", "Object map file")
|
2018-06-27 18:03:23 +00:00
|
|
|
exportCmd.Flags().StringVar(&exportRemote, "remote", "", "Remote from which to download objects")
|
2018-06-13 21:10:32 +00:00
|
|
|
|
2017-06-09 23:35:11 +00:00
|
|
|
RegisterCommand("migrate", nil, func(cmd *cobra.Command) {
|
2017-09-08 17:57:52 +00:00
|
|
|
cmd.PersistentFlags().StringVarP(&includeArg, "include", "I", "", "Include a list of paths")
|
|
|
|
cmd.PersistentFlags().StringVarP(&excludeArg, "exclude", "X", "", "Exclude a list of paths")
|
|
|
|
|
|
|
|
cmd.PersistentFlags().StringSliceVar(&migrateIncludeRefs, "include-ref", nil, "An explicit list of refs to include")
|
|
|
|
cmd.PersistentFlags().StringSliceVar(&migrateExcludeRefs, "exclude-ref", nil, "An explicit list of refs to exclude")
|
|
|
|
cmd.PersistentFlags().BoolVar(&migrateEverything, "everything", false, "Migrate all local references")
|
2017-11-20 17:48:50 +00:00
|
|
|
cmd.PersistentFlags().BoolVar(&migrateSkipFetch, "skip-fetch", false, "Assume up-to-date remote references.")
|
2017-06-09 23:35:11 +00:00
|
|
|
|
commands: warn if working copy is dirty
In 'git lfs migrate import' and 'git lfs migrate export', Git LFS makes
destructive changes to a caller's repository and therefore invokes 'git
checkout --force', which throws away local changes.
To prevent this, let's introduce a check that notifies users when they
are going to throw away local changes, and allows for the user to abort
if they do not wish to discard their local changes.
With this, a user can safely migrate over dirty repositories (i.e., in
the case that they wanted to fix a file that should have been in Git
LFS, but wasn't) without having to finagle their repository to get it
into a migrate-able state.
For users with lots of pending migrations, also teach --yes, which
allows a user to avoid the check, and instead simply prints the warning
message to STDERR.
2018-07-10 15:18:46 +00:00
|
|
|
cmd.PersistentFlags().BoolVarP(&migrateYes, "yes", "y", false, "Don't prompt for answers.")
|
|
|
|
|
2018-06-25 20:06:43 +00:00
|
|
|
cmd.AddCommand(exportCmd, importCmd, info)
|
2017-06-09 23:35:11 +00:00
|
|
|
})
|
2017-06-07 17:47:58 +00:00
|
|
|
}
|