public void ColorizingTest()
{
var syntax = new[] {
Syntax.StaticKeyword,
Syntax.Space, Syntax.NewType("int"),
Syntax.Space, Syntax.Name("num"),
Syntax.Space, Syntax.EqualsOp,
Syntax.Space, Syntax.ConstVal("5")
};
var syntaxHighlighting = RexUtils.SyntaxHighlingting(new MemberDetails(syntax), RexUtils.SyntaxHighlightColors);
var regex = new Regex("<color.*>(?<const>.*)</color> <color.*>(?<type>.*)</color> (?<name>.*) = <color.*>(?<value>.*)</color>");
var match = regex.Match(syntaxHighlighting);
Assert.IsTrue(match.Success);
var _const = match.Groups["const"];
var type = match.Groups["type"];
var name = match.Groups["name"];
var value = match.Groups["value"];
Assert.AreEqual(syntax.First(i => i.Type == SyntaxType.Keyword).String, _const.Value);
Assert.AreEqual(syntax.First(i => i.Type == SyntaxType.Type).String, type.Value);
Assert.AreEqual(syntax.First(i => i.Type == SyntaxType.Name).String, name.Value);
Assert.AreEqual(syntax.First(i => i.Type == SyntaxType.ConstVal).String, value.Value);
}
public void OnEnable()
{
hideFlags = HideFlags.HideAndDontSave;
if (_instance == null)
{
_instance = this;
}
else if (_instance != this)
{
Destroy(this);
return;
}
if (NamespaceInfos == null)
{
NamespaceInfos = RexUtils.LoadNamespaceInfos(false);
}
var _compileThread = new Thread(CompilerMainThread)
{
IsBackground = true,
Name = "REX Compiler thread"
};
_compileThread.Start();
_compileThreadID = _compileThread.ManagedThreadId;
}
public static string SyntaxHighlingting(IEnumerable <Syntax> syntax)
{
if (EditorGUIUtility.isProSkin)
{
return(RexUtils.SyntaxHighlingting(syntax, RexUtils.SyntaxHighlightColors));
}
else
{
return(RexUtils.SyntaxHighlingting(syntax, RexUtils.SyntaxHighlightProColors));
}
}
internal static string SyntaxHighlingting(MemberDetails details, string search)
{
if (EditorGUIUtility.isProSkin)
{
return(RexUtils.SyntaxHighlingting(details, RexUtils.SyntaxHighlightColors, search));
}
else
{
return(RexUtils.SyntaxHighlingting(details, RexUtils.SyntaxHighlightProColors, search));
}
}
public void ColorizingPerformanceTest()
{
var mathPIHelp = Parser.Intellisense("Math.PI.");
SpeedTestAction(() =>
{
foreach (var help in mathPIHelp)
{
RexUtils.SyntaxHighlingting(help.Details, RexUtils.SyntaxHighlightColors);
}
}, 100);
}
/// <summary>
/// Uses the method info to build an member details.
/// </summary>
/// <param name="meth">Method to inspect</param>
public static MemberDetails GetMemberDetails(MethodInfo meth)
{
var syntax = new List <Syntax>();
//if (meth.IsStatic)
// syntax.AddRange(new[] { Syntax.StaticKeyword, Syntax.Space });
syntax.AddRange(RexUtils.GetCSharpRepresentation(meth.ReturnType));
syntax.AddRange(new[] { Syntax.Space, Syntax.Name(meth.Name) });
if (meth.IsGenericMethod)
{
syntax.Add(Syntax.GenericParaOpen);
syntax.AddRange(RexUtils.GenericArgumentsToSyntax(meth.GetGenericArguments().ToList(), false));
syntax.Add(Syntax.GenericParaClose);
}
syntax.Add(Syntax.ParaOpen);
var paras = meth.GetParameters();
for (int i = 0; i < paras.Length; i++)
{
if (paras[i].IsOut)
{
syntax.AddRange(new[] { Syntax.OutKeyword, Syntax.Space });
}
if (!paras[i].IsOut && !paras[i].IsIn && paras[i].ParameterType.IsByRef)
{
syntax.AddRange(new[] { Syntax.RefKeyword, Syntax.Space });
}
syntax.AddRange(RexUtils.GetCSharpRepresentation(paras[i].ParameterType));
syntax.AddRange(new[] { Syntax.Space, Syntax.ParaName(paras[i].Name) });
if (paras[i].IsOptional)
{
syntax.AddRange(new[] { Syntax.Space, Syntax.EqualsOp, Syntax.Space });
syntax.AddRange(GetSyntaxForValue(paras[i].RawDefaultValue));
}
if (i + 1 != paras.Length)
{
syntax.AddRange(new[] { Syntax.Comma, Syntax.Space });
}
}
syntax.Add(Syntax.ParaClose);
return(new MemberDetails(syntax)
{
Type = MemberType.Method
});
}
/// <summary>
/// Uses the field info to build an member details.
/// </summary>
/// <param name="field">field to inspect</param>
public static MemberDetails GetMemberDetails(FieldInfo field)
{
var syntax = new List <Syntax>();
//if (field.IsStatic && !field.IsLiteral)
// syntax.AddRange(new[] { Syntax.StaticKeyword, Syntax.Space });
if (field.IsInitOnly)
{
syntax.AddRange(new[] { Syntax.ReadonlyKeyword, Syntax.Space });
}
if (field.IsLiteral)
{
syntax.AddRange(new[] { Syntax.ConstKeyword, Syntax.Space });
}
syntax.AddRange(RexUtils.GetCSharpRepresentation(field.FieldType));
syntax.AddRange(new[] { Syntax.Space, Syntax.Name(field.Name) });
var showValue = false;
object value = null;
if (field.IsLiteral)
{
showValue = true;
value = field.GetRawConstantValue();
}
else if (field.IsStatic && field.IsInitOnly)
{
showValue = true;
value = field.GetValue(null);
}
if (showValue)
{
syntax.AddRange(new[] {
Syntax.Space,
Syntax.EqualsOp,
Syntax.Space,
});
syntax.AddRange(GetSyntaxForValue(value));
}
return(new MemberDetails(syntax)
{
Type = MemberType.Field
});
}
/// <summary>
/// Generates the equals and value part of the syntax e.g '= 3.52'
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public static IEnumerable <Syntax> GetSyntaxForValue(object value)
{
if (value == null)
{
return(new[] { Syntax.ConstVal("null") });
}
var type = value.GetType();
if (type == typeof(string))
{
return(new[] {
Syntax.QuotationMark,
Syntax.ConstVal(value.ToString()),
Syntax.QuotationMark,
});
}
if (type == typeof(char))
{
return(new[] {
Syntax.SingleQuotationMark,
Syntax.ConstVal(value.ToString()),
Syntax.SingleQuotationMark,
});
}
var enumerableItems = "";
if (!IsOverridingToStirng(type) &&
value is IEnumerable &&
ExtractValue(value, out enumerableItems))
{
return(RexUtils.GetCSharpRepresentation(type).Concat(new[]
{
Syntax.Space,
Syntax.CurlyOpen,
Syntax.Space,
Syntax.ConstVal(enumerableItems.Replace("\n", "\\n")),
Syntax.Space,
Syntax.CurlyClose
}));
}
return(new[] { Syntax.ConstVal(value.ToString()) });
}
public void GetCSharpRepTest()
{
//Simple types:
GetCSharpRepTest("System.Int32", typeof(int), true);
GetCSharpRepTest("int", typeof(int), false);
//Simple types arrays:
GetCSharpRepTest("System.String[]", typeof(string[]), true);
GetCSharpRepTest("System.Int32[]", typeof(int[]), true);
GetCSharpRepTest("string[]", typeof(string[]), false);
GetCSharpRepTest("int[]", typeof(int[]), false);
//Generic types:
GetCSharpRepTest("Action<bool, int, Action<IEnumerable<string>>>", typeof(Action<bool, int, Action<IEnumerable<string>>>), false);
GetCSharpRepTest(
"System.Action<System.Boolean, System.Int32, System.Action<System.Collections.Generic.IEnumerable<System.String>>>",
typeof(Action<bool, int, Action<IEnumerable<string>>>), true);
//nested types:
GetCSharpRepTest("RexHelperTest.ComplexValueType", typeof(ComplexValueType), false);
GetCSharpRepTest("Rex.Utilities.Test.RexHelperTest.ComplexValueType", typeof(ComplexValueType), true);
GetCSharpRepTest("RexHelperTest.ComplexValueType[]", typeof(ComplexValueType[]), false);
GetCSharpRepTest("Rex.Utilities.Test.RexHelperTest.ComplexValueType[]", typeof(ComplexValueType[]), true);
GetCSharpRepTest("Action<RexHelperTest.ComplexValueType[]>", typeof(Action<ComplexValueType[]>), false);
GetCSharpRepTest("System.Action<Rex.Utilities.Test.RexHelperTest.ComplexValueType[]>", typeof(Action<ComplexValueType[]>), true);
GetCSharpRepTest("Action<RexHelperTest.ComplexValueType>", typeof(Action<ComplexValueType>), false);
GetCSharpRepTest("System.Action<Rex.Utilities.Test.RexHelperTest.ComplexValueType>", typeof(Action<ComplexValueType>), true);
GetCSharpRepTest("Rex.Utilities.Test.RexHelperTest.ComplexValueType[]", typeof(ComplexValueType[]), true);
//Nested Generic types:
GetCSharpRepTest("RexHelperTest.ComplexValueType<int>", typeof(ComplexValueType<int>), false);
GetCSharpRepTest("Rex.Utilities.Test.RexHelperTest.ComplexValueType<System.Int32>", typeof(ComplexValueType<int>), true);
GetCSharpRepTest(
"System.Action<Rex.Utilities.Test.RexHelperTest.ComplexValueType<System.Int32>>",
typeof(Action<ComplexValueType<int>>), true);
GetCSharpRepTest("System.Action", typeof(Action), true);
Assert.NotNull(RexUtils.GetCSharpRepresentation(typeof(Action<>), true));
}
/// <summary>
/// Setups a single value output.
/// </summary>
/// <param name="value">output value</param>
protected virtual void LoadSingleObject(object value)
{
if (value == null)
{
Text = "null";
return;
}
var valType = value.GetType();
if (RexUtils.IsToStringOverride(valType))
{
Text = value.ToString();
}
else
{
Text = RexUtils.GetCSharpRepresentation(valType, true).ToString();
}
}
public void ColorizingSearchTest()
{
var syntax = new MemberDetails(new[] {
Syntax.StaticKeyword,
Syntax.Space, Syntax.NewType("int"),
Syntax.Space, Syntax.Name("myNumber"),
Syntax.Space, Syntax.EqualsOp,
Syntax.Space, Syntax.ConstVal("5")
});
var syntaxHighlighting = RexUtils.SyntaxHighlingting(syntax, RexUtils.SyntaxHighlightColors, "myNum");
TestRest(syntax, syntaxHighlighting, "<b>myNum</b>ber");
syntaxHighlighting = RexUtils.SyntaxHighlingting(syntax, RexUtils.SyntaxHighlightColors, "Num");
TestRest(syntax, syntaxHighlighting, "my<b>Num</b>ber");
syntaxHighlighting = RexUtils.SyntaxHighlingting(syntax, RexUtils.SyntaxHighlightColors, "Number");
TestRest(syntax, syntaxHighlighting, "my<b>Number</b>");
}
/// <summary>
/// Uses the property info to build an member details.
/// </summary>
/// <param name="prop">property to inspect</param>
public static MemberDetails GetMemberDetails(PropertyInfo prop)
{
var syntax = new List <Syntax>();
var get = prop.GetGetMethod();
var set = prop.GetSetMethod();
if ((get != null && get.IsStatic) ||
(set != null && set.IsStatic))
{
syntax.AddRange(new[] { Syntax.StaticKeyword, Syntax.Space });
}
syntax.AddRange(RexUtils.GetCSharpRepresentation(prop.PropertyType));
syntax.AddRange(new[] {
Syntax.Space,
Syntax.Name(prop.Name),
Syntax.Space,
Syntax.CurlyOpen
});
if (get != null)
{
syntax.AddRange(new[] { Syntax.Space, Syntax.GetKeyword, Syntax.Semicolon });
}
if (set != null)
{
syntax.AddRange(new[] { Syntax.Space, Syntax.SetKeyword, Syntax.Semicolon });
}
syntax.Add(Syntax.Space);
syntax.Add(Syntax.CurlyClose);
return(new MemberDetails(syntax)
{
Type = MemberType.Property
});
}
private static string GetVaribleWrapper()
{
if (RexHelper.Variables.SequenceEqual(_currentWrapperVaribles))
{
return(_wrapperVariables);
}
_wrapperVariables = RexHelper.Variables.Aggregate("", (codeString, var) =>
codeString + Environment.NewLine +
string.Format(@" {0} {1}
{{
get
{{
if (!Rex.Utilities.RexHelper.Variables.ContainsKey(""{1}""))
throw new Rex.Utilities.Helpers.AccessingDeletedVariableException() {{ VarName = ""{1}"" }};
return ({0})Rex.Utilities.RexHelper.Variables[""{1}""].VarValue;
}}
set {{ Rex.Utilities.RexHelper.Variables[""{1}""].VarValue = value; }}
}}" ,
RexUtils.GetCSharpRepresentation(var.Value.VarType, true).ToString(), var.Key));
_currentWrapperVaribles = RexHelper.Variables.ToDictionary(i => i.Key, i => i.Value);
return(_wrapperVariables);
}
/// <summary>
/// Displays a single variable, returns true if the varible was deleted else false.
/// </summary>
/// <param name="VarName">Name of the var. (key of the <see cref="RexHelper.Variables"/>)</param>
/// <param name="var">The varible to display. (Value of the <see cref="RexHelper.Variables"/>)</param>
private bool DisplayVariable(string VarName, RexHelper.Variable var)
{
string highlightedString;
var type = RexUtils.GetCSharpRepresentation(var.VarType);
// Format the code for syntax highlighting using richtext.
highlightedString = RexUIUtils.SyntaxHighlingting(type.Concat(new[] {
Syntax.Space, Syntax.Name(VarName), Syntax.Space, Syntax.EqualsOp, Syntax.Space
}).Concat(RexReflectionUtils.GetSyntaxForValue(var.VarValue)));
var shouldDelete = GUILayout.Button(_texts.GetText("remove_variable", tooltipFormat: VarName), GUILayout.Width(20));
// Draw the button as a label.
if (GUILayout.Button(_texts.GetText("inspect_variable", highlightedString, VarName), varLabelStyle, GUILayout.ExpandWidth(true)))
{
var ouput = new OutputEntry();
ouput.LoadObject(var.VarValue);
RexHelper.AddOutput(ouput);
}
return(shouldDelete);
}
public void LoadNamspacePerformanceTest()
{
SpeedTestAction(() => RexUtils.LoadNamespaceInfos(true), 2);
}
public void Setup()
{
RexUtils.LoadNamespaceInfos(true);
Parser = new RexParser();
}
void GetCSharpRepTest(string text, Type type, bool showFull)
{
Assert.AreEqual(text, RexUtils.GetCSharpRepresentation(type, showFull).ToString());
}
public void TopLevelNameSpaceTest()
{
Assert.AreEqual("System", RexUtils.TopLevelNameSpace("System.Linq"));
Assert.AreEqual("System", RexUtils.TopLevelNameSpace("System.Collections.Generic"));
}
public static CompiledExpression Compile(ParseResult parseResult)
{
var errors = Enumerable.Empty <string>();
var returnTypes = new[] { FuncType._object, FuncType._void };
foreach (var returnType in returnTypes)
{
var wrapper = MakeWrapper(Instance.NamespaceInfos.Where(ns => ns.Selected), parseResult, returnType);
var result = CompileCode(wrapper);
//Path.
if (result.Errors.Count == 1)
{
var error = result.Errors[0];
if (error.ErrorNumber == "CS0103")
{
var errorRegex = Regex.Match(error.ErrorText, "The name (?<type>.*) does not exist in the current context");
var typeNotFound = errorRegex.Groups["type"].Value.Substring(1).Trim('\'');
var canditateTypes = (from t in RexUtils.AllVisibleTypes
where t.Name == typeNotFound
select t).ToArray();
if (canditateTypes.Length == 0)
{
return(new CompiledExpression
{
Parse = parseResult,
Errors = new List <string> {
result.Errors.Cast <CompilerError>().First().ErrorText
}
});
}
if (canditateTypes.Length > 1)
{
var types = from n in canditateTypes
select RexUtils.GetCSharpRepresentation(n, true).ToString();
var allTypeNames = string.Join(Environment.NewLine, types.ToArray());
return(new CompiledExpression
{
Parse = parseResult,
Errors = new List <string> {
string.Format("Ambiguous type name '{1}': {0} {2} {0} {3}", Environment.NewLine,
typeNotFound,
allTypeNames,
"Use the Scope settings to select which namespace to use.")
}
});
}
var name = canditateTypes.First().Namespace;
var info = Instance.NamespaceInfos.First(i => i.Name == name);
if (!info.Selected)
{
var usings = Instance.NamespaceInfos.Where(ns => ns.Selected || ns.Name == name);
wrapper = MakeWrapper(usings, parseResult, returnType);
result = CompileCode(wrapper);
}
}
}
errors = RexHelper.DealWithErrors(result);
if (!errors.Any())
{
return(new CompiledExpression
{
Assembly = result.CompiledAssembly,
Parse = parseResult,
FuncType = returnType,
Errors = errors
});
}
}
return(new CompiledExpression
{
Parse = parseResult,
Errors = errors
});
}
