[clone] Capabilities now can have multiple values (per command) for V2

We  handle all of this in a single, simple type, which is nice and makes
things easier.

git-transport/src/client/capabilities.rs

@@ -29,7 +29,10 @@ quick_error! {
     }
 }
 
-pub struct Capabilities(BString);
+pub struct Capabilities {
+    data: BString,
+    value_sep: u8,
+}
 pub struct Capability<'a>(&'a BStr);
 
 impl<'a> Capability<'a> {
@@ -43,6 +46,9 @@ impl<'a> Capability<'a> {
     pub fn value(&self) -> Option<&BStr> {
         self.0.splitn(2, |b| *b == b'=').nth(1).map(|s| s.as_bstr())
     }
+    pub fn values(&self) -> Option<impl Iterator<Item = &BStr>> {
+        self.value().map(|v| v.split(|b| *b == b' ').map(|s| s.as_bstr()))
+    }
 }
 
 impl Capabilities {
@@ -52,7 +58,13 @@ impl Capabilities {
             return Err(Error::NoCapabilities);
         }
         let capabilities = &bytes[delimiter_pos + 1..];
-        Ok((Capabilities(capabilities.as_bstr().to_owned()), delimiter_pos))
+        Ok((
+            Capabilities {
+                data: capabilities.as_bstr().to_owned(),
+                value_sep: b' ',
+            },
+            delimiter_pos,
+        ))
     }
     pub fn from_lines(read: impl io::BufRead) -> Result<Capabilities, Error> {
         let mut lines = read.lines();
@@ -69,23 +81,26 @@ impl Capabilities {
             }
             _ => return Err(Error::MalformattedVersionLine(version_line)),
         };
-        Ok(Capabilities(
-            lines
+        Ok(Capabilities {
+            value_sep: b'\n',
+            data: lines
                 .inspect(|l| {
                     if let Ok(l) = l {
                         assert!(
-                            !l.contains(" "),
-                            "spaces are not expected in keys or values, got '{}'",
+                            !l.contains('\n'),
+                            "newlines are not expected in keys or values, got '{}'",
                             l
                         )
                     }
                 })
                 .collect::<Result<Vec<_>, _>>()?
-                .join(" ")
+                .join("\n")
                 .into(),
-        ))
+        })
     }
     pub fn iter(&self) -> impl Iterator<Item = Capability> {
-        self.0.split(|b| *b == b' ').map(|c| Capability(c.as_bstr()))
+        self.data
+            .split(move |b| *b == self.value_sep)
+            .map(|c| Capability(c.as_bstr()))
     }
 }

git-transport/tests/client/http.rs

@@ -233,6 +233,29 @@ User-Agent: git/oxide-{}
             refs.is_none(),
             "refs are only returned in V1, as V2 favors a separate command (with more options)"
         );
+        assert_eq!(
+            capabilities
+                .iter()
+                .map(|v| {
+                    (
+                        v.name().to_owned(),
+                        v.values().map(|v| v.map(ToOwned::to_owned).collect::<Vec<_>>()),
+                    )
+                })
+                .collect::<Vec<_>>(),
+            [
+                ("agent", Some(&["git/github-gdf51a71f0236"][..])),
+                ("ls-refs", None),
+                ("fetch", Some(&["shallow", "filter"])),
+                ("server-option", None)
+            ]
+            .iter()
+            .map(|(k, v)| (
+                k.as_bytes().into(),
+                v.map(|v| v.iter().map(|v| v.as_bytes().into()).collect::<Vec<_>>())
+            ))
+            .collect::<Vec<_>>()
+        );
 
         assert_eq!(
             server.received_as_string().lines().collect::<Vec<_>>(),
@@ -241,6 +264,7 @@ User-Agent: git/oxide-{}
 Host: 127.0.0.1:{}
 Accept: */*
 User-Agent: git/oxide-{}
+Git-Protocol: version=2
 
 ",
                 server.addr.port(),

tasks.md

@@ -23,10 +23,16 @@
       * [ ] ssh?
     * [ ] git://git-upload-pack
       * [x] V1 handshake
+        * [ ] send values
+        * [ ] receive data with sidebands
       * [x] V2 handshake
+        * [ ] send command request
     * [ ] http://git-upload-pack
       * [x] V1 handshake
-      * [ ] V2 handshake
+        * [ ] send values
+        * [ ] receive data with sidebands
+      * [x] V2 handshake
+        * [ ] send command request
 * **git-refs**
   * [ ] a way to know if a ref needs to be parsed (like `ref/name^{}`)
   * [ ] create ref pointing to ID