[protocol #145] Unify the `previous` and `previous_result` parameters…

…to be called `previous_response` instead.

Sebastian Thiel committed 5 years ago

Commit 96f77c71 parent 8dfc9434 files · +42 −34Browse files

Unified · Split

4 files

git-protocol/src/fetch/delegate.rs +30 −22
git-protocol/tests/fetch/mod.rs +6 −6
gitoxide-core/src/pack/receive.rs +3 −3
gitoxide-core/src/remote.rs +3 −3

git-protocol/src/fetch/delegate.rs+30−22

     /// A method called repeatedly to negotiate the objects to receive in [`receive_pack(…)`][Delegate::receive_pack()].
     ///
-    /// The first call has `previous` set to `None` as there was no previous response. Every call that follows `previous`
+    /// The first call has `previous_response` set to `None` as there was no previous response. Every call that follows `previous_response`
     /// will be set to `Some`.
     ///
-    /// ### If `previous` is `None`…
+    /// ### If `previous_response` is `None`…
     ///
     /// Given a list of `arguments` to populate with wants, want-refs, shallows, filters and other contextual information to be
     /// sent to the server. This method is called once.
     /// Return `Action::Close` if you know that there are no `haves` on your end to allow the server to send all of its objects
     /// as is the case during initial clones.
     ///
-    /// ### If `previous` is `Some`…
+    /// ### If `previous_response` is `Some`…
     ///
     /// Populate `arguments` with the objects you `have` starting from the tips of _your_ refs, taking into consideration
-    /// the `previous` response of the server to see which objects they acknowledged to have. You have to maintain
+    /// the `previous_response` response of the server to see which objects they acknowledged to have. You have to maintain
     /// enough state to be able to walk down from your tips on each call, if they are not in common, and keep setting `have`
     /// for those which are in common if that helps teaching the server about our state and to acknowledge their existence on _their_ end.
     /// This method is called until the other side signals they are ready to send a pack.
     /// Return `Action::Close` if you want to give up before finding a common base. This can happen if the remote repository
     /// has radically changed so there are no bases, or they are very far in the past, causing all objects to be sent.
-    fn negotiate(&mut self, refs: &[Ref], arguments: &mut Arguments, previous: Option<&Response>)
+    fn negotiate(
-        -> io::Result<Action>;
+        &mut self,
+        refs: &[Ref],
+        arguments: &mut Arguments,
+        previous_response: Option<&Response>,
+    ) -> io::Result<Action>;
     /// Return true if the server should be informed that the operation is completed and no further commands will be issued
     /// at the end of the fetch operation.
         &mut self,
         refs: &[Ref],
         arguments: &mut Arguments,
-        previous: Option<&Response>,
+        previous_response: Option<&Response>,
     ) -> io::Result<Action> {
-        self.deref_mut().negotiate(refs, arguments, previous)
+        self.deref_mut().negotiate(refs, arguments, previous_response)
     }
 }
         &mut self,
         refs: &[Ref],
         arguments: &mut Arguments,
-        previous: Option<&Response>,
+        previous_response: Option<&Response>,
     ) -> io::Result<Action> {
-        self.deref_mut().negotiate(refs, arguments, previous)
+        self.deref_mut().negotiate(refs, arguments, previous_response)
     }
 }
         ///
         /// Use `progress` to emit your own progress messages when decoding the pack.
         ///
-        /// `refs` of the remote side are provided for convenience, along with the parsed `previous` response in case you want
+        /// `refs` of the remote side are provided for convenience, along with the parsed `previous_response` response in case you want
         /// to check additional acks.
         fn receive_pack(
             &mut self,
             input: impl io::BufRead,
             progress: impl Progress,
             refs: &[Ref],
-            previous: &Response,
+            previous_response: &Response,
         ) -> io::Result<()>;
     }
             input: impl BufRead,
             progress: impl Progress,
             refs: &[Ref],
-            previous: &Response,
+            previous_response: &Response,
         ) -> io::Result<()> {
-            self.deref_mut().receive_pack(input, progress, refs, previous)
+            self.deref_mut().receive_pack(input, progress, refs, previous_response)
         }
     }
             input: impl BufRead,
             progress: impl Progress,
             refs: &[Ref],
-            previous: &Response,
+            previous_response: &Response,
         ) -> io::Result<()> {
-            self.deref_mut().receive_pack(input, progress, refs, previous)
+            self.deref_mut().receive_pack(input, progress, refs, previous_response)
         }
     }
 }
         ///
         /// Use `progress` to emit your own progress messages when decoding the pack.
         ///
