public CodeFunction FindCodeFunction(VsProjectScope projectScope, IBindingMethod bindingMethod)
{
var project = projectScope.Project;
var function = FindCodeFunction(project, bindingMethod);
if (function != null)
{
return(function);
}
var specFlowProject = projectScope.SpecFlowProjectConfiguration;
if (specFlowProject != null)
{
foreach (var assemblyName in specFlowProject.RuntimeConfiguration.AdditionalStepAssemblies)
{
string simpleName = assemblyName.Split(new[] { ',' }, 2)[0];
var stepProject = VsxHelper.FindProjectByAssemblyName(project.DTE, simpleName);
if (stepProject != null)
{
function = FindCodeFunction(stepProject, bindingMethod);
if (function != null)
{
return(function);
}
}
}
}
return(null);
}
public static SpecFlowProjectConfiguration LoadSpecFlowConfigurationFromDteProject(Project project)
{
if (project == null || !VsProjectScope.IsProjectSupported(project))
{
return(null);
}
try
{
return(LoadSpecFlowConfigurationFromDteProjectInternal(project));
}
catch
{
return(null);
}
}
private IEnumerable <string> CollectPaths(VsProjectScope projectScope, ProjectItem projectItem)
{
var testPath = GetPath(projectScope, projectItem);
if (testPath != null)
{
yield return(testPath);
}
else
{
foreach (var subItemPath in VsxHelper.GetAllSubProjectItem(projectItem).Select(pi => GetPath(projectScope, pi)).Where(p => p != null))
{
yield return(subItemPath);
}
}
}
protected override ProjectSettings LoadProjectSettings()
{
tracer.Trace("Discover project settings", "VsGeneratorServices");
ProjectPlatformSettings projectPlatformSettings;
var tergetLanguage = VsProjectScope.GetTargetLanguage(project);
switch (tergetLanguage)
{
case ProgrammingLanguage.CSharp:
projectPlatformSettings = new ProjectPlatformSettings
{
Language = GenerationTargetLanguage.CSharp,
LanguageVersion = new Version("3.0"),
Platform = GenerationTargetPlatform.DotNet,
PlatformVersion = new Version("3.5"),
};
break;
case ProgrammingLanguage.VB:
projectPlatformSettings = new ProjectPlatformSettings
{
Language = GenerationTargetLanguage.VB,
LanguageVersion = new Version("9.0"),
Platform = GenerationTargetPlatform.DotNet,
PlatformVersion = new Version("3.5"),
};
break;
default:
throw new NotSupportedException("target language not supported");
}
var configurationHolder = configurationReader.ReadConfiguration();
return(new ProjectSettings
{
ProjectName = Path.GetFileNameWithoutExtension(project.FullName),
AssemblyName = VsxHelper.GetProjectAssemblyName(project),
ProjectFolder = VsxHelper.GetProjectFolder(project),
DefaultNamespace = VsxHelper.GetProjectDefaultNamespace(project),
ProjectPlatformSettings = projectPlatformSettings,
ConfigurationHolder = configurationHolder
});
}
private string GetPath(VsProjectScope projectScope, ProjectItem projectItem)
{
var projectRelativePath = VsxHelper.GetProjectRelativePath(projectItem);
if (projectRelativePath != null && projectRelativePath.EndsWith(".feature", StringComparison.InvariantCultureIgnoreCase))
{
var featureFileInfo = projectScope.FeatureFilesTracker.Files.FirstOrDefault(ffi => ffi.ProjectRelativePath == projectRelativePath);
if (featureFileInfo == null)
{
tracer.Trace("Feature file info not found.", GetType().Name);
}
else if (featureFileInfo.ParsedFeature == null)
{
tracer.Trace("Feature file is not yet analyzed.", GetType().Name);
}
else
{
string path = string.Format("testpath:Feature:{0}", Escape(featureFileInfo.ParsedFeature.Title));
return(path);
}
}
return(null);
}
public StepInstanceWithProjectScope(StepInstance stepInstance, VsProjectScope projectScope)
{
StepInstance = stepInstance;
ProjectScope = projectScope;
}
private IEnumerable <StepInstanceWithProjectScope> GetMatchingSteps(IBindingMethod bindingMethod, VsProjectScope projectScope)
{
return(projectScope.StepSuggestionProvider.GetMatchingInstances(bindingMethod)
.Where(si => si is ISourceFilePosition)
.Distinct(StepInstanceComparer.Instance)
.OrderBy(si => si, StepInstanceComparer.Instance)
.Select(si => new StepInstanceWithProjectScope(si, projectScope)));
}
public bool GoToDefinition(GherkinEditorContext editorContext)
{
var step = GetCurrentStep(editorContext);
if (step == null)
{
return(false);
}
var bindingMatchService = GetBindingMatchService(editorContext.LanguageService);
if (bindingMatchService == null)
{
return(false);
}
if (!bindingMatchService.Ready)
{
MessageBox.Show("Step bindings are still being analyzed. Please wait.", "Go to binding");
return(true);
}
List <BindingMatch> candidatingMatches;
StepDefinitionAmbiguityReason ambiguityReason;
CultureInfo bindingCulture = editorContext.ProjectScope.SpecFlowConfiguration.BindingCulture ?? step.StepContext.Language;
var match = bindingMatchService.GetBestMatch(step, bindingCulture, out ambiguityReason, out candidatingMatches);
var binding = match.StepBinding;
if (!match.Success)
{
if (candidatingMatches.Any())
{
string bindingsText = string.Join(Environment.NewLine, candidatingMatches.Select(b => b.StepBinding.Method.GetShortDisplayText()));
MessageBox.Show("Multiple matching bindings found. Navigating to the first match..."
+ Environment.NewLine + Environment.NewLine + bindingsText, "Go to binding");
binding = candidatingMatches.First().StepBinding;
}
else
{
var language = editorContext.ProjectScope is VsProjectScope?VsProjectScope.GetTargetLanguage(((VsProjectScope)editorContext.ProjectScope).Project) : ProgrammingLanguage.CSharp;
var stepDefinitionSkeletonStyle = editorContext.ProjectScope.SpecFlowConfiguration.StepDefinitionSkeletonStyle;
string skeleton = stepDefinitionSkeletonProvider.GetStepDefinitionSkeleton(language, step, stepDefinitionSkeletonStyle, bindingCulture);
var result = MessageBox.Show("No matching step binding found for this step! Do you want to copy the step binding skeleton to the clipboard?"
+ Environment.NewLine + Environment.NewLine + skeleton, "Go to binding", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (result == DialogResult.Yes)
{
Clipboard.SetText(skeleton);
}
return(true);
}
}
var method = binding.Method;
var codeFunction = new VsBindingMethodLocator().FindCodeFunction(((VsProjectScope)editorContext.ProjectScope), method);
if (codeFunction != null)
{
if (!codeFunction.ProjectItem.IsOpen)
{
codeFunction.ProjectItem.Open();
}
var navigatePoint = codeFunction.GetStartPoint(vsCMPart.vsCMPartHeader);
navigatePoint.TryToShow();
navigatePoint.Parent.Selection.MoveToPoint(navigatePoint);
}
return(true);
}
public bool IsCodeFile(ProjectItem projectItem)
{
return(VsProjectScope.IsCodeFileSupported(projectItem));
}
private bool GenerateStepDefinitionSkeleton(GherkinEditorContext editorContext)
{
var bindingMatchService = GetBindingMatchService(editorContext.LanguageService);
if (bindingMatchService == null)
{
return(false);
}
var fileScope = editorContext.LanguageService.GetFileScope(waitForLatest: true);
if (fileScope == null)
{
return(false);
}
var featureTitle = GetFeatureTitle(fileScope);
var bindingCulture = editorContext.ProjectScope.SpecFlowConfiguration.BindingCulture ?? fileScope.GherkinDialect.CultureInfo;
var steps = GetUnboundSteps(bindingMatchService, fileScope, bindingCulture).ToArray();
if (steps.Length == 0)
{
MessageBox.Show("All steps are bound!", "Generate step definition skeleton");
return(true);
}
var specFlowProject = ((VsProjectScope)editorContext.ProjectScope).Project;
var defaultLanguage = VsProjectScope.GetTargetLanguage(specFlowProject);
var stepDefinitionSkeletonStyle = editorContext.ProjectScope.SpecFlowConfiguration.StepDefinitionSkeletonStyle;
using (var skeletonGeneratorForm = new GenerateStepDefinitionSkeletonForm(featureTitle, steps, specFlowProject, stepDefinitionSkeletonStyle, defaultLanguage, dte))
{
skeletonGeneratorForm.OnPreview = (form) =>
{
var skeleton = stepDefinitionSkeletonProvider.GetBindingClassSkeleton(
defaultLanguage, form.SelectedSteps, "MyNamespace",
form.ClassName, form.Style, bindingCulture);
MessageBox.Show(skeleton, "Step definition skeleton preview");
};
skeletonGeneratorForm.OnCopy = (form) =>
{
var skeleton = string.Join(Environment.NewLine,
form.SelectedSteps.Select(si => stepDefinitionSkeletonProvider.GetStepDefinitionSkeleton(
defaultLanguage, si, form.Style, bindingCulture)).Distinct()).Indent(StepDefinitionSkeletonProvider.METHOD_INDENT);
Clipboard.SetText(skeleton);
return(true);
};
skeletonGeneratorForm.OnGenerate = (form, targetPath) =>
{
var project = GetTartgetProject(targetPath, specFlowProject);
var language = VsProjectScope.GetTargetLanguage(project);
var skeleton = stepDefinitionSkeletonProvider.GetBindingClassSkeleton(
language, form.SelectedSteps, CalculateNamespace(targetPath, project),
form.ClassName, form.Style, bindingCulture);
string folder = Path.GetDirectoryName(targetPath);
if (folder != null && !Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
File.WriteAllText(targetPath, skeleton, Encoding.UTF8);
var projectItem = VsxHelper.FindProjectItemByFilePath(project, targetPath);
if (projectItem == null)
{
projectItem = project.ProjectItems.AddFromFile(targetPath);
}
if (projectItem != null)
{
projectItem.Open();
}
return(true);
};
skeletonGeneratorForm.ShowDialog();
}
return(true);
}
public VsProjectScopeReference(VsProjectScope vsProjectScope) : base(vsProjectScope.Project)
{
VsProjectScope = vsProjectScope;
}
