/// <summary>
/// Writes the javascript to evalutate the format group
/// </summary>
/// <param name="expander">The expander (not used).</param>
/// <param name="writer">The generator to write the output to.</param>
/// <param name="argumentWriters">Argument 1: Format string, Argument 2: Value to put in format string.</param>
public override void WriteEvaluator(HashTagFormatGroupExpander expander, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
argumentWriters[0]();
writer.Output.Write(".replace(\"{#}\",");
argumentWriters[1]();
writer.Output.Write(")");
}
public override void WriteEvaluator(IntervalCondition <T> proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
if (proc.Min.HasValue)
{
argumentWriters[0]();
writer.Output.Write(">");
if (proc.MinInclusive)
{
writer.Output.Write("=");
}
WriteLimit(proc.Min.Value, writer);
if (proc.Max.HasValue)
{
writer.Output.Write("&&");
}
}
if (proc.Max.HasValue)
{
argumentWriters[0]();
writer.Output.Write("<");
if (proc.MaxInclusive)
{
writer.Output.Write("=");
}
WriteLimit(proc.Max.Value, writer);
}
}
public override void WriteEvaluator(PatternLookupEvaluator proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
//NOTE: This one is hard to put in a general purpose function in Localization.js as it relies on formatters
writer.Output.Write("(function(){");
writer.Output.Write("k=");
if (proc.PatternKey.StartsWith("@"))
{
var parts = proc.PatternKey.Substring(1).Split('+');
WriteGetParameter(writer, writer.Json.Serialize(parts[0]));
if (parts.Length > 1)
{
writer.Output.Write("+" + writer.Json.Serialize(parts[1]));
}
}
else
{
writer.Output.Write(writer.Json.Serialize(proc.PatternKey));
}
writer.Output.Write(";");
writer.Output.Write("var i=k.indexOf(" + writer.Json.Serialize(proc.NamespaceQualifier) + ");" +
"var ns=c.n;if(i!=-1){ns=k.substr(0, k);k=k.substr(k+" + proc.NamespaceQualifier.Length + ");}");
writer.Output.Write("var vs={};");
int i = 0;
foreach (var p in proc.Parameters)
{
writer.Output.Write("var v=");
if ((p.Key.StartsWith("\"") || p.Key.StartsWith("'")) && (p.Key.EndsWith("\"") || p.Key.EndsWith("'")))
{
writer.Output.Write(writer.Json.Serialize(p.Key.Substring(1, p.Key.Length - 2)));
}
else
{
WriteGetParameter(writer, writer.Json.Serialize(p.Key));
writer.Output.Write(";vs[" + writer.Json.Serialize(p.Key) + "]=v");
if (p.Value != null)
{
//TODO: Restore original format
writer.Output.Write(";v.defaultFormat=");
writer.Output.Write("function(v){return ");
var formatter = writer.Writers[p.Value.GetType()];
formatter.WriteEvaluator(p.Value, writer, () => writer.Output.Write("v"));
writer.Output.Write("}");
}
//TODO: Format
}
writer.Output.Write(";vs[''+" + writer.Json.Serialize(i++) + "]=v;");
}
writer.Output.Write("return m.unencoded(");
WriteGetText(writer, "ns", "k", "vs");
writer.Output.Write(");})()");
}
public override void WriteEvaluator(BooleanExpressionCondition proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
var left = writer.Writers[proc.Left.GetType()];
var right = writer.Writers[proc.Left.GetType()];
left.WriteEvaluator(proc.Left, writer, argumentWriters[0]);
writer.Output.Write(proc.Disjunction ? "||" : "&&");
right.WriteEvaluator(proc.Right, writer, argumentWriters[0]);
}
public override void WriteEvaluator(ReflectionParameterEvaluator proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
writer.Output.Write("rp(");
WriteGetParameter(writer, writer.Json.Serialize(proc.BaseParameterName));
if (proc.Properties.Any())
{
writer.Output.Write(",[");
writer.Output.Write(string.Join(",", proc.Properties.Select(p => writer.Json.Serialize(p))));
writer.Output.Write("]");
}
writer.Output.Write(")");
}
public override void WriteEvaluator(StringFormatFormatter proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
if (!string.IsNullOrEmpty(proc.FormatExpression))
{
writer.Output.Write("sf(");
writer.Output.Write(writer.Json.Serialize("{0:" + proc.FormatExpression + "}"));
writer.Output.Write(",");
argumentWriters[0]();
writer.Output.Write(")");
}
else
{
argumentWriters[0]();
}
}
public override void WriteEvaluator(ValueListCondition <T> proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
int i = 0;
foreach (var val in proc.Values)
{
if (i++ > 0)
{
writer.Output.Write("||");
}
argumentWriters[0]();
writer.Output.Write("===");
WriteScriptConstant(writer, val);
}
}
public override void WriteEvaluator(LookupCondition proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
//NOTE: This will not work if parameters are involved.
var pattern = (string)proc.Evaluator.GetValue(writer.BaseContext).Value;
if (!string.IsNullOrEmpty(pattern))
{
var condition = proc.Dialect.GetSwitchConditionEvaluator(Expression.Text(pattern), proc.Evaluator.Manager);
var conditionWriter = writer.Writers[condition.GetType()];
conditionWriter.WriteEvaluator(condition, writer, argumentWriters[0]);
}
else
{
//TODO: Inform the user that this key doesn't exist in a better way
writer.Output.Write(writer.Json.Serialize(false));
}
}
public override void WriteEvaluator(ArithmeticCondition proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
foreach (var op in proc.Operations)
{
if (op.Operator == ArithmeticOperator.IntegerDivision)
{
writer.Output.Write("Math.floor");
}
writer.Output.Write("(");
}
argumentWriters[0]();
foreach (var op in proc.Operations)
{
writer.Output.Write(GetOperator(op.Operator));
writer.Output.Write(op.Number.ToString(writer.ScriptCulture));
writer.Output.Write(")");
}
writer.Output.Write(GetComparer(proc.CompareOperator));
WriteScriptConstant(writer, proc.TargetValue);
}
public override void WriteEvaluator(StringCaseFormatter proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
switch (proc.TransformationType)
{
case StringCaseTransformationType.Lowercase:
writer.Output.Write("_lc(");
break;
case StringCaseTransformationType.Uppercase:
writer.Output.Write("_uc(");
break;
case StringCaseTransformationType.CapitalizeFirst:
writer.Output.Write("_cf(");
break;
case StringCaseTransformationType.CapitalizeAll:
writer.Output.Write("_ca(");
break;
}
writer.Output.Write(writer.Json.Serialize("") + "+");
argumentWriters[0]();
writer.Output.Write(")");
}
protected void Write(string ns, string key, LanguageInfo language, Expression expr, TextWriter output, string clientClassName)
{
var context = new EvaluationContext
{
Namespace = ns,
Language = language,
StringEncoder = x => x
};
var writer = new JavaScriptExpressionWriter(Writers, output, context);
writer.ClientClassName = clientClassName;
expr.Accept(writer);
}
public override void WriteEvaluator(DefaultFormatter proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
writer.Output.Write("dv(");
argumentWriters[0]();
writer.Output.Write(")");
}
public override void WriteEvaluator(SimpleParameterEvaluator proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
WriteGetParameter(writer, writer.Json.Serialize(proc.ParameterName));
}
public override void WriteEvaluator(SingleValueCondition <T> proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
argumentWriters[0]();
writer.Output.Write((proc.NotEquals ? "!" : "=") + "==");
WriteScriptConstant(writer, proc.Value);
}
protected virtual void WriteLimit(T value, JavaScriptExpressionWriter writer)
{
WriteScriptConstant(writer, value);
}
public override void WriteEvaluator(TakeAllCondition proc, JavaScriptExpressionWriter writer, params Action[] argumentWriters)
{
writer.Output.Write("true");
}
protected override void WriteLimit(TimeSpan value, JavaScriptExpressionWriter writer)
{
WriteScriptConstant(writer, (long)value.TotalMilliseconds);
}