-        /// `refs` of the remote side are provided for convenience, along with the parsed `previous` response in case you want
+        /// `refs` of the remote side are provided for convenience, along with the parsed `previous_response` response in case you want
         /// to check additional acks.
         async fn receive_pack(
             &mut self,
             input: impl AsyncBufRead + Unpin + 'async_trait,
             progress: impl Progress,
             refs: &[Ref],
-            previous: &Response,
+            previous_response: &Response,
         ) -> io::Result<()>;
     }
     #[async_trait(?Send)]
             input: impl AsyncBufRead + Unpin + 'async_trait,
             progress: impl Progress,
             refs: &[Ref],
-            previous: &Response,
+            previous_response: &Response,
         ) -> io::Result<()> {
-            self.deref_mut().receive_pack(input, progress, refs, previous).await
+            self.deref_mut()
+                .receive_pack(input, progress, refs, previous_response)
+                .await
         }
     }
             input: impl AsyncBufRead + Unpin + 'async_trait,
             progress: impl Progress,
             refs: &[Ref],
-            previous: &Response,
+            previous_response: &Response,
         ) -> io::Result<()> {
-            self.deref_mut().receive_pack(input, progress, refs, previous).await
+            self.deref_mut()
+                .receive_pack(input, progress, refs, previous_response)
+                .await
         }
     }
 }

git-protocol/tests/fetch/mod.rs+6−6

