threads / patch / 36989

patch, 4 partsgit replace --edit --raw

Subject: [PATCH 0/4] git replace --edit --raw

## tl;dr

9 messages between Jun 24, 2014 and Jun 26, 2014. Diffs are folded; open one to read it.

replies: 8people: 3as markdown or json

Jeff King· Jun 24, 2014, 09:42 UTC · lore

I tried to use "git replace --edit" today to repair a corrupted tree that had an empty filename:

  $ git replace --edit HEAD^{tree}
  fatal: empty filename in tree entry
  fatal: cat-file reported failure

Oops. One of the major purposes of the command is to repair broken objects. This series introduces a "--raw" option to let you easily edit the binary if need be.

The first two patches are unrelated cleanups I noticed in the area. The third is refactoring, and the final one is the interesting bit.

There's a minor textual conflict in the documentation with cc/replace-graft, but it's pretty straightforward to resolve.

  [1/4]: replace: replace spaces with tabs in indentation
  [2/4]: avoid double close of descriptors handed to run_command
  [3/4]: replace: use argv_array in export_object
  [4/4]: replace: add a --raw mode for --edit
-Peff
Jeff King· Jun 24, 2014, 09:43 UTC · re: Jeff King · lore

[PATCH 1/4] replace: replace spaces with tabs in indentation

This matches our usual style and the surrounding code.
Signed-off-by: Jeff King <peff@peff.net>
---
 builtin/replace.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
