private void WriteMethod(TextWriter writer, JsonMethodDescription method)
{
if (EcmaScriptIdentifier.IsValidIdentifier(method.Name, false))
{
writer.Write(this.formatter.MethodBeginFormat, this.ProxyNamespace, method.Name, this.ConvertParamType(method.Return.Type));
}
else
{
writer.Write(this.formatter.SafeMethodBeginFormat, this.ProxyNamespace, EcmaScriptWriter.Serialize(method.Name), this.ConvertParamType(method.Return.Type));
}
foreach (JsonNamedParameterDescription param in method.Params)
{
this.WriteParameter(writer, param);
}
writer.Write(this.formatter.MethodMiddleFormat, EcmaScriptWriter.Serialize(method.Name));
if (method.Params.Length > 0)
{
string[] args = new string[method.Params.Length];
for (int i = 0; i < method.Params.Length; i++)
{
args[i] = method.Params[i].Name;
}
writer.Write(this.formatter.ArgsFormat, String.Join(",", args));
}
else
{
writer.Write("null");
}
writer.Write(this.formatter.MethodEndFormat);
}
/// <summary>
/// Generates a globals list from import directives
/// </summary>
/// <returns></returns>
private string GetGlobals()
{
StringBuilder globals = new StringBuilder();
this.Imports.Insert(0, "JsonML.BST");
foreach (string import in this.Imports)
{
string ident = EcmaScriptIdentifier.EnsureValidIdentifier(import, true);
if (String.IsNullOrEmpty(ident))
{
continue;
}
if (globals.Length > 0)
{
globals.Append(", ");
}
int dot = ident.IndexOf('.');
globals.Append((dot < 0) ? ident : ident.Substring(0, dot));
}
return(globals.ToString());
}
private void ProcessDirective(string directiveName, IDictionary <string, string> attribs, int lineNumber)
{
if (String.IsNullOrEmpty(directiveName))
{
return;
}
switch (directiveName.ToLowerInvariant())
{
case "page":
case "control":
{
this.JbstName = attribs.ContainsKey("name") ?
EcmaScriptIdentifier.EnsureValidIdentifier(attribs["name"], true) :
null;
if (attribs.ContainsKey("AutoMarkup"))
{
try
{
this.AutoMarkup = (AutoMarkupType)Enum.Parse(typeof(AutoMarkupType), attribs["AutoMarkup"], true);
}
catch
{
throw new ArgumentException("\"" + attribs["AutoMarkup"] + "\" is an invalid value for AutoMarkup.");
}
}
else
{
this.AutoMarkup = AutoMarkupType.None;
}
string package = attribs.ContainsKey("import") ? attribs["import"] : null;
if (!String.IsNullOrEmpty(package))
{
string[] packages = package.Split(ImportDelim, StringSplitOptions.RemoveEmptyEntries);
this.Imports.AddRange(packages);
}
break;
}
case "import":
{
string package = attribs.ContainsKey("namespace") ? attribs["namespace"] : null;
if (!String.IsNullOrEmpty(package))
{
this.Imports.Add(package);
}
break;
}
default:
{
// not implemented
break;
}
}
}
protected override void WriteObjectPropertyName(string name)
{
if (EcmaScriptIdentifier.IsValidIdentifier(name, nested: false))
{
base.TextWriter.Write(name);
}
else
{
base.WriteObjectPropertyName(name);
}
}
private void WriteProperty(TextWriter writer, string name, object value)
{
if (EcmaScriptIdentifier.IsValidIdentifier(name, false))
{
writer.Write(this.formatter.PropertyFormat, this.ProxyNamespace, name, EcmaScriptWriter.Serialize(value));
}
else
{
writer.Write(this.formatter.SafePropertyFormat, this.ProxyNamespace, EcmaScriptWriter.Serialize(name), EcmaScriptWriter.Serialize(value));
}
}
/// <summary>
/// Bind the JBST to the provided data.
/// </summary>
/// <param name="jbstName"></param>
/// <param name="data"></param>
/// <returns></returns>
public static string Bind(EcmaScriptIdentifier jbstName, object data)
{
StringWriter writer = new StringWriter();
// render the JBST
JbstBuildResult jbst = JbstBuildResult.FindJbst(jbstName);
jbst.IsDebug = IsDebug;
jbst.Write(writer, data);
return(writer.ToString());
}
protected override void WriteObjectPropertyName(string name)
{
if (EcmaScriptIdentifier.IsValidIdentifier(name, false))
{
// write out without quoting
this.TextWriter.Write(name);
}
else
{
// write out as an escaped string
base.WriteObjectPropertyName(name);
}
}
public override bool Equals(object obj)
{
EcmaScriptIdentifier ecmaScriptIdentifier = obj as EcmaScriptIdentifier;
if (ecmaScriptIdentifier == null)
{
return(base.Equals(obj));
}
if (string.IsNullOrEmpty(identifier) && string.IsNullOrEmpty(ecmaScriptIdentifier.identifier))
{
return(true);
}
return(StringComparer.Ordinal.Equals(identifier, ecmaScriptIdentifier.identifier));
}
// TODO: create a custom TypeConverter to allow simple declarative assignment
/// <summary>
/// Gets and sets values in the JavaScript global namespace.
/// </summary>
/// <param name="varName"></param>
/// <returns></returns>
public object this[string varName]
{
get
{
if (!this.Data.ContainsKey(varName))
{
return(null);
}
return(this.Data[varName]);
}
set
{
varName = EcmaScriptIdentifier.EnsureValidIdentifier(varName, true);
this.Data[varName] = value;
}
}
/// <summary>
/// Verifies is a valid EcmaScript variable expression.
/// </summary>
/// <param name="varExpr">the variable expression</param>
/// <returns>varExpr</returns>
/// <remarks>
/// http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf
///
/// IdentifierName =
/// IdentifierStart | IdentifierName IdentifierPart
/// IdentifierStart =
/// Letter | '$' | '_'
/// IdentifierPart =
/// IdentifierStart | Digit
/// </remarks>
public static bool IsValidIdentifier(string varExpr, bool nested)
{
if (String.IsNullOrEmpty(varExpr))
{
return(false);
}
if (nested)
{
string[] parts = varExpr.Split('.');
foreach (string part in parts)
{
if (!EcmaScriptIdentifier.IsValidIdentifier(part, false))
{
return(false);
}
}
return(true);
}
if (EcmaScriptIdentifier.IsReservedWord(varExpr))
{
return(false);
}
bool indentPart = false;
foreach (char ch in varExpr)
{
if (indentPart && Char.IsDigit(ch))
{
// digits are only allowed after first char
continue;
}
// can be start or part
if (Char.IsLetter(ch) || ch == '_' || ch == '$')
{
indentPart = true;
continue;
}
return(false);
}
return(true);
}
/// <summary>
/// Compares the identifiers.
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
EcmaScriptIdentifier that = obj as EcmaScriptIdentifier;
if (that == null)
{
return(base.Equals(obj));
}
if (String.IsNullOrEmpty(this.identifier) && String.IsNullOrEmpty(that.identifier))
{
// null and String.Empty are equivalent
return(true);
}
return(StringComparer.Ordinal.Equals(this.identifier, that.identifier));
}
/// <summary>
/// Bind the JBST to the provided data.
/// </summary>
/// <param name="jbstName"></param>
/// <param name="dataName">named data to bind</param>
/// <param name="dataItems">collection of data to emit</param>
/// <returns></returns>
public static string Bind(EcmaScriptIdentifier jbstName, EcmaScriptIdentifier dataName, IDictionary <string, object> dataItems)
{
StringWriter writer = new StringWriter();
JbstBuildResult jbst = JbstBuildResult.FindJbst(jbstName);
jbst.IsDebug = IsDebug;
if (dataItems != null)
{
// render data block
new DataBlockWriter(jbst.AutoMarkup, jbst.IsDebug).Write(writer, dataItems);
}
// render the JBST
jbst.Write(writer, dataName);
return(writer.ToString());
}
/// <summary>
/// Ensures is a valid EcmaScript variable expression.
/// </summary>
/// <param name="varExpr">the variable expression</param>
/// <returns>varExpr</returns>
public static string EnsureValidIdentifier(string varExpr, bool nested, bool throwOnEmpty)
{
if (String.IsNullOrEmpty(varExpr))
{
if (throwOnEmpty)
{
throw new ArgumentException("Variable expression is empty.");
}
return(String.Empty);
}
varExpr = varExpr.Replace(" ", "");
if (!EcmaScriptIdentifier.IsValidIdentifier(varExpr, nested))
{
throw new ArgumentException("Variable expression \"" + varExpr + "\" is not supported.");
}
return(varExpr);
}
public JsonNameAttribute(string jsonName)
{
this.jsonName = EcmaScriptIdentifier.EnsureValidIdentifier(jsonName, nested: false);
}
/// <summary>
/// Ensures is a valid EcmaScript variable expression.
/// </summary>
/// <param name="varExpr">the variable expression</param>
/// <returns>varExpr</returns>
public static string EnsureValidIdentifier(string varExpr, bool nested)
{
return(EcmaScriptIdentifier.EnsureValidIdentifier(varExpr, nested, true));
}
/// <summary>
/// Ctor
/// </summary>
public EcmaScriptIdentifier(string ident)
{
this.identifier = String.IsNullOrEmpty(ident) ? String.Empty :
EcmaScriptIdentifier.EnsureValidIdentifier(ident, true);
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="jbstName"></param>
public JbstBuildResult(EcmaScriptIdentifier jbstName)
: this(jbstName, AutoMarkupType.None)
{
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="jbstName"></param>
/// <param name="autoMarkup"></param>
public JbstBuildResult(EcmaScriptIdentifier jbstName, AutoMarkupType autoMarkup)
{
this.jbstName = jbstName;
this.autoMarkup = autoMarkup;
}
/// <summary>
/// Ctor
/// </summary>
/// <param name="writer"></param>
public SimpleJbstBuildResult(EcmaScriptIdentifier jbstName, AutoMarkupType autoMarkup)
: base(jbstName, autoMarkup)
{
}
