Fossil

** tree.  Return TRUE on success.  On failure, print and error
** message and quit if the errFatal flag is true.  If errFatal is
** false, then simply return 0.
**
** The root of the tree is defined by the g.zLocalRoot variable.
*/
int file_tree_name(const char *zOrigName, Blob *pOut, int errFatal){
  int m,n;
  Blob full;
  db_must_be_within_tree();
  file_canonical_name(zOrigName, &full);
  n = strlen(g.zLocalRoot);
  m = blob_size(&full);
  if( m<n-1 || memcmp(g.zLocalRoot, blob_buffer(&full), n-1) ){
    blob_reset(&full);
    if( errFatal ){
      fossil_fatal("file outside of checkout tree: %s", zOrigName);
    }
    return 0;
  }
  blob_zero(pOut);
  if (m == n - 1)
     return 1;
  blob_append(pOut, blob_buffer(&full)+n, blob_size(&full)-n);
  return 1;
}

/*
** COMMAND:  test-tree-name
**

*/
#include "config.h"
#include "finfo.h"

/*
** COMMAND: finfo
** 
** Usage: %fossil finfo {?-l|--log? / -s|--status / --p|--print} FILENAME
**
** Print the complete change history for a single file going backwards
** in time.  The default is -l.
**
** For the -l|--log option: If "-b|--brief" is specified one line per revision
** is printed, otherwise the full comment is printed.  The "--limit N"
** and "--offset P" options limits the output to the first N changes
** after skipping P changes.
**
** In the -s form prints the status as <status> <revision>.  This is
** a quick status and does not check for up-to-date-ness of the file.
**
** The -p form, there's an optional flag "-r|--revision REVISION".  The
** specified version (or the latest checked out version) is printed to
** stdout.
**
** Print the change history for a single file.
**
** The "--limit N" and "--offset P" options limit the output to the first
** N changes after skipping P changes.
*/
void finfo_cmd(void){

  int vid;






  db_must_be_within_tree();
  vid = db_lget_int("checkout", 0);
  if( vid==0 ){
    fossil_panic("no checkout to finfo files in");
  }
  vfile_check_signature(vid, 1);
  if (find_option("status","s",0)) {
      Stmt q;
      Blob line;
      Blob fname;


      if (g.argc != 3) {
	  usage("-s|--status FILENAME");
      }
      file_tree_name(g.argv[2], &fname, 1);
      db_prepare(&q,
		 "SELECT pathname, deleted, rid, chnged, coalesce(origname!=pathname,0)"
		 "  FROM vfile WHERE vfile.pathname=%B", &fname);
      blob_zero(&line);
      if ( db_step(&q)==SQLITE_ROW ) {
	  Blob uuid;
	  int isDeleted = db_column_int(&q, 1);
	  int isNew = db_column_int(&q,2) == 0;
	  int chnged = db_column_int(&q,3);
	  int renamed = db_column_int(&q,4);

	  blob_zero(&uuid);
	  db_blob(&uuid,"SELECT uuid FROM blob, mlink, vfile WHERE "
		  "blob.rid = mlink.mid AND mlink.fid = vfile.rid AND "
		  "vfile.pathname=%B",&fname);
	  if (isNew) {
	      blob_appendf(&line, "new");
	  } else if (isDeleted) {
	      blob_appendf(&line, "deleted");
	  } else if (renamed) {
	      blob_appendf(&line, "renamed");
	  } else if (chnged) {
	      blob_appendf(&line, "edited");
	  } else {
	      blob_appendf(&line, "unchanged");
	  }
	  blob_appendf(&line, " ");
	  blob_appendf(&line, " %10.10s", blob_str(&uuid));
	  blob_reset(&uuid);
      } else {
	  blob_appendf(&line, "unknown 0000000000");
      }
      db_finalize(&q);
      printf("%s\n", blob_str(&line));
      blob_reset(&fname);
      blob_reset(&line);
  } else if (find_option("print","p",0)) {
      Blob record;
      Blob fname;
      const char *zRevision = find_option("revision", "r", 1);




      file_tree_name(g.argv[2], &fname, 1);
      if (zRevision) {
	  historical_version_of_file(zRevision, blob_str(&fname), &record, 0);
      } else {
	  int rid = db_int(0, "SELECT rid FROM vfile WHERE pathname=%B", &fname);
	  if( rid==0 ){

	      fossil_fatal("no history for file: %b", &fname);
	  }
	  content_get(rid, &record);
      }
      blob_write_to_file(&record, "-");
      blob_reset(&record);
      blob_reset(&fname);
  } else {
      Blob line;
      Stmt q;
      Blob fname;

      int rid;
      const char *zFilename;

      const char *zLimit;
      const char *zOffset;
      int iLimit, iOffset, iBrief;
 
      if (find_option("log","l",0)) { /* this is the default, no-op */
      }
      zLimit = find_option("limit",0,1);
      iLimit = zLimit ? atoi(zLimit) : -1;
      zOffset = find_option("offset",0,1);
      iOffset = zOffset ? atoi(zOffset) : 0;
      iBrief = (find_option("brief","b",0) == 0);
      if (g.argc != 3) {
	  usage("?-l|--log? ?-b|--brief? FILENAME");
      }
      file_tree_name(g.argv[2], &fname, 1);
      rid = db_int(0, "SELECT rid FROM vfile WHERE pathname=%B", &fname);
      if( rid==0 ){
	  fossil_fatal("no history for file: %b", &fname);
      }
      zFilename = blob_str(&fname);
      db_prepare(&q,
		 "SELECT b.uuid, ci.uuid, date(event.mtime,'localtime'),"
		 "       coalesce(event.ecomment, event.comment),"
		 "       coalesce(event.euser, event.user)"
		 "  FROM mlink, blob b, event, blob ci"
		 " WHERE mlink.fnid=(SELECT fnid FROM filename WHERE name=%Q)"
		 "   AND b.rid=mlink.fid"
		 "   AND event.objid=mlink.mid"
		 "   AND event.objid=ci.rid"
		 " ORDER BY event.mtime DESC LIMIT %d OFFSET %d",
		 zFilename, iLimit, iOffset
	  );
      blob_zero(&line);
      if (iBrief) {
	  printf("History of %s\n", blob_str(&fname));
      }
      while( db_step(&q)==SQLITE_ROW ){
	  const char *zFileUuid = db_column_text(&q, 0);
	  const char *zCiUuid = db_column_text(&q,1);
	  const char *zDate = db_column_text(&q, 2);
	  const char *zCom = db_column_text(&q, 3);
	  const char *zUser = db_column_text(&q, 4);
	  char *zOut;
	  if (iBrief) {
	      printf("%s ", zDate);
	      zOut = sqlite3_mprintf("[%.10s] %s (user: %s, artifact: [%.10s])",
				     zCiUuid, zCom, zUser, zFileUuid);

	      comment_print(zOut, 11, 79);
	      sqlite3_free(zOut);
	  } else {
	      blob_reset(&line);
	      blob_appendf(&line, "%.10s ", zCiUuid);
	      blob_appendf(&line, "%.10s ", zDate);
	      blob_appendf(&line, "%8.8s ", zUser);
	      blob_appendf(&line,"%-40.40s\n", zCom );
	      comment_print(blob_str(&line), 0, 79);
	  }
      }
      db_finalize(&q);
      blob_reset(&fname);
  }
}