Show changes to builtin/replace.c +3 −3
diff --git a/builtin/replace.c b/builtin/replace.c
index 1bb491d..8507835 100644
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -23,9 +23,9 @@ static const char * const git_replace_usage[] = {
 };
 
 enum replace_format {
-      REPLACE_FORMAT_SHORT,
-      REPLACE_FORMAT_MEDIUM,
-      REPLACE_FORMAT_LONG
+	REPLACE_FORMAT_SHORT,
+	REPLACE_FORMAT_MEDIUM,
+	REPLACE_FORMAT_LONG
 };
 
 struct show_data {
-- 
2.0.0.566.gfe3e6b2
Jeff King· Jun 24, 2014, 09:45 UTC · re: Jeff King · lore

[PATCH 2/4] avoid double close of descriptors handed to run_command

When a file descriptor is given to run_command via the "in", "out", or "err" parameters, run_command takes ownership. The descriptor will be closed in the parent process whether the process is spawned successfully or not, and closing it again is wrong.

In practice this has not caused problems, because we usually close() right after start_command returns, meaning no other code has opened a descriptor in the meantime. So we just get EBADF and ignore it (rather than accidentally closing somebody else's descriptor!).

Signed-off-by: Jeff King <peff@peff.net>
---
I noticed the one in replace, and grepped around for other instances. I
think this is all of them. The only possible cases I didn't investigate
carefully were in send-pack/receive-pack. The logic there is quite
complicated, and I remember looking at and fixing close() issues there
not too long ago (e.g., 49ecfa1), so I assumed it was OK.
 builtin/replace.c | 2 --
 daemon.c          | 1 -
 2 files changed, 3 deletions(-)
Show changes to 2 files +0 −3

builtin/replace.c, daemon.c

diff --git a/builtin/replace.c b/builtin/replace.c
index 8507835..eb1d2ec 100644
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -207,8 +207,6 @@ static void export_object(const unsigned char *sha1, const char *filename)
 
 	if (run_command(&cmd))
 		die("cat-file reported failure");
-
-	close(fd);
 }
 
 /*
diff --git a/daemon.c b/daemon.c
index f9c63e9..e1e424d 100644
--- a/daemon.c
+++ b/daemon.c
@@ -775,7 +775,6 @@ static void handle(int incoming, struct sockaddr *addr, socklen_t addrlen)
 		logerror("unable to fork");
 	else
 		add_child(&cld, addr, addrlen);
-	close(incoming);
 }
 
 static void child_handler(int signo)
-- 
2.0.0.566.gfe3e6b2
Jeff King· Jun 24, 2014, 09:46 UTC · re: Jeff King · lore

[PATCH 3/4] replace: use argv_array in export_object

This is a little more verbose, but will make it easier to make parts of our command-line conditional (without resorting to magic numbers or lots of NULLs to get an appropriately sized argv array).

Signed-off-by: Jeff King <peff@peff.net>
---
 builtin/replace.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)
Show changes to builtin/replace.c +5 −3
diff --git a/builtin/replace.c b/builtin/replace.c
index eb1d2ec..2584170 100644
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -193,15 +193,17 @@ static int replace_object(const char *object_ref, const char *replace_ref, int f
  */
 static void export_object(const unsigned char *sha1, const char *filename)
 {
-	const char *argv[] = { "--no-replace-objects", "cat-file", "-p", NULL, NULL };
-	struct child_process cmd = { argv };
+	struct child_process cmd = { NULL };
 	int fd;
 
 	fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
 	if (fd < 0)
 		die_errno("unable to open %s for writing", filename);
 
-	argv[3] = sha1_to_hex(sha1);
+	argv_array_push(&cmd.args, "--no-replace-objects");
+	argv_array_push(&cmd.args, "cat-file");
+	argv_array_push(&cmd.args, "-p");
+	argv_array_push(&cmd.args, sha1_to_hex(sha1));
 	cmd.git_cmd = 1;
 	cmd.out = fd;
 
-- 
2.0.0.566.gfe3e6b2
Jeff King· Jun 24, 2014, 09:46 UTC · re: Jeff King · lore

[PATCH 4/4] replace: add a --raw mode for --edit

One of the purposes of "git replace --edit" is to help a user repair objects which are malformed or corrupted. Usually we pretty-print trees with "ls-tree", which is much easier to work with than the raw binary data. However, some forms of corruption break the tree-walker, in which case our pretty-printing fails, rendering "--edit" useless for the user.

This patch introduces a "--raw" option, which lets you edit the binary data in these instances.

Signed-off-by: Jeff King <peff@peff.net>
---
 Documentation/git-replace.txt |  8 ++++++++
 builtin/replace.c             | 31 +++++++++++++++++++++----------
 2 files changed, 29 insertions(+), 10 deletions(-)
Show changes to 2 files +29 −10

Documentation/git-replace.txt, builtin/replace.c

diff --git a/Documentation/git-replace.txt b/Documentation/git-replace.txt
index 61461b9..089dcac 100644
--- a/Documentation/git-replace.txt
+++ b/Documentation/git-replace.txt
@@ -73,6 +73,14 @@ OPTIONS
 	newly created object. See linkgit:git-var[1] for details about
 	how the editor will be chosen.
 
+--raw::
+	When editing, provide the raw object contents rather than
+	pretty-printed ones. Currently this only affects trees, which
+	will be shown in their binary form. This is harder to work with,
+	but can help when repairing a tree that is so corrupted it
+	cannot be pretty-printed. Note that you may need to configure
+	your editor to cleanly read and write binary data.
+
 -l <pattern>::
 --list <pattern>::
 	List replace refs for objects that match the given pattern (or
diff --git a/builtin/replace.c b/builtin/replace.c
index 2584170..d1ea2c2 100644
--- a/builtin/replace.c
+++ b/builtin/replace.c
@@ -188,10 +188,12 @@ static int replace_object(const char *object_ref, const char *replace_ref, int f
 }
 
 /*
- * Write the contents of the object named by "sha1" to the file "filename",
- * pretty-printed for human editing based on its type.
+ * Write the contents of the object named by "sha1" to the file "filename".
+ * If "raw" is true, then the object's raw contents are printed according to
+ * "type". Otherwise, we pretty-print the contents for human editing.
  */
-static void export_object(const unsigned char *sha1, const char *filename)
+static void export_object(const unsigned char *sha1, enum object_type type,
+			  int raw, const char *filename)
 {
 	struct child_process cmd = { NULL };
 	int fd;
@@ -202,7 +204,10 @@ static void export_object(const unsigned char *sha1, const char *filename)
 
 	argv_array_push(&cmd.args, "--no-replace-objects");
 	argv_array_push(&cmd.args, "cat-file");
-	argv_array_push(&cmd.args, "-p");
+	if (raw)
+		argv_array_push(&cmd.args, typename(type));
+	else
+		argv_array_push(&cmd.args, "-p");
 	argv_array_push(&cmd.args, sha1_to_hex(sha1));
 	cmd.git_cmd = 1;
 	cmd.out = fd;
@@ -217,7 +222,7 @@ static void export_object(const unsigned char *sha1, const char *filename)
  * The sha1 of the written object is returned via sha1.
  */
 static void import_object(unsigned char *sha1, enum object_type type,
-			  const char *filename)
+			  int raw, const char *filename)
 {
 	int fd;
 
@@ -225,7 +230,7 @@ static void import_object(unsigned char *sha1, enum object_type type,
 	if (fd < 0)
 		die_errno("unable to open %s for reading", filename);
 
-	if (type == OBJ_TREE) {
+	if (!raw && type == OBJ_TREE) {
 		const char *argv[] = { "mktree", NULL };
 		struct child_process cmd = { argv };
 		struct strbuf result = STRBUF_INIT;
@@ -265,7 +270,7 @@ static void import_object(unsigned char *sha1, enum object_type type,
 	 */
 }
 
-static int edit_and_replace(const char *object_ref, int force)
+static int edit_and_replace(const char *object_ref, int force, int raw)
 {
 	char *tmpfile = git_pathdup("REPLACE_EDITOBJ");
 	enum object_type type;
@@ -281,10 +286,10 @@ static int edit_and_replace(const char *object_ref, int force)
 
 	check_ref_valid(old, prev, ref, sizeof(ref), force);
 
-	export_object(old, tmpfile);
+	export_object(old, type, raw, tmpfile);
 	if (launch_editor(tmpfile, NULL, NULL) < 0)
 		die("editing object file failed");
-	import_object(new, type, tmpfile);
+	import_object(new, type, raw, tmpfile);
 
 	free(tmpfile);
 
@@ -297,6 +302,7 @@ static int edit_and_replace(const char *object_ref, int force)
 int cmd_replace(int argc, const char **argv, const char *prefix)
 {
 	int force = 0;
+	int raw = 0;
 	const char *format = NULL;
 	enum {
 		MODE_UNSPECIFIED = 0,
@@ -310,6 +316,7 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
 		OPT_CMDMODE('d', "delete", &cmdmode, N_("delete replace refs"), MODE_DELETE),
 		OPT_CMDMODE('e', "edit", &cmdmode, N_("edit existing object"), MODE_EDIT),
 		OPT_BOOL('f', "force", &force, N_("replace the ref if it exists")),
+		OPT_BOOL(0, "raw", &raw, N_("do not pretty-print contents for --edit")),
 		OPT_STRING(0, "format", &format, N_("format"), N_("use this format")),
 		OPT_END()
 	};
@@ -329,6 +336,10 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
 		usage_msg_opt("-f only makes sense when writing a replacement",
 			      git_replace_usage, options);
 
+	if (raw && cmdmode != MODE_EDIT)
+		usage_msg_opt("--raw only makes sense with --edit",
+			      git_replace_usage, options);
+
 	switch (cmdmode) {
 	case MODE_DELETE:
 		if (argc < 1)
@@ -346,7 +357,7 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
 		if (argc != 1)
 			usage_msg_opt("-e needs exactly one argument",
 				      git_replace_usage, options);
-		return edit_and_replace(argv[0], force);
+		return edit_and_replace(argv[0], force, raw);
 
 	case MODE_LIST:
 		if (argc > 1)
-- 
2.0.0.566.gfe3e6b2
Eric Sunshine· Jun 25, 2014, 01:40 UTC · re: Jeff King · lore

Re: [PATCH 4/4] replace: add a --raw mode for --edit

On Tue, Jun 24, 2014 at 5:46 AM, Jeff King <peff@peff.net> wrote:
Show 10 quoted lines
> One of the purposes of "git replace --edit" is to help a
> user repair objects which are malformed or corrupted.
> Usually we pretty-print trees with "ls-tree", which is much
> easier to work with than the raw binary data.  However, some
> forms of corruption break the tree-walker, in which case our
> pretty-printing fails, rendering "--edit" useless for the
> user.
>
> This patch introduces a "--raw" option, which lets you edit
> the binary data in these instances.

Is there a possibility that any of the other git-replace modes will grow a need for "raw"? If not, would it make sense to make this specific to "edit" as --edit=raw?

Show 139 quoted lines
> Signed-off-by: Jeff King <peff@peff.net>
> ---
>  Documentation/git-replace.txt |  8 ++++++++
>  builtin/replace.c             | 31 +++++++++++++++++++++----------
>  2 files changed, 29 insertions(+), 10 deletions(-)
>
> diff --git a/Documentation/git-replace.txt b/Documentation/git-replace.txt
> index 61461b9..089dcac 100644
> --- a/Documentation/git-replace.txt
> +++ b/Documentation/git-replace.txt
> @@ -73,6 +73,14 @@ OPTIONS
>         newly created object. See linkgit:git-var[1] for details about
>         how the editor will be chosen.
>
> +--raw::
> +       When editing, provide the raw object contents rather than
> +       pretty-printed ones. Currently this only affects trees, which
> +       will be shown in their binary form. This is harder to work with,
> +       but can help when repairing a tree that is so corrupted it
> +       cannot be pretty-printed. Note that you may need to configure
> +       your editor to cleanly read and write binary data.
> +
>  -l <pattern>::
>  --list <pattern>::
>         List replace refs for objects that match the given pattern (or
> diff --git a/builtin/replace.c b/builtin/replace.c
> index 2584170..d1ea2c2 100644
> --- a/builtin/replace.c
> +++ b/builtin/replace.c
> @@ -188,10 +188,12 @@ static int replace_object(const char *object_ref, const char *replace_ref, int f
>  }
>
>  /*
> - * Write the contents of the object named by "sha1" to the file "filename",
> - * pretty-printed for human editing based on its type.
> + * Write the contents of the object named by "sha1" to the file "filename".
> + * If "raw" is true, then the object's raw contents are printed according to
> + * "type". Otherwise, we pretty-print the contents for human editing.
>   */
> -static void export_object(const unsigned char *sha1, const char *filename)
> +static void export_object(const unsigned char *sha1, enum object_type type,
> +                         int raw, const char *filename)
>  {
>         struct child_process cmd = { NULL };
>         int fd;
> @@ -202,7 +204,10 @@ static void export_object(const unsigned char *sha1, const char *filename)
>
>         argv_array_push(&cmd.args, "--no-replace-objects");
>         argv_array_push(&cmd.args, "cat-file");
> -       argv_array_push(&cmd.args, "-p");
> +       if (raw)
> +               argv_array_push(&cmd.args, typename(type));
> +       else
> +               argv_array_push(&cmd.args, "-p");
>         argv_array_push(&cmd.args, sha1_to_hex(sha1));
>         cmd.git_cmd = 1;
>         cmd.out = fd;
> @@ -217,7 +222,7 @@ static void export_object(const unsigned char *sha1, const char *filename)
>   * The sha1 of the written object is returned via sha1.
>   */
>  static void import_object(unsigned char *sha1, enum object_type type,
> -                         const char *filename)
> +                         int raw, const char *filename)
>  {
>         int fd;
>
> @@ -225,7 +230,7 @@ static void import_object(unsigned char *sha1, enum object_type type,
>         if (fd < 0)
>                 die_errno("unable to open %s for reading", filename);
>
> -       if (type == OBJ_TREE) {
> +       if (!raw && type == OBJ_TREE) {
>                 const char *argv[] = { "mktree", NULL };
>                 struct child_process cmd = { argv };
>                 struct strbuf result = STRBUF_INIT;
> @@ -265,7 +270,7 @@ static void import_object(unsigned char *sha1, enum object_type type,
>          */
>  }
>
> -static int edit_and_replace(const char *object_ref, int force)
> +static int edit_and_replace(const char *object_ref, int force, int raw)
>  {
>         char *tmpfile = git_pathdup("REPLACE_EDITOBJ");
>         enum object_type type;
> @@ -281,10 +286,10 @@ static int edit_and_replace(const char *object_ref, int force)
>
>         check_ref_valid(old, prev, ref, sizeof(ref), force);
>
> -       export_object(old, tmpfile);
> +       export_object(old, type, raw, tmpfile);
>         if (launch_editor(tmpfile, NULL, NULL) < 0)
>                 die("editing object file failed");
> -       import_object(new, type, tmpfile);
> +       import_object(new, type, raw, tmpfile);
>
>         free(tmpfile);
>
> @@ -297,6 +302,7 @@ static int edit_and_replace(const char *object_ref, int force)
>  int cmd_replace(int argc, const char **argv, const char *prefix)
>  {
>         int force = 0;
> +       int raw = 0;
>         const char *format = NULL;
>         enum {
>                 MODE_UNSPECIFIED = 0,
> @@ -310,6 +316,7 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
>                 OPT_CMDMODE('d', "delete", &cmdmode, N_("delete replace refs"), MODE_DELETE),
>                 OPT_CMDMODE('e', "edit", &cmdmode, N_("edit existing object"), MODE_EDIT),
>                 OPT_BOOL('f', "force", &force, N_("replace the ref if it exists")),
> +               OPT_BOOL(0, "raw", &raw, N_("do not pretty-print contents for --edit")),
>                 OPT_STRING(0, "format", &format, N_("format"), N_("use this format")),
>                 OPT_END()
>         };
> @@ -329,6 +336,10 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
>                 usage_msg_opt("-f only makes sense when writing a replacement",
>                               git_replace_usage, options);
>
> +       if (raw && cmdmode != MODE_EDIT)
> +               usage_msg_opt("--raw only makes sense with --edit",
> +                             git_replace_usage, options);
> +
>         switch (cmdmode) {
>         case MODE_DELETE:
>                 if (argc < 1)
> @@ -346,7 +357,7 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
>                 if (argc != 1)
>                         usage_msg_opt("-e needs exactly one argument",
>                                       git_replace_usage, options);
> -               return edit_and_replace(argv[0], force);
> +               return edit_and_replace(argv[0], force, raw);
>
>         case MODE_LIST:
>                 if (argc > 1)
> --
> 2.0.0.566.gfe3e6b2
> --
> To unsubscribe from this list: send the line "unsubscribe git" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
Jeff King· Jun 25, 2014, 10:24 UTC · re: Eric Sunshine · lore

Re: [PATCH 4/4] replace: add a --raw mode for --edit

On Tue, Jun 24, 2014 at 09:40:09PM -0400, Eric Sunshine wrote:
Show 15 quoted lines
> On Tue, Jun 24, 2014 at 5:46 AM, Jeff King <peff@peff.net> wrote:
> > One of the purposes of "git replace --edit" is to help a
> > user repair objects which are malformed or corrupted.
> > Usually we pretty-print trees with "ls-tree", which is much
> > easier to work with than the raw binary data.  However, some
> > forms of corruption break the tree-walker, in which case our
> > pretty-printing fails, rendering "--edit" useless for the
> > user.
> >
> > This patch introduces a "--raw" option, which lets you edit
> > the binary data in these instances.
> 
> Is there a possibility that any of the other git-replace modes will
> grow a need for "raw"? If not, would it make sense to make this
> specific to "edit" as --edit=raw?

I doubt that any other modes will want it, as it is about the pretty-printing step which is pretty specific to --edit. However, making it "--edit=raw" also precludes adding other "modes" to --edit. I do not have any in mind, but I do not see it as impossible.

Preclude is maybe a strong word. You could have "--edit=raw,flag1,flag2", but then we are essentially reinventing an option parser inside --edit's value. Not to mention that you cannot do "--no-raw", even without other flags being added.

-Peff
Junio C Hamano· Jun 25, 2014, 22:33 UTC · re: Jeff King · lore

Re: [PATCH 4/4] replace: add a --raw mode for --edit

Jeff King <peff@peff.net> writes:
Show 13 quoted lines
> One of the purposes of "git replace --edit" is to help a
> user repair objects which are malformed or corrupted.
> Usually we pretty-print trees with "ls-tree", which is much
> easier to work with than the raw binary data.  However, some
> forms of corruption break the tree-walker, in which case our
> pretty-printing fails, rendering "--edit" useless for the
> user.
>
> This patch introduces a "--raw" option, which lets you edit
> the binary data in these instances.
>
> Signed-off-by: Jeff King <peff@peff.net>
> ---

Hmmmmm, this feels almost like inviting accidents to make it easy and limiting the attempt to only one shot at the "transformation" step.

Will queue, but we can do the same with "cat-file $type >temp", do some transformation on "temp", doubly make sure what is in "temp" is sensible and then finally "hash-object -w -t $type temp". And it makes me feel uneasy that the new feature seems to make it harder to do the "doubly make sure" part.

I dunno.
Show 131 quoted lines
>  Documentation/git-replace.txt |  8 ++++++++
>  builtin/replace.c             | 31 +++++++++++++++++++++----------
>  2 files changed, 29 insertions(+), 10 deletions(-)
>
> diff --git a/Documentation/git-replace.txt b/Documentation/git-replace.txt
> index 61461b9..089dcac 100644
> --- a/Documentation/git-replace.txt
> +++ b/Documentation/git-replace.txt
> @@ -73,6 +73,14 @@ OPTIONS
>  	newly created object. See linkgit:git-var[1] for details about
>  	how the editor will be chosen.
>  
> +--raw::
> +	When editing, provide the raw object contents rather than
> +	pretty-printed ones. Currently this only affects trees, which
> +	will be shown in their binary form. This is harder to work with,
> +	but can help when repairing a tree that is so corrupted it
> +	cannot be pretty-printed. Note that you may need to configure
> +	your editor to cleanly read and write binary data.
> +
>  -l <pattern>::
>  --list <pattern>::
>  	List replace refs for objects that match the given pattern (or
> diff --git a/builtin/replace.c b/builtin/replace.c
> index 2584170..d1ea2c2 100644
> --- a/builtin/replace.c
> +++ b/builtin/replace.c
> @@ -188,10 +188,12 @@ static int replace_object(const char *object_ref, const char *replace_ref, int f
>  }
>  
>  /*
> - * Write the contents of the object named by "sha1" to the file "filename",
> - * pretty-printed for human editing based on its type.
> + * Write the contents of the object named by "sha1" to the file "filename".
> + * If "raw" is true, then the object's raw contents are printed according to
> + * "type". Otherwise, we pretty-print the contents for human editing.
>   */
> -static void export_object(const unsigned char *sha1, const char *filename)
> +static void export_object(const unsigned char *sha1, enum object_type type,
> +			  int raw, const char *filename)
>  {
>  	struct child_process cmd = { NULL };
>  	int fd;
> @@ -202,7 +204,10 @@ static void export_object(const unsigned char *sha1, const char *filename)
>  
>  	argv_array_push(&cmd.args, "--no-replace-objects");
>  	argv_array_push(&cmd.args, "cat-file");
> -	argv_array_push(&cmd.args, "-p");
> +	if (raw)
> +		argv_array_push(&cmd.args, typename(type));
> +	else
> +		argv_array_push(&cmd.args, "-p");
>  	argv_array_push(&cmd.args, sha1_to_hex(sha1));
>  	cmd.git_cmd = 1;
>  	cmd.out = fd;
> @@ -217,7 +222,7 @@ static void export_object(const unsigned char *sha1, const char *filename)
>   * The sha1 of the written object is returned via sha1.
>   */
>  static void import_object(unsigned char *sha1, enum object_type type,
> -			  const char *filename)
> +			  int raw, const char *filename)
>  {
>  	int fd;
>  
> @@ -225,7 +230,7 @@ static void import_object(unsigned char *sha1, enum object_type type,
>  	if (fd < 0)
>  		die_errno("unable to open %s for reading", filename);
>  
> -	if (type == OBJ_TREE) {
> +	if (!raw && type == OBJ_TREE) {
>  		const char *argv[] = { "mktree", NULL };
>  		struct child_process cmd = { argv };
>  		struct strbuf result = STRBUF_INIT;
> @@ -265,7 +270,7 @@ static void import_object(unsigned char *sha1, enum object_type type,
>  	 */
>  }
>  
> -static int edit_and_replace(const char *object_ref, int force)
> +static int edit_and_replace(const char *object_ref, int force, int raw)
>  {
>  	char *tmpfile = git_pathdup("REPLACE_EDITOBJ");
>  	enum object_type type;
> @@ -281,10 +286,10 @@ static int edit_and_replace(const char *object_ref, int force)
>  
>  	check_ref_valid(old, prev, ref, sizeof(ref), force);
>  
> -	export_object(old, tmpfile);
> +	export_object(old, type, raw, tmpfile);
>  	if (launch_editor(tmpfile, NULL, NULL) < 0)
>  		die("editing object file failed");
> -	import_object(new, type, tmpfile);
> +	import_object(new, type, raw, tmpfile);
>  
>  	free(tmpfile);
>  
> @@ -297,6 +302,7 @@ static int edit_and_replace(const char *object_ref, int force)
>  int cmd_replace(int argc, const char **argv, const char *prefix)
>  {
>  	int force = 0;
> +	int raw = 0;
>  	const char *format = NULL;
>  	enum {
>  		MODE_UNSPECIFIED = 0,
> @@ -310,6 +316,7 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
>  		OPT_CMDMODE('d', "delete", &cmdmode, N_("delete replace refs"), MODE_DELETE),
>  		OPT_CMDMODE('e', "edit", &cmdmode, N_("edit existing object"), MODE_EDIT),
>  		OPT_BOOL('f', "force", &force, N_("replace the ref if it exists")),
> +		OPT_BOOL(0, "raw", &raw, N_("do not pretty-print contents for --edit")),
>  		OPT_STRING(0, "format", &format, N_("format"), N_("use this format")),
>  		OPT_END()
>  	};
> @@ -329,6 +336,10 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
>  		usage_msg_opt("-f only makes sense when writing a replacement",
>  			      git_replace_usage, options);
>  
> +	if (raw && cmdmode != MODE_EDIT)
> +		usage_msg_opt("--raw only makes sense with --edit",
> +			      git_replace_usage, options);
> +
>  	switch (cmdmode) {
>  	case MODE_DELETE:
>  		if (argc < 1)
> @@ -346,7 +357,7 @@ int cmd_replace(int argc, const char **argv, const char *prefix)
>  		if (argc != 1)
>  			usage_msg_opt("-e needs exactly one argument",
>  				      git_replace_usage, options);
> -		return edit_and_replace(argv[0], force);
> +		return edit_and_replace(argv[0], force, raw);
>  
>  	case MODE_LIST:
>  		if (argc > 1)
Jeff King· Jun 26, 2014, 15:55 UTC · re: Junio C Hamano · lore

Re: [PATCH 4/4] replace: add a --raw mode for --edit

On Wed, Jun 25, 2014 at 03:33:42PM -0700, Junio C Hamano wrote:
Show 25 quoted lines
> Jeff King <peff@peff.net> writes:
> 
> > One of the purposes of "git replace --edit" is to help a
> > user repair objects which are malformed or corrupted.
> > Usually we pretty-print trees with "ls-tree", which is much
> > easier to work with than the raw binary data.  However, some
> > forms of corruption break the tree-walker, in which case our
> > pretty-printing fails, rendering "--edit" useless for the
> > user.
> >
> > This patch introduces a "--raw" option, which lets you edit
> > the binary data in these instances.
> >
> > Signed-off-by: Jeff King <peff@peff.net>
> > ---
> 
> Hmmmmm, this feels almost like inviting accidents to make it easy
> and limiting the attempt to only one shot at the "transformation"
> step.
> 
> Will queue, but we can do the same with "cat-file $type >temp", do
> some transformation on "temp", doubly make sure what is in "temp" is
> sensible and then finally "hash-object -w -t $type temp".  And it
> makes me feel uneasy that the new feature seems to make it harder to
> do the "doubly make sure" part.

I do not think it is any worse than "--edit" is by itself. True, editing the binary contents is hard, but we do check that the format is sane when we read it back in (using the same checks that hash-object does). I think it would be nice to take that a step further and actually let hash-object (and "replace --edit") do the more rigorous fsck checks on created objects.

I do still think even with those automated sanity checks that it makes sense to double-check the replacement manually. But I think that is one of the features of replace objects: you are not doing anything permanent, and can view the object in place. So not only can you examine the object by "git show $new_sha1", you can see it in place as "git log -p", etc. And easily back it out with "git replace -d" (or fix it up again with "git replace --edit") if need be.

-Peff

← back to recent threads