version = "0.3.11"

checksum = "6d7d6b8f3a64453fd7e8191eb80b351eb7ac0839b40a1237cd2c137d5079fe53"

version = "0.25.1"

checksum = "2be87bb8685fc7e6e7032ef71c45068ffff609724a0c897b8047fde10db6ae71"

version = "0.9.2"

checksum = "691142b1a34d18e8ed6e6114bc1a2736516c5ad60ef3aa9bd1b694886e3ca92d"

version = "0.48.0"

checksum = "a327be31a392144b60ab0b1c863362c32a1c8f7effdfa2141d5d5b6b916ef3bf"

version = "0.12.0"

checksum = "34740384d8d763975858fa2c176b68652a6fcc09f616e24e3ce967b0d370e4d8"

version = "0.46.0"

checksum = "65d93e2bbfa83a307e47f45e45de7b6c04d7375a8bd5907b215f4bf45237d879"

version = "0.65.0"

checksum = "93bed6e1b577c25a6bb8e6ecbf4df525f29a671ddf5f2221821a56a8dbeec4e3"

version = "0.55.0"

checksum = "9b91fec04d359544fecbb8e85117ec746fbaa9046ebafcefb58cb74f20dc76d4"

version = "0.18.1"

checksum = "8a720e5bebf494c3ceffa85aa89f57a5859450a0da0a29ebe89171e23543fa78"

version = "0.8.9"

checksum = "7a7822afc4bc9c5fbbc6ce80b00f41c129306b7685cac3248dbfa14784960594"

version = "0.46.1"

checksum = "7a7e7e51a0dea531d3448c297e2fa919b2de187111a210c324b7e9f81508b8ca"

version = "0.43.1"

checksum = "39a1a41357b7236c03e0c984147f823d87c3e445a8581bac7006df141577200b"

version = "0.43.0"

checksum = "3ff2ec9f779680f795363db1c563168b32b8d6728ec58564c628e85c92d29faf"

version = "0.28.1"

checksum = "e09f97db3618fb8e473d7d97e77296b50aaee0ddcd6a867f07443e3e87391099"

use gix_protocol::FetchConnection;

