public void TestRawStatements()
{
var c = new ClassType("test");
var x2 = "a" + new RawStatement("b");
var x3 = new RawStatement("a") + "b";
var s1 = new RawStatements()
{
Statements = { "xxx" }
};
var s2 = new RawStatements("asd", new RawStatement("tttt"));
s1.Add(s2);
s1.Add(new TypescriptTypeReference(c));
s1.Add(":");
s1.Add(c);
var g = new OutputGenerator();
g.Generate(s1);
Assert.AreEqual("xxxasdtttttest:test", g.Formatter.Output.ToString());
var test2 = new RawStatements("t1 ", c, " t2");
g.Formatter.Output.Clear();
g.Generate(test2);
Assert.AreEqual("t1 test t2", g.Output);
}
public virtual void VisitRaw(RawStatements raw)
{
foreach (var item in raw.Statements.ToArray())
{
Visit(raw, item);
}
}
private void AddFromJsFunction(DeclarationBase src, ClassType target)
{
var fromJS = new RawStatements();
if (target.Extends != null)
{
fromJS.Add("super.fromJS(obj);\n");
}
foreach (var targetItem in target.Members.OfType <PropertyMember>())
{
var srcItem = src.Members.OfType <PropertyMember>().First(x => x.Name == targetItem.Name);
TypescriptTypeBase itemType = null;
if (srcItem.MemberType != null && srcItem.MemberType.ReferencedType != null)
{
itemType = srcItem.MemberType.ReferencedType;
}
if (Options.JsConversion_Function_PropertyExistenceCheck)
{
fromJS.Add("if (obj." + srcItem.Name + ") { ");
}
if (itemType is ArrayType)
{
var elementType = srcItem.MemberType.ExtractArrayElement();
if (elementType != null && elementType.ReferencedType != null && elementType.ReferencedType is DeclarationBase)
{
fromJS.Add("this." + srcItem.Name + "(obj." + srcItem.Name + ".map(item=>new ", elementType, "().fromJS(item)))");
}
else
{
//todo:conversions
fromJS.Add("this." + srcItem.Name + "(obj." + srcItem.Name + ")");
}
}
else
{
if (itemType == PrimitiveType.Date)
{
fromJS.Add("this." + srcItem.Name + "(new Date(obj." + srcItem.Name + "))");
}
else
{
fromJS.Add("this." + srcItem.Name + "(obj." + srcItem.Name + ")");
}
}
if (Options.JsConversion_Function_PropertyExistenceCheck)
{
fromJS.Add("};");
}
fromJS.Add("\n");
}
fromJS.Add("return this;");
target.Members.Add(new FunctionMember("fromJS", fromJS)
{
Parameters = { new FunctionParameter("obj") }
});
}
public virtual RawStatements RewriteRaw(RawStatements raw)
{
if (raw == null)
{
return(null);
}
var result = new RawStatements()
{
ExtraData = RewriteExtraData(raw)
};
result.Statements.AddRange(raw.Statements.Select(RewriteStatement).Where(x => x != null));
return(result);
}
public virtual void Visit(RawStatements raw, RawStatementBase item)
{
if (item is RawStatement)
{
VisitRawStatement(item);
}
else if (item is RawStatementTypeReference)
{
VisitRawTypeReference(item);
}
else
{
NonVisitable(raw, "raw statement {0}");
}
}
private static void GenerateMethodParametersSignature(ActionModel action, FunctionMember method, ReflectionGeneratorBase reflectionGenerator)
{
method.Parameters.AddRange(action.Parameters
.Where(p => !p.IsOptional)
.Select(p => new FunctionParameter(p.Name)
{
ParameterType = reflectionGenerator.GenerateFromType(p.Type),
IsOptional = false
}));
//consider:
// if there is only one optional parameter, or all opt. parameters are last (it must be in c# decl),
// we can generate myMethod(p1,p2,..., po1:string? = null, po2:number? = null)
// but, it is needed then to call it with positional params (TypeScript doesn't know named params)
// xxx.myMethod("asd","qwe",...,null, 42)
//compare to: call via optional properties of anonymous object
// xxx.myMethod("asd","qwe",..., { po2: 42} )
// BUT, it can be called with any object, because all positional parameters are optional, so any object will match
// xxx.myMethod("asd","qwe",..., "nonsense" )
// partially solved:
// positional parameters are unions of non-nullable parameter objects (see code)
// but this approach will still validate only one of parameters, others are than ignored (because at least one matched)
if (action.Parameters.Any(p => p.IsOptional))
{
var optParams = action.Parameters
.Where(p => p.IsOptional)
.Select(p => new RawStatements("{ ", p.Name, ": ", reflectionGenerator.GenerateFromType(p.Type), " }"))
.ToArray();
var raw = new RawStatements();
foreach (var item in optParams)
{
raw.Add(item);
if (item != optParams.Last())
{
raw.Add(" | ");
}
raw.Add(" ");
}
raw.Add(" = <any>{}");
method.Parameters.Add(new FunctionParameter("opt")
{
ParameterType = new TypescriptTypeReference(raw)
});
}
}
private RawStatements MapRaw(RawStatements source)
{
if (source == null)
{
return(null);
}
var result = new RawStatements();
foreach (var s in source.Statements)
{
var sr = s as RawStatementTypeReference;
if (sr != null)
{
result.Add(MapType(sr.TypeReference));
}
else
{
result.Add(s);
}
}
return(result);
}
public virtual void VisitTypeReferenceRaw(TypescriptTypeReference obj, RawStatements raw)
{
VisitRaw(raw);
}
