ostree-repo-resolve-rev: Add function to accept a partial checksum

This patch adds a function that will parse a partial checksum when
resolving a refspec.  If the inputted refspec matches a truncated
existing checksum, it will return that checksum to be parsed.  If
multiple truncated checksums match the partial refspec, it is not
unique and will return false.  This addition is inspired by the same
functionality in Docker, which allows a user to reference a specific
commit without typing the entire checksum.

partial checksums: Add function to abstract comparison

This modifies the list_objects and list_objects_at functions
to take an additional argument for the string that a commit starts
with.  If this string arg is not null, it will only list commit
objects beginning with that string.  This allows for a new function
ostree_repo_list_commit_objects_starting_with to pass a partial string
and return a list of all matching commits.  This improves on the
previous strategy of listing refs because it will list all commit objects,
even ones in past history.  This update also includes bugfixes on
error handling and string comparison, and changes the output structure
of resolve_partial_checksum. The new strcuture will no longer return FALSE
without error.  Also, the hashtable foreach now uses iter.  Also
includes modified test file

src/libostree/ostree-repo.c

@@ -990,12 +990,14 @@ list_loose_objects_at (OstreeRepo             *self,
                        GHashTable             *inout_objects,
                        const char             *prefix,
                        int                     dfd,
+                       const char             *commit_starting_with,
                        GCancellable           *cancellable,
                        GError                **error)
 {
   gboolean ret = FALSE;
   DIR *d = NULL;
   struct dirent *dent;
+  GVariant *key, *value;
 
   d = fdopendir (dfd);
   if (!d)
@@ -1030,21 +1032,33 @@ list_loose_objects_at (OstreeRepo             *self,
       else
         continue;
 
-      if ((dot - name) == 62)
+      if ((dot - name) != 62)
+        continue;
+
+      memcpy (buf, prefix, 2);
+      memcpy (buf + 2, name, 62);
+      buf[sizeof(buf)-1] = '\0';
+
+      /* if we passed in a "starting with" argument, then
+         we only want to return .commit objects with a checksum
+         that matches the commit_starting_with argument */
+      if (commit_starting_with)
         {
-          GVariant *key, *value;
+          /* object is not a commit, do not add to array */
+          if (objtype != OSTREE_OBJECT_TYPE_COMMIT)
+              continue;
 
-          memcpy (buf, prefix, 2);
-          memcpy (buf + 2, name, 62);
-          buf[sizeof(buf)-1] = '\0';
-
-          key = ostree_object_name_serialize (buf, objtype);
-          value = g_variant_new ("(b@as)",
-                                 TRUE, g_variant_new_strv (NULL, 0));
-          /* transfer ownership */
-          g_hash_table_replace (inout_objects, key,
-                                g_variant_ref_sink (value));
+          /* commit checksum does not match "starting with", do not add to array */     
+          if (!g_str_has_prefix (buf, commit_starting_with))
+            continue;
         }
+
+        key = ostree_object_name_serialize (buf, objtype);
+        value = g_variant_new ("(b@as)",
+                               TRUE, g_variant_new_strv (NULL, 0));
+        /* transfer ownership */
+        g_hash_table_replace (inout_objects, key,
+                              g_variant_ref_sink (value));
     }
 
   ret = TRUE;
@@ -1057,6 +1071,7 @@ list_loose_objects_at (OstreeRepo             *self,
 static gboolean
 list_loose_objects (OstreeRepo                     *self,
                     GHashTable                     *inout_objects,
+                    const char                     *commit_starting_with,
                     GCancellable                   *cancellable,
                     GError                        **error)
 {
@@ -1084,7 +1099,8 @@ list_loose_objects (OstreeRepo                     *self,
         }
       /* Takes ownership of dfd */
       if (!list_loose_objects_at (self, inout_objects, buf, dfd,
-                                  cancellable, error))
+                                       commit_starting_with,
+                                       cancellable, error))
         goto out;
     }
 
@@ -1702,11 +1718,11 @@ ostree_repo_list_objects (OstreeRepo                  *self,
 
   if (flags & OSTREE_REPO_LIST_OBJECTS_LOOSE)
     {
-      if (!list_loose_objects (self, ret_objects, cancellable, error))
+      if (!list_loose_objects (self, ret_objects, NULL, cancellable, error))
         goto out;
       if (self->parent_repo)
         {
-          if (!list_loose_objects (self->parent_repo, ret_objects, cancellable, error))
+          if (!list_loose_objects (self->parent_repo, ret_objects, NULL, cancellable, error))
             goto out;
         }
     }
@@ -1722,6 +1738,53 @@ ostree_repo_list_objects (OstreeRepo                  *self,
   return ret;
 }
 
+/**
+ * ostree_repo_list_commit_objects_starting_with:
+ * @self: Repo
+ * @start: List commits starting with this checksum
+ * @out_commits: Array of GVariants
+ * @cancellable: Cancellable
+ * @error: Error
+ *
+ * This function synchronously enumerates all commit objects starting
+ * with @start, returning data in @out_commits.
+ *
+ * Returns: %TRUE on success, %FALSE on error, and @error will be set
+ */
+gboolean
+ostree_repo_list_commit_objects_starting_with (OstreeRepo                  *self,
+                                               const char                  *start,
+                                               GHashTable                 **out_commits,
+                                               GCancellable                *cancellable,
+                                               GError                     **error)
+{
+  gboolean ret = FALSE;
+  gs_unref_hashtable GHashTable *ret_commits = NULL;
+
+  g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
+  g_return_val_if_fail (self->inited, FALSE);
+
+  ret_commits = g_hash_table_new_full (ostree_hash_object_name, g_variant_equal,
+                                       (GDestroyNotify) g_variant_unref,
+                                       (GDestroyNotify) g_variant_unref);
+
+  if (!list_loose_objects (self, ret_commits, start, cancellable, error))
+        goto out;
+
+
+  if (self->parent_repo)
+    {
+      if (!list_loose_objects (self->parent_repo, ret_commits, start,
+                               cancellable, error))
+        goto out;
+    }
+
+  ret = TRUE;
+  ot_transfer_out_value (out_commits, &ret_commits);
+ out:
+  return ret;
+}
+
 /**
  * ostree_repo_read_commit:
  * @self: Repo