[PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Junio C Hamano]

This makes paths with 'nodiff' attribute not to produce
"textual" diffs from 'git-diff' family.

Signed-off-by: Junio C Hamano <junkio@cox.net>
---
 attr.c |   18 ------------------
 diff.c |   40 +++++++++++++++++++++++++++++++---------
 2 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/attr.c b/attr.c
index d35ae9e..bdbc4a3 100644
--- a/attr.c
+++ b/attr.c
@@ -299,21 +299,3 @@ int git_checkattr(const char *path, int num, struct git_attr_check *check)
 		rem = fill(path, pathlen, stk, check, num, rem);
 	return 0;
 }
-
-static void setup_binary_check(struct git_attr_check *check)
-{
-	static struct git_attr *attr_binary;
-
-	if (!attr_binary)
-		attr_binary = git_attr("binary", 6);
-	check->attr = attr_binary;
-}
-
-int git_path_is_binary(const char *path)
-{
-	struct git_attr_check attr_binary_check;
-
-	setup_binary_check(&attr_binary_check);
-	return (!git_checkattr(path, 1, &attr_binary_check) &&
-		(0 < attr_binary_check.isset));
-}
diff --git a/diff.c b/diff.c
index fbb79d7..bc4af5c 100644
--- a/diff.c
+++ b/diff.c
@@ -8,6 +8,7 @@
 #include "delta.h"
 #include "xdiff-interface.h"
 #include "color.h"
+#include "attr.h"
 
 #ifdef NO_FAST_WORKING_DIRECTORY
 #define FAST_WORKING_DIRECTORY 0
@@ -1051,13 +1052,34 @@ static void emit_binary_diff(mmfile_t *one, mmfile_t *two)
 	emit_binary_diff_body(two, one);
 }
 
+static void setup_nodiff_check(struct git_attr_check *check)
+{
+	static struct git_attr *attr_nodiff;
+
+	if (!attr_nodiff)
+		attr_nodiff = git_attr("nodiff", 6);
+	check->attr = attr_nodiff;
+}
+
 #define FIRST_FEW_BYTES 8000
