public MergeViewer(Project p, string filename, string original, string myVersion, string newVersion)
        {
            InitializeComponent();

              gitFilename = filename;
              project = p;

              if (myVersion == null) {
            titleMe.Text += " (file was deleted)";
            deletedSide = 0;
              } else if (original == null) {
            titleMe.Text += " (file was added)";
              } else {
            titleMe.Text += " (file was modified)";
              }

              if (newVersion == null) {
            titleNew.Text += " (file was deleted)";
            deletedSide = 1;
            // Only one side can be deleted in a conflict, so deletedSide is either 0 or 1
              } else if (original == null) {
            titleNew.Text += " (file was added)";
              } else {
            titleNew.Text += " (file was modified)";
              }
        }
        public TextMergeViewer(Project p, string filename, string original, string myVersion, string newVersion)
            : base(p, filename, original, myVersion, newVersion)
        {
            this.filename = filename;
              this.myVersion = myVersion;
              this.newVersion = newVersion;

              if (original == null) {
            original = ""; // We don't really have to display anything differently.
            // Also, add-add conflicts don't need any special treatment.
              }

              ProcessDiff(original, myVersion, newVersion);
              InitializeEditor();

              // Select the first conflict, update the conflict indicators.
              conflictHover = new int[conflictBlocks.Count];
              conflictChoice = new int[conflictBlocks.Count];
              for (int i = 0; i < conflictChoice.Length; i++) {
            conflictHover[i] = conflictChoice[i] = -1;
              }
              SelectConflict(0);
              if (conflictBlocks.Count > 1) {
            nextConflict.IsEnabled = prevConflict.IsEnabled = true;
              }

              UpdateStatus();
        }
        public CommitForm(Project p)
        {
            InitializeComponent();
              Style = (Style)FindResource(typeof(Window));

              Title += " for " + p.name;
              project = p;
              GetChanges();
        }
        public BinaryMergeViewer(Project p, string filename, string original, string myVersion, string newVersion)
            : base(p, filename, original, myVersion, newVersion)
        {
            editMe.Visibility = editThem.Visibility = Visibility.Collapsed;
              revertMe.Visibility = revertThem.Visibility = Visibility.Collapsed;
              manualMerge.Visibility = Visibility.Collapsed;
              grid.RowDefinitions.Add(new RowDefinition { Height = GridLength.Auto });
              Grid.SetRow(actionsMe, 1);
              Grid.SetRow(actionsThem, 1);

              CreateFiles(filename, myVersion, newVersion);
              status.Text = "1 unresolved conflicts remaining.";
        }
        public ProjectHistory(Project p, string hash = null)
        {
            InitializeComponent();
              Style = (Style)FindResource(typeof(Window));

              Title += " for " + p.name;
              project = p;

              string dir = ProjectMonitor.GetProjectDirectory(project);
              ProcessReturn ret = GitWrapper.Log(dir);
              string[] commits = SentenceFilter.SplitLines(ret.Output.Trim());
              if (ret.ReturnValue != 0 || commits.Length == 0) {
            throw new InvalidRepositoryException(project);
              }
              var actualCommits = new string[commits.Length - 1];
              Array.Copy(commits, actualCommits, commits.Length - 1);

              var timestamp = (int)(Directory.GetLastWriteTimeUtc(dir) - epoch).TotalSeconds;
              projectHistory.Items.Add(CreateListViewItem("", "Current Version", "", timestamp));
              commitHashes = new List<string>();

              int cIndex = 1;
              int? hashIndex = null;
              if (actualCommits.Count() > 0 && hash == "HEAD") {
            hashIndex = 1;
              }

              foreach (var commit in actualCommits) {
            var match = Regex.Match(commit, "^([a-z0-9]+) '(.*?)' ([0-9]+) (.*)$");
            if (match.Success) {
              commitHashes.Add(match.Groups[1].Value);
              if (match.Groups[1].Value == hash) {
            hashIndex = cIndex;
              }
              cIndex++;
              projectHistory.Items.Add(CreateListViewItem(match.Groups[1].Value, match.Groups[4].Value,
              match.Groups[2].Value, int.Parse(match.Groups[3].Value)));
            }
              }

              if (hash != null && hashIndex == null) {
            MessageBox.Show("Could not find that revision. You may have to update the project.", "Version not found");
              }
              projectHistory.SelectedIndex = hashIndex ?? 0;
              projectHistory.ScrollIntoView(projectHistory.Items[projectHistory.SelectedIndex]);
              projectHistory.Focus();
        }
        public FileHistory(Project p, string filename, string hash = null)
        {
            InitializeComponent();
              Style = (Style)FindResource(typeof(Window));

              Title += " for " + filename + " (" + p.name + ")";
              project = p;
              this.filename = filename;
              gitFilename = filename.Replace(Path.DirectorySeparatorChar, '/');

              string dir = ProjectMonitor.GetProjectDirectory(p);
              ProcessReturn ret = GitWrapper.Log(dir, String.Format("-- \"{0}\"", filename));
              string[] commits = SentenceFilter.SplitLines(ret.Output.Trim());
              if (ret.ReturnValue != 0 || commits.Length == 0) {
            throw new InvalidRepositoryException(p);
              }

              fileData = new Dictionary<string, string>();
              hashes = new List<string>();
              fullpath = Util.PathCombine(dir, filename);
              fileData[""] = Util.ReadFile(fullpath);
              hashes.Add("");
              var timestamp = (int)(File.GetLastWriteTimeUtc(fullpath) - epoch).TotalSeconds;
              fileHistory.Items.Add(CreateListViewItem("", "Current Version", "", timestamp));
              int cIndex = 1;
              int? hashIndex = null;
              foreach (var commit in commits) {
            var match = Regex.Match(commit, "^([a-z0-9]+) '(.*?)' ([0-9]+) (.*)$");
            if (match.Success) {
              hashes.Add(match.Groups[1].Value);
              if (match.Groups[1].Value == hash) {
            hashIndex = cIndex;
              }
              cIndex++;
              fileHistory.Items.Add(CreateListViewItem(match.Groups[1].Value, match.Groups[4].Value,
              match.Groups[2].Value, int.Parse(match.Groups[3].Value)));
            }
              }

              if (hash != null && hashIndex == null) {
            MessageBox.Show("Could not find that version of the file. You may have to update the project.", "Version not found");
              }
              fileHistory.SelectedIndex = hashIndex ?? 0;
              fileHistory.ScrollIntoView(fileHistory.Items[fileHistory.SelectedIndex]);
              fileHistory.Focus();
        }
        public bool UploadProject(Project p, Window window, BackgroundWorker worker, bool progress = true)
        {
            LockProject(p.id);

              string dir = GetProjectDirectory(p);
              bool committed = false, success = false;
              string commitMsg = null;

              try {
            if (worker.CancellationPending) return false;

            Project updatedProject;
            lock (projects) {
              updatedProject = projects.Find(pr => pr.id == p.id);
            }
            if (!updatedProject.can_write) {
              window.Dispatcher.Invoke(new Action(() =>
            MessageBox.Show(window, "You don't have write access to this project.", "Not Authorized")
              ));
              return false;
            }

            while (true) {
              worker.ReportProgress(progress ? 25 : -1, "First, checking for updates...");
              if (!UpdateProject(p, window, worker, false)) {
            return false;
              }
              if (worker.CancellationPending) return false;

              GitWrapper.AddAll(dir);
              worker.ReportProgress(progress ? 50 : -1, "Saving your changes...");
              ProcessReturn ret = CheckReturn("status", GitWrapper.Status(dir), worker);
              if (worker.CancellationPending) return false;
              if (ret.Stdout.Trim() != "") {
            if (commitMsg == null) {
              CommitForm commitForm = null;
              window.Dispatcher.Invoke(new Action(() => {
                commitForm = new CommitForm(p);
                commitForm.ShowDialog();
              }));
              commitMsg = commitForm.savedMessage;
              if (commitMsg == null) {
                return false;
              }
            }
            CheckReturn("commit", GitWrapper.Commit(dir, commitMsg), worker);
            committed = true;
            if (worker.CancellationPending) return false;

            worker.ReportProgress(progress ? 75 : -1, "Uploading...");
            ret = GitWrapper.Push(dir);
            worker.ReportProgress(-1, ret.Output);
            if (ret.ReturnValue == 0) {
              worker.ReportProgress(progress ? 100 : -1, "Upload successful.");
              break;
            } else if (ret.Output.Contains("non-fast-forward")) {
              if (worker.CancellationPending) return false;
              committed = false;
              CheckReturn("reset", GitWrapper.Reset(dir, "HEAD^"), worker);
              MessageBoxResult resp = MessageBoxResult.Cancel;
              window.Dispatcher.Invoke(new Action(() =>
                resp = MessageBox.Show(window,
                  "Additional updates must be merged in. Continue?",
                  "Project Updated", MessageBoxButton.OKCancel)));
              if (resp == MessageBoxResult.Cancel) {
                return false;
              }
            } else if (ret.Output.Contains("not authorized")) {
              ShowError(window, "You don't have write access to this project anymore.");
              return false;
            } else {
              ShowError(window, "Could not connect to the SciGit servers. Please try again later.");
              return false;
            }
              } else {
            worker.ReportProgress(progress ? 100 : -1, "No changes to upload.");
            break;
              }
            }
            success = true;
            return true;
              } catch (Exception e) {
            throw e;
              } finally {
            if (!success && committed) {
              CheckReturn("reset", GitWrapper.Reset(dir, "HEAD^"), worker);
            } else if (success) {
              lock (editedProjects) {
            editedProjects.RemoveAll(pr => pr.id == p.id);
              }
            }
            UnlockProject(p.id);
              }
        }
 public bool CheckProject(Project p)
 {
     string dir = GetProjectDirectory(p);
       if (!Directory.Exists(dir) || !Directory.Exists(Path.Combine(dir, ".git"))) {
     var result = Util.ShowMessageBox("Project " + p.name + " seems to be corrupted. Do you want SciGit to repair it?\r\n" +
       "You may want to back up your files first.", "Project corrupted", MessageBoxButtons.YesNo);
     if (result == DialogResult.Yes) {
       return InitializeProject(p);
     }
     return false;
       }
       return true;
 }
 public static string GetProjectDirectory(Project p)
 {
     if (p.id == 0) {
     return Path.GetTempPath(); // for testing
       }
       return Util.PathCombine(GetProjectDirectory(), p.name);
 }
