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) { }