[ref] refactor

Sebastian Thiel committed 5 years ago

Commit eb0328f1 parent ce7f83b4 files · +49 −58Browse files

Unified · Split

4 files

git-ref/src/store/file/transaction.rs +2 −2
git-ref/src/transaction.rs +34 −37
git-ref/tests/file/transaction.rs +7 −7
git-ref/tests/refs.rs +6 −12

git-ref/src/store/file/transaction.rs+2−2

                 }
                 for change in self.updates.iter_mut() {
+                    assert!(!change.update.deref, "Deref mode is turned into splits and turned off");
                     match &change.update.change {
                         Change::Update { .. } => {}
-                        Change::Delete { deref, mode, .. } => {
+                        Change::Delete { mode, .. } => {
                             let lock = change.lock.take().expect("each ref is locked, even deletions");
-                            assert!(!deref, "Deref mode is turned into splits and turned off");
                             let (rm_reflog, rm_ref) = match mode {
                                 DeleteMode::RefAndRefLog => (true, true),
                                 DeleteMode::RefLogOnly => (true, false),

git-ref/src/transaction.rs+34−37

     Update {
         /// How to treat the reference log.
         mode: UpdateMode,
-        /// If set, symbolic references will be dereferenced so the change gets applied to their target. Has no effect if the reference
-        /// isn't symbolic.
-        deref: bool,
         /// The previous value of the ref, which will be used to assure the ref is still in the known `previous` state before
         /// updating it. It will also be filled in automatically for use in the reflog, if applicable.
         previous: Option<Target>,
         previous: Option<Target>,
         /// How to thread the reference log during deletion.
         mode: DeleteMode,
-        /// If set, symbolic references will be dereferenced so the change gets applied to their target. Has no effect if the reference
-        /// isn't symbolic.
-        deref: bool,
     },
 }
     pub change: Change,
     /// The name of the reference to apply the change to
     pub name: FullName,
+    /// If set, symbolic references  identified by `name`  will be dereferenced to have the `change` applied to their target.
+    /// This flag has no effect if the reference isn't symbolic.
+    pub deref: bool,
+}
+/// The way to deal with the Reflog in deletions.
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
+pub enum DeleteMode {
+    /// Delete the reference and the log
+    RefAndRefLog,
+    /// Delete only the reflog
+    RefLogOnly,
+}
+/// The way to deal with the Reflog in a particular edit
+///
+/// If the `create_unconditionally` field is set, create a reflog even if it otherwise wouldn't be created,
+/// as is the case for tags.
+#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
+pub enum UpdateMode {
+    /// As symbolic references only ever see this when you want to detach them, we won't try to dereference them
+    /// in this case and apply the change to it directly.
+    RefAndRefLog {
+        /// If set, update the reflog even if it otherwise wouldn't.
+        create_unconditionally: bool,
+    },
+    /// Only update the reflog but require this to be a symbolic ref so the actual update can be performed on the
+    /// referent.
+    RefLogOnly {
+        /// If set, update the reflog even if it otherwise wouldn't.
+        create_unconditionally: bool,
+    },
 }
 mod ext {
             for edit in self.iter_mut() {
                 let edit = edit.borrow_mut();
                 match edit.change {
-                    Change::Delete { ref mut deref, .. } | Change::Update { ref mut deref, .. } => {
+                    Change::Delete { .. } | Change::Update { .. } => {
                         match store.find_one_existing(edit.name.to_partial()).ok() {
                             Some(Target::Symbolic(_name)) => {
                                 // todo!("split into new edit")
                             }
                             Some(Target::Peeled(_)) => {
-                                *deref = false;
+                                edit.deref = false;
                             }
                             None => {}
                         }
     }
 }
 pub use ext::RefEditsExt;
-/// The way to deal with the Reflog in deletions.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-pub enum DeleteMode {
-    /// Delete the reference and the log
-    RefAndRefLog,
-    /// Delete only the reflog
-    RefLogOnly,
-}
-/// The way to deal with the Reflog in a particular edit
-///
-/// If the `create_unconditionally` field is set, create a reflog even if it otherwise wouldn't be created,
-/// as is the case for tags.
-#[derive(PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Clone, Copy)]
-pub enum UpdateMode {
-    /// As symbolic references only ever see this when you want to detach them, we won't try to dereference them
-    /// in this case and apply the change to it directly.
-    RefAndRefLog {
-        /// If set, update the reflog even if it otherwise wouldn't.
-        create_unconditionally: bool,
-    },
-    /// Only update the reflog but require this to be a symbolic ref so the actual update can be performed on the
-    /// referent.
-    RefLogOnly {
-        /// If set, update the reflog even if it otherwise wouldn't.
-        create_unconditionally: bool,
-    },
-}

git-ref/tests/file/transaction.rs+7−7

                             },
                             new: Target::Symbolic(referent.try_into()?),
                             previous: None, // TODO: check failure if it doesn't exist
-                            deref: false,
                         },
                         name: "HEAD".try_into()?,
+                        deref: false,
                     }),
                     Fail::Immediately,
                 );
                         change: Change::Delete {
                             previous: None,
                             mode: DeleteMode::RefAndRefLog,
-                            deref: false,
                         },
                         name: "DOES_NOT_EXIST".try_into().unwrap(),