Exemple #10
0
 private void ProjectEdited(Project p)
 {
     if (!Settings.Default.AutoSave && (Settings.Default.NotifyMask & (int)NotifyFlags.NotifyUpload) != 0) {
     QueueBalloonTip("Project Edited",
                 "You made changes to project " + p.name + ". Click to upload your changes...",
                 CreateUploadProjectHandler(p));
       }
 }
Exemple #11
0
 private void ProjectUpdated(Project p)
 {
     if (!Settings.Default.AutoUpdate && (Settings.Default.NotifyMask & (int)NotifyFlags.NotifyUpdate) != 0) {
     QueueBalloonTip("Project Updated",
                 "Project " + p.name + " has been updated. Click to update the local version...",
                 CreateUpdateProjectHandler(p));
       }
 }
Exemple #12
0
        private void OpenFileHistory(Project p, string filename, string hash = null)
        {
            if (!projectMonitor.CheckProject(p)) return;

              string dir = ProjectMonitor.GetProjectDirectory(p);
              if (!File.Exists(Util.PathCombine(dir, filename))) {
            Util.ShowMessageBox("File " + filename + " does not exist. You may have to update the project.", "SciGit error");
              } else {
            FileHistory fh = null;
            try {
              fh = new FileHistory(p, filename, hash);
              ShowTop(fh);
            } catch (InvalidRepositoryException) {
              if (fh != null) fh.Hide();
              Util.ShowMessageBox("This file does not belong to a valid SciGit project.", "SciGit error");
            } catch (Exception e) {
              if (fh != null) fh.Hide();
              ErrorForm.Show(e);
            }
              }
        }
