internal SearchRefactoringWorkitem(ICodeHistoryRecord latestRecord,
DocumentId documentId)
{
this.latestRecord = latestRecord;
this.documentId = documentId;
logger = NLoggerUtil.GetNLogger(typeof(SearchRefactoringWorkitem));
}
private CompilationUnitRecord(string uniqueName, string sourePath, long time,
IDataSource dataSource, ICodeHistoryRecord previousRecord)
{
this.uniqueName = uniqueName;
this.sourePath = sourePath;
this.time = time;
this.dataSource = dataSource;
this.previousRecord = previousRecord;
}
public void DetectRefactorings(ICodeHistoryRecord head)
{
int depth = 0;
// For every head in the head chain, look back to detect refactorings.
// We do not search records that are older than SEARCH_DEPTH away from the head.
for (var current = head; current.HasPreviousRecord() && depth < SEARCH_DEPTH;
current = current.GetPreviousRecord(), depth ++)
{
logger.Info("Detect refactorings with depth of head: " + depth);
LookBackToDetectRefactorings(current);
}
}
/* Detect intermediate refactorings the determined before record. */
private void DetectIntermediateRefactorings(ICodeHistoryRecord baseBefore, ICodeHistoryRecord head,
IExternalRefactoringDetector detector)
{
// Get the source code for base before.
var before = baseBefore.GetSource();
// From the head, iteratively get previous record (until reach base before record)
// and detect if refactorings exist.
for (var currentRecord = head; !currentRecord.Equals(baseBefore);
currentRecord = currentRecord.GetPreviousRecord())
{
var after = currentRecord.GetSource();
DetectRefactoringByDetector(before, after, detector);
}
}
public override void StartRefactoringSearch(ICodeHistoryRecord record)
{
Enqueue(new SearchExtractMethodWorkitem(record));
}
/* Called when manual refactoring is detected. */
protected abstract void OnRefactoringDetected(ICodeHistoryRecord before, ICodeHistoryRecord after,
IEnumerable<IManualRefactoring> refactorings);
/* Start the searching of performed refactorings. */ public abstract void StartRefactoringSearch(ICodeHistoryRecord record);
public override void StartRefactoringSearch(ICodeHistoryRecord record)
{
Enqueue(new SearchChangeMethodSignatureWorkItem(record));
}
protected override void OnRefactoringDetected(ICodeHistoryRecord before, ICodeHistoryRecord after,
IEnumerable<IManualRefactoring> refactorings)
{
logger.Info("Change Method Signature Detected.");
logger.Info("Before:\n" + before.GetSource());
logger.Info("After:\n" + after.GetSource());
// Enqueue the condition checking process for this detected refactoring.
GhostFactorComponents.conditionCheckingComponent.CheckRefactoringCondition(before, after, refactorings.First());
}
protected override void OnRefactoringDetected(ICodeHistoryRecord before, ICodeHistoryRecord after,
IEnumerable<IManualRefactoring> refactorings)
{
logger.Info("\n Extract Method dectected.");
logger.Info("\n Before: \n" + before.GetSource());
logger.Info("\n After: \n" + after.GetSource());
// Get the first refactoring detected.
IManualRefactoring refactoring = refactorings.First();
// Enqueue workitem for conditions checking component.
GhostFactorComponents.conditionCheckingComponent.CheckRefactoringCondition(before, after, refactoring);
}
/* Use all the refactoring detectors to detect refactoring, return whether a refactoring is detected. */
private bool HandlePreviousRecordWithDetectors(ICodeHistoryRecord before, ICodeHistoryRecord head)
{
// If a refactoring is found, initially false.
bool hasRefactorings = false;
// For each detectors.
foreach (var detector in externalRefactoringDetectors)
{
// If found by the detector hasRefactoring is set to be true.
if(HandlePreviousRecord(before, head, detector))
{
hasRefactorings = true;
}
}
return hasRefactorings;
}
protected override void OnRefactoringDetected(ICodeHistoryRecord before, ICodeHistoryRecord after,
IEnumerable<IManualRefactoring> refactorings)
{
logger.Info("Rename dectected.");
logger.Info("\nBefore: \n" + before.GetSource());
logger.Info("\nAfter: \n" + after.GetSource());
}
private void OnNoRefactoringDetected(ICodeHistoryRecord after)
{
logger.Info("No refactoring detected.");
}
public SearchRenameWorkItem(ICodeHistoryRecord latestRecord)
: base(latestRecord)
{
}
protected override void OnNoRefactoringDetected(ICodeHistoryRecord record)
{
//logger.Info("No Rename Detected.");
}
public override void StartRefactoringSearch(ICodeHistoryRecord record)
{
Enqueue(new SearchRenameWorkItem(record));
}
public bool Equals(ICodeHistoryRecord other)
{
return GetTime() == other.GetTime();
}
public SearchChangeMethodSignatureWorkItem(ICodeHistoryRecord latestRecord)
: base(latestRecord)
{
}
public SearchExtractMethodWorkitem(ICodeHistoryRecord latestRecord)
: base(latestRecord)
{
}
public void StartRefactoringSearch(ICodeHistoryRecord record, DocumentId documentId)
{
queue.Add(new SearchRefactoringWorkitem(record, documentId));
}
protected override void OnNoRefactoringDetected(ICodeHistoryRecord record)
{
//logger.Info("No extract method detected.");
}
public void CheckRefactoringCondition(ICodeHistoryRecord before, ICodeHistoryRecord after, IManualRefactoring refactoring)
{
Enqueue(new ConditionCheckWorkItem(before, after, refactoring));
}
/* Handle a previous record with the head of the record chain. */
private bool HandlePreviousRecord(ICodeHistoryRecord previous, ICodeHistoryRecord head,
IExternalRefactoringDetector detector)
{
var after = head.GetSource();
var before = previous.GetSource();
// Detect if a refactoring happens before head and the previous record.
if (DetectRefactoringByDetector(before, after, detector))
{
// If there is a refactoring detected, search intermediate refactorings.
DetectIntermediateRefactorings(previous, head.GetPreviousRecord(), detector);
return true;
}
return false;
}
protected SearchRefactoringWorkitem(ICodeHistoryRecord latestRecord)
{
this.latestRecord = latestRecord;
this.logger = GetLogger();
}
private void LookBackToDetectRefactorings(ICodeHistoryRecord head)
{
var currentRecord = head;
// Look back until no parent or reach the search depth.
for (int i = 0; i < LOOK_BACK_LIMIT && currentRecord.HasPreviousRecord();
i++, currentRecord = currentRecord.GetPreviousRecord())
{
try
{
logger.Info("Looking back " + i + " revisions.");
// Handle current record.
if(HandlePreviousRecordWithDetectors(currentRecord.GetPreviousRecord(), head))
{
break;
}
}
catch (Exception e)
{
logger.Fatal(e);
}
}
}
/* Called when no manual refactoring is detected. */ protected abstract void OnNoRefactoringDetected(ICodeHistoryRecord after);
public ConditionCheckWorkItem(ICodeHistoryRecord before, ICodeHistoryRecord after, IManualRefactoring refactoring)
{
this.before = before.Convert2Document();
this.after = after.Convert2Document();
this.DocumentKey = before.GetKey();
this.refactoring = refactoring;
logger = NLoggerUtil.GetNLogger(typeof(ConditionCheckWorkItem));
}
protected override void OnNoRefactoringDetected(ICodeHistoryRecord record)
{
//logger.Info("No change method signature detected.");
}
