StatisticsAspect: adding advice for counting analyzed text selections

[ifi-stolz-refaktor.git] / software / no.uio.ifi.refaktor / src / no / uio / ifi / refaktor / aspects / StatisticsAspect.aj

package no.uio.ifi.refaktor.aspects;

import java.util.HashMap;
import java.util.Map;

import no.uio.ifi.refaktor.analyze.ExtractAndMoveMethodAnalysisResult;
import no.uio.ifi.refaktor.analyze.analyzers.CompilationUnitWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.ExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.SearchBasedExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.analyze.analyzers.TypeWideExtractAndMoveMethodAnalyzer;
import no.uio.ifi.refaktor.change.executors.ExtractAndMoveMethodExecutor;
import no.uio.ifi.refaktor.change.performers.RefactoringPerformer;
import no.uio.ifi.refaktor.utils.RefaktorDebug;

import org.eclipse.jdt.core.IMethod;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.ltk.core.refactoring.Refactoring;

privileged public aspect StatisticsAspect {

	public class Statistics {

		private final Map<String, Integer> successfullyPerformedRefactorings;
		private final Map<String, Integer> notPerformedRefactorings;
		private final String snapshotTimeSinceStart;

		private long startTime;
		private int methodCount;
		private int typeCount;
		private int compilationUnitCount;
		private int packageCount;
		private int extractAndMoveMethodExecutedCount;
		private int extractAndMoveMethodNotExecutedCount;
		private int extractAndMoveMethodResultFoundCount;
		private int extractAndMoveMethodResultNotFoundCount;
		private int extractAndMoveMethodResultGeneratedCount;
		private int selectionsAnalyzedCount;

		private Statistics() {
			startTime = System.currentTimeMillis();
			methodCount = typeCount = compilationUnitCount = packageCount = 0;
			successfullyPerformedRefactorings = new HashMap<String, Integer>();
			notPerformedRefactorings = new HashMap<String, Integer>();
			extractAndMoveMethodExecutedCount = extractAndMoveMethodNotExecutedCount = 0;
			extractAndMoveMethodResultFoundCount = extractAndMoveMethodResultNotFoundCount = 0;
			extractAndMoveMethodResultGeneratedCount = selectionsAnalyzedCount = 0;
			snapshotTimeSinceStart = timeSinceStart();
		}

		private Statistics(Statistics statistics) {
			this.startTime = statistics.startTime;
			this.successfullyPerformedRefactorings = new HashMap<String, Integer>(statistics.successfullyPerformedRefactorings);
			this.notPerformedRefactorings = new HashMap<String, Integer>(statistics.notPerformedRefactorings);
			this.methodCount = statistics.methodCount;
			this.typeCount = statistics.typeCount;
			this.compilationUnitCount = statistics.compilationUnitCount;
			this.packageCount = statistics.packageCount;
			this.extractAndMoveMethodExecutedCount = statistics.extractAndMoveMethodExecutedCount;
			this.extractAndMoveMethodNotExecutedCount = statistics.extractAndMoveMethodNotExecutedCount;
			this.extractAndMoveMethodResultFoundCount = statistics.extractAndMoveMethodResultFoundCount;
			this.extractAndMoveMethodResultNotFoundCount = statistics.extractAndMoveMethodResultNotFoundCount;
			this.extractAndMoveMethodResultGeneratedCount = statistics.extractAndMoveMethodResultGeneratedCount;
			this.selectionsAnalyzedCount = statistics.selectionsAnalyzedCount;
			this.snapshotTimeSinceStart = timeSinceStart();
		}

		private String timeSinceStart() {
			long durationInMillis = System.currentTimeMillis() - startTime;
			long secondsSinceAnalysisStart = durationInMillis/1000;

			if (secondsSinceAnalysisStart > 0)
				return secondsSinceAnalysisStart/60 + "m" + secondsSinceAnalysisStart % 60 + "s";
			else
				return durationInMillis + "ms";
		}

		public int getMethodCount() {
			return methodCount;
		}

		public int getTypeCount() {
			return typeCount;
		}

		public int getCompilationUnitCount() {
			return compilationUnitCount;
		}

		public int getPackageCount() {
			return packageCount;
		}

		public String getSnapshotTimeSinceStart() {
			return snapshotTimeSinceStart;
		}

		public Statistics generateSnapshot() {
			return new Statistics(this);
		}

		@Override
		public String toString() {
			String message = "Statistics:\n-----------\nTime used: " + snapshotTimeSinceStart
					+ (packageCount > 0 ? "\n\nNumber of packages analyzed: " + packageCount : "") 
					+ (compilationUnitCount > 0 ? "\nNumber of compilation units analyzed: " + compilationUnitCount : "")
					+ (typeCount > 0 ? "\nNumber of types analyzed: " + typeCount : "")
					+ "\nNumber of methods analyzed: " + methodCount 
					+ "\nNumber of text selections analyzed: " + selectionsAnalyzedCount 
					+ "\n\n" + extractAndMoveMethodResultFoundCount 
					+ " methods are chosen as candidates for the Extract and Move Method refactoring, while " 
					+ extractAndMoveMethodResultNotFoundCount + " are not"
					+ "\n" + extractAndMoveMethodResultGeneratedCount + " possible candidates found (can be multiple candidates per method)"
					+ "\n\nPrimitive refactorings performed:";

			for (String refactoringName: successfullyPerformedRefactorings.keySet()) {
				Integer successCount = successfullyPerformedRefactorings.get(refactoringName);
				Integer notPerformedCount = notPerformedRefactorings.get(refactoringName);
				message += "\n" + refactoringName + ": " + successCount + " performed" 
						+ (notPerformedCount != null ? ", " + notPerformedCount + " not performed" : "")
						+ (" (" + (successCount + (notPerformedCount != null ? notPerformedCount : 0)) + " in total)");
			}

			if (extractAndMoveMethodExecutedCount > 0 || extractAndMoveMethodNotExecutedCount > 0) {
				message += "\n\nExtract and Move Method refactorings executed:"
						+ (extractAndMoveMethodExecutedCount > 0 ? "\nFully executed: " + extractAndMoveMethodExecutedCount : "")
						+ (extractAndMoveMethodNotExecutedCount > 0 ? "\nNot fully executed: " + extractAndMoveMethodNotExecutedCount : "")
						+ "\n(" + (extractAndMoveMethodExecutedCount + extractAndMoveMethodNotExecutedCount) + " in total)";
			}

			return message;
		}

	}

	private Statistics statistics;

	public StatisticsAspect() {
		this.statistics = new Statistics();
	}

	pointcut selectionAnalyze() : call(* ExtractAndMoveMethodAnalyzer.analyze()) ;
	pointcut methodAnalyze(SearchBasedExtractAndMoveMethodAnalyzer analyzer) : 
		call(* SearchBasedExtractAndMoveMethodAnalyzer.analyze()) && target(analyzer);
	pointcut typeAnalyze() : call(* TypeWideExtractAndMoveMethodAnalyzer.analyze());
	pointcut compilationUnitAnalyze() : call(* CompilationUnitWideExtractAndMoveMethodAnalyzer.analyze());
	pointcut packageAnalyze() : call(* CompilationUnitWideExtractAndMoveMethodAnalyzer.analyze());
	pointcut performRefactoring(Refactoring refactoring) : 
		call(* RefactoringPerformer+.performRefactoring(Refactoring)) && args(refactoring);
	pointcut extractAndMoveExecuted() : call(* ExtractAndMoveMethodExecutor.execute(..));
	pointcut analysisResultCreated() : call(public ExtractAndMoveMethodAnalysisResult.new(..));
	
	after() : selectionAnalyze() {
		statistics.selectionsAnalyzedCount++;
	}

	after(SearchBasedExtractAndMoveMethodAnalyzer analyzer) : methodAnalyze(analyzer) {
		statistics.methodCount++;
		debugPrintMethodAnalysisProgress(analyzer.method);
	}

	private void debugPrintMethodAnalysisProgress(IMethod method) {
		try {
			RefaktorDebug.println("#" + statistics.methodCount + " (" + timeSinceStart() + "): " 
					+ method.getDeclaringType().getElementName() + "." + method.getElementName() + " (" + "offset: "
					+ method.getSourceRange().getOffset() + ", length: " + method.getSourceRange().getLength() + ")");
		} catch (JavaModelException e) {
			RefaktorDebug.println("No info about " + method.getElementName());
		}
	}

	after(SearchBasedExtractAndMoveMethodAnalyzer analyzer) returning(): methodAnalyze(analyzer) {
		statistics.extractAndMoveMethodResultFoundCount++;
	}

	after(SearchBasedExtractAndMoveMethodAnalyzer analyzer) throwing(): methodAnalyze(analyzer) {
		statistics.extractAndMoveMethodResultNotFoundCount++;
	}

	after(): typeAnalyze() {
		statistics.typeCount++;
	}

	after(): compilationUnitAnalyze() {
		statistics.compilationUnitCount++;
	}

	after(): packageAnalyze() {
		statistics.packageCount++;
	}

	after(Refactoring refactoring) returning() : performRefactoring(refactoring) {
		Integer count = statistics.successfullyPerformedRefactorings.get(refactoring.getName());
		if (count == null)
			statistics.successfullyPerformedRefactorings.put(refactoring.getName(), 1);
		else
			statistics.successfullyPerformedRefactorings.put(refactoring.getName(), count + 1);
	}

	after(Refactoring refactoring) throwing() : performRefactoring(refactoring) {
		Integer count = statistics.notPerformedRefactorings.get(refactoring.getName());
		if (count == null)
			statistics.notPerformedRefactorings.put(refactoring.getName(), 1);
		else
			statistics.notPerformedRefactorings.put(refactoring.getName(), count + 1);
	}

	after() returning() : extractAndMoveExecuted() {
		statistics.extractAndMoveMethodExecutedCount++;
	}

	after() throwing() : extractAndMoveExecuted() {
		statistics.extractAndMoveMethodNotExecutedCount++;
	}
	
	after() returning() : analysisResultCreated() {
		statistics.extractAndMoveMethodResultGeneratedCount++;
	}

	public void init() {
		this.statistics = new Statistics();
	}

	public String timeSinceStart() {
		return statistics.timeSinceStart();
	}

	public int getMethodCount() {
		return statistics.getMethodCount();
	}

	public int getTypeCount() {
		return statistics.getTypeCount();
	}

	public int getCompilationUnitCount() {
		return statistics.getCompilationUnitCount();
	}

	public int getPackageCount() {
		return statistics.getPackageCount();
	}

	public Statistics getSnapshot() {
		return statistics.generateSnapshot();
	}

}