Exemple #13
0
 private void ProjectAdded(Project p)
 {
     if ((Settings.Default.NotifyMask & (int)NotifyFlags.NotifyAddDelete) != 0) {
     QueueBalloonTip("Project Added",
                 "Project " + p.name + (p.can_write ? "" : " (read-only)") +
                   " has been added. Click to open the project folder...", CreateOpenDirectoryHandler(p));
       }
 }
Exemple #14
0
 private EventHandler CreateUploadProjectHandler(Project p)
 {
     return (s, e) => {
     var progressForm = new ProgressForm("Uploading " + p.name, (form, bw) => projectMonitor.UploadProject(p, form, bw));
     ShowTop(progressForm);
       };
 }
Exemple #15
0
 public static ProcessReturn Clone(string dir, Project p, string options = "")
 {
     return ExecuteCommand(String.Format("clone git@{0}:r{1} {2} " + options, ServerHost, p.id, EscapeShellArg(p.name)), dir);
 }
        public bool UpdateProject(Project p, Window window, BackgroundWorker worker, bool progress = true)
        {
            LockProject(p.id);

              string dir = GetProjectDirectory(p);
              bool possibleCommit = false, rebaseStarted = false, success = false;
              ProcessReturn ret;

              try {
            if (worker.CancellationPending) return false;

            if (!Directory.Exists(dir)) {
              worker.ReportProgress(progress ? 25 : -1, "Repairing project...");
              MessageBoxResult result = MessageBox.Show("Project " + p.name + " does not exist. Would you like to re-create it?",
                                                    "Project does not exist", MessageBoxButton.YesNo);
              if (result == MessageBoxResult.Yes) {
            if (!InitializeProject(p)) {
              ShowError(window, "Could not obtain project from the SciGit servers. Please try again later.");
            } else {
              worker.ReportProgress(progress ? 100 : -1, "Repair and update successful.");
              return true;
            }
              }
              return false;
            }

            if (GitWrapper.RebaseInProgress(dir)) {
              GitWrapper.Rebase(dir, "--abort");
            }
            if (worker.CancellationPending) return false;

            worker.ReportProgress(progress ? 25 : -1, "Checking for updates...");
            ret = GitWrapper.Fetch(dir);
            worker.ReportProgress(-1, ret.Output);
            if (ret.ReturnValue != 0) {
              if (ret.Output.Contains("Not a git")) {
            MessageBoxResult res = MessageBox.Show("Project " + p.name + " seems to be corrupted. Do you want SciGit to repair it?\r\n" +
              "You may want to back up your files first.", "Project corrupted", MessageBoxButton.YesNo);
            if (res == MessageBoxResult.Yes) {
              string gitDir = Path.Combine(dir, ".git");
              if (Directory.Exists(gitDir)) {
                Directory.Delete(gitDir, true);
              }
              worker.ReportProgress(progress ? 30 : -1, "Repairing project...");
              if (!InitializeProject(p)) {
                ShowError(window, "Could not obtain project from the SciGit servers. Please try again later.");
                return false;
              }
              worker.ReportProgress(progress ? 35 : -1, "Checking for updates...");
              ret = GitWrapper.Fetch(dir);
              worker.ReportProgress(-1, ret.Output);
            } else {
              return false;
            }
              }
              if (ret.ReturnValue != 0) {
            ShowError(window, "Could not connect to the SciGit servers. Please try again later.");
            return false;
              }
            }

            while (true) {
              if (worker.CancellationPending) return false;

              // Reset commits until we get to something in common with FETCH_HEAD.
              ret = CheckReturn("merge-base", GitWrapper.MergeBase(dir, "HEAD", "FETCH_HEAD"), worker);
              string baseCommit = ret.Stdout.Trim();
              GitWrapper.Reset(dir, baseCommit);

              if (worker.CancellationPending) return false;

              // Make a temporary commit to facilitate merging.
              GitWrapper.AddAll(dir);
              worker.ReportProgress(-1, "Creating temporary commit...");
              ret = GitWrapper.Commit(dir, "tempCommit " + DateTime.Now);
              possibleCommit = true;
              worker.ReportProgress(-1, ret.Output);

              if (worker.CancellationPending) return false;

              worker.ReportProgress(progress ? 50 : -1, "Merging...");
              ret = GitWrapper.Rebase(dir, "FETCH_HEAD");
              worker.ReportProgress(-1, ret.Output);
              if (ret.Output.Contains("Permission denied")) {
            // One of the files is open.
            // If the return value isn't 0, there was a merge conflict on top of this (so abort the rebase)
            if (ret.ReturnValue == 0) {
              GitWrapper.Reset(dir, baseCommit);
            } else {
              rebaseStarted = true;
            }
            var match = Regex.Match(ret.Output, "error: unable to unlink old '(.*)' \\(Permission denied\\)");
            string file = "";
            if (match.Success) {
              file = "(" + match.Groups[1].Value + ") ";
            }
            var resp = MessageBox.Show("One of the project files is currently open " + file + "and cannot be edited. "
              + "Please save and close your changes before continuing.", "File Locked", MessageBoxButton.OKCancel);
            if (resp == MessageBoxResult.Cancel) {
              return false;
            }
            if (rebaseStarted) GitWrapper.Rebase(dir, "--abort");
              } else {
            break;
              }
            }

            if (ret.ReturnValue != 0) {
              rebaseStarted = true;
              if (worker.CancellationPending) return false;
              if (ret.Output.Contains("CONFLICT")) {
            MessageBoxResult resp = MessageBoxResult.Cancel;
            window.Dispatcher.Invoke(
              new Action(() => resp = MessageBox.Show(window, "Merge conflict(s) were detected. Would you like to resolve them now using the SciGit editor?\r\n" +
              "Please save any changes to open files before continuing.", "Merge Conflict", MessageBoxButton.OKCancel)));
            MergeResolver mr = null;
            Exception exception = null;
            if (resp == MessageBoxResult.OK) {
              window.Dispatcher.Invoke(new Action(() => {
                try {
                  mr = new MergeResolver(p);
                  mr.ShowDialog();
                } catch (Exception e) {
                  if (mr != null) mr.Hide();
                  exception = e;
                }
              }));
            }
            if (exception != null) throw new Exception("", exception);

            if (resp != MessageBoxResult.No && (mr == null || !mr.Saved)) {
              // Cancel the process here.
              return false;
            } else {
              GitWrapper.AddAll(dir);
              worker.ReportProgress(progress ? 75 : -1, "Continuing merge...");
              ret = GitWrapper.Rebase(dir, "--continue");
              worker.ReportProgress(-1, ret.Output);
              if (ret.ReturnValue != 0) {
                if (ret.Output.Contains("No changes")) {
                  // The temp commit was effectively ignored. Just skip it.
                  CheckReturn("rebase", GitWrapper.Rebase(dir, "--skip"), worker);
                } else {
                  throw new Exception("rebase: " + ret.Output);
                }
              }
              worker.ReportProgress(progress ? 100 : -1, "Merge successful.");
              success = true;
              rebaseStarted = false;
            }
              } else {
            throw new Exception("rebase: " + ret.Output);
              }
            } else {
              worker.ReportProgress(progress ? 100 : -1, ret.Output.Contains("up to date") ? "No changes." : "Changes merged without conflict.");
              success = true;
              if (progress && !ret.Output.Contains("up to date")) {
            var result = MessageBox.Show("Project " + p.name + " was successfully updated. Would you like to view the changes?",
                "Project updated", MessageBoxButton.YesNo);
            if (result == MessageBoxResult.Yes) {
              window.Dispatcher.Invoke(new Action(() => {
                var ph = new ProjectHistory(p, "HEAD");
                ph.Show();
              }));
            }
              }
            }
              } catch (Exception e) {
            throw new Exception("", e);
              } finally {
            if (rebaseStarted) GitWrapper.Rebase(dir, "--abort");
            if (possibleCommit) {
              // Reset commits until we get to something in common with FETCH_HEAD.
              ret = CheckReturn("merge-base", GitWrapper.MergeBase(dir, "HEAD", "FETCH_HEAD"), worker);
              CheckReturn("reset", GitWrapper.Reset(dir, ret.Stdout.Trim()), worker);
            }
            if (success) {
              lock (noAutoUpdateProjects) {
            noAutoUpdateProjects.Remove(p.id);
              }
              lock (updatedProjects) {
            updatedProjects.RemoveAll(pr => pr.id == p.id);
              }
            }
            UnlockProject(p.id);
              }

              return success;
        }
        public bool HasUpload(Project p)
        {
            string dir = GetProjectDirectory(p);
              if (!Directory.Exists(dir)) return false;

              ProcessReturn ret = GitWrapper.Status(dir);
              return ret.Stdout.Trim() != "";
        }
        public bool HasUpdate(Project p)
        {
            string dir = GetProjectDirectory(p);
              if (!Directory.Exists(dir)) return false;

              ProcessReturn ret = GitWrapper.GetLastCommit(dir);
              string lastHash = "";
              if (ret.ReturnValue == 0) {
            lastHash = ret.Stdout.Trim();
              }
              return lastHash != p.last_commit_hash;
        }
