dblsaiko/pijul - Change E3DD265TSU5HFAAUYOIYFK5D3GYSPIJSWDVSQX5Q226WPCH43EFQC

Fork to a state

Created by pmeunier on February 7, 2024

E3DD265TSU5HFAAUYOIYFK5D3GYSPIJSWDVSQX5Q226WPCH43EFQC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/commands/fork.rs at line 4 [6.167873]
∅:D[4.1111] → [5.4083:4126]
B:BD[7.2350] → [5.4083:4126]
```
use libpijul::{MutTxnT, MutTxnTExt, TxnT};
```
[4.1111]
[7.2351]
```
use libpijul::{Base32, ChannelTxnT, MutTxnT, MutTxnTExt, TxnT, TxnTExt};
```

Insertion in pijul/src/commands/fork.rs at line 14 [6.167873]

[6.168107]

[8.3329]

    /// Make the new channel from this state instead of the current channel
    #[clap(long = "state", conflicts_with = "change", conflicts_with = "channel")]
    state: Option<String>,

Replacement in pijul/src/commands/fork.rs at line 18 [6.167873]
∅:D[8.3407] → [6.168107:168164]
B:BD[6.168107] → [6.168107:168164]
```
    #[clap(long = "channel", conflicts_with = "change")]
```
[8.3407]
[6.168164]
```
    #[clap(long = "channel", conflicts_with = "change", conflicts_with = "state")]
```
Replacement in pijul/src/commands/fork.rs at line 21 [6.167873]
∅:D[9.2431] → [6.168193:168250]
∅:D[8.3476] → [6.168193:168250]
B:BD[6.168193] → [6.168193:168250]
```
    #[clap(long = "change", conflicts_with = "channel")]
```
[9.2431]
[6.168250]
```
    #[clap(long = "change", conflicts_with = "channel", conflicts_with = "state")]
```

Replacement in pijul/src/commands/fork.rs at line 38 [6.167873]

B:BD[6.168764] → [10.15692:15753]

B:BD[10.15753] → [3.860:914]

∅:D[3.914] → [10.15804:15834]

B:BD[10.15804] → [10.15804:15834]

∅:D[10.15834] → [11.2740:2825]

B:BD[6.168764] → [11.2740:2825]

            let cur = txn
                .current_channel()
                .unwrap_or(libpijul::DEFAULT_CHANNEL)
                .to_string();
            let channel_name = if let Some(ref c) = self.channel {
                c

[6.168764]

[11.2825]

            let mut fork = if let Some(ref channel_name) = self.channel {
                if let Some(channel) = txn.load_channel(channel_name)? {
                    txn.fork(&channel, &self.to)?
                } else {
                    anyhow::bail!("Channel not found: {:?}", channel_name);
                }

Replacement in pijul/src/commands/fork.rs at line 45 [6.167873]

B:BD[11.2846] → [10.15835:15864]

                cur.as_str()

[11.2846]

[10.15864]

                let cur = txn
                    .current_channel()
                    .unwrap_or(libpijul::DEFAULT_CHANNEL)
                    .to_string();
                if let Some(channel) = txn.load_channel(&cur)? {
                    txn.fork(&channel, &self.to)?
                } else {
                    anyhow::bail!("Channel not found: {:?}", cur);
                }

Replacement in pijul/src/commands/fork.rs at line 55 [6.167873]

∅:D[10.15879] → [11.2958:3028]

B:BD[11.2958] → [11.2958:3028]

∅:D[11.3028] → [6.168919:168966]

∅:D[12.17354] → [6.168919:168966]

B:BD[6.168919] → [6.168919:168966]

B:BD[6.168966] → [2.0:93]

            if let Some(channel) = txn.load_channel(&channel_name)? {
                txn.fork(&channel, &self.to)?;
            } else {
                anyhow::bail!("Channel not found: {:?}", channel_name);

[10.15879]

[6.168966]


            if let Some(ref state) = self.state {
                if let Some(state) = libpijul::Merkle::from_base32(state.as_bytes()) {
                    let ch = fork.write();
                    if let Some(n) = txn.channel_has_state(&ch.states, &state.into())? {
                        let n: u64 = n.into();
                        let mut v = Vec::new();
                        for l in txn.reverse_log(&ch, None)? {
                            let (n_, h) = l?;
                            if n_ > n {
                                v.push(h.0.into())
                            } else {
                                break;
                            }
                        }
                        std::mem::drop(ch);
                        for h in v {
                            txn.unrecord(&repo.changes, &mut fork, &h, 0)?;
                        }
                    }
                }

Fork to a *state*