예제 #1
0
 private void SwitchBranch(string branch)
 {
     if (EditorUtility.DisplayDialog(ConfirmSwitchTitle, String.Format(ConfirmSwitchMessage, branch), ConfirmSwitchOK,
                                     ConfirmSwitchCancel))
     {
         Repository.SwitchBranch(branch)
         .FinallyInUI((success, e) =>
         {
             if (success)
             {
                 UsageTracker.IncrementBranchesViewButtonCheckoutLocalBranch();
                 Redraw();
             }
             else
             {
                 EditorUtility.DisplayDialog(Localization.SwitchBranchTitle,
                                             String.Format(Localization.SwitchBranchFailedDescription, branch), Localization.Ok);
             }
         }).Start();
     }
 }
예제 #2
0
        private void Commit()
        {
            isBusy = true;
            var   files   = treeChanges.GetCheckedFiles().ToList();
            ITask addTask = null;

            if (files.Count == gitStatusEntries.Count)
            {
                addTask = Repository.CommitAllFiles(commitMessage, commitBody);
            }
            else
            {
                ITask commit = Repository.CommitFiles(files, commitMessage, commitBody);

                // if there are files that have been staged outside of Unity, but they aren't selected for commit, remove them
                // from the index before commiting, otherwise the commit will take them along.
                var filesStagedButNotChecked = gitStatusEntries.Where(x => x.Staged).Select(x => x.Path).Except(files).ToList();
                if (filesStagedButNotChecked.Count > 0)
                {
                    addTask = GitClient.Remove(filesStagedButNotChecked);
                }
                addTask = addTask == null ? commit : addTask.Then(commit);
            }

            addTask
            .FinallyInUI((success, exception) =>
            {
                if (success)
                {
                    UsageTracker.IncrementChangesViewButtonCommit();

                    commitMessage = "";
                    commitBody    = "";
                }
                isBusy = false;
            }).Start();
        }
예제 #3
0
        private void CheckoutRemoteBranch(string branch)
        {
            var indexOfFirstSlash = branch.IndexOf('/');
            var originName        = branch.Substring(0, indexOfFirstSlash);
            var branchName        = branch.Substring(indexOfFirstSlash + 1);

            if (Repository.LocalBranches.Any(localBranch => localBranch.Name == branchName))
            {
                EditorUtility.DisplayDialog(WarningCheckoutBranchExistsTitle,
                                            String.Format(WarningCheckoutBranchExistsMessage, branchName), WarningCheckoutBranchExistsOK);
            }
            else
            {
                var confirmCheckout = EditorUtility.DisplayDialog(ConfirmCheckoutBranchTitle,
                                                                  String.Format(ConfirmCheckoutBranchMessage, branch, originName), ConfirmCheckoutBranchOK,
                                                                  ConfirmCheckoutBranchCancel);

                if (confirmCheckout)
                {
                    Repository.CreateBranch(branchName, branch)
                    .FinallyInUI((success, e) =>
                    {
                        if (success)
                        {
                            UsageTracker.IncrementBranchesViewButtonCheckoutRemoteBranch();
                            Redraw();
                        }
                        else
                        {
                            EditorUtility.DisplayDialog(Localization.SwitchBranchTitle,
                                                        String.Format(Localization.SwitchBranchFailedDescription, branch), Localization.Ok);
                        }
                    }).Start();
                }
            }
        }
