Amended IndexConflict to make it sensitive to the possibility that git_index_conflict_iterator returns a NULL pointer for one of the trio of IndexEntries. Also added Reference::find_reference_dwim to make it a little easier to find refs.

Author: iancormac84

libgit2-sys/lib.rs

@@ -1886,6 +1886,9 @@ extern {
     pub fn git_reference_lookup(out: *mut *mut git_reference,
                                 repo: *mut git_repository,
                                 name: *const c_char) -> c_int;
+    pub fn git_reference_dwim(out: *mut *mut git_reference,
+                              repo: *mut git_repository,
+                              refname: *const c_char) -> c_int;
     pub fn git_reference_name(r: *const git_reference) -> *const c_char;
     pub fn git_reference_name_to_id(out: *mut git_oid,
                                     repo: *mut git_repository,

src/index.rs

@@ -33,13 +33,13 @@ pub struct IndexConflicts<'index> {
 /// A structure to represent the information returned when a conflict is detected in an index entry
 pub struct IndexConflict {
     /// The ancestor index entry of the two conflicting index entries
-    pub ancestor: IndexEntry,
+    pub ancestor: Option<IndexEntry>,
     /// The index entry originating from the user's copy of the repository.
     /// Its contents conflict with 'their' index entry
-    pub our: IndexEntry,
+    pub our: Option<IndexEntry>,
     /// The index entry originating from the external repository.
     /// Its contents conflict with 'our' index entry
-    pub their: IndexEntry,
+    pub their: Option<IndexEntry>,
 }
 
 /// A callback function to filter index matches.
@@ -588,9 +588,18 @@ impl<'index> Iterator for IndexConflicts<'index> {
                 self.conflict_iter
             ));
             Some(Ok(IndexConflict {
-                ancestor: IndexEntry::from_raw(*ancestor),
-                our: IndexEntry::from_raw(*our),
-                their: IndexEntry::from_raw(*their),
+                ancestor: match ancestor.is_null() {
+                    false => Some(IndexEntry::from_raw(*ancestor)),
+                    true  => None,
+                },
+                our: match our.is_null() {
+                    false => Some(IndexEntry::from_raw(*our)),
+                    true  => None,
+                },
+                their: match their.is_null() {
+                    false => Some(IndexEntry::from_raw(*their)),
+                    true  => None,
+                },
             }))
         }
     }

src/repo.rs

@@ -1218,6 +1218,19 @@ impl Repository {
         }
     }
 
+    /// Lookup a reference to one of the objects in a repository.
+    /// `Repository::find_reference` with teeth; give the method your reference in
+    /// human-readable format e.g. 'master' instead of 'refs/heads/master', and it
+    /// will do-what-you-mean, returning the `Reference`.
+    pub fn find_reference_dwim(&self, refname: &str) -> Result<Reference, Error> {
+        let refname = try!(CString::new(refname));
+        let mut raw = ptr::null_mut();
+        unsafe {
+            try_call!(raw::git_reference_dwim(&mut raw, self.raw(), refname));
+            Ok(Binding::from_raw(raw))
+        }
+    }
+
     /// Lookup a reference by name and resolve immediately to OID.
     ///
     /// This function provides a quick way to resolve a reference name straight