use gix_transport::client::TransportWithoutIO as _;

            &mut Connection::new(read, write, FetchConnection::AllowReuse, self.repo.clone()),

                extra_params: vec![],

            Connection::new(read, write, FetchConnection::AllowReuse, self.repo.clone()),

                Connection::new(read, write, FetchConnection::AllowReuse, self.repo.clone()),

    mode: FetchConnection,

    pub fn new(read: R, write: W, mode: FetchConnection, repo: BString) -> Self {

            mode,

fn indicate_end_of_interaction<R, W>(transport: &mut Connection<R, W>) -> Result<(), client::Error>

where

    R: io::Read,

    W: io::Write,

{

    // An empty request marks the (early) end of the interaction. Only relevant in stateful transports though.

    if transport.connection_persists_across_multiple_requests() {

        transport

            .request(client::WriteMode::Binary, client::MessageKind::Flush, false)?

            .into_read()?;

    }

    Ok(())

}

use std::borrow::Cow;

use std::io::BufRead;

use gix_features::progress::NestedProgress;

use gix_protocol::fetch::{Delegate, DelegateBlocking};

use gix_protocol::ls_refs;

use gix_protocol::FetchConnection;

use gix_transport::bstr::BString;

use gix_transport::client;

use gix_transport::client::{ExtendedBufRead, MessageKind};

use gix_transport::Protocol;

use crate::git::packfile;

use super::{agent_name, indicate_end_of_interaction, Connection, WantsHaves};

pub type Error = gix_protocol::fetch::Error;

    pub fn write_pack<P>(

        mut pack: impl BufRead,

        mut progress: P,

    ) -> Result<pack::bundle::write::Outcome, error::PackWriter>

    where

        P: NestedProgress,

        P::SubProgress: 'static,

    {

            &mut pack,

            &mut progress,

pub struct Fetch {

    pack_writer: PackWriter,

    out: FetchOut,

// FIXME: the delegate pattern will be removed in the near future and

// we should look at the fetch code being used in gix to see how we

// can migrate to the proper form of fetching.

impl<'a> Delegate for &'a mut Fetch {

    fn receive_pack(

        input: impl io::BufRead,

        progress: impl NestedProgress + 'static,

        _refs: &[handshake::Ref],

        previous_response: &fetch::Response,

    ) -> io::Result<()> {

        self.out

            .refs

            .extend(previous_response.wanted_refs().iter().map(

                |fetch::response::WantedRef { id, path }| Ref::Direct {

                    full_ref_name: path.clone(),

                    object: *id,

                },

            ));

        let pack = self

            .pack_writer

            .write_pack(input, progress)

            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;

        self.out.keepfile = pack.keep_path.as_ref().and_then(packfile::Keepfile::new);

        self.out.pack = Some(pack);

        Ok(())

}

impl<'a> DelegateBlocking for &'a mut Fetch {

    fn negotiate(

        _refs: &[handshake::Ref],

        _previous_response: Option<&fetch::Response>,

    ) -> io::Result<fetch::Action> {

        use crate::git::oid;

        // N.b. sends `done` packet

        Ok(fetch::Action::Cancel)

    }

    fn prepare_ls_refs(

        &mut self,

        _server: &client::Capabilities,

        _arguments: &mut Vec<BString>,

        _features: &mut Vec<(&str, Option<Cow<'_, str>>)>,

    ) -> io::Result<ls_refs::Action> {

        // N.b. we performed ls-refs before the fetch already.

        Ok(ls_refs::Action::Skip)

    }

    fn prepare_fetch(

        &mut self,

        _version: Protocol,

        _server: &client::Capabilities,

        _features: &mut Vec<(&str, Option<Cow<'_, str>>)>,

        _refs: &[handshake::Ref],

    ) -> io::Result<fetch::Action> {

        if self.wants_haves.wants.is_empty() {

            return Err(io::Error::new(io::ErrorKind::InvalidData, "empty fetch"));

        }

        Ok(fetch::Action::Continue)

    let mut delegate = Fetch {

        wants_haves,

        pack_writer,

        out: FetchOut {

            refs: Vec::new(),

            pack: None,

            keepfile: None,

        },

    };

    let handshake::Outcome {

        server_protocol_version: protocol,

        refs: _refs,

        v1_shallow_updates: _,

        capabilities,

    } = handshake;

    let agent = agent_name()?;

    let fetch = gix_protocol::Command::Fetch;

    let mut features = fetch.default_features(*protocol, capabilities);

    match (&mut delegate).prepare_fetch(*protocol, capabilities, &mut features, &[]) {

        Ok(fetch::Action::Continue) => {

            // FIXME: this is a private function in gitoxide

            // fetch.validate_argument_prefixes_or_panic(protocol, &capabilities, &[], &features)

        }

        // N.b. we always return Action::Continue

        Ok(fetch::Action::Cancel) => unreachable!(),

        Err(err) => {

            indicate_end_of_interaction(&mut conn)?;

            return Err(err.into());

        }

    }

    gix_protocol::fetch::Response::check_required_features(*protocol, &features)?;

    let sideband_all = features.iter().any(|(n, _)| *n == "sideband-all");

    features.push(("agent", Some(Cow::Owned(agent))));

    let mut args = fetch::Arguments::new(*protocol, features, false);

    let mut previous_response = None::<fetch::Response>;

    let mut round = 1;

    'negotiation: loop {

        progress.step();

        progress.set_name(format!("negotiate (round {round})"));

        round += 1;

        let action = (&mut delegate).negotiate(&[], &mut args, previous_response.as_ref())?;

        let mut reader = args.send(&mut conn, action == fetch::Action::Cancel)?;

        if sideband_all {

            setup_remote_progress(progress, &mut reader);

        }

        let response = fetch::Response::from_line_reader(*protocol, &mut reader, true, false)?;

        previous_response = if response.has_pack() {

            progress.step();

            if !sideband_all {

                setup_remote_progress(progress, &mut reader);

            }

            let timer = std::time::Instant::now();

            // TODO: remove delegate in favor of functional style to fix progress-hack,

            //       needed as it needs `'static`. As the top-level seems to pass `Discard`,

            //       there should be no repercussions right now.

            (&mut delegate).receive_pack(

                &mut reader,

                progress.add_child("receiving pack"),

                &[],

                &response,

            )?;

            log::trace!(target: "fetch", "Received pack ({}ms)", timer.elapsed().as_millis());

            assert_eq!(

                reader.stopped_at(),

                None,

                "packs are read without 'overshooting', hence it never encountered EOF"

            );

            // Consume anything that might still be left on the wire - this is 'EOF' most of the time,

            // but some tests have 'garbage' here as well.

            std::io::copy(&mut reader, &mut std::io::sink())?;

            assert_eq!(

                reader.stopped_at(),

                Some(MessageKind::Flush),

                "the flush packet was now consumed"

            );

            break 'negotiation;

        } else {

            match action {

                fetch::Action::Cancel => break 'negotiation,

                fetch::Action::Continue => Some(response),

            }

        }

    }

    if matches!(protocol, Protocol::V2)

        && matches!(conn.mode, FetchConnection::TerminateOnSuccessfulCompletion)

    {

        log::trace!(target: "fetch", "Indicating end of interaction");

        indicate_end_of_interaction(&mut conn)?;

    log::trace!(target: "fetch", "fetched refs: {:?}", delegate.out.refs);

    Ok(delegate.out)

}

fn setup_remote_progress<'a, P>(

    progress: &mut P,

    reader: &mut Box<dyn gix_transport::client::ExtendedBufRead<'a> + Unpin + 'a>,

) where

    P: NestedProgress,

    P::SubProgress: 'static,

{

    reader.set_progress_handler(Some(Box::new({

        let mut remote_progress = progress.add_child("remote");

        move |is_err: bool, data: &[u8]| {

            gix_protocol::RemoteProgress::translate_to_progress(is_err, data, &mut remote_progress);

            gix_transport::packetline::read::ProgressAction::Continue

        }

    }) as gix_transport::client::HandleProgress<'a>));

use std::io::{self, BufRead};

use bstr::ByteSlice;

use gix_protocol::fetch::{self, Delegate, DelegateBlocking};

use gix_protocol::{ls_refs, Command};

use gix_transport::client::{self, TransportV2Ext};

use super::{agent_name, indicate_end_of_interaction, Connection};

    /// Extra parameters to pass to the ls-refs process.

    pub extra_params: Vec<(String, Option<String>)>,

/// The Gitoxide delegate for running the ls-refs process.

struct LsRefs {

    /// Configuration for the ls-refs process.

    config: Config,

    /// The resulting references returned by the ls-refs process.

    refs: Vec<Ref>,

}

impl LsRefs {

    fn new(config: Config) -> Self {

        Self {

            config,

            refs: Vec::new(),

        }

    }

}

// FIXME: the delegate pattern will be removed in the near future and

// we should look at the fetch code being used in gix to see how we

// can migrate to the proper form of fetching.

impl DelegateBlocking for LsRefs {

    fn handshake_extra_parameters(&self) -> Vec<(String, Option<String>)> {

        self.config.extra_params.clone()

    }

    fn prepare_ls_refs(

        &mut self,

        _caps: &client::Capabilities,

        args: &mut Vec<BString>,

        _: &mut Vec<(&str, Option<Cow<'_, str>>)>,

    ) -> io::Result<ls_refs::Action> {

        for prefix in &self.config.prefixes {

            let mut arg = BString::from("ref-prefix ");

            arg.push_str(prefix);

            args.push(arg)

        }

        Ok(ls_refs::Action::Continue)

    }

    fn prepare_fetch(

        &mut self,

        _: Protocol,

        _: &client::Capabilities,

        _: &mut Vec<(&str, Option<Cow<'_, str>>)>,

        refs: &[Ref],

    ) -> io::Result<fetch::Action> {

        self.refs.extend_from_slice(refs);

        Ok(fetch::Action::Cancel)

    }

    fn negotiate(

        &mut self,

        _: &[Ref],

        _: &mut fetch::Arguments,

        _: Option<&fetch::Response>,

    ) -> io::Result<fetch::Action> {

        unreachable!("`negotiate` called even though no `fetch` command was sent")

    }

}

impl Delegate for LsRefs {

    fn receive_pack(

        &mut self,

        _: impl BufRead,

        _: impl Progress,

        _: &[Ref],

        _: &fetch::Response,

    ) -> io::Result<()> {

        unreachable!("`receive_pack` called even though no `fetch` command was sent")

    }

}

    let mut delegate = LsRefs::new(config);

    let ls = Command::LsRefs;

    let mut features = ls.default_features(Protocol::V2, capabilities);

    // N.b. copied from gitoxide

    let mut args = vec![

        b"symrefs".as_bstr().to_owned(),

        b"peel".as_bstr().to_owned(),

    ];

    if capabilities

        .capability("ls-refs")

        .and_then(|cap| cap.supports("unborn"))

        .unwrap_or_default()

    {

        args.push("unborn".into());

    }

    let refs = match delegate.prepare_ls_refs(capabilities, &mut args, &mut features) {

        Ok(ls_refs::Action::Skip) => Vec::new(),

        Ok(ls_refs::Action::Continue) => {

            // FIXME: this is a private function

            // ls.validate_argument_prefixes_or_panic(Protocol::V2, capabilities, &args, &features);

            let agent = agent_name()?;

            features.push(("agent", Some(Cow::Owned(agent))));

            progress.step();

            progress.set_name("list refs".into());

            let mut remote_refs = conn.invoke(

                ls.as_str(),

                features.clone().into_iter(),

                if args.is_empty() {

                    None

                } else {

                    Some(args.into_iter())

                },

                false,

            )?;

            handshake::refs::from_v2_refs(&mut remote_refs)?

        }

        Err(err) => {

            indicate_end_of_interaction(&mut conn)?;

            return Err(err.into());

        }

    };