//---------------------------------------------------------------------------------
/// <summary>
/// Translated vesion of GotoStack
/// </summary>
//---------------------------------------------------------------------------------
public void GoToStack(StackInfo stack, StackLevel stackLevel)
{
DoRpcCall(() =>
{
var requestParams = new StackedRequestParams(stack, stackLevel);
var result = _server.InvokeWithParameterObjectAsync <StackInfoRequestResponse>(StringConstants.GoToStackLevel, requestParams).Result;
});
}
//---------------------------------------------------------------------------------
/// <summary>
/// Fill in the details of a level
/// </summary>
//---------------------------------------------------------------------------------
public StackLevel GetLevelDetails(StackInfo stack, StackLevel level)
{
return(DoRpcCall(() =>
{
var requestParams = new StackedRequestParams(stack, level);
var result = _server.InvokeWithParameterObjectAsync <GetLevelDetailsResponse>(StringConstants.GetLevelDetails, requestParams).Result;
return result.StackLevel;
}));
}
//---------------------------------------------------------------------------------
/// <summary>
/// Current level in the stack
/// </summary>
//---------------------------------------------------------------------------------
public static void SetCurrentLevel(this StackInfo stack, StackLevel newLevel)
{
stack.CurrentLevelNumber = -1;
foreach (var level in stack.Levels)
{
level.IsCurrent = (newLevel != null && level.Number == newLevel.Number);
if (level.IsCurrent)
{
stack.CurrentLevelNumber = level.Number;
}
}
}
//---------------------------------------------------------------------------------
/// <summary>
/// Fills in difficult to obtains details for a stacklevel
/// </summary>
//---------------------------------------------------------------------------------
public StackLevel GetLevelDetails(StackLevel level)
{
Branch localBranch = _git.GetBranch(level.LocalBranch);
Branch targetBranch = _git.GetBranch(level.TargetOriginBranch);
Branch sourceBranch = _git.GetBranch(level.OriginBranch);
StackCommit[] GetCommitData(IEnumerable <Commit> commits)
{
return(commits?.Select(c => new StackCommit()
{
Id = c.Id.ToString(), ShortMessage = c.MessageShort
}).ToArray());
}
try
{
var lookingBack = _git.GetCommitDifference(sourceBranch.CanonicalName, localBranch.CanonicalName);
var lookingForward = _git.GetCommitDifference(localBranch.CanonicalName, targetBranch.CanonicalName);
if (lookingBack.CommonAncestor != null)
{
level.UnpulledCommits = GetCommitData(lookingBack.UnpulledCommits);
level.AllCommits = GetCommitData(lookingBack.AllChildCommits);
}
if (lookingForward.CommonAncestor != null)
{
level.UnpushedCommits = GetCommitData(lookingForward.UnpulledCommits);
}
}
catch (Exception e)
{
Debug.WriteLine(e.ToString());
throw new ShortStackException("Fill error: " + e.Message);
}
level.PullRequest = new VSTSAccess(_git.RemoteUrl).GetPullRequestByBranch(level.TargetOriginBranch);
return(level);
}
//---------------------------------------------------------------------------------
/// <summary>
/// Add a level
/// </summary>
//---------------------------------------------------------------------------------
public void AddLevel(StackLevel level)
{
_levels.Add(level);
level.Stack = this;
}
public StackLevel GetLevelDetails(StackInfo stack, StackLevel level) => _processor.GetLevelDetails(level);
//---------------------------------------------------------------------------------
/// <summary>
/// Create the next level in the specified stack
/// </summary>
//---------------------------------------------------------------------------------
public void CreateNextStackLevel(string currentStackName, string origin = null)
{
if (_git.HasUncommittedChanges)
{
throw new ShortStackException("There are uncommitted edits. Please resolve or stash these before attempting this operation.");
}
var currentStack = GetStack(currentStackName);
if (currentStack == null)
{
throw new ShortStackException($"There is no stack information for the stack named '{currentStackName}'");
}
int currentLevelNumber = -1;
var lastLevel = currentStack.LastLevel();
if (lastLevel != null)
{
currentLevelNumber = lastLevel.Number;
if (origin != null)
{
throw new ShortStackException("Only the zero-level of a stack can have an origin override.");
}
// Make sure we are at the top of the stack
if (!lastLevel.IsCurrent)
{
_git.Checkout(lastLevel.LocalBranch);
currentStack.SetCurrentLevel(lastLevel);
LogVerbose($"Change branch to {lastLevel.LocalBranch}");
}
}
// Set the origin to point to the lastLevel if there is one
if (origin == null)
{
origin = lastLevel?.TargetOriginBranch;
}
// If we don't have an origin, something is wrong
if (origin == null)
{
throw new ShortStackException("The origin must be specified for zero-level branches!");
}
// Fix up the origin branch name
if (!origin.StartsWith("origin/"))
{
origin = "origin/" + origin;
}
// Create the new stack branch
var newLevelNumber = currentLevelNumber + 1;
string newBranchName = currentStack.CreateBranchLevelName(newLevelNumber);
_git.CreateBranch(newBranchName, origin);
LogVerbose($"Creating branch {newBranchName} to track {origin}");
_git.Checkout(newBranchName, origin);
LogVerbose($"Change branch to {newBranchName}");
// Push up to the server to enforce branch creation there
_git.Push(newBranchName);
LogVerbose($"Pushed from {newBranchName} to origin/{newBranchName} ");
// Put it on the current stack record
var newLevel = new StackLevel()
{
IsCurrent = true,
RecentCommitDescription = "[new]",
LocalBranch = newBranchName,
Number = newLevelNumber,
OriginBranch = origin,
TargetOriginBranch = "origin/" + newBranchName,
RepositoryUrl = _git.RemoteUrl,
StackName = currentStack.StackName,
};
currentStack.AddLevel(newLevel);
currentStack.SetCurrentLevel(newLevel);
LogInformation($"Now on stack '{currentStack.StackName}', Level {newLevelNumber}");
}
//---------------------------------------------------------------------------------
/// <summary>
/// ProcessRecord - main processing goes here
/// </summary>
//---------------------------------------------------------------------------------
protected override void ProcessRecord()
{
base.ProcessRecord();
if (CurrentStack == null)
{
Print(ConsoleColor.Red, "You are not in a stacked branch. Use Get-Stacks to see available stacks.");
return;
}
var danglingStatus = Handler.CheckServerForDanglingWork();
if (danglingStatus == DanglingWorkStatus.UncommittedChanges)
{
Print(ConsoleColor.Red, "There are uncommitted changes. Please commit your changes first.");
return;
}
int startLevel, stopLevel;
if (!this.TryParseLevelNumber(Start, out startLevel))
{
if (String.IsNullOrEmpty(Start))
{
startLevel = 1;
}
else
{
Print(ConsoleColor.Red, "Start is an invalid level number");
return;
}
}
if (!this.TryParseLevelNumber(Stop, out stopLevel))
{
if (String.IsNullOrEmpty(Stop))
{
stopLevel = CurrentStack.CurrentLevel().Number;
}
else
{
Print(ConsoleColor.Red, "Stop is an invalid level number");
return;
}
}
if (startLevel > stopLevel)
{
Print(ConsoleColor.Red, "Start must be an earlier level than Stop");
return;
}
StackLevel originalLevel = this.GetCurrentStackLevel();
for (int i = startLevel; i <= stopLevel; i++)
{
StackLevel level = this.CurrentStack.Levels[i];
this.Handler.GoToStack(this.CurrentStack.StackName, level.Number);
level.FillDetails(this.Handler);
if (level.UnpulledCommits.Any())
{
//Pull and do a merge conflict
}
if (level.UnpushedCommits.Any() || level.UnpushedCommits.Any())
{
this.Handler.PushStackLevel();
}
}
this.Handler.GoToStack(this.CurrentStack.StackName, originalLevel.Number);
}
