[ref-ls] Make things compile

Looks like none fo the transports aer working yet :D.
Unexpected input and handling.

Now it's about beefing up debugging capabilities.

Author: Byron

git-transport/src/client/connect.rs

@@ -28,6 +28,41 @@ quick_error! {
     }
 }
 
+/// Would be so nice if this wasn't necessary
+mod box_impl {
+    use crate::{
+        client::{self, Error, Identity, MessageKind, RequestWriter, SetServiceResponse, WriteMode},
+        Protocol, Service,
+    };
+    use std::ops::{Deref, DerefMut};
+
+    impl client::Transport for Box<dyn client::Transport> {
+        fn handshake(&mut self, service: Service) -> Result<SetServiceResponse, Error> {
+            self.deref_mut().handshake(service)
+        }
+
+        fn set_identity(&mut self, identity: Identity) -> Result<(), Error> {
+            self.deref_mut().set_identity(identity)
+        }
+
+        fn request(&mut self, write_mode: WriteMode, on_drop: Vec<MessageKind>) -> Result<RequestWriter, Error> {
+            self.deref_mut().request(write_mode, on_drop)
+        }
+
+        fn close(&mut self) -> Result<(), Error> {
+            self.deref_mut().close()
+        }
+
+        fn to_url(&self) -> String {
+            self.deref().to_url()
+        }
+
+        fn desired_protocol_version(&self) -> Protocol {
+            self.deref().desired_protocol_version()
+        }
+    }
+}
+
 /// A general purpose connector with just the default configuration.
 pub fn connect(url: &[u8], version: crate::Protocol) -> Result<Box<dyn Transport>, Error> {
     let urlb = url;

git-transport/src/client/file.rs

@@ -121,8 +121,8 @@ impl client::Transport for SpawnProcessOnDemand {
             .request(write_mode, on_drop)
     }
 
-    fn close(mut self) -> Result<(), client::Error> {
-        if let Some(c) = self.connection.take() {
+    fn close(&mut self) -> Result<(), client::Error> {
+        if let Some(mut c) = self.connection.take() {
             c.close()
         } else {
             Ok(())

git-transport/src/client/git.rs

@@ -103,7 +103,7 @@ where
         ))
     }
 
-    fn close(mut self) -> Result<(), client::Error> {
+    fn close(&mut self) -> Result<(), client::Error> {
         if self.actual_version == Protocol::V2 {
             git_packetline::encode::flush_to_write(&mut self.writer)?;
             self.writer.flush()?;

git-transport/src/client/http/mod.rs

@@ -173,7 +173,7 @@ impl<H: Http> client::Transport for Transport<H> {
         ))
     }
 
-    fn close(self) -> Result<(), client::Error> {
+    fn close(&mut self) -> Result<(), client::Error> {
         Ok(())
     }
 

git-transport/src/client/mod.rs

@@ -214,7 +214,7 @@ pub trait Transport {
     fn request(&mut self, write_mode: WriteMode, on_drop: Vec<MessageKind>) -> Result<RequestWriter, Error>;
 
     /// Closes the connection to indicate no further requests will be made.
-    fn close(self) -> Result<(), Error>;
+    fn close(&mut self) -> Result<(), Error>;
 
     /// Returns the canonical URL pointing to the destination of this transport.
     /// Please note that local paths may not be represented correctly, as they will go through a potentially lossy

gitoxide-core/src/remote.rs

@@ -42,7 +42,7 @@ pub mod refs {
         <P as Progress>::SubProgress: Send + 'static,
         <<P as Progress>::SubProgress as Progress>::SubProgress: Send,
     {
-        let mut transport = git_transport::client::connect(url.as_bytes(), protocol.unwrap_or_default().into())?;
+        let transport = git_transport::client::connect(url.as_bytes(), protocol.unwrap_or_default().into())?;
         let mut delegate = LsRemotes::default();
         git_protocol::fetch(transport, &mut delegate, git_protocol::credentials::helper, progress)?;
 
@@ -54,16 +54,20 @@ pub mod refs {
         Ok(())
     }
 
-    fn print(out: impl io::Write, refs: &[Ref]) -> io::Result<()> {
+    fn print(mut out: impl io::Write, refs: &[Ref]) -> io::Result<()> {
         for r in refs {
             match r {
-                Ref::Direct { path, object } => writeln!(out, "{} {}", object.to_sha1_hex_string(), path),
+                Ref::Direct { path, object } => writeln!(&mut out, "{} {}", object.to_sha1_hex_string(), path),
                 Ref::Peeled { path, object, tag } => {
-                    writeln!(out, "{} {} tag:{}", object.to_sha1_hex_string(), path, tag)
-                }
-                Ref::Symbolic { path, target, object } => {
-                    writeln!(out, "{} {} symref-target:{}", object.to_sha1_hex_string(), path, target)
+                    writeln!(&mut out, "{} {} tag:{}", object.to_sha1_hex_string(), path, tag)
                 }
+                Ref::Symbolic { path, target, object } => writeln!(
+                    &mut out,
+                    "{} {} symref-target:{}",
+                    object.to_sha1_hex_string(),
+                    path,
+                    target
+                ),
                 Ref::SymbolicForLookup { .. } => unreachable!("Bug: these should be resolved already"),
             }?;
         }