/*
** WEBPAGE: finfo
** URL: /finfo?name=FILENAME
**

      fossil_fatal("Multiple descendants");
    }
    tid = db_int(0, "SELECT rid FROM leaves, event"
                    " WHERE event.objid=leaves.rid"
                    " ORDER BY event.mtime DESC"); 
  }

  if( !verboseFlag && (tid==vid)) return;  /* Nothing to update */
  db_begin_transaction();
  vfile_check_signature(vid, 1);
  if( !nochangeFlag ) undo_begin();
  load_vfile_from_rid(tid);

  /*
  ** The record.fn field is used to match files against each other.  The

  db_finalize(&q);

  /* If FILES appear on the command-line, remove from the "fv" table
  ** every entry that is not named on the command-line.
  */
  if( g.argc>=4 ){
    Blob sql;              /* SQL statement to purge unwanted entries */

    Blob treename;         /* Normalized filename */
    int i;                 /* Loop counter */

    blob_zero(&sql);
    blob_append(&sql, "DELETE FROM fv WHERE ", -1);
    for(i=3; i<g.argc; i++){
      file_tree_name(g.argv[i], &treename, 1);
      if (file_isdir(g.argv[i]) == 1) {
	  if (blob_size(&treename) > 0) {
	      blob_appendf(&sql, "fn NOT GLOB '%b/*' ", &treename);
	  } else {
	      blob_appendf(&sql, "fn NOT GLOB '*' ");
	  }
      } else {
	  blob_appendf(&sql, "fn <> %B ", &treename);

      }
      if (i < g.argc - 1) {
	  blob_append(&sql, "AND ", -1);
      }
      blob_reset(&treename);
    }
    fprintf(stderr, "%s\n", blob_str(&sql));
    db_multi_exec(blob_str(&sql));
    blob_reset(&sql);
  }

  db_prepare(&q, 
    "SELECT fn, idv, ridv, idt, ridt, chnged FROM fv ORDER BY 1"
  );

        printf("***** Cannot merge binary file %s\n", zName);
      }
      blob_reset(&v);
      blob_reset(&e);
      blob_reset(&t);
      blob_reset(&r);
    }else if( verboseFlag ){
	if (chnged) {
	    printf("EDITED %s\n", zName);
	} else {
	    printf("UNCHANGED %s\n", zName);
	}
    }
    free(zFullPath);
  }
  db_finalize(&q);
  
  /*
  ** Clean up the mid and pid VFILE entries.  Then commit the changes.