public GenerateStepDefinitionSkeletonForm(string featureTitle, StepInstance[] steps, Project specFlowProject, StepDefinitionSkeletonStyle stepDefinitionSkeletonStyle, ProgrammingLanguage defaultLanguage, DTE dte)
{
this.dte = dte;
InitializeComponent();
stepsList.BeginUpdate();
stepsList.Items.Clear();
foreach (var step in steps)
{
stepsList.Items.Add(new ListItem(step), true);
}
stepsList.EndUpdate();
classNameTextBox.Text = string.Format("{0} Steps", featureTitle).ToIdentifier();
styleComboBox.BeginUpdate();
var styles = Enum.GetValues(typeof (StepDefinitionSkeletonStyle)).Cast<StepDefinitionSkeletonStyle>()
.Where(value => value != StepDefinitionSkeletonStyle.MethodNameRegex || defaultLanguage == ProgrammingLanguage.FSharp)
.ToArray();
styleComboBox.Items.Clear();
styleComboBox.Items.AddRange(styles.Select(s => new StyleItem(s)).ToArray<object>());
int selectedIndex = Array.IndexOf(styles, stepDefinitionSkeletonStyle);
styleComboBox.SelectedIndex = selectedIndex < 0 ? 0 : selectedIndex;
styleComboBox.EndUpdate();
defaultFolder = Path.Combine(VsxHelper.GetProjectFolder(specFlowProject), "StepDefinitions");
if (!Directory.Exists(defaultFolder))
defaultFolder = VsxHelper.GetProjectFolder(specFlowProject);
}
private void btnExport_Click(object sender, EventArgs e)
{
if (rbLayerSelected.Checked)
LayerOption = ExportLayer.SelectedOnly;
else if (rbLayerVisible.Checked)
LayerOption = ExportLayer.VisibleOnly;
else if (rbLayerAll.Checked)
LayerOption = ExportLayer.All;
if (rbLanguageCPP.Checked)
LanguageOption = ProgrammingLanguage.CPP;
else if (rbLanguageCS.Checked)
LanguageOption = ProgrammingLanguage.CSharp;
else if (rbLanguageActionScript.Checked)
LanguageOption = ProgrammingLanguage.ActionScript;
else if (rbLanguageXML.Checked)
LanguageOption = ProgrammingLanguage.XML;
else if (rbLanguageXMLLite.Checked)
LanguageOption = ProgrammingLanguage.XMLLite;
if (rbTileBMP.Checked)
TileOption = ImageFormat.Bmp;
else if (rbTileJPEG.Checked)
TileOption = ImageFormat.Jpeg;
else if (rbTileGIF.Checked)
TileOption = ImageFormat.Gif;
else if (rbTilePNG.Checked)
TileOption = ImageFormat.Png;
}
public void TraceNoMatchingStepDefinition(StepArgs stepArgs, ProgrammingLanguage targetLanguage, List<BindingMatch> matchesWithoutScopeCheck)
{
// string stepDescription = stepFormatter.GetStepDescription(stepArgs);
// return new BindingException(
// string.Format("Multiple step definitions found, but none of them have matching scope for step '{0}': {1}",
// stepDescription,
// string.Join(", ", matches.Select(m => GetMethodText(m.StepBinding.MethodInfo)).ToArray())));
IStepDefinitionSkeletonProvider stepDefinitionSkeletonProvider = ObjectContainer.StepDefinitionSkeletonProvider(targetLanguage);
StringBuilder message = new StringBuilder();
if (matchesWithoutScopeCheck == null || matchesWithoutScopeCheck.Count == 0)
message.AppendLine("No matching step definition found for the step. Use the following code to create one:");
else
{
string preMessage = string.Format("No matching step definition found for the step. There are matching step definitions, but none of them have matching scope for this step: {0}.",
string.Join(", ", matchesWithoutScopeCheck.Select(m => stepFormatter.GetMatchText(m, null)).ToArray()));
traceListener.WriteToolOutput(preMessage);
message.AppendLine("Change the scope or use the following code to create a new step definition:");
}
message.Append(
stepDefinitionSkeletonProvider.GetBindingClassSkeleton(
stepDefinitionSkeletonProvider.GetStepDefinitionSkeleton(stepArgs))
.Indent(StepDefinitionSkeletonProviderBase.CODEINDENT));
traceListener.WriteToolOutput(message.ToString());
}
public static string SolutionFile(ProgrammingLanguage language, bool Is2010)
{
if (language == ProgrammingLanguage.CSharp)
{
if (Is2010)
{
if (null == _solutionFile2010CS)
_solutionFile2010CS = Translator.ReadString("ProjectWizard.CodeTemplates.Solution2010CS.txt");
return _solutionFile2010CS;
}
else
{
if (null == _solutionFile2008CS)
_solutionFile2008CS = Translator.ReadString("ProjectWizard.CodeTemplates.Solution2008CS.txt");
return _solutionFile2008CS;
}
}
else
{
if (Is2010)
{
if (null == _solutionFile2010VB)
_solutionFile2010VB = Translator.ReadString("ProjectWizard.CodeTemplates.Solution2010VB.txt");
return _solutionFile2010VB;
}
else
{
if (null == _solutionFile2008VB)
_solutionFile2008VB = Translator.ReadString("ProjectWizard.CodeTemplates.Solution2008VB.txt");
return _solutionFile2008VB;
}
}
}
public MigrationsTheoryCommand(IMethodInfo method, DatabaseProvider provider, ProgrammingLanguage language)
:base(method)
{
_provider = provider;
_language = language;
DisplayName = string.Format(
"{0} - DatabaseProvider: {1}, ProgrammingLanguage: {2}", DisplayName, _provider, _language);
}
public MigrationsTestCase(IMessageSink diagnosticMessageSink, TestMethodDisplay defaultMethodDisplay, TestMethodDisplayOptions defaultMethodDisplayOptions, ITestMethod testMethod, DatabaseProvider provider, ProgrammingLanguage language)
: base(diagnosticMessageSink, defaultMethodDisplay, defaultMethodDisplayOptions, testMethod)
{
_provider = provider;
_language = language;
DisplayName = string.Format(
"{0} - DatabaseProvider: {1}, ProgrammingLanguage: {2}", DisplayName, _provider, _language);
}
public static bool PrintWithDRV(byte[] bytes, string printerName, bool isWriteLog, ProgrammingLanguage progLanguage)
{
PrinterType = DeviceType.DRV;
PrinterName = printerName;
IsWriteLog = isWriteLog;
PrinterProgrammingLanguage = progLanguage;
return(PrintGraphics(bytes));
}
public MigrationsTheoryCommand(IMethodInfo method, DatabaseProvider provider, ProgrammingLanguage language)
: base(method)
{
_provider = provider;
_language = language;
DisplayName = string.Format(
"{0} - DatabaseProvider: {1}, ProgrammingLanguage: {2}", DisplayName, _provider, _language);
}
public static bool PrintWithLPT(byte[] bytes, int port, bool isWriteLog, ProgrammingLanguage progLanguage)
{
PrinterType = DeviceType.LPT;
Port = port;
IsWriteLog = isWriteLog;
PrinterProgrammingLanguage = progLanguage;
return(PrintGraphics(bytes));
}
public static CompilationQuery Create(string sourceCode, string input, ProgrammingLanguage language)
{
Fail.IfNullOrEmpty(sourceCode);
Fail.IfNull(input);
Fail.IfNull(language);
return(new CompilationQuery(sourceCode, input, language));
}
public async Task <int> GetNumberOfSearchResults(ProgrammingLanguage programmingLanguage)
{
var query = $"customsearch/v1?key={GOOGLE_API_KEY}&cx={GOOGLE_CUSTOM_SEARCH_ENGINE_ID}&q={programmingLanguage.Name}";
var response = await httpClient.GetStringAsync(query);
return(0);
}
public async Task <ActionResult> DeleteConfirmed(long id)
{
ProgrammingLanguage programmingLanguage = await db.ProgrammingLanguages.FindAsync(id);
db.ProgrammingLanguages.Remove(programmingLanguage);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
//TODO: Webscrapping to get list of current programming languages in the world via Wikipedia
//Wikipedia page: https://en.wikipedia.org/wiki/List_of_programming_languages
//File with source code is located in this file. Name: Wiki_List_of_Programming_Languages.html
public List <ProgrammingLanguage> GetProgrammingLanguageList()
{
List <ProgrammingLanguage> listOfProgrammingLanguages = new List <ProgrammingLanguage>();
ProgrammingLanguage program1 = new ProgrammingLanguage()
{
Id = 1, Name = "C++"
};
ProgrammingLanguage program2 = new ProgrammingLanguage()
{
Id = 2, Name = "C#"
};
ProgrammingLanguage program3 = new ProgrammingLanguage()
{
Id = 3, Name = "COBOL"
};
ProgrammingLanguage program4 = new ProgrammingLanguage()
{
Id = 4, Name = "Java"
};
ProgrammingLanguage program5 = new ProgrammingLanguage()
{
Id = 5, Name = "JavaScript"
};
ProgrammingLanguage program6 = new ProgrammingLanguage()
{
Id = 6, Name = "Go"
};
ProgrammingLanguage program7 = new ProgrammingLanguage()
{
Id = 7, Name = "Python"
};
ProgrammingLanguage program8 = new ProgrammingLanguage()
{
Id = 8, Name = "Ruby"
};
ProgrammingLanguage program9 = new ProgrammingLanguage()
{
Id = 9, Name = "Game Maker Language"
};
ProgrammingLanguage program10 = new ProgrammingLanguage()
{
Id = 10, Name = "Kotlin"
};
listOfProgrammingLanguages.Add(program1);
listOfProgrammingLanguages.Add(program2);
listOfProgrammingLanguages.Add(program3);
listOfProgrammingLanguages.Add(program4);
listOfProgrammingLanguages.Add(program5);
listOfProgrammingLanguages.Add(program6);
listOfProgrammingLanguages.Add(program7);
listOfProgrammingLanguages.Add(program8);
listOfProgrammingLanguages.Add(program9);
listOfProgrammingLanguages.Add(program10);
return(listOfProgrammingLanguages);
}
public CodeEditor(ProgrammingLanguage language)
{
_language = language;
Handler.SetProgrammingLanguage(language, GetKeywords(language));
SetColor(Section.Comment, Drawing.Colors.DarkGray, Drawing.Colors.White);
SetColor(Section.Keyword, Drawing.Colors.Blue, Drawing.Colors.White);
SetColor(Section.LineNumber, Drawing.Colors.Gray, Drawing.Colors.White);
}
/// <summary>
/// Initializes a new instance of the <see cref="Word"/> class.
/// </summary>
/// <param name="startPosition">
/// The <see cref="TextPointer"/> pointing at the first letter of the <see cref="Word"/>.
/// </param>
/// <param name="endPosition">
/// The <see cref="TextPointer"/> pointing at the last letter of the <see cref="Word"/>.
/// </param>
/// <param name="content">
/// A <see cref="string"/> representing the <see cref="Word.Content"/>. Should be exactly in the range of the two <see cref="TextPointer"/>.
/// </param>
/// <param name="programmingLanguage">
/// The <see cref="programmingLanguage"/> used to recognize the <see cref="Word"/>.
/// </param>
/// <param name="allWords">
/// An <see cref="IEnumerable{Word}"/> containing all <see cref="Word"/>s in the code.
/// </param>
/// <exception cref="ArgumentNullException">
/// One or all of the parameters were passed as null.
/// </exception>
/// <exception cref="ArgumentException">
/// <see cref="endPosition"/> points at a <see cref="char"/> behind <see cref="startPosition"/>.
/// </exception>
private Word(TextPointer startPosition, TextPointer endPosition, string content, ProgrammingLanguage programmingLanguage, List <Word> allWords)
{
this.programmingLanguage = programmingLanguage;
this.allWords = allWords;
this.StartPosition = startPosition;
this.EndPosition = endPosition;
this.Content = content;
this.Type = this.GetTypeOfWord(this, allWords);
}
public CodeFile(
ProgrammingLanguage language,
string fileName,
string content)
{
Language = language;
Content = content;
FileName = fileName;
}
public string GetStepDefinitionClassTemplate(ProgrammingLanguage language)
{
string key = string.Format("{0}/StepDefinitionClass", language);
string template = GetTemplate(key);
if (template == null)
return MissingTemplate(key);
return template;
}
public string GetStepDefinitionTemplate(ProgrammingLanguage language, bool withRegex)
{
string key = string.Format("{0}/StepDefinition{1}", language, withRegex ? "Regex" : "");
string template = GetTemplate(key);
if (template == null)
return MissingTemplate(key);
return template;
}
public Developer(double idNumber, string firstName, string lastName, string companyEmail, ProgrammingLanguage language, bool pluralSightLicense)
{
IdNumber = idNumber;
FirstName = firstName;
LastName = lastName;
CompanyEmail = companyEmail;
SpecificLanguage = language;
PluralSightLicense = pluralSightLicense;
}
public ProgrammingLanguage Update(int id, ProgrammingLanguage programmingLanguage)
{
var updatedLanguage = GetById(id);
if (updatedLanguage != null)
{
updatedLanguage.Name = programmingLanguage.Name;
}
return(updatedLanguage);
}
private void Init()
{
// initialized some variables
ShowGridOn = true;
ShowWalkableOn = false;
SelectedTile = null;
Selection = new SelectionTool();
Format = ImageFormat.Bmp;
Language = ProgrammingLanguage.CPP;
}
public async Task <ActionResult> EditLanguage(int languageId)
{
Debug.WriteLine("AdministratorController.EditLanguage(int languageId)");
ProgrammingLanguage language = await _programmingLanguageProvider.GetProgrammingLanguageAsync(languageId);
ProgrammingLanguageViewModel languageViewModel = new ProgrammingLanguageViewModel(language);
return(View("_ProgrammingLanguageEdit", languageViewModel));
}
public ProgrammingLanguageViewModel(ProgrammingLanguage language, bool isSelected)
{
if (language == null)
{
throw new ArgumentNullException("language");
}
LanguageId = language.LanguageId;
LanguageName = language.LanguageName;
IsSelected = isSelected;
}
public void ProgrammingLanguageService_GetByIdWithFrameworks_NonRelatedFrameworks()
{
dynamic testData = GetTestData(1, 2, 2);
ProgrammingLanguage programmingLanguageWithFrameworks = testData.ProgrammingLanguageService.GetByIdWithFrameworks(testData.ProgrammingLanguage.Id);
Assert.NotNull(programmingLanguageWithFrameworks);
Assert.Equal(testData.ProgrammingLanguage.Id, programmingLanguageWithFrameworks.Id);
Assert.NotNull(programmingLanguageWithFrameworks.Frameworks);
Assert.Equal(programmingLanguageWithFrameworks.Frameworks.Count(), 0);
}
public void SetProgrammingLanguage(ProgrammingLanguage language, string[] keywordSets)
{
Language = language;
if (keywordSets != null)
{
for (int i = 0; i < keywordSets.Length; i++)
{
SetKeywords(i, keywordSets[i]);
}
}
}
/// <summary>
/// Constructor
/// </summary>
public OperationsView()
{
InitializeComponent();
_codeColumn = new DataGridViewTextBoxColumn();
_codeColumn.Name = "Filters Applied";
_codeColumn.ReadOnly = true;
_codeColumn.Width = 300;
dataGridView1.Columns.Add(_codeColumn);
dataGridView1.RowHeadersVisible = false;
_language = ProgrammingLanguage.CSharp;
}
/// <summary>
/// Constructor
/// </summary>
public OperationsView()
{
InitializeComponent();
_codeColumn = new DataGridViewTextBoxColumn();
_codeColumn.Name = "code";
_codeColumn.ReadOnly = true;
_codeColumn.Width = 300;
dataGridView1.Columns.Add(_codeColumn);
dataGridView1.RowHeadersVisible = false;
_language = ProgrammingLanguage.CSharp;
}
public static string ToOptionValue(this ProgrammingLanguage p)
{
try
{
return(optionValues[(int)p]);
}
catch (IndexOutOfRangeException e)
{
throw new NotImplementedException(string.Format("Convertion from {0} to option value is not supported", p), e);
}
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Title")] ProgrammingLanguage programmingLanguage)
{
if (ModelState.IsValid)
{
db.Entry(programmingLanguage).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(programmingLanguage));
}
public static IStepDefinitionSkeletonProvider StepDefinitionSkeletonProvider(ProgrammingLanguage targetLanguage)
{
switch (targetLanguage)
{
case ProgrammingLanguage.VB:
return(GetOrCreate(ref _stepDefinitionSkeletonProviderVB, typeof(StepDefinitionSkeletonProviderVB)));
default:
return(GetOrCreate(ref _stepDefinitionSkeletonProviderCS, typeof(StepDefinitionSkeletonProviderCS)));
}
}
internal static string LangToFileExtension(ProgrammingLanguage lang)
{
switch (lang)
{
case ProgrammingLanguage.ACRYLIC: return(".acr");
case ProgrammingLanguage.CRAYON: return(".cry");
default: throw new System.InvalidOperationException();
}
}
public async Task <IActionResult> Create([Bind("ID,Language,Experience")] ProgrammingLanguage programmingLanguage)
{
if (ModelState.IsValid)
{
_context.Add(programmingLanguage);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(programmingLanguage));
}
public static void GetBlockTypeAndLanguage(this ICoreObject coreObject,
out BlockType blockType,
out ProgrammingLanguage blockLanguage)
{
blockType = BlockType.Undef;
blockLanguage = ProgrammingLanguage.Undef;
Reflector.RunStaticMethodByName(typeof(EditorStarterFacade),
"GetBlockTypeAndLanguage",
ReflectionWays.SystemReflection,
coreObject, blockType, blockLanguage);
}
//Get the details of a particular Language
public ProgrammingLanguage GetLanguageData(int id)
{
try
{
ProgrammingLanguage Language = db.tblLanguage.Find(id);
return(Language);
}
catch
{
throw;
}
}
public override string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
if (getSkeleton != null)
return getSkeleton(stepInstance);
if (usageIndex < stepDefinitionSkeletons.Length)
{
return stepDefinitionSkeletons[usageIndex++];
}
return stepDefinitionSkeletons[stepDefinitionSkeletons.Length - 1];
}
public IStepDefinitionSkeletonProvider GetProvider(ProgrammingLanguage targetLanguage, GherkinDialect gherkinDialect)
{
switch (targetLanguage)
{
case ProgrammingLanguage.CSharp:
return new StepDefinitionSkeletonProviderCS(gherkinDialect);
case ProgrammingLanguage.VB:
return new StepDefinitionSkeletonProviderVB(gherkinDialect);
default:
return new StepDefinitionSkeletonProviderCS(gherkinDialect);
}
}
public bool IsProgrammingLanguageEnable(Solomon.TypesExtensions.ProgrammingLanguages PL)
{
ProgrammingLanguage pl = context.ProgrammingLanguages.FirstOrDefault(l => l.ProgrammingLanguageID == PL);
if (pl != null)
{
context.Entry(pl).Reload();
return(pl.Enable);
}
return(false);
}
//To Update the records of a particluar Language
public void UpdateLanguage(ProgrammingLanguage Language)
{
try
{
db.Entry(Language).State = EntityState.Modified;
db.SaveChanges();
}
catch
{
throw;
}
}
public string GetBindingClassSkeleton(ProgrammingLanguage language, StepInstance[] stepInstances, string namespaceName, string className, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var template = templateProvider.GetStepDefinitionClassTemplate(language);
var bindings = string.Join(Environment.NewLine, GetOrderedSteps(stepInstances)
.Select(si => GetStepDefinitionSkeleton(language, si, style, bindingCulture)).Distinct().ToArray()).TrimEnd();
if (bindings.Length > 0)
bindings = bindings.Indent(METHOD_INDENT);
//{namespace}/{className}/{bindings}
return ApplyTemplate(template, new { @namespace = namespaceName, className, bindings});
}
//To Add new Language record
public void AddLanguage(ProgrammingLanguage Language)
{
try
{
db.tblLanguage.Add(Language);
db.SaveChanges();
}
catch
{
throw;
}
}
public CompilationScope(
ParserContext context,
ExternalAssemblyMetadata metadata,
Locale locale,
ProgrammingLanguage programmingLanguage)
{
this.Locale = locale;
this.ProgrammingLanguage = programmingLanguage;
this.ScopeNumId = context.ScopeIdAlloc++;
this.Metadata = metadata;
this.ScopeKey = this.Metadata.CanonicalKey;
}
public FeatureInfo(CultureInfo language, string title, string description, ProgrammingLanguage programmingLanguage, params string[] tags)
{
if (language.IsNeutralCulture)
{
// for backwards compatibility (execution of files that were generated with pre 1.3)
language = LanguageHelper.GetSpecificCultureInfo(language);
}
Language = language;
Title = title;
Description = description;
GenerationTargetLanguage = programmingLanguage;
Tags = tags ?? new string[0];
}
public virtual string GetStepDefinitionSkeleton(ProgrammingLanguage language, StepInstance stepInstance, StepDefinitionSkeletonStyle style, CultureInfo bindingCulture)
{
var withRegex = style == StepDefinitionSkeletonStyle.RegexAttribute;
var template = templateProvider.GetStepDefinitionTemplate(language, withRegex);
var analyzedStepText = Analyze(stepInstance, bindingCulture);
//{attribute}/{regex}/{methodName}/{parameters}
return ApplyTemplate(template, new
{
attribute = stepInstance.StepDefinitionType,
regex = withRegex ? GetRegex(analyzedStepText) : "",
methodName = GetMethodName(stepInstance, analyzedStepText, style, language),
parameters = string.Join(", ", analyzedStepText.Parameters.Select(p => ToDeclaration(language, p)).ToArray())
});
}
/// <summary>
/// Creates a class file, based on a table and it's columns
/// </summary>
/// <param name="table">the database table to be based in</param>
/// <param name="programmingLanguage">the programming language used (some may differ from one another)</param>
/// <returns></returns>
public virtual ClassFile CreateClass(GenericDatabaseTable table, ProgrammingLanguage programmingLanguage)
{
ClassFile file = new ClassFile();
file.FileName = ClassFileName(table.Name);
string templateFolder = AppDomain.CurrentDomain.BaseDirectory + "Templates";
string languagePrefix = Enum.GetName(typeof(ProgrammingLanguage), programmingLanguage);
string classTemplate = File.ReadAllText(string.Concat(templateFolder, "\\", languagePrefix, "Class.eixox"));
string attributeTemplate = System.IO.File.ReadAllText(string.Concat(templateFolder, "\\", languagePrefix, "Attribute.eixox"));
List<string> attributes = new List<string>();
foreach (GenericDatabaseColumn column in table.Columns)
{
List<string> annotations = new List<string>();
// Adding restriction annotation
if (column.MaxLength > 0)
annotations.Add(Annotations.MaxLength.Replace("{{value}}", column.MaxLength.ToString()));
// Adding UI annotations
if (column.IsIdentity)
annotations.Add(Annotations.UIHidden);
else
annotations.Add(Annotations.UISingleLine);
// Adding database annotations
if (column.IsIdentity)
annotations.Add(Annotations.DatabaseIdentityColumn);
else if (column.Name.Equals("DateCreated", StringComparison.OrdinalIgnoreCase))
annotations.Add(Annotations.DateGeneratorInsert);
else if (column.Name.Equals("DateUpdated", StringComparison.OrdinalIgnoreCase))
annotations.Add(Annotations.DateGeneratorUpdate);
else
annotations.Add(Annotations.DatabaseColumn);
attributes.Add(attributeTemplate
.Replace("{{annotations}}", String.Join("\n\t\t", annotations))
.Replace("{{datatype}}", column.DataType.Name.ToString())
.Replace("{{name}}", column.Name)
.Replace("{{visibility}}", "\t\tpublic"));
}
file.FileContent = classTemplate
.Replace("{{namespace}}", table.DatabaseName)
.Replace("{{classname}}", table.Name)
.Replace("{{attributes}}", String.Join("\n\n\t\t", attributes));
return file;
}
public FeatureInfo(CultureInfo language, string title, string description, ProgrammingLanguage programmingLanguage, params string[] tags)
{
if (language.IsNeutralCulture)
{
//TODO: as Gherkin parser does not provide the default specific culture for neutral languages (eg. 'sv' -> 'sv-SE'), this code will be required and has to be extended
// for backwards compatibility (execution of files that were generated with pre 1.3)
language = LanguageHelper.GetSpecificCultureInfo(language);
}
Language = language;
Title = title;
Description = description;
GenerationTargetLanguage = programmingLanguage;
Tags = tags ?? new string[0];
}
public void ShouldReturnTheLanguageAndNumberOfLines(string filepath, string resourceName,
ProgrammingLanguage expectedLanguage, int expectedlines)
{
var detector = new ExtensionDetector();
var assembly = Assembly.GetExecutingAssembly();
var names = Assembly.GetExecutingAssembly().GetManifestResourceNames();
using (var stream = assembly.GetManifestResourceStream($"Proggr.LangDetect.Tests.Fixtures.{resourceName}"))
using (var reader = new StreamReader(stream))
{
var contents = reader.ReadToEnd();
var result = detector.Detect(filepath, contents);
Assert.Equal(expectedLanguage, result.Language);
Assert.Equal(expectedlines, result.Lines);
}
}
public void TraceNoMatchingStepDefinition(StepInstance stepInstance, ProgrammingLanguage targetLanguage, CultureInfo bindingCulture, List<BindingMatch> matchesWithoutScopeCheck)
{
StringBuilder message = new StringBuilder();
if (matchesWithoutScopeCheck == null || matchesWithoutScopeCheck.Count == 0)
message.AppendLine("No matching step definition found for the step. Use the following code to create one:");
else
{
string preMessage = string.Format("No matching step definition found for the step. There are matching step definitions, but none of them have matching scope for this step: {0}.",
string.Join(", ", matchesWithoutScopeCheck.Select(m => stepFormatter.GetMatchText(m, null)).ToArray()));
traceListener.WriteToolOutput(preMessage);
message.AppendLine("Change the scope or use the following code to create a new step definition:");
}
message.Append(
stepDefinitionSkeletonProvider.GetStepDefinitionSkeleton(targetLanguage, stepInstance, runtimeConfiguration.StepDefinitionSkeletonStyle, bindingCulture)
.Indent(StepDefinitionSkeletonProvider.METHOD_INDENT));
traceListener.WriteToolOutput(message.ToString());
}
public ClassesFromDatabaseCommand(ProgrammingLanguage language, string directory, IRocketLauncherView view)
{
this.Language = language;
this.View = view;
this._Directory = directory;
switch (language)
{
case ProgrammingLanguage.Csharp:
this.ClassGenerator = new CSharpClassGenerator(directory);
break;
case ProgrammingLanguage.Java:
break;
case ProgrammingLanguage.VBNET:
break;
default:
break;
}
}
private string GetMethodName(StepInstance stepInstance, AnalyzedStepText analyzedStepText, StepDefinitionSkeletonStyle style, ProgrammingLanguage language)
{
var keyword = LanguageHelper.GetDefaultKeyword(stepInstance.StepContext.Language, stepInstance.StepDefinitionType);
switch (style)
{
case StepDefinitionSkeletonStyle.RegexAttribute:
return keyword.ToIdentifier() + string.Concat(analyzedStepText.TextParts.ToArray()).ToIdentifier();
case StepDefinitionSkeletonStyle.MethodNameUnderscores:
return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsUnderscored, "_{0}");
case StepDefinitionSkeletonStyle.MethodNamePascalCase:
return GetMatchingMethodName(keyword, analyzedStepText, stepInstance.StepContext.Language, AppendWordsPascalCase, "_{0}_");
case StepDefinitionSkeletonStyle.MethodNameRegex:
if (language != ProgrammingLanguage.FSharp)
goto case StepDefinitionSkeletonStyle.MethodNameUnderscores;
return "``" + GetRegex(analyzedStepText) + "``";
default:
throw new NotSupportedException();
}
}
public static Boolean IsValidName(string name, ProgrammingLanguage language)
{
if (!IsValidNameFormat(name))
return false;
switch (language)
{
case ProgrammingLanguage.CPP:
return IsValidCPPWord(name);
case ProgrammingLanguage.CSharp:
return IsValidCSharpWord(name);
case ProgrammingLanguage.ActionScript:
return IsValidASWord(name);
case ProgrammingLanguage.XML:
return IsValidXMLWord(name);
case ProgrammingLanguage.XMLLite:
return IsValidXMLLiteWord(name);
default:
return true;
}
}
public static string TaskPaneDesigner(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _taskPaneDesignerCS)
_taskPaneDesignerCS = Translator.ReadString("ProjectWizard.CodeTemplates.TaskPaneControlDesignerCS.txt");
return _taskPaneDesignerCS;
}
else
{
if (null == _taskPaneDesignerVB)
_taskPaneDesignerVB = Translator.ReadString("ProjectWizard.CodeTemplates.TaskPaneControlDesignerVB.txt");
return _taskPaneDesignerVB;
}
}
public static string TaskPaneToolsMethod(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _taskPaneToolsMethodCS)
_taskPaneToolsMethodCS = Translator.ReadString("ProjectWizard.CodeTemplates.TaskPaneToolsMethodCS.txt");
return _taskPaneToolsMethodCS;
}
else
{
if (null == _taskPaneToolsMethodVB)
_taskPaneToolsMethodVB = Environment.NewLine + Translator.ReadString("ProjectWizard.CodeTemplates.TaskPaneToolsMethodVB.txt");
return _taskPaneToolsMethodVB;
}
}
public static string Using(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _usingCSharp)
_usingCSharp = Translator.ReadString("ProjectWizard.CodeTemplates.UsingCSharp.txt");
return _usingCSharp;
}
else
{
if (null == _usingVB)
_usingVB = Translator.ReadString("ProjectWizard.CodeTemplates.UsingVB.txt");
return _usingVB;
}
}
public static string RibbonImplement(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _ribbonImplementCSharp)
_ribbonImplementCSharp = Translator.ReadString("ProjectWizard.CodeTemplates.RibbonImplementCSharp.txt");
return _ribbonImplementCSharp;
}
else
{
if (null == _ribbonImplementVB)
_ribbonImplementVB = Translator.ReadString("ProjectWizard.CodeTemplates.RibbonImplementVB.txt");
return _ribbonImplementVB;
}
}
public static string RegisterCode(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _registerCodeCSharp)
_registerCodeCSharp = Translator.ReadString("ProjectWizard.CodeTemplates.RegisterCodeCSharp.txt");
return _registerCodeCSharp;
}
else
{
if (null == _registerCodeVB)
_registerCodeVB = Translator.ReadString("ProjectWizard.CodeTemplates.RegisterCodeVB.txt");
return _registerCodeVB;
}
}
public static string ClassicUICall(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _classicUIMethodCallCSharp)
_classicUIMethodCallCSharp = Translator.ReadString("ProjectWizard.CodeTemplates.CreateUICallCodeCSharp.txt");
return _classicUIMethodCallCSharp;
}
else
{
if (null == _classicUIMethodCallVB)
_classicUIMethodCallVB = Translator.ReadString("ProjectWizard.CodeTemplates.CreateUICallCodeVB.txt");
return _classicUIMethodCallVB;
}
}
public static string AppFieldCode(ProgrammingLanguage language)
{
if (language == ProgrammingLanguage.CSharp)
{
if (null == _appFieldCodeCSharp)
_appFieldCodeCSharp = Translator.ReadString("ProjectWizard.CodeTemplates.ApplicationFieldCodeCSharp.txt");
return _appFieldCodeCSharp;
}
else
{
if (null == _appFieldCodeVB)
_appFieldCodeVB = Translator.ReadString("ProjectWizard.CodeTemplates.ApplicationFieldCodeVB.txt");
return _appFieldCodeVB;
}
}
public VariantAttribute(DatabaseProvider provider, ProgrammingLanguage language)
{
DatabaseProvider = provider;
ProgrammingLanguage = language;
}
/// <summary>
/// Represent this operation as code
/// </summary>
/// <returns></returns>
public String ToCode(ProgrammingLanguage language)
{
Type[] genericArguments = _mi.GetGenericArguments();
Object[] genericParameters = new object[genericArguments.Length];
Object[] nonGenericParameters = new object[_parameters.Length - genericParameters.Length];
Array.Copy(_parameters, genericParameters, genericParameters.Length);
Array.Copy(_parameters, genericParameters.Length, nonGenericParameters, 0, nonGenericParameters.Length);
String genericArgString =
genericArguments.Length > 0 ?
String.Join(",", Array.ConvertAll<Object, String>(genericParameters,
delegate(Object t)
{
return (t as GenericParameter).SelectedType.Name;
}))
: string.Empty;
String res = String.Empty;
switch (language)
{
case ProgrammingLanguage.CSharp:
if (genericArguments.Length > 0)
genericArgString = String.Format("<{0}>", genericArgString);
res = String.Format("{0}.{1}{2}({3})",
"{instance}",
Method.Name,
genericArgString,
String.Join(", ", System.Array.ConvertAll<Object, String>(nonGenericParameters, delegate(Object p) { return ParameterToCode(p, language); })));
break;
case ProgrammingLanguage.CPlusPlus:
if (genericArguments.Length > 0)
genericArgString = String.Format("<{0}>", genericArgString);
res = String.Format("{0}->{1}{2}({3})",
"{instance}",
Method.Name,
genericArgString,
String.Join(", ", System.Array.ConvertAll<Object, String>(nonGenericParameters, delegate(Object p) { return ParameterToCode(p, language); })));
break;
}
return res;
}
private static String ParameterToCode(Object parameter, ProgrammingLanguage language)
{
ICodeGenerable gen = parameter as ICodeGenerable;
return gen == null ? Convert.ToString(parameter) :
gen.ToCode(language);
}
