Struct MigrateImportArgs 

pub struct MigrateImportArgs {

    pub args: Vec<String>,
    pub include: Vec<String>,
    pub exclude: Vec<String>,
    pub include_ref: Vec<String>,
    pub exclude_ref: Vec<String>,
    pub everything: bool,
    pub above: String,
    pub no_rewrite: bool,
    pub message: Option<String>,
    pub fixup: bool,
    pub object_map: Option<PathBuf>,
    pub verbose: bool,
    pub remote: Option<String>,
    pub skip_fetch: bool,
    pub yes: bool,
}

Convert Git objects to Git LFS pointers

Migrate objects present in the Git history to pointer files tracked and stored with Git LFS. Adds entries for the converted file types to .gitattributes, creating those files if they don’t exist — as if git lfs track had been run at the points in history where each type first appears.

With --fixup, examine existing .gitattributes files and convert only Git objects that should be tracked by Git LFS according to those rules but aren’t yet.

With --no-rewrite, migrate objects to pointers in a single new commit on top of HEAD without rewriting history. The base migrate options (--include-ref, --everything, etc.) are ignored in this sub-mode, and the positional argument list changes from branches to a list of files. Files must be tracked by patterns already in .gitattributes.

Fields

args: Vec<String>

Branches to rewrite (default: the currently checked-out branch). With --no-rewrite, instead a list of working-tree files to convert. References prefixed with ^ are excluded.

include: Vec<String>

Convert paths matching this glob (repeatable, comma-delimited). Required unless --above is set or --no-rewrite is given.

exclude: Vec<String>

Exclude paths matching this glob (repeatable, comma-delimited).

include_ref: Vec<String>

Restrict the rewrite to commits reachable from these refs. Repeatable.

exclude_ref: Vec<String>

Exclude commits reachable from these refs. Repeatable.

everything: bool

Consider all commits reachable from any local or remote ref.

Only local refs are updated even with --everything; remote refs stay synchronized with their remote.

above: String

Only migrate files whose individual filesize is above the given size (e.g. 1b, 20 MB, 3 TiB).

Cannot be used with --include, --exclude, or --fixup.

no_rewrite: bool

Migrate objects in a new commit on top of HEAD without rewriting Git history.

Switches to a different argument list (positional args become files, not branches) and ignores the core migrate options (--include-ref, --everything, etc.).

message: Option<String>

Commit message for the --no-rewrite commit.

If omitted, a message is generated from the file arguments.

fixup: bool

Infer --include and --exclude filters per-commit from the repository’s .gitattributes files.

Imports filepaths that should be tracked by Git LFS but aren’t yet pointers. Incompatible with explicitly given --include / --exclude filters.

object_map: Option<PathBuf>

Write a CSV of <OLD-SHA>,<NEW-SHA> for every rewritten commit to the named file.

verbose: bool

Print the commit OID and filename of migrated files to standard output.

remote: Option<String>

Remote to consult when fetching missing LFS objects (default origin).

skip_fetch: bool

Don’t refresh the known set of remote references before determining the set of “un-pushed” commits to migrate.

Has no effect when combined with --include-ref or --exclude-ref.

yes: bool

Assume a yes answer to any prompts, permitting noninteractive use.

Currently we don’t prompt for any reason, so this is accepted as a no-op for upstream parity.

Trait Implementations

impl Args for MigrateImportArgs

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl FromArgMatches for MigrateImportArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.