PBGitCommitController.m

   1 //
   2 //  PBGitCommitController.m
   3 //  GitX
   4 //
   5 //  Created by Pieter de Bie on 19-09-08.
   6 //  Copyright 2008 __MyCompanyName__. All rights reserved.
   7 //
   8
   9 #import "PBGitCommitController.h"
  10 #import "NSFileHandleExt.h"
  11 #import "PBChangedFile.h"
  12 #import "PBWebChangesController.h"
  13
  14
  15 @interface PBGitCommitController (PrivateMethods)
  16 - (NSArray *) linesFromNotification:(NSNotification *)notification;
  17 - (void) doneProcessingIndex;
  18 - (NSMutableDictionary *)dictionaryForLines:(NSArray *)lines;
  19 - (void) addFilesFromDictionary:(NSMutableDictionary *)dictionary staged:(BOOL)staged tracked:(BOOL)tracked;
  20 - (void)processHunk:(NSString *)hunk stage:(BOOL)stage reverse:(BOOL)reverse;
  21 @end
  22
  23 @implementation PBGitCommitController
  24
  25 @synthesize files, status, busy, amend;
  26
  27 - (void)awakeFromNib
  28 {
  29         self.files = [NSMutableArray array];
  30         [super awakeFromNib];
  31         [self refresh:self];
  32
  33         [commitMessageView setTypingAttributes:[NSDictionary dictionaryWithObject:[NSFont fontWithName:@"Monaco" size:12.0] forKey:NSFontAttributeName]];
  34
  35         [unstagedFilesController setFilterPredicate:[NSPredicate predicateWithFormat:@"hasUnstagedChanges == 1"]];
  36         [cachedFilesController setFilterPredicate:[NSPredicate predicateWithFormat:@"hasStagedChanges == 1"]];
  37
  38         [unstagedFilesController setSortDescriptors:[NSArray arrayWithObjects:
  39                 [[NSSortDescriptor alloc] initWithKey:@"status" ascending:false],
  40                 [[NSSortDescriptor alloc] initWithKey:@"path" ascending:true], nil]];
  41         [cachedFilesController setSortDescriptors:[NSArray arrayWithObject:
  42                 [[NSSortDescriptor alloc] initWithKey:@"path" ascending:true]]];
  43 }
  44 - (void) removeView
  45 {
  46         [webController closeView];
  47         [super finalize];
  48 }
  49
  50 - (void) setAmend:(BOOL)newAmend
  51 {
  52         if (newAmend == amend)
  53                 return;
  54         amend = newAmend;
  55
  56         // Replace commit message with the old one if it's less than 3 characters long.
  57         // This is just a random number.
  58         if (amend && [[commitMessageView string] length] <= 3) {
  59                 NSString *message = [repository outputForCommand:@"cat-file commit HEAD"];
  60                 NSRange r = [message rangeOfString:@"\n\n"];
  61                 if (r.location != NSNotFound)
  62                         message = [message substringFromIndex:r.location + 2];
  63
  64                 commitMessageView.string = message;
  65         }
  66
  67
  68         [self refresh:self];
  69 }
  70
  71 - (NSArray *) linesFromNotification:(NSNotification *)notification
  72 {
  73         NSDictionary *userInfo = [notification userInfo];
  74         NSData *data = [userInfo valueForKey:NSFileHandleNotificationDataItem];
  75         if (!data)
  76                 return NULL;
  77
  78         NSString* string = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
  79         if (!string)
  80                 return NULL;
  81
  82         // Strip trailing newline
  83         if ([string hasSuffix:@"\n"])
  84                 string = [string substringToIndex:[string length]-1];
  85
  86         NSArray *lines = [string componentsSeparatedByString:@"\0"];
  87         return lines;
  88 }
  89
  90 - (NSString *) parentTree
  91 {
  92         NSString *parent = amend ? @"HEAD^" : @"HEAD";
  93
  94         if (![repository parseReference:parent])
  95                 // We don't have a head ref. Return the empty tree.
  96                 return @"4b825dc642cb6eb9a060e54bf8d69288fbee4904";
  97
  98         return parent;
  99 }
 100
 101 - (void) refresh:(id) sender
 102 {
 103         if (![repository workingDirectory])
 104                 return;
 105
 106         self.status = @"Refreshing index…";
 107
 108         // If self.busy reaches 0, all tasks have finished
 109         self.busy = 0;
 110
 111         // Refresh the index, necessary for the next methods (that's why it's blocking)
 112         // FIXME: Make this non-blocking. This call can be expensive in large repositories
 113         [repository outputInWorkdirForArguments:[NSArray arrayWithObjects:@"update-index", @"-q", @"--unmerged", @"--ignore-missing", @"--refresh", nil]];
 114
 115         NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
 116         [nc removeObserver:self];
 117
 118         // Other files (not tracked, not ignored)
 119         NSArray *arguments = [NSArray arrayWithObjects:@"ls-files", @"--others", @"--exclude-standard", @"-z", nil];
 120         NSFileHandle *handle = [repository handleInWorkDirForArguments:arguments];
 121         [nc addObserver:self selector:@selector(readOtherFiles:) name:NSFileHandleReadToEndOfFileCompletionNotification object:handle];
 122         self.busy++;
 123         [handle readToEndOfFileInBackgroundAndNotify];
 124
 125         // Unstaged files
 126         handle = [repository handleInWorkDirForArguments:[NSArray arrayWithObjects:@"diff-files", @"-z", nil]];
 127         [nc addObserver:self selector:@selector(readUnstagedFiles:) name:NSFileHandleReadToEndOfFileCompletionNotification object:handle];
 128         self.busy++;
 129         [handle readToEndOfFileInBackgroundAndNotify];
 130
 131         // Staged files
 132         handle = [repository handleInWorkDirForArguments:[NSArray arrayWithObjects:@"diff-index", @"--cached", @"-z", [self parentTree], nil]];
 133         [nc addObserver:self selector:@selector(readCachedFiles:) name:NSFileHandleReadToEndOfFileCompletionNotification object:handle];
 134         self.busy++;
 135         [handle readToEndOfFileInBackgroundAndNotify];
 136 }
 137
 138 - (void) updateView
 139 {
 140         [self refresh:nil];
 141 }
 142
 143 // This method is called for each of the three processes from above.
 144 // If all three are finished (self.busy == 0), then we can delete
 145 // all files previously marked as deletable
 146 - (void) doneProcessingIndex
 147 {
 148         [self willChangeValueForKey:@"files"];
 149         if (!--self.busy) {
 150                 self.status = @"Ready";
 151                 for (PBChangedFile *file in files) {
 152                         if (!file.hasStagedChanges && !file.hasUnstagedChanges) {
 153                                 NSLog(@"Deleting file: %@", [file path]);
 154                                 [files removeObject:file];
 155                         }
 156                 }
 157         }
 158         [self didChangeValueForKey:@"files"];
 159 }
 160
 161 - (void) readOtherFiles:(NSNotification *)notification;
 162 {
 163         [unstagedFilesController setAutomaticallyRearrangesObjects:NO];
 164         NSArray *lines = [self linesFromNotification:notification];
 165         NSMutableDictionary *dictionary = [[NSMutableDictionary alloc] initWithCapacity:[lines count]];
 166         // We fake this files status as good as possible.
 167         NSArray *fileStatus = [NSArray arrayWithObjects:@":000000", @"100644", @"0000000000000000000000000000000000000000", @"0000000000000000000000000000000000000000", @"A", nil];
 168         for (NSString *path in lines) {
 169                 if ([path length] == 0)
 170                         continue;
 171                 [dictionary setObject:fileStatus forKey:path];
 172         }
 173         [self addFilesFromDictionary:dictionary staged:NO tracked:NO];
 174         [self doneProcessingIndex];
 175 }
 176
 177 - (NSMutableDictionary *)dictionaryForLines:(NSArray *)lines
 178 {
 179         NSMutableDictionary *dictionary = [NSMutableDictionary dictionaryWithCapacity:[lines count]/2];
 180
 181         // Fill the dictionary with the new information
 182         NSArray *fileStatus;
 183         BOOL even = FALSE;
 184         for (NSString *line in lines) {
 185                 if (!even) {
 186                         even = TRUE;
 187                         fileStatus = [line componentsSeparatedByString:@" "];
 188                         continue;
 189                 }
 190
 191                 even = FALSE;
 192                 [dictionary setObject:fileStatus forKey:line];
 193         }
 194         return dictionary;
 195 }
 196
 197 - (void) addFilesFromDictionary:(NSMutableDictionary *)dictionary staged:(BOOL)staged tracked:(BOOL)tracked
 198 {
 199         // Iterate over all existing files
 200         for (PBChangedFile *file in files) {
 201                 NSArray *fileStatus = [dictionary objectForKey:file.path];
 202                 // Object found, this is still a cached / uncached thing
 203                 if (fileStatus) {
 204                         if (tracked) {
 205                                 NSString *mode = [[fileStatus objectAtIndex:0] substringFromIndex:1];
 206                                 NSString *sha = [fileStatus objectAtIndex:2];
 207
 208                                 if (staged) {
 209                                         file.hasStagedChanges = YES;
 210                                         file.commitBlobSHA = sha;
 211                                         file.commitBlobMode = mode;
 212                                 } else
 213                                         file.hasUnstagedChanges = YES;
 214                         } else {
 215                                 // Untracked file, set status to NEW, only unstaged changes
 216                                 file.hasStagedChanges = NO;
 217                                 file.hasUnstagedChanges = YES;
 218                                 file.status = NEW;
 219                         }
 220                         [dictionary removeObjectForKey:file.path];
 221                 } else { // Object not found, let's remove it from the changes
 222                         if (staged)
 223                                 file.hasStagedChanges = NO;
 224                         else if (tracked && file.status != NEW) // Only remove it if it's not an untracked file. We handle that with the other thing
 225                                 file.hasUnstagedChanges = NO;
 226                         else if (!tracked && file.status == NEW)
 227                                 file.hasUnstagedChanges = NO;
 228                 }
 229         }
 230
 231         // Do new files
 232         for (NSString *path in [dictionary allKeys]) {
 233                 NSArray *fileStatus = [dictionary objectForKey:path];
 234
 235                 PBChangedFile *file = [[PBChangedFile alloc] initWithPath:path];
 236                 if ([[fileStatus objectAtIndex:4] isEqualToString:@"D"])
 237                         file.status = DELETED;
 238                 else if([[fileStatus objectAtIndex:0] isEqualToString:@":000000"])
 239                         file.status = NEW;
 240                 else
 241                         file.status = MODIFIED;
 242
 243                 if (staged) {
 244                         file.commitBlobMode = [[fileStatus objectAtIndex:0] substringFromIndex:1];
 245                         file.commitBlobSHA = [fileStatus objectAtIndex:2];
 246                 }
 247
 248                 file.hasStagedChanges = staged;
 249                 file.hasUnstagedChanges = !staged;
 250
 251                 [files addObject: file];
 252         }
 253 }
 254
 255 - (void) readUnstagedFiles:(NSNotification *)notification
 256 {
 257         NSArray *lines = [self linesFromNotification:notification];
 258         NSMutableDictionary *dic = [self dictionaryForLines:lines];
 259         [self addFilesFromDictionary:dic staged:NO tracked:YES];
 260         [self doneProcessingIndex];
 261 }
 262
 263 - (void) readCachedFiles:(NSNotification *)notification
 264 {
 265         NSArray *lines = [self linesFromNotification:notification];
 266         NSMutableDictionary *dic = [self dictionaryForLines:lines];
 267         [self addFilesFromDictionary:dic staged:YES tracked:YES];
 268         [self doneProcessingIndex];
 269 }
 270
 271 - (void) commitFailedBecause:(NSString *)reason
 272 {
 273         self.busy--;
 274         self.status = [@"Commit failed: " stringByAppendingString:reason];
 275         [[NSAlert alertWithMessageText:@"Commit failed"
 276                                          defaultButton:nil
 277                                    alternateButton:nil
 278                                            otherButton:nil
 279                  informativeTextWithFormat:reason] runModal];
 280         return;
 281 }
 282
 283 - (IBAction) commit:(id) sender
 284 {
 285         if ([[cachedFilesController arrangedObjects] count] == 0) {
 286                 [[NSAlert alertWithMessageText:@"No changes to commit"
 287                                                  defaultButton:nil
 288                                            alternateButton:nil
 289                                                    otherButton:nil
 290                          informativeTextWithFormat:@"You must first stage some changes before committing"] runModal];
 291                 return;
 292         }
 293
 294         NSString *commitMessage = [commitMessageView string];
 295         if ([commitMessage length] < 3) {
 296                 [[NSAlert alertWithMessageText:@"Commitmessage missing"
 297                                                  defaultButton:nil
 298                                            alternateButton:nil
 299                                                    otherButton:nil
 300                          informativeTextWithFormat:@"Please enter a commit message before committing"] runModal];
 301                 return;
 302         }
 303
 304         [cachedFilesController setSelectionIndexes:[NSIndexSet indexSet]];
 305         [unstagedFilesController setSelectionIndexes:[NSIndexSet indexSet]];
 306
 307         NSString *commitSubject;
 308         NSRange newLine = [commitMessage rangeOfString:@"\n"];
 309         if (newLine.location == NSNotFound)
 310                 commitSubject = commitMessage;
 311         else
 312                 commitSubject = [commitMessage substringToIndex:newLine.location];
 313
 314         commitSubject = [@"commit: " stringByAppendingString:commitSubject];
 315
 316         NSString *commitMessageFile;
 317         commitMessageFile = [repository.fileURL.path
 318                                                  stringByAppendingPathComponent:@"COMMIT_EDITMSG"];
 319
 320         [commitMessage writeToFile:commitMessageFile atomically:YES encoding:NSUTF8StringEncoding error:nil];
 321
 322         self.busy++;
 323         self.status = @"Creating tree..";
 324         NSString *tree = [repository outputForCommand:@"write-tree"];
 325         if ([tree length] != 40)
 326                 return [self commitFailedBecause:@"Could not create a tree"];
 327
 328         int ret;
 329
 330         NSMutableArray *arguments = [NSMutableArray arrayWithObjects:@"commit-tree", tree, nil];
 331         NSString *parent = amend ? @"HEAD^" : @"HEAD";
 332         if ([repository parseReference:parent]) {
 333                 [arguments addObject:@"-p"];
 334                 [arguments addObject:parent];
 335         }
 336
 337         NSString *commit = [repository outputForArguments:arguments
 338                                                                                   inputString:commitMessage
 339                                                                                          retValue: &ret];
 340
 341         if (ret || [commit length] != 40)
 342                 return [self commitFailedBecause:@"Could not create a commit object"];
 343
 344         if (![repository executeHook:@"pre-commit" output:nil])
 345                 return [self commitFailedBecause:@"Pre-commit hook failed"];
 346
 347         if (![repository executeHook:@"commit-msg" withArgs:[NSArray arrayWithObject:commitMessageFile] output:nil])
 348     return [self commitFailedBecause:@"Commit-msg hook failed"];
 349
 350         [repository outputForArguments:[NSArray arrayWithObjects:@"update-ref", @"-m", commitSubject, @"HEAD", commit, nil]
 351                                                   retValue: &ret];
 352         if (ret)
 353                 return [self commitFailedBecause:@"Could not update HEAD"];
 354
 355         if (![repository executeHook:@"post-commit" output:nil])
 356                 [webController setStateMessage:[NSString stringWithFormat:@"Post-commit hook failed, however, successfully created commit %@", commit]];
 357         else
 358                 [webController setStateMessage:[NSString stringWithFormat:@"Successfully created commit %@", commit]];
 359
 360         repository.hasChanged = YES;
 361         self.busy--;
 362         [commitMessageView setString:@""];
 363         amend = NO;
 364         [self refresh:self];
 365         self.amend = NO;
 366 }
 367
 368 - (void) stageHunk:(NSString *)hunk reverse:(BOOL)reverse
 369 {
 370         [self processHunk:hunk stage:TRUE reverse:reverse];
 371 }
 372
 373 - (void)discardHunk:(NSString *)hunk
 374 {
 375         [self processHunk:hunk stage:FALSE reverse:TRUE];
 376 }
 377
 378 - (void)processHunk:(NSString *)hunk stage:(BOOL)stage reverse:(BOOL)reverse
 379 {
 380         NSMutableArray *array = [NSMutableArray arrayWithObjects:@"apply", nil];
 381         if (stage)
 382                 [array addObject:@"--cached"];
 383         if (reverse)
 384                 [array addObject:@"--reverse"];
 385
 386         int ret = 1;
 387         NSString *error = [repository outputForArguments:array
 388                                                                                  inputString:hunk
 389                                                                                         retValue:&ret];
 390
 391         // FIXME: show this error, rather than just logging it
 392         if (ret)
 393                 NSLog(@"Error: %@", error);
 394
 395         // TODO: We should do this smarter by checking if the file diff is empty, which is faster.
 396         [self refresh:self];
 397 }
 398
 399 @end