-static int mmfile_is_binary(mmfile_t *mf)
+static int file_is_binary(struct diff_filespec *one)
 {
-	long sz = mf->size;
+	unsigned long sz;
+	struct git_attr_check attr_nodiff_check;
+
+	setup_nodiff_check(&attr_nodiff_check);
+	if (!git_checkattr(one->path, 1, &attr_nodiff_check) &&
+	    (0 < attr_nodiff_check.isset))
+		return 1;
+	if (!one->data) {
+		if (!DIFF_FILE_VALID(one))
+			return 0;
+		diff_populate_filespec(one, 0);
+	}
+	sz = one->size;
 	if (FIRST_FEW_BYTES < sz)
 		sz = FIRST_FEW_BYTES;
-	return !!memchr(mf->ptr, 0, sz);
+	return !!memchr(one->data, 0, sz);
 }
 
 static void builtin_diff(const char *name_a,
@@ -1114,7 +1136,7 @@ static void builtin_diff(const char *name_a,
 	if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
 		die("unable to read files to diff");
 
-	if (!o->text && (mmfile_is_binary(&mf1) || mmfile_is_binary(&mf2))) {
+	if (!o->text && (file_is_binary(one) || file_is_binary(two))) {
 		/* Quite common confusing case */
 		if (mf1.size == mf2.size &&
 		    !memcmp(mf1.ptr, mf2.ptr, mf1.size))
@@ -1190,7 +1212,7 @@ static void builtin_diffstat(const char *name_a, const char *name_b,
 	if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
 		die("unable to read files to diff");
 
-	if (mmfile_is_binary(&mf1) || mmfile_is_binary(&mf2)) {
+	if (file_is_binary(one) || file_is_binary(two)) {
 		data->is_binary = 1;
 		data->added = mf2.size;
 		data->deleted = mf1.size;
@@ -1228,7 +1250,7 @@ static void builtin_checkdiff(const char *name_a, const char *name_b,
 	if (fill_mmfile(&mf1, one) < 0 || fill_mmfile(&mf2, two) < 0)
 		die("unable to read files to diff");
 
-	if (mmfile_is_binary(&mf2))
+	if (file_is_binary(two))
 		return;
 	else {
 		/* Crazy xdl interfaces.. */
@@ -1805,8 +1827,8 @@ static void run_diff(struct diff_filepair *p, struct diff_options *o)
 
 		if (o->binary) {
 			mmfile_t mf;
-			if ((!fill_mmfile(&mf, one) && mmfile_is_binary(&mf)) ||
-			    (!fill_mmfile(&mf, two) && mmfile_is_binary(&mf)))
+			if ((!fill_mmfile(&mf, one) && file_is_binary(one)) ||
+			    (!fill_mmfile(&mf, two) && file_is_binary(two)))
 				abbrev = 40;
 		}
 		len += snprintf(msg + len, sizeof(msg) - len,
@@ -2701,7 +2723,7 @@ static int diff_get_patch_id(struct diff_options *options, unsigned char *sha1)
 			return error("unable to read files to diff");
 
 		/* Maybe hash p->two? into the patch id? */
-		if (mmfile_is_binary(&mf2))
+		if (file_is_binary(p->two))
 			continue;
 
 		len1 = remove_space(p->one->path, strlen(p->one->path));
-- 
1.5.1.1.784.g95e2

Re: [PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Johannes Sixt]

Junio C Hamano wrote:
> 
> This makes paths with 'nodiff' attribute not to produce
> "textual" diffs from 'git-diff' family.

If saying "nodiff" can be made equivalent to "!diff", then I'd strongly
prefer an attribute "diff" over "nodiff". I'm a strong disbeliever in
double negation.

-- Hannes "Can't we not have no double negation please?" Sixt

Re: [PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Andy Parkins]

On Friday 2007, April 13, Johannes Sixt wrote:

> -- Hannes "Can't we not have no double negation please?" Sixt

There's nothing wrong with double negatives per se.  They often confer 
more meaning than simple logic would suggest.

For example:

 I can't not hate CVS
 I hate CVS

Logically identical, but semantically different.  In the first, the 
speak would be suggesting that they've tried, but failed, to like CVS; 
in the second the speaker just hates it.  Language isn't logic, it's 
fuzzy logic :-).

The reason I think it's relevant to bring this up is that I think 
identifier naming in programming should try to use language to lead the 
reader down the same thought path as the writer.

You want a flag that controls whether a thread is running - should it be 
called RunFlag or StopFlag?

 while( RunFlag )

 while( !StopFlag )

I think that the context is important.

I, personally, wouldn't like to say which is correct in that case - or 
in the "nodiff"/"!diff" question.  However, I don't think it's correct 
to universally rule out all double negative use - they have their 
place.



Andy

-- 
Dr Andy Parkins, M Eng (hons), MIET
andyparkins@gmail.com

Re: [PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Johannes Sixt]

Andy Parkins wrote:
> I, personally, wouldn't like to say which is correct in that case - or
> in the "nodiff"/"!diff" question.  However, I don't think it's correct
> to universally rule out all double negative use - they have their
> place.

Yet in Junio's introductory message, the example was

        *       crlf !nodiff

and it made me think: huh? And then again: huh?

I don't mind if you call me dumb now, but even an intelligent person
will have to think a second or two about the meaning. That's plainly not
necessary. In particular, where there can be no difference between
"diff" and "!nodiff".

-- Hannes

Re: [PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Andy Parkins]

On Friday 2007, April 13, Johannes Sixt wrote:

> Yet in Junio's introductory message, the example was
>
>         *       crlf !nodiff
>
> and it made me think: huh? And then again: huh?
>
> I don't mind if you call me dumb now, but even an intelligent person

Wouldn't dream of it.

> will have to think a second or two about the meaning. That's plainly
> not necessary. In particular, where there can be no difference
> between "diff" and "!nodiff".

As I said, I wouldn't like to make the call.

I understand your point - however I think I understand why Junio chose 
nodiff as the attribute.  I would imagine that git /wants/ to show a 
textual diff for everything as its default.  In that case, the 
attribute that you would assign to the least number of files 
is "nodiff".  Mostly you want diffs, so the attribute implemented is 
for the special case and is "nodiff".

If I've understood the attributes system correctly, it's worth bearing 
in mind that "!diff" is not the same as "nodiff".  The not in "!diff" 
means "supress the attribute diff", not as you would traditionally 
imagine "not-diff".  In this case it doesn't matter because there are 
only two possibilities for the diff engine - show the diff or don't.  
However, more attributes might get added that aren't so simple.

Junio - This makes me think that perhaps "!" is not the right symbol for 
this - that's going to get read by programmers everywhere as NOT, 
rather than suppress.  Perhaps it doesn't matter, I might be 
over-thinking this.



Andy

-- 
Dr Andy Parkins, M Eng (hons), MIET
andyparkins@gmail.com

Re: [PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Nicolas Pitre]

On Fri, 13 Apr 2007, Andy Parkins wrote:

> If I've understood the attributes system correctly, it's worth bearing 
> in mind that "!diff" is not the same as "nodiff".  The not in "!diff" 
> means "supress the attribute diff", not as you would traditionally 
> imagine "not-diff".  In this case it doesn't matter because there are 
> only two possibilities for the diff engine - show the diff or don't.  
> However, more attributes might get added that aren't so simple.
> 
> Junio - This makes me think that perhaps "!" is not the right symbol for 
> this - that's going to get read by programmers everywhere as NOT, 
> rather than suppress.  Perhaps it doesn't matter, I might be 
> over-thinking this.

Maybe "-" then?  That better convey the notion of suppression while "!" 
is more about negation.


Nicolas

Re: [PATCH 3/3] Teach 'diff' about 'nodiff' attribute.

[Julian Phillips]

On Fri, 13 Apr 2007, Nicolas Pitre wrote:

> On Fri, 13 Apr 2007, Andy Parkins wrote:
>
>> If I've understood the attributes system correctly, it's worth bearing
>> in mind that "!diff" is not the same as "nodiff".  The not in "!diff"
>> means "supress the attribute diff", not as you would traditionally
>> imagine "not-diff".  In this case it doesn't matter because there are
>> only two possibilities for the diff engine - show the diff or don't.
>> However, more attributes might get added that aren't so simple.
>>
>> Junio - This makes me think that perhaps "!" is not the right symbol for
>> this - that's going to get read by programmers everywhere as NOT,
>> rather than suppress.  Perhaps it doesn't matter, I might be
>> over-thinking this.
>
> Maybe "-" then?  That better convey the notion of suppression while "!"
> is more about negation.

"-flag" will certainly be a more familiar way to say "disable flag" to 
gentoo users ... ;)

-- 
Julian

  ---
Lie, n.:
 	A very poor substitute for the truth, but the only one
 	discovered to date.