예제 #4
0
        public override void OnGUI()
        {
            GUILayout.BeginHorizontal(Styles.AuthHeaderBoxStyle);
            {
                GUILayout.Label(PublishToGithubLabel, EditorStyles.boldLabel);
            }
            GUILayout.EndHorizontal();

            EditorGUI.BeginDisabledGroup(isBusy);
            {
                if (connections.Length > 1)
                {
                    EditorGUI.BeginChangeCheck();
                    {
                        selectedConnection = EditorGUILayout.Popup("Connections:", selectedConnection, connectionLabels);
                    }
                    if (EditorGUI.EndChangeCheck())
                    {
                        selectedClient    = GetApiClient(connections[selectedConnection]);
                        ownersNeedLoading = true;
                        Redraw();
                    }
                }

                selectedOwner   = EditorGUILayout.Popup(SelectedOwnerLabel, selectedOwner, owners);
                repoName        = EditorGUILayout.TextField(RepositoryNameLabel, repoName);
                repoDescription = EditorGUILayout.TextField(DescriptionLabel, repoDescription);

                togglePrivate = EditorGUILayout.Toggle(CreatePrivateRepositoryLabel, togglePrivate);

                var repoPrivacyExplanation = togglePrivate ? PrivateRepoMessage : PublicRepoMessage;
                EditorGUILayout.HelpBox(repoPrivacyExplanation, MessageType.None);

                GUILayout.BeginHorizontal();
                {
                    GUILayout.FlexibleSpace();
                    EditorGUI.BeginDisabledGroup(!IsFormValid);
                    if (GUILayout.Button(PublishViewCreateButton))
                    {
                        GUI.FocusControl(null);
                        isBusy = true;

                        var organization = owners[selectedOwner] == connections[selectedConnection].Username ? null : owners[selectedOwner];

                        var cleanRepoDescription = repoDescription.Trim();
                        cleanRepoDescription = string.IsNullOrEmpty(cleanRepoDescription) ? null : cleanRepoDescription;

                        selectedClient.CreateRepository(repoName, cleanRepoDescription, togglePrivate, (repository, ex) =>
                        {
                            if (ex != null)
                            {
                                Logger.Error(ex, "Repository Create Error Type:{0}", ex.GetType().ToString());
                                error  = GetPublishErrorMessage(ex);
                                isBusy = false;
                                return;
                            }

                            UsageTracker.IncrementPublishViewButtonPublish();

                            if (repository == null)
                            {
                                Logger.Warning("Returned Repository is null");
                                isBusy = false;
                                return;
                            }
                            Repository.RemoteAdd("origin", repository.CloneUrl)
                            .Then(Repository.Push("origin"))
                            .ThenInUI(Finish)
                            .Start();
                        }, organization);
                    }
                    EditorGUI.EndDisabledGroup();
                }
                GUILayout.EndHorizontal();
                GUILayout.Space(10);

                if (error != null)
                {
                    EditorGUILayout.HelpBox(error, MessageType.Error);
                }

                GUILayout.FlexibleSpace();
            }
            EditorGUI.EndDisabledGroup();
        }
        public void Run()
        {
            isBusy = true;
            progress.UpdateProgress(0, 100, "Initializing...");

            if (firstRun)
            {
                UsageTracker.IncrementNumberOfStartups();
            }

            var thread = new Thread(() =>
            {
                GitInstallationState state = new GitInstallationState();
                try
                {
                    if (Environment.IsMac)
                    {
                        var getEnvPath = new SimpleProcessTask(TaskManager.Token, "bash".ToNPath(), "-c \"/usr/libexec/path_helper\"")
                                         .Configure(ProcessManager, dontSetupGit: true)
                                         .Catch(e => true); // make sure this doesn't throw if the task fails
                        var path = getEnvPath.RunSynchronously();
                        if (getEnvPath.Successful)
                        {
                            Logger.Trace("Existing Environment Path Original:{0} Updated:{1}", Environment.Path, path);
                            Environment.Path = path?.Split(new[] { "\"" }, StringSplitOptions.None)[1];
                        }
                    }

                    progress.UpdateProgress(20, 100, "Setting up octorun...");

                    Environment.OctorunScriptPath = new OctorunInstaller(Environment, TaskManager)
                                                    .SetupOctorunIfNeeded();

                    progress.UpdateProgress(50, 100, "Setting up git...");

                    state = Environment.GitInstallationState;
                    if (!state.GitIsValid && !state.GitLfsIsValid && FirstRun)
                    {
                        // importing old settings
                        NPath gitExecutablePath = Environment.SystemSettings.Get(Constants.GitInstallPathKey, NPath.Default);
                        if (gitExecutablePath.IsInitialized)
                        {
                            Environment.SystemSettings.Unset(Constants.GitInstallPathKey);
                            state.GitExecutablePath          = gitExecutablePath;
                            state.GitInstallationPath        = gitExecutablePath.Parent.Parent;
                            Environment.GitInstallationState = state;
                        }
                    }


                    var installer = new GitInstaller(Environment, ProcessManager, TaskManager.Token);
                    installer.Progress.OnProgress += progressReporter.UpdateProgress;
                    if (state.GitIsValid && state.GitLfsIsValid)
                    {
                        if (firstRun)
                        {
                            installer.ValidateGitVersion(state);
                            if (state.GitIsValid)
                            {
                                installer.ValidateGitLfsVersion(state);
                            }
                        }
                    }

                    if (!state.GitIsValid || !state.GitLfsIsValid)
                    {
                        state = installer.SetupGitIfNeeded();
                    }

                    SetupGit(state);

                    progress.UpdateProgress(80, 100, "Initializing repository...");

                    if (state.GitIsValid && state.GitLfsIsValid)
                    {
                        RestartRepository();
                    }

                    progress.UpdateProgress(100, 100, "Initialization failed");
                }
                catch (Exception ex)
                {
                    Logger.Error(ex, "A problem ocurred setting up Git");
                    progress.UpdateProgress(90, 100, "Initialization failed");
                }

                new ActionTask <bool>(TaskManager.Token, (s, gitIsValid) =>
                {
                    InitializationComplete();
                    if (gitIsValid)
                    {
                        InitializeUI();
                    }
                },
                                      () => state.GitIsValid && state.GitLfsIsValid)
                {
                    Affinity = TaskAffinity.UI
                }
                .Start();
            });

            thread.Start();
        }
