Enum MigrateAction 

pub enum MigrateAction {
    Inventory {
        target: Utf8PathBuf,
        json: bool,
    },
    Archive {
        target: Utf8PathBuf,
        apply: bool,
        rebuild: bool,
        json: bool,
    },
    Mark {
        name: String,
        status: String,
        group: Option<String>,
        tags: Vec<String>,
        destinations: Vec<String>,
        reason: Option<String>,
        target: Utf8PathBuf,
        json: bool,
    },
    Status {
        target: Utf8PathBuf,
        json: bool,
    },
    Close {
        target: Utf8PathBuf,
        apply: bool,
        json: bool,
    },
}

The migration verbs. The archive opens a migration, the marks record the map and the loop, and the close ends it; the workspace under the state root keeps the archive and the registry between runs.

Variants

Inventory

List every predecessor file with its tool and its kind, and the root files that stay in place; read-only.

Fields

target: Utf8PathBuf

The repository to read.

json: bool

Emit one JSON object on stdout instead of the human report.

Archive

Move every predecessor file into a new workspace, snapshot what no Git holds, and open the migration; preview by default. On an open migration it takes the forge snapshots still missing.

Fields

target: Utf8PathBuf

The repository to act on.

apply: bool

Move the files and write the workspace; without it the archive is reported and nothing is touched.

rebuild: bool

Recreate the archived files of the open migration from Git at its base commit, on a clone whose workspace is gone; preview by default, written with --apply. It writes the workspace alone, never the target.

json: bool

Emit one JSON object on stdout instead of the human report.

Mark

Record a status for a source or a group, appending a dated history entry; --group files a source, --destination names where a group’s kept content lives, and a drop names its reason.

Fields

name: String

A source, by id or path, or a group, by id.

status: String

pending, mapped, written, verified, or dropped.

group: Option<String>

The group a source joins, created where it is new.

tags: Vec<String>

A topic label for a source; repeatable.

destinations: Vec<String>

A destination a group’s kept content lives at; repeatable.

reason: Option<String>

Why a source or a group is dropped.

target: Utf8PathBuf

The repository whose migration to mark.

json: bool

Emit one JSON object on stdout instead of the human report.

Status

Report the open migration: each source’s status and checksum, the groups, the snapshots, and what still blocks the close; read-only.

Fields

target: Utf8PathBuf

The repository to read.

json: bool

Emit one JSON object on stdout instead of the human report.

Close

End the migration once every source is verified or dropped and the setup proof is current, removing the configuration key; preview by default. The workspace stays for the operator.

Fields

target: Utf8PathBuf

The repository to act on.

apply: bool

Remove the key; without it the close is judged and nothing is touched.

json: bool

Emit one JSON object on stdout instead of the human report.

Trait Implementations

impl Debug for MigrateAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for MigrateAction

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<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for MigrateAction

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

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

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

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

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand