change!: Target::as_(id|name) -> Target::try_(id|name) (#364)

Conform to naming conventions, whenever something returns an option
or Result while there is a more direct name that panics, prefix `try_`.

Author: Byron

git-ref/src/store/file/raw_ext.rs

@@ -108,7 +108,7 @@ impl ReferenceExt for Reference {
                     }
                 };
                 let mut buf = Vec::new();
-                let mut oid = self.target.as_id().expect("peeled ref").to_owned();
+                let mut oid = self.target.try_id().expect("peeled ref").to_owned();
                 let peeled_id = loop {
                     let (kind, data) = find(oid, &mut buf)
                         .map_err(|err| Box::new(err) as Box<dyn std::error::Error + Send + Sync + 'static>)?

git-ref/src/target.rs

@@ -14,7 +14,7 @@ impl<'a> TargetRef<'a> {
         }
     }
     /// Interpret this target as object id which maybe `None` if it is symbolic.
-    pub fn as_id(&self) -> Option<&oid> {
+    pub fn try_id(&self) -> Option<&oid> {
         match self {
             TargetRef::Symbolic(_) => None,
             TargetRef::Peeled(oid) => Some(oid),
@@ -28,7 +28,7 @@ impl<'a> TargetRef<'a> {
         }
     }
     /// Interpret this target as name of the reference it points to which maybe `None` if it an object id.
-    pub fn as_name(&self) -> Option<&BStr> {
+    pub fn try_name(&self) -> Option<&BStr> {
         match self {
             TargetRef::Symbolic(path) => Some(path.as_bstr()),
             TargetRef::Peeled(_) => None,
@@ -66,7 +66,7 @@ impl Target {
     }
 
     /// Interpret this target as object id which maybe `None` if it is symbolic.
-    pub fn as_id(&self) -> Option<&oid> {
+    pub fn try_id(&self) -> Option<&oid> {
         match self {
             Target::Symbolic(_) => None,
             Target::Peeled(oid) => Some(oid),
@@ -95,7 +95,7 @@ impl Target {
         }
     }
     /// Interpret this target as name of the reference it points to which maybe `None` if it an object id.
-    pub fn as_name(&self) -> Option<&BStr> {
+    pub fn try_name(&self) -> Option<&BStr> {
         match self {
             Target::Symbolic(name) => Some(name.as_bstr()),
             Target::Peeled(_) => None,

git-ref/tests/file/reference.rs

@@ -79,7 +79,7 @@ mod peel {
         let mut head: Reference = store.find_loose("HEAD")?.into();
         let expected = hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03");
         assert_eq!(head.peel_to_id_in_place(&store, peel::none)?, expected);
-        assert_eq!(head.target.as_id().map(ToOwned::to_owned), Some(expected));
+        assert_eq!(head.target.try_id().map(ToOwned::to_owned), Some(expected));
 
         let mut head = store.find("dt1")?;
         assert_eq!(head.peel_to_id_in_place(&store, peel::none)?, expected);
@@ -93,7 +93,7 @@ mod peel {
 
         let head = store.find("dt1")?;
         assert_eq!(
-            head.target.as_id().map(ToOwned::to_owned),
+            head.target.try_id().map(ToOwned::to_owned),
             Some(hex_to_id("4c3f4cce493d7beb45012e478021b5f65295e5a3"))
         );
         assert_eq!(
@@ -104,7 +104,7 @@ mod peel {
 
         let peeled = head.follow(&store).expect("a peeled ref for the object")?;
         assert_eq!(
-            peeled.target.as_id().map(ToOwned::to_owned),
+            peeled.target.try_id().map(ToOwned::to_owned),
             Some(hex_to_id("134385f6d781b7e97062102c6a483440bfda2a03")),
             "packed refs are always peeled (at least the ones we choose to read)"
         );
@@ -192,8 +192,8 @@ mod parse {
                     let reference =
                         Reference::try_from_path("HEAD".try_into().expect("valid static name"), $input).unwrap();
                     assert_eq!(reference.kind(), $kind);
-                    assert_eq!(reference.target.to_ref().as_id(), $id);
-                    assert_eq!(reference.target.to_ref().as_name(), $ref);
+                    assert_eq!(reference.target.to_ref().try_id(), $id);
+                    assert_eq!(reference.target.to_ref().try_name(), $ref);
                 }
             };
         }

git-ref/tests/file/transaction/prepare_and_commit/create_or_update.rs

@@ -443,7 +443,7 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
         let head = store.find_loose(edits[0].name.to_partial())?;
         assert_eq!(head.name.as_bstr(), "HEAD");
         assert_eq!(head.kind(), git_ref::Kind::Symbolic);
-        assert_eq!(head.target.to_ref().as_name(), Some(referent.as_bytes().as_bstr()));
+        assert_eq!(head.target.to_ref().try_name(), Some(referent.as_bytes().as_bstr()));
         assert!(!head.log_exists(&store), "no reflog is written for symbolic ref");
         assert!(store.try_find_loose(referent)?.is_none(), "referent wasn't created");
 
@@ -506,15 +506,15 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
             "head is still symbolic, not detached"
         );
         assert_eq!(
-            head.target.to_ref().as_name(),
+            head.target.to_ref().try_name(),
             Some(referent.as_bytes().as_bstr()),
             "it still points to the referent"
         );
 
         let referent_ref = store.find_loose(referent)?;
         assert_eq!(referent_ref.kind(), git_ref::Kind::Peeled, "referent is a peeled ref");
         assert_eq!(
-            referent_ref.target.to_ref().as_id(),
+            referent_ref.target.to_ref().try_id(),
             Some(new_oid.as_ref()),
             "referent points to desired hash"
         );
@@ -544,7 +544,7 @@ fn symbolic_head_missing_referent_then_update_referent() -> crate::Result {
 fn write_reference_to_which_head_points_to_does_not_update_heads_reflog_even_though_it_should() -> crate::Result {
     let (_keep, store) = store_writable("make_repo_for_reflog.sh")?;
     let head = store.find_loose("HEAD")?;
-    let referent = head.target.to_ref().as_name().expect("symbolic ref").to_owned();
+    let referent = head.target.to_ref().try_name().expect("symbolic ref").to_owned();
     let previous_head_reflog = reflog_lines(&store, "HEAD")?;
 
     let new_id = hex_to_id("01dd4e2a978a9f5bd773dae6da7aa4a5ac1cdbbc");
@@ -642,7 +642,7 @@ fn packed_refs_are_looked_up_when_checking_existing_values() -> crate::Result {
         "packed refs aren't rewritten, the change goes into the loose ref instead which shadows packed refs of same name"
         );
     assert_eq!(
-        store.find_loose("main")?.target.as_id(),
+        store.find_loose("main")?.target.try_id(),
         Some(new_id.as_ref()),
         "the new id was written to the loose ref"
     );
@@ -719,7 +719,7 @@ fn packed_refs_creation_with_packed_refs_mode_leave_keeps_original_loose_refs()
     let packed = store.open_packed_buffer()?.expect("packed-refs");
     assert_ne!(
         packed.find("newer-as-loose")?.target(),
-        branch.target.as_id().expect("peeled"),
+        branch.target.try_id().expect("peeled"),
         "the packed ref is outdated"
     );
     let previous_reflog_entries = branch.log_iter(&store).all()?.expect("log").count();

git-ref/tests/file/transaction/prepare_and_commit/delete.rs

@@ -374,7 +374,7 @@ fn a_loose_ref_with_old_value_check_and_outdated_packed_refs_value_deletes_both_
     let (_keep, store) = store_writable("make_packed_ref_repository_for_overlay.sh")?;
     let packed = store.open_packed_buffer()?.expect("packed-refs");
     let branch = store.find("newer-as-loose")?;
-    let branch_id = branch.target.as_id().map(ToOwned::to_owned).expect("peeled");
+    let branch_id = branch.target.try_id().map(ToOwned::to_owned).expect("peeled");
     assert_ne!(
         packed.find("newer-as-loose")?.target(),
         branch_id,