예제 #6
0
        private void OnButtonBarGUI()
        {
            if (mode == BranchesMode.Default)
            {
                // Delete button
                // If the current branch is selected, then do not enable the Delete button
                EditorGUI.BeginDisabledGroup(disableDelete);
                {
                    if (GUILayout.Button(DeleteBranchButton, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
                    {
                        DeleteLocalBranch(treeLocals.SelectedNode.Path);
                    }
                }
                EditorGUI.EndDisabledGroup();

                // Create button
                GUILayout.FlexibleSpace();
                EditorGUI.BeginDisabledGroup(disableCreate);
                {
                    if (GUILayout.Button(CreateBranchButton, EditorStyles.miniButton, GUILayout.ExpandWidth(false)))
                    {
                        targetMode = BranchesMode.Create;
                    }
                }
                EditorGUI.EndDisabledGroup();
            }
            // Branch name + cancel + create
            else if (mode == BranchesMode.Create)
            {
                GUILayout.BeginHorizontal();
                {
                    var createBranch = false;
                    var cancelCreate = false;
                    var cannotCreate = treeLocals.SelectedNode == null ||
                                       treeLocals.SelectedNode.IsFolder ||
                                       !Validation.IsBranchNameValid(newBranchName);

                    // Create on return/enter or cancel on escape
                    var offsetID = GUIUtility.GetControlID(FocusType.Passive);
                    if (Event.current.isKey && GUIUtility.keyboardControl == offsetID + 1)
                    {
                        if (Event.current.keyCode == KeyCode.Escape)
                        {
                            cancelCreate = true;
                            Event.current.Use();
                        }
                        else if (Event.current.keyCode == KeyCode.Return || Event.current.keyCode == KeyCode.KeypadEnter)
                        {
                            if (cannotCreate)
                            {
                                EditorApplication.Beep();
                            }
                            else
                            {
                                createBranch = true;
                            }
                            Event.current.Use();
                        }
                    }
                    newBranchName = EditorGUILayout.TextField(newBranchName);

                    // Create
                    EditorGUI.BeginDisabledGroup(cannotCreate);
                    {
                        if (GUILayout.Button(NewBranchConfirmButton, EditorStyles.miniButtonLeft, GUILayout.ExpandWidth(false)))
                        {
                            createBranch = true;
                        }
                    }
                    EditorGUI.EndDisabledGroup();

                    // Cancel create
                    if (GUILayout.Button(NewBranchCancelButton, EditorStyles.miniButtonRight, GUILayout.ExpandWidth(false)))
                    {
                        cancelCreate = true;
                    }

                    // Effectuate create
                    if (createBranch)
                    {
                        Repository.CreateBranch(newBranchName, treeLocals.SelectedNode.Path)
                        .FinallyInUI((success, e) =>
                        {
                            if (success)
                            {
                                UsageTracker.IncrementBranchesViewButtonCreateBranch();
                                Redraw();
                            }
                            else
                            {
                                var errorHeader  = "fatal: ";
                                var errorMessage = e.Message.StartsWith(errorHeader) ? e.Message.Remove(0, errorHeader.Length) : e.Message;

                                EditorUtility.DisplayDialog(CreateBranchTitle,
                                                            errorMessage,
                                                            Localization.Ok);
                            }
                        })
                        .Start();
                    }

                    // Cleanup
                    if (createBranch || cancelCreate)
                    {
                        newBranchName = "";
                        GUIUtility.keyboardControl = -1;
                        targetMode = BranchesMode.Default;
                    }
                }
                GUILayout.EndHorizontal();
            }
        }