Exemple #19
0
 private EventHandler CreateOpenDirectoryHandler(Project p)
 {
     return (s, e) => Process.Start(ProjectMonitor.GetProjectDirectory(p));
 }
        private bool AutoUpdateProject(Project p, bool notify = true)
        {
            LockProject(p.id);

              string dir = GetProjectDirectory(p);
              bool possibleCommit = false, rebaseStarted = false, success = false;
              ProcessReturn ret;

              try {
            if (!Directory.Exists(dir)) {
              if (!InitializeProject(p)) {
            return false;
              }
              return true;
            }

            if (GitWrapper.RebaseInProgress(dir)) {
              GitWrapper.Rebase(dir, "--abort");
            }

            ret = GitWrapper.Fetch(dir);
            if (ret.ReturnValue != 0) {
              if (ret.Output.Contains("Not a git")) {
            MessageBoxResult res = MessageBox.Show("Project " + p.name + " seems to be corrupted. Do you want SciGit to repair it?\r\n" +
              "You may want to back up your files first.", "Project corrupted", MessageBoxButton.YesNo);
            if (res == MessageBoxResult.Yes) {
              string gitDir = Path.Combine(dir, ".git");
              if (Directory.Exists(gitDir)) {
                Directory.Delete(gitDir, true);
              }
              if (!InitializeProject(p)) {
                return false;
              }
              ret = GitWrapper.Fetch(dir);
            } else {
              DisableAutoUpdates(p);
            }
              }
              if (ret.ReturnValue != 0) {
            return false;
              }
            }

            while (true) {
              // Reset commits until we get to something in common with FETCH_HEAD.
              ret = CheckReturn("merge-base", GitWrapper.MergeBase(dir, "HEAD", "FETCH_HEAD"));
              string baseCommit = ret.Stdout.Trim();
              GitWrapper.Reset(dir, baseCommit);

              // Make a temporary commit to facilitate merging.
              GitWrapper.AddAll(dir);
              ret = GitWrapper.Commit(dir, "tempCommit " + DateTime.Now);
              possibleCommit = true;

              ret = GitWrapper.Rebase(dir, "FETCH_HEAD");
              if (ret.Output.Contains("Permission denied")) {
            // One of the files is open.
            // If the return value isn't 0, there was a merge conflict on top of this (so abort the rebase)
            if (ret.ReturnValue == 0) {
              GitWrapper.Reset(dir, baseCommit);
            } else {
              rebaseStarted = true;
            }
            var match = Regex.Match(ret.Output, "error: unable to unlink old '(.*)' \\(Permission denied\\)");
            string file = "";
            if (match.Success) {
              file = " (" + match.Groups[1].Value + ")";
            }
            var resp = Util.ShowMessageBox("Project " + p.name + " cannot be updated, as one of the project files is currently open" + file + ".\n"
              + "Please save and close your changes before continuing.", "File Locked", MessageBoxButtons.RetryCancel);
            if (resp == DialogResult.Cancel) {
              DisableAutoUpdates(p);
              return false;
            }
            if (rebaseStarted) GitWrapper.Rebase(dir, "--abort");
              } else {
            break;
              }
            }

            if (ret.ReturnValue != 0) {
              rebaseStarted = true;
              if (ret.Output.Contains("CONFLICT")) {
            var resp = Util.ShowMessageBox("Merge conflict(s) were detected in project " + p.name + ". Would you like to resolve them now using the SciGit editor?\r\n" +
              "Please save any changes to open files before continuing.", "Auto-update: merge conflict", MessageBoxButtons.OKCancel);
            MergeResolver mr = null;
            Exception exception = null;
            if (resp == DialogResult.OK) {
              parent.Invoke(new Action(() => {
                try {
                  mr = new MergeResolver(p);
                  mr.ShowDialog();
                } catch (Exception e) {
                  if (mr != null) mr.Hide();
                  exception = e;
                }
              }));
            }
            if (exception != null) throw new Exception("", exception);

            if (mr == null || !mr.Saved) {
              DisableAutoUpdates(p);
              return false;
            } else {
              GitWrapper.AddAll(dir);
              ret = GitWrapper.Rebase(dir, "--continue");
              if (ret.ReturnValue != 0) {
                if (ret.Output.Contains("No changes")) {
                  // The temp commit was effectively ignored. Just skip it.
                  CheckReturn("rebase", GitWrapper.Rebase(dir, "--skip"));
                } else {
                  throw new Exception("rebase: " + ret.Output);
                }
              }
              success = true;
              rebaseStarted = false;
            }
              } else {
            throw new Exception("rebase: " + ret.Output);
              }
            } else {
              success = true;
              if (!ret.Output.Contains("up to date") && notify) {
            DispatchCallbacks(projectAutoUpdatedCallbacks, p);
              }
            }
              } catch (Exception e) {
            return false;
              } finally {
            if (rebaseStarted) GitWrapper.Rebase(dir, "--abort");
            if (possibleCommit) {
              // Reset commits until we get to something in common with FETCH_HEAD.
              ret = CheckReturn("merge-base", GitWrapper.MergeBase(dir, "HEAD", "FETCH_HEAD"));
              CheckReturn("reset", GitWrapper.Reset(dir, ret.Stdout.Trim()));
            }
            if (success) {
              lock (updatedProjects) {
            updatedProjects.RemoveAll(pr => pr.id == p.id);
              }
            }
            UnlockProject(p.id);
              }

              return success;
        }
