static void Main(string[] args)
{
Console.ForegroundColor = ConsoleColor.Blue;
Console.OutputEncoding = System.Text.Encoding.GetEncoding(28591);
Console.WriteLine(Logo.Art);
Console.WriteLine("Ultramarine QueryLanguage CLI");
Console.ResetColor();
while (true)
{
Console.Write('>');
var input = Console.ReadLine();
if (input.Equals("exit", StringComparison.OrdinalIgnoreCase))
{
break;
}
try
{
var compiler = new ConditionCompiler(input);
Console.WriteLine(compiler.Execute());
}
catch
{
//TODO: proper parsing error
Console.WriteLine("Can't understand that expression. Yet!");
}
}
}
public List <ICodeElementModel> GetCodeElements(string expression)
{
var result = new List <CodeElement>();
var codeModel = GetCodeModel(_projectItem);
if (codeModel == null)
{
return(null);
}
foreach (CodeElement codeElement in _projectItem.FileCodeModel.CodeElements)
{
if (codeElement.IsCodeType)
{
var condition = new ConditionCompiler(expression, codeElement.Name);
if (condition.Execute())
{
result.Add(codeElement);
}
else
{
result.AddRange(GetInnerCodeElements(codeElement, expression));
}
}
else
{
result.AddRange(GetInnerCodeElements(codeElement, expression));
}
}
return(result.Select <CodeElement, ICodeElementModel>(c => new CodeElementModel(c)).ToList());
}
public static bool Check(string propertyName, string conditionTemplate)
{
var condition = conditionTemplate.Replace("${property}", propertyName);
var compiler = new ConditionCompiler(condition);
return((bool)compiler.Execute());
}
public void ShouldEvaluateEqualsConditionAsTrue()
{
var expression = "'Test1' equals 'Test1'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateOrTruthyComplexConditions()
{
var expression = "'Test1' equals 'Test1' or 'Test2' equals 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateFalsyComplexConditions()
{
var expression = "Test2 endsWith Test1 and Test2 endsWith Test2";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateAndTruthyComplexConditionsWrappedInParens()
{
var expression = "(Test1 endsWith Test1) and (Test2 endsWith Test2)";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateEndsWithConditionAsTrue()
{
var expression = "Test1 endsWith Test1";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateOrTruthyComplexConditions()
{
var expression = "Test1 endsWith Test1 or Test2 endsWith Test2";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateEqualsConditionAsFalse()
{
var expression = "Test1 equals Test2";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateAndTruthyComplexConditions()
{
var expression = "Test1 equals Test1 and Test2 equals Test2";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateEqualsConditionAsTrueWrappedInParens()
{
var expression = "(Test1 equals Test1)";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateConditionsContainingTrueKeyword()
{
var expression = "true contains true";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateContainsConditionAsTrueWrappedInParens()
{
var expression = "('Test1' contains 't1')";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateContainsConditionWithWhitespacesAsFalse()
{
var expression = "'Solution items' contains 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateContainsWithNoContainingString()
{
var expression = "'test1' contains 'p'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateOrTruthyComplexConditionsWithSpecialOperands()
{
var expression = "'Test1.Test1' contains 'Test1' or 'Test2' contains 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateContainsConditionWithAliasAsFalse()
{
var expression = "$this contains 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateAndTruthyComplexConditionsWrappedInParens()
{
var expression = "('Test1' contains 'Test1') and ('Test2' contains 'Test2')";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateFalseComplexConditions()
{
var expression = "'Test2' contains 'Test1' and 'Test1' contains 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateStartsWithConditionAsFalse()
{
var expression = "'Test1' startsWith 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateAndTruthyComplexConditions()
{
var expression = "'Test1' startsWith 'Test1' and 'Test2' startsWith 'Test2'";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
public void ShouldEvaluateConditionsContainingCombinedKeyword()
{
var expression = "true startsWith false";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsFalse(result);
}
public void ShouldEvaluateStartsWithConditionAsTrueWrappedInParens()
{
var expression = "('Test1' startsWith 'te')";
var compiler = new ConditionCompiler(expression);
var result = (bool)compiler.Execute();
Assert.IsTrue(result);
}
/// <summary>
/// Gets all the projects which satisfy given expression
/// </summary>
/// <param name="projectNameExpression">Expression given in the QueryLanguage form</param>
/// <returns>List of Visual Studio projects</returns>
public List <Project> GetProjects(string expression)
{
var result = new List <Project>();
var projects = GetProjects();
foreach (var project in projects)
{
var projectName = project.Name;
var condition = new ConditionCompiler(expression, projectName);
if (condition.Execute())
{
result.Add(project);
}
}
return(result);
}
public IEnumerable<IProjectItemModel> GetProjectItems(string expression, string propertyName = "FileName")
{
var result = new List<IProjectItemModel>();
foreach (var item in ProjectItems)
{
var condition = new ConditionCompiler(expression, item.GetProperty(propertyName));
if (condition.Execute())
result.Add(item);
var subItems = item.GetProjectItems(expression);
if (subItems != null)
{
subItems.Remove(item);
result.AddRange(subItems);
}
}
return result;
}
public List <IProjectItemModel> GetProjectItems(string expression)
{
var result = new List <IProjectItemModel>();
var condition = new ConditionCompiler(expression, Name);
if (condition.Execute())
{
result.Add(this);
}
foreach (var item in ProjectItems)
{
var subItems = item.GetProjectItems(expression);
if (subItems != null)
{
result.AddRange(subItems);
}
}
return(result);
}
private List <CodeElement> GetCodeElements(CodeElement codeElement, string expression)
{
var result = new List <CodeElement>();
var elements = new List <CodeElement>();
switch (codeElement.Kind)
{
case vsCMElement.vsCMElementInterface:
{
var codeInterface = codeElement as CodeInterface2;
elements.AddRange(codeInterface.Parts.Cast <CodeElement>());
break;
}
case vsCMElement.vsCMElementClass:
{
var codeClass = codeElement as CodeClass2;
elements.AddRange(codeClass.Parts.Cast <CodeElement>());
break;
}
case vsCMElement.vsCMElementStruct:
{
var codeStruct = codeElement as CodeStruct2;
elements.AddRange(codeStruct.Parts.Cast <CodeElement>());
break;
}
case vsCMElement.vsCMElementNamespace:
{
elements.AddRange(new List <CodeElement> {
codeElement
});
break;
}
}
if (!elements.Any())
{
elements.Add(codeElement);
}
foreach (var element in elements)
{
foreach (CodeElement child in element.Children)
{
var children = GetCodeElements(child, expression);
result.AddRange(children);
if (child.HasName())
{
var condition = new ConditionCompiler(expression, child.Name);
if (condition.Execute())
{
result.Add(child);
continue;
}
}
result.AddRange(GetInnerCodeElements(child, expression));
}
}
return(result);
}