@@ -34,7 +34,7 @@ impl fetch::DelegateBlocking for CloneDelegate { · 33 unmodified lines
34	&mut self,	34	&mut self,
35	refs: &[Ref],	35	refs: &[Ref],
36	arguments: &mut Arguments,	36	arguments: &mut Arguments,
37	_previous_result: Option<&Response>,	37	_previous_response: Option<&Response>,
38	) -> io::Result<Action> {	38	) -> io::Result<Action> {
39	for r in refs {	39	for r in refs {
40	arguments.want(r.unpack().1);	40	arguments.want(r.unpack().1);
@@ -125,7 +125,7 @@ impl fetch::DelegateBlocking for LsRemoteDelegate { · 84 unmodified lines
125	&mut self,	125	&mut self,
126	_refs: &[Ref],	126	_refs: &[Ref],
127	_arguments: &mut Arguments,	127	_arguments: &mut Arguments,
128	_previous_result: Option<&Response>,	128	_previous_response: Option<&Response>,
129	) -> io::Result<Action> {	129	) -> io::Result<Action> {
130	unreachable!("this must not be called after closing the connection in `prepare_fetch(…)`")	130	unreachable!("this must not be called after closing the connection in `prepare_fetch(…)`")
131	}	131	}
@@ -147,7 +147,7 @@ mod blocking_io { · 15 unmodified lines
147	mut input: impl io::BufRead,	147	mut input: impl io::BufRead,
148	_progress: impl Progress,	148	_progress: impl Progress,
149	_refs: &[Ref],	149	_refs: &[Ref],
150	_previous: &Response,	150	_previous_response: &Response,
151	) -> io::Result<()> {	151	) -> io::Result<()> {
152	self.pack_bytes = io::copy(&mut input, &mut io::sink())? as usize;	152	self.pack_bytes = io::copy(&mut input, &mut io::sink())? as usize;
153	Ok(())	153	Ok(())
@@ -179,7 +179,7 @@ mod blocking_io { · 25 unmodified lines
179	_input: impl io::BufRead,	179	_input: impl io::BufRead,
180	_progress: impl Progress,	180	_progress: impl Progress,
181	_refs: &[Ref],	181	_refs: &[Ref],
182	_previous: &Response,	182	_previous_response: &Response,
183	) -> io::Result<()> {	183	) -> io::Result<()> {
184	unreachable!("Should not be called for ls-refs");	184	unreachable!("Should not be called for ls-refs");
185	}	185	}
@@ -205,7 +205,7 @@ mod async_io { · 19 unmodified lines
205	mut input: impl AsyncBufRead + Unpin + 'async_trait,	205	mut input: impl AsyncBufRead + Unpin + 'async_trait,
206	_progress: impl Progress,	206	_progress: impl Progress,
207	_refs: &[Ref],	207	_refs: &[Ref],
208	_previous: &Response,	208	_previous_response: &Response,
209	) -> io::Result<()> {	209	) -> io::Result<()> {
210	self.pack_bytes = futures_lite::io::copy(&mut input, &mut futures_lite::io::sink()).await? as usize;	210	self.pack_bytes = futures_lite::io::copy(&mut input, &mut futures_lite::io::sink()).await? as usize;
211	Ok(())	211	Ok(())
@@ -239,7 +239,7 @@ mod async_io { · 27 unmodified lines
239	_input: impl AsyncBufRead + Unpin + 'async_trait,	239	_input: impl AsyncBufRead + Unpin + 'async_trait,
240	_progress: impl Progress,	240	_progress: impl Progress,
241	_refs: &[Ref],	241	_refs: &[Ref],
242	_previous: &Response,	242	_previous_response: &Response,
243	) -> io::Result<()> {	243	) -> io::Result<()> {
244	unreachable!("Should not be called for ls-refs");	244	unreachable!("Should not be called for ls-refs");
245	}	245	}

gitoxide-core/src/pack/receive.rs+3−3

@@ -59,7 +59,7 @@ impl<W> protocol::fetch::DelegateBlocking for CloneDelegate<W> { · 58 unmodified lines
59	&mut self,	59	&mut self,
60	refs: &[Ref],	60	refs: &[Ref],
61	arguments: &mut Arguments,	61	arguments: &mut Arguments,
62	_previous: Option<&Response>,	62	_previous_response: Option<&Response>,
63	) -> io::Result<Action> {	63	) -> io::Result<Action> {
64	for r in refs {	64	for r in refs {
65	let (path, id) = r.unpack();	65	let (path, id) = r.unpack();
@@ -97,7 +97,7 @@ mod blocking_io { · 31 unmodified lines
97	input: impl BufRead,	97	input: impl BufRead,
98	progress: impl Progress,	98	progress: impl Progress,
99	refs: &[Ref],	99	refs: &[Ref],
100	_previous: &Response,	100	_previous_response: &Response,
101	) -> io::Result<()> {	101	) -> io::Result<()> {
102	let options = pack::bundle::write::Options {	102	let options = pack::bundle::write::Options {
103	thread_limit: self.ctx.thread_limit,	103	thread_limit: self.ctx.thread_limit,
@@ -188,7 +188,7 @@ mod async_io { · 84 unmodified lines
188	input: impl AsyncBufRead + Unpin + 'async_trait,	188	input: impl AsyncBufRead + Unpin + 'async_trait,
189	progress: impl Progress,	189	progress: impl Progress,
190	refs: &[Ref],	190	refs: &[Ref],
191	_previous: &Response,	191	_previous_response: &Response,
192	) -> io::Result<()> {	192	) -> io::Result<()> {
193	let options = pack::bundle::write::Options {	193	let options = pack::bundle::write::Options {
194	thread_limit: self.ctx.thread_limit,	194	thread_limit: self.ctx.thread_limit,

gitoxide-core/src/remote.rs+3−3

@@ -33,7 +33,7 @@ pub mod refs { · 32 unmodified lines
33	&mut self,	33	&mut self,
34	_refs: &[Ref],	34	_refs: &[Ref],
35	_arguments: &mut Arguments,	35	_arguments: &mut Arguments,
36	_previous_result: Option<&Response>,	36	_previous_response: Option<&Response>,
37	) -> io::Result<Action> {	37	) -> io::Result<Action> {
38	unreachable!("not to be called due to Action::Close in `prepare_fetch`")	38	unreachable!("not to be called due to Action::Close in `prepare_fetch`")
39	}	39	}
@@ -59,7 +59,7 @@ pub mod refs { · 19 unmodified lines
59	input: impl AsyncBufRead + Unpin + 'async_trait,	59	input: impl AsyncBufRead + Unpin + 'async_trait,
60	progress: impl Progress,	60	progress: impl Progress,
61	refs: &[Ref],	61	refs: &[Ref],
62	previous: &Response,	62	previous_response: &Response,
63	) -> io::Result<()> {	63	) -> io::Result<()> {
64	unreachable!("not called for ls-refs")	64	unreachable!("not called for ls-refs")
65	}	65	}
@@ -119,7 +119,7 @@ pub mod refs { · 53 unmodified lines
119	_input: impl io::BufRead,	119	_input: impl io::BufRead,
120	_progress: impl Progress,	120	_progress: impl Progress,
121	_refs: &[Ref],	121	_refs: &[Ref],
122	_previous: &Response,	122	_previous_response: &Response,
123	) -> io::Result<()> {	123	) -> io::Result<()> {
124	unreachable!("not called for ls-refs")	124	unreachable!("not called for ls-refs")
125	}	125	}

[protocol #145] Unify the `previous` and `previous_result` parameters…

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code