Exemple #21
0
 private EventHandler CreateViewProjectHistoryHandler(Project p, string hash = null)
 {
     return (s, e) => {
     if (!projectMonitor.CheckProject(p)) return;
     var ph = new ProjectHistory(p, hash);
     ShowTop(ph);
       };
 }
        private void AutoUploadProject(Project p)
        {
            LockProject(p.id);

              string dir = GetProjectDirectory(p);
              bool committed = false, success = false;

              try {
            Project updatedProject;
            lock (projects) {
              updatedProject = projects.Find(pr => pr.id == p.id);
            }
            if (!updatedProject.can_write) {
              return;
            }

            while (true) {
              if (!AutoUpdateProject(p, false)) {
            return;
              }

              GitWrapper.AddAll(dir);
              ProcessReturn ret = CheckReturn("status", GitWrapper.Status(dir));
              if (ret.Stdout.Trim() != "") {
            CheckReturn("commit", GitWrapper.Commit(dir, "autocommit"));
            committed = true;

            ret = GitWrapper.Push(dir);
            if (ret.ReturnValue == 0) {
              break;
            } else if (ret.Output.Contains("non-fast-forward")) {
              committed = false;
              CheckReturn("reset", GitWrapper.Reset(dir, "HEAD^"));
              // have to update; repeat the loop
              return;
            } else {
              return;
            }
              } else {
            break;
              }
            }
            success = true;
            messageCallback("Auto-save successful", "Changes to project " + p.name + " were uploaded successfully.");
              } catch (Exception e) {
            return;
              } finally {
            if (!success && committed) {
              GitWrapper.Reset(dir, "HEAD^");
            } else if (success) {
              lock (editedProjects) {
            editedProjects.RemoveAll(pr => pr.id == p.id);
              }
            }
            UnlockProject(p.id);
              }
        }