+                        deref: false,
                     }),
                     Fail::Immediately,
                 )
                         change: Change::Delete {
                             previous: Some(Target::Peeled(ObjectId::null_sha1())),
                             mode: DeleteMode::RefAndRefLog,
-                            deref: false,
                         },
                         name: "DOES_NOT_EXIST".try_into().unwrap(),
+                        deref: false,
                     }),
                     Fail::Immediately,
                 )
                         change: Change::Delete {
                             previous: Some(Target::Peeled(ObjectId::null_sha1())),
                             mode: DeleteMode::RefAndRefLog,
-                            deref: false,
                         },
                         name: head.name().into(),
+                        deref: false,
                     }),
                     Fail::Immediately,
                 )
                     change: Change::Delete {
                         previous: Some(Target::Symbolic("refs/heads/main".try_into()?)),
                         mode: DeleteMode::RefAndRefLog,
-                        deref: false
                     },
                     name: head.name().into(),
+                    deref: false
                 }],
                 "the previous value was updated with the actual one"
             );
                         change: Change::Delete {
                             previous: Some(Target::Symbolic("refs/heads/main".try_into()?)),
                             mode: DeleteMode::RefLogOnly,
-                            deref: false,
                         },
                         name: head.name().into(),
+                        deref: false,
                     }),
                     Fail::Immediately,
                 )
                         change: Change::Delete {
                             previous: Some(Target::Symbolic("refs/heads/main".try_into().unwrap())),
                             mode: DeleteMode::RefLogOnly,
-                            deref: true,
                         },
                         name: head.name().into(),
+                        deref: true,
                     }),
                     Fail::Immediately,
                 )

git-ref/tests/refs.rs+6−12

                 change: Change::Delete {
                     previous: None,
                     mode: DeleteMode::RefAndRefLog,
-                    deref: false,
                 },
                 name: name.try_into().expect("valid name"),
+                deref: false,
             }
         }
                 }
             }
-            fn is_deref(edit: &RefEdit) -> bool {
-                match edit.change {
-                    Change::Delete { deref, .. } | Change::Update { deref, .. } => deref,
-                }
-            }
             fn find<'a>(edits: &'a [RefEdit], name: &str) -> &'a RefEdit {
                 let name: FullName = name.try_into().unwrap();
                 edits
                         change: Change::Delete {
                             previous: None,
                             mode: DeleteMode::RefAndRefLog,
-                            deref: false,
                         },
                         name: "SYMBOLIC_PROBABLY_BUT_DEREF_IS_FALSE_SO_IGNORED".try_into()?,
+                        deref: false,
                     },
                     RefEdit {
                         change: Change::Delete {
                             previous: None,
                             mode: DeleteMode::RefAndRefLog,
-                            deref: true,
                         },
                         name: "refs/heads/anything-but-not-symbolic".try_into()?,
+                        deref: true,
                     },
                     RefEdit {
                         change: Change::Delete {
                             previous: None,
                             mode: DeleteMode::RefAndRefLog,
-                            deref: true,
                         },
                         name: "refs/heads/does-not-exist-and-deref-is-ignored".try_into()?,
+                        deref: true,
                     },
                 ];
                 edits.extend_with_splits_of_symbolic_refs(&store, |_| panic!("should not be called"))?;
                 assert_eq!(edits.len(), 3, "no edit was added");
                 assert!(
-                    !is_deref(find(&edits, "refs/heads/anything-but-not-symbolic")),
+                    !find(&edits, "refs/heads/anything-but-not-symbolic").deref,
                     "the algorithm corrects these flags"
                 );
                 assert!(
-                    is_deref(find(&edits, "refs/heads/does-not-exist-and-deref-is-ignored")),
+                    find(&edits, "refs/heads/does-not-exist-and-deref-is-ignored").deref,
                     "non-existing refs won't change the flag"
                 );
                 store.assert_empty();