private async Task AddProjectAsync(AnalyzedProject analyzedProject, string targetIndex)
{
Console.WriteLine("Updating project {0}", analyzedProject.Id);
await Provider.RemoveProjectAsync(analyzedProject.Id, targetIndex);
var modelProject = ModelConverter.FromObjectModel(analyzedProject);
modelProject.DateUploaded = DateTime.UtcNow;
await Provider.AddProjectAsync(modelProject, targetIndexName : targetIndex);
}
public static ProjectModel FromObjectModel(AnalyzedProject analyzedProject)
{
Contract.Requires(analyzedProject != null);
Contract.Ensures(Contract.Result <ProjectModel>() != null);
return
(new ProjectModel(analyzedProject.Id, analyzedProject.RepositoryName)
{
ProjectKind = analyzedProject.ProjectKind
}
.AddReferencedProjects(FromObjectModel(analyzedProject.ReferencedProjects).ToArray()));
}
internal static string GetTextReportLine(AnalyzedProject project, AnalyzedTargetFramework targetFramework, AnalyzedDependency dependency)
{
var upgradeSeverity = Enum.GetName(typeof(DependencyUpgradeSeverity), dependency.UpgradeSeverity);
return(string.Format("{0};{1};{2};{3};{4};{5}",
project.Name,
targetFramework.Name,
dependency.Name,
dependency.ResolvedVersion,
dependency.LatestVersion,
upgradeSeverity));
}
public ManagedProjectAnalyzer(
SemanticServices semanticServices,
RepoProject repoProject,
ProjectId projectId,
Lazy <Task <Solution> > lazySolution)
{
this.semanticServices = semanticServices;
ProjectId = projectId;
this.lazySolution = lazySolution;
var analyzedProject = new AnalyzedProject(repoProject.Repo.Name, repoProject.ProjectId);
ProjectContext = new AnalyzedProjectContext(analyzedProject);
}
public DocumentAnalyzer(
SemanticServices semanticServices,
Document document,
CompilationServices compilationServices,
string logicalPath,
AnalyzedProjectContext context,
BoundSourceFileBuilder boundSourceFile)
{
_document = document;
CompilationServices = compilationServices;
_compilation = compilationServices.Compilation;
_analyzedProject = context.Project;
this.semanticServices = semanticServices;
this.context = context;
references = new List <ReferenceSpan>();
this.boundSourceFile = boundSourceFile;
}
public async Task AddProjectAsync(IRepoProject repoProject, AnalyzedProject analyzedProject)
{
string targetIndex = repoProject.Repo.TargetIndex;
await AddProjectAsync(analyzedProject, targetIndex);
}
public virtual Task AddProjectAsync(IRepoProject repoProject, AnalyzedProject analyzedProject)
{
return(analysisTarget.AddProjectAsync(repoProject, analyzedProject));
}
public Task AddProjectAsync(IRepoProject repoProject, AnalyzedProject analyzedProject)
{
return(Task.FromResult(true));
}
public AnalyzedProjectContext(AnalyzedProject project)
{
Project = project;
}
public AnalyzedSolution AnalyzeSolution()
{
//var analyzedSolution = new AnalyzedSolution();
var basicMetricsProvider = new BasicMetricsProvider();
var solutionToAnalyze = GetSolutionToAnalyze(_workspace, _pathToSolution);
foreach (Project proj in solutionToAnalyze.Projects)
{
var analyzedProject = new AnalyzedProject();
var project = GetProjectToAnalyze(solutionToAnalyze, proj.Name);
var projectCompiledAssembly = GetProjectCompiledAssembly(project);
analyzedProject.OutputFilePath = project.OutputFilePath;
analyzedProject.Name = project.Name;
var projectClasses = basicMetricsProvider.GetProjectClasses(projectCompiledAssembly);
foreach (ClassDeclarationSyntax c in projectClasses)
{
var newClass = new Class()
{
Name = c.Identifier.ToString()
};
IEnumerable <MethodDeclarationSyntax> methods = c.Members.OfType <MethodDeclarationSyntax>().ToList();
IEnumerable <FieldDeclarationSyntax> attributes = c.Members.OfType <FieldDeclarationSyntax>().ToList();
IEnumerable <PropertyDeclarationSyntax> properties = c.Members.OfType <PropertyDeclarationSyntax>().ToList();
ConstructorDeclarationSyntax constructor = c.Members.OfType <ConstructorDeclarationSyntax>().FirstOrDefault();
if (constructor != null)
{
newClass.Constructor = new Constructor();
foreach (var cp in constructor.ParameterList.Parameters)
{
newClass.Constructor.Parameters.Add(new MethodParameter()
{
Name = cp.Identifier.ToString(),
Type = cp.Type.ToString()
});
}
}
foreach (var m in methods)
{
var methodParameters = new List <MethodParameter>();
// add method's parameters
foreach (var mp in m.ParameterList.Parameters)
{
methodParameters.Add(new MethodParameter()
{
Name = mp.Identifier.ToString(),
Type = mp.Type.ToString()
});
}
// add method's body
var methodBody = new Body();
var index = 0;
foreach (StatementSyntax statement in m.Body.Statements)
{
methodBody.Statements.Add(new Statement
{
Content = statement.ToString(),
Position = index
});
index++;
}
newClass.Methods.Add(new Method()
{
Accessor = m.Modifiers.First().ToString(),
ReturnType = m.ReturnType.ToString(),
Name = m.Identifier.ToString(),
Parameters = methodParameters,
MethodBody = methodBody
});
}
foreach (var a in attributes)
{
var attDeclaration = a.Declaration.ToString();
newClass.Attributes.Add(new Models.Attribute()
{
Accessor = a.Modifiers.First().ToString(),
Name = a.Declaration.ToString().Split(' ')[1],
Type = a.Declaration.ToString().Split(' ')[0]
});
}
foreach (var p in properties)
{
newClass.Attributes.Add(new Models.Attribute()
{
Accessor = p.Modifiers.First().ToString(),
Name = p.Identifier.ToString(),
Type = p.Type.ToString()
});
}
analyzedProject.Classes.Add(newClass);
}
_analyzedSolution.Projects.Add(analyzedProject);
}
return(_analyzedSolution);
}
protected static void UploadProject(RepoProject project, AnalyzedProject analyzedProject)
{
analyzedProject.ProjectKind = project.ProjectKind;
project.Repo.AnalysisServices.TaskDispatcher.QueueInvoke(() =>
project.Repo.AnalysisServices.AnalysisTarget.AddProjectAsync(project, analyzedProject), TaskType.Upload);
}
public virtual void UploadProject(RepoProject project)
{
AnalyzedProject analyzedProject = new AnalyzedProject(project.Repo.Name, project.ProjectId);
UploadProject(project, analyzedProject);
}