Exemple #23
0
        private void OpenProjectHistory(Project p, string hash = null)
        {
            if (!projectMonitor.CheckProject(p)) return;

              string dir = ProjectMonitor.GetProjectDirectory(p);
              if (!Directory.Exists(dir)) {
            Util.ShowMessageBox("Project does not exist.", "Error");
              } else {
            ProjectHistory ph = null;
            try {
              ph = new ProjectHistory(p, hash);
              ShowTop(ph);
            } catch (InvalidRepositoryException) {
              if (ph != null) ph.Hide();
              Util.ShowMessageBox("This file does not belong to a valid SciGit project.", "Error");
            } catch (Exception e) {
              if (ph != null) ph.Hide();
              ErrorForm.Show(e);
            }
              }
        }
 private void DisableAutoUpdates(Project p)
 {
     Util.ShowMessageBox("This project will not be automatically synced until the issue has been resolved.\n" +
     "Please manually update the project by right-clicking on the tray icon or the project folder to try again.",
     "Error updating project");
       lock (noAutoUpdateProjects) {
     noAutoUpdateProjects.Add(p.id);
       }
 }
Exemple #25
0
 private void ProjectAutoUpdated(Project p)
 {
     if ((Settings.Default.NotifyMask & (int)NotifyFlags.NotifyUpdate) != 0) {
     QueueBalloonTip("Project Updated",
                 "Project " + p.name + " has been successfully auto-updated. Click to view changes...",
                 CreateViewProjectHistoryHandler(p, "HEAD"));
       }
 }
 private void DispatchCallbacks(List<ProjectCallback> callbacks, Project p)
 {
     foreach (var callback in callbacks) {
     callback(p);
       }
 }
Exemple #27
0
 private void ProjectRemoved(Project p)
 {
     if ((Settings.Default.NotifyMask & (int)NotifyFlags.NotifyAddDelete) != 0) {
     QueueBalloonTip("Project Removed",
                 "You are no longer receiving updates for project " + p.name +
                   ". Click to open the project folder...", CreateOpenDirectoryHandler(p));
       }
 }
        private bool InitializeProject(Project p)
        {
            string dir = GetProjectDirectory();
              string pdir = Util.PathCombine(dir, p.name);
              ProcessReturn ret;

              lock (projectLocks) {
            if (!projectLocks.ContainsKey(p.id)) {
              projectLocks.Add(p.id, new Mutex());
            }
              }

              LockProject(p.id);

              try {
            if (Directory.Exists(pdir)) {
              if (!Directory.Exists(Util.PathCombine(pdir, ".git"))) {
            // Re-generate the .git directory only. Make a clone in a temp directory:
            string tempPath = Path.Combine(Util.GetTempPath(), p.name);
            if (Directory.Exists(tempPath)) {
              Directory.Delete(tempPath, true);
            }
            ret = GitWrapper.Clone(Util.GetTempPath(), p, "-n");
            if (ret.ReturnValue != 0) return false;
            Directory.Move(Path.Combine(tempPath, ".git"), Path.Combine(pdir, ".git"));
            return true;
              } else {
            return false;
              }
            }

            ret = GitWrapper.Clone(dir, p);
            if (ret.ReturnValue != 0) return false;
            dir = GetProjectDirectory(p);
            File.WriteAllText(Util.PathCombine(dir, ".git", "info", "attributes"), "* -merge -diff");
            // Ignore some common temporary files.
            string[] exclude = new string[] {"*~", "~*", "*.tmp", "*.scigitUpdated*", "*.swp"};
            File.WriteAllText(Util.PathCombine(dir, ".git", "info", "exclude"), String.Join("\n", exclude));
            return true;
              } catch (Exception ex) {
            Logger.LogException(ex);
            return false;
              } finally {
            UnlockProject(p.id);
              }
        }
Exemple #29
0
 public InvalidRepositoryException(Project p)
 {
     Project = p;
 }
        public MergeResolver(Project p)
        {
            InitializeComponent();
              Style = (Style)FindResource(typeof(Window));

              Title += " for " + p.name;
              project = p;

              if (p.id == 0) {
            string orig_big = "", my_big = "", new_big = "";
            for (int i = 0; i < 25; i++) {
              orig_big += "a\na\n";
              my_big += "b\na\n";
              new_big += "c\na\n";
            }

            unmergedFiles = new List<FileData> {
              new FileData {
            filename = "file.txt",
            original = "Sentence one.\nSentence two. Sentence three. Sentence four.\nSome crap after\na change\netc\nanother conflict\n",
            myVersion = "Sentence one.\nSentence two. Sentence threea.\nPlus a newline. Sentence four.\nSome crap after\na change\netc\nanother disagreement\n",
            newVersion = "Sentence one.\nSentence two. Sentence threeb. Sentence four.\nSome crap after\na small change\netc\nanother difference\n"
              },
              new FileData {
            filename = "bin_file.txt",
            original = "\007Sentence one.\nSentence two. Sentence three. Sentence four.\nSome crap after\na change\netc\nanother conflict\n",
            myVersion = null,
            newVersion = "\007Sentence one.\nSentence two. Sentence threeb. Sentence four.\nSome crap after\na small change\netc\nanother difference\n"
              },
              new FileData {
            filename = "file.docx",
            original = "\007Sentence one.\nSentence two. Sentence three. Sentence four.\nSome crap after\na change\netc\nanother conflict\n",
            myVersion = "\007x", //File.ReadAllText("C:\\temp\\a.docx", Encoding.Default),
            newVersion = "\007y" //File.ReadAllText("C:\\temp\\b.docx", Encoding.Default)
              },
              new FileData {
            filename = "big_file.txt",
            original = orig_big,
            myVersion = my_big,
            newVersion = new_big
              },
              new FileData {
            filename = "added_file.txt",
            original = null,
            myVersion = "Sentence one.\nSentence two. Sentence threea.\nPlus a newline. Sentence four.\nSome crap after\na change\netc\nanother disagreement\n",
            newVersion = "Sentence one.\nSentence two. Sentence threeb. Sentence four.\nSome crap after\na small change\netc\nanother difference\n"
              },
              new FileData {
            filename = "my_deletion.txt",
            original = "Sentence one.\nSentence two. Sentence three. Sentence four.\nSome crap after\na change\netc\nanother conflict\n",
            myVersion = null,
            newVersion = "Sentence one.\nSentence two. Sentence threeb. Sentence four.\nSome crap after\na small change\netc\nanother difference\n"
              },
              new FileData {
            filename = "their_deletion.txt",
            original = "Sentence one.\nSentence two. Sentence three. Sentence four.\nSome crap after\na change\netc\nanother conflict\n",
            myVersion = "Sentence one.\nSentence two. Sentence threea.\nPlus a newline. Sentence four.\nSome crap after\na change\netc\nanother disagreement\n",
            newVersion = null
              }
            };
              } else {
            unmergedFiles = GetUnmergedFiles();
              }

              diffViewerMap = new Dictionary<string, MergeViewer>();
              updated = new List<string>();
              created = new List<string>();
              deleted = new List<string>();

              for (int i = 0; i < unmergedFiles.Count; i++) {
            CreateDiffViewer(unmergedFiles[i]);
              }

              updated.Sort();
              created.Sort();
              deleted.Sort();
              combined = new List<string>(updated);
              combined.AddRange(created);
              combined.AddRange(deleted);
              diffViewers = new List<MergeViewer>(combined.Select(name => diffViewerMap[name]));

              var unmergedMap = unmergedFiles.ToDictionary(x => x.filename);
              unmergedFiles = new List<FileData>(combined.Select(name => unmergedMap[name]));

              foreach (var name in updated) {
            fileListing.AddFile(0, name);
              }
              foreach (var name in created) {
            fileListing.AddFile(1, name);
              }
              foreach (var name in deleted) {
            fileListing.AddFile(2, name);
              }
              fileListing.SelectionHandlers.Add(SelectFilename);

              active = 0;
              diffViewers[active].Visibility = Visibility.Visible;
              SetActiveFile(active);
              if (unmergedFiles.Count <= 1) {
            nextFile.IsEnabled = false;
              }
        }