private Class GenerateClass(object node)
{
var names = node.GetNames();
var ce = new Class
{
FullName = node.Get<string>("name"),
Tag = node,
};
ImportDocumentation(ce, node);
Assembly.Classes.Add(ce);
return ce;
}
string Class(Class ce, Class context=null)
{
if (context == null)
context = ContextClass;
string name = null;
if (ce.GenericArguments.Count > 0)
name = ce.Name.Substring(0, ce.Name.IndexOf("`")) + ce.GenericArguments.StringConcat(t=>Class(t), "<", ", ", ">");
else
name = ce.Name;
if (ce.Namespace.IsNotNullOrEmpty())
{
if(context!=null && !context.Namespace.StartsWith(ce.Namespace))
name = ce.Namespace + "." + name;
else if (Assembly != null && Assembly.AllClasses.Where(t => t.Name == name).Count() > 1)
name = ce.Namespace + "." + name;
}
return name;
}
public void Export(Class ce)
{
if (!SingleFile)
{
ExportHeader();
BeginNamespace(ce.Namespace);
}
ContextClass = ce;
ExportXmlDoc2(ce);
ce.Attributes.ForEach(Export);
Write("public {0}partial {1} {2}", ce.IsNew.If("new "), ce.IsInterface.If("interface", "class"), Identifier(ce.Name));
var bases = new List<Class>();
if (ce.BaseClass != null)
bases.Add(ce.BaseClass);
bases.AddRange(ce.Interfaces);
if(bases.Count>0)
{
Write(" : ");
bases.ForEachJoin(t => Write("{0}", Class(t)), WriteComma);
}
WriteLine();
BeginBlock();
ce.Members.ForEach(Export);
EndBlock();
ContextClass = null;
if (!SingleFile)
EndNamespace();
}
void ReplaceType(Class a, Class b)
{
foreach (var ce in Assembly.AllClasses)
{
ce.Members.Where(t => t.Type == a).ForEach(t => t.Type = b);
foreach (var me in ce.Methods())
{
me.Parameters.Where(t => t.Type == a).ForEach(t => t.Type = b);
}
}
}
private static void AddOptionalOverloads(Class ce, Method me, List<Parameter> optionalParameters)
{
foreach (var prm in optionalParameters.ToArray())
{
var me2 = me.Clone();
me2.Parameters.Remove(me2.Parameters.Where(t => t.Name == prm.Name).First());
ce.Members.Add(me2);
var op2 = optionalParameters.ToArray().ToList();
op2.Remove(prm);
AddOptionalOverloads(ce, me2, op2);
}
}
static bool HasEmptyOrDefaultConstructor( Class ce )
{
var ctors = ce.Members.OfType<Method>().Where( t => t.IsConstructor ).ToList();
return ctors.Count == 0 || ctors.Any( ctor => ctor.Parameters.Count == 0 || ctor.Parameters.All( t => t.IsOptional ) );
}
static bool IsDeclared( Class ce, ExtMember me2 )
{
return ce.Members.Any( m => m.Name.Replace( "@", "" ).Equals( me2.name.Replace( "@", "" ) ) );
}
private static void InitAssemlyContext()
{
Assembly = new Assembly
{
Usings = new List<string>
{
"SharpKit.JavaScript",
}
};
Context = new AssemblyContext
{
ClassMappings = new Dictionary<string, string>
{
{"object", "object"},
{"Object", "object"},
{"Element", "Ext.dom.Element"},
{"Ext.Element", "Ext.dom.Element"},
{"Ext.core.Element", "Ext.dom.Element"},
{"Ext.dom.ElementLoader", "Ext.ElementLoader"},
{"Ext.ux.form.FileUploadField","Ext.form.field.File"},
{"HTMLElement", "Ext.dom.Element"},
{"Function", "System.Delegate"},
{"Array", "JsArray"},
{"String", "JsString"},
{"string", "JsString"},
{"Boolean", "bool"},
{"Boolan", "bool"},
{"boolean", "bool"},
{"Float", "JsNumber"},
{"integer", "JsNumber"},
{"Number", "JsNumber"},
{"number", "JsNumber"},
{"int", "JsNumber"},
{"Date", "JsDate"},
{"RegExp", "JsRegExp"},
{"Mixed", "JsObject"},
{"Ext.fx.target", "Ext.fx.target.Target"},
{"Ext", "Ext.ExtContext"},
{"Ext.Container", "Ext.container.Container"},
{"Container", "Ext.container.Container"},
{"Mixed component", "JsObject"},
{"Ext.TabBar", "Ext.tab.Bar"},
{"Component", "Ext.Component"},
{"Region", "Ext.util.Region"},
{"ResizeTracker", "Ext.resizer.ResizeTracker"},
{"Regexp", "JsRegExp"},
{"Menu", "Ext.menu.Menu"},
{"Store", "Ext.data.Store"},
{"CompositeElement", "Ext.dom.CompositeElement"},
{"Ext.CompositeElement", "Ext.dom.CompositeElement"},
{"Label", "Ext.form.Label"},
{"Model", "Ext.data.Model"},
{"Ext.grid.Grid", "Ext.grid.property.Grid"},
//{"*", "JsObject"},
{"ColorPicker", "Ext.menu.ColorPicker"},
{"MultiSlider", "Ext.slider.Multi"},
{"XMLElement", "JsObject"},
{"CSSStyleSheet", "JsObject"},
{"CSSStyleRule", "JsObject"},
}
};
Context.Assemblies.Add( Assembly );
var asm = new Assembly
{
Classes = new List<Class>
{
new Class{Name="void"},
new Class{Name="object"},
new Class{Name="object"},
new Class{Name="JsObject"},
new Class{Name="JsArray"},
new Class{Name="JsArray`1"},
new Class{Name="JsDate"},
new Class{Name="JsRegExp"},
new Class{Name="JsFunc`1`1"},
new Class{Name="JsFunc`1`2"},
new Class{Name="JsFunc`1`3"},
new Class{Name="JsFunc`1`4"},
new Class{Name="JsAction"},
new Class{Name="JsAction`1"},
new Class{Name="JsAction`2"},
new Class{Name="JsAction`3"},
new Class{Name="JsAction`4"},
new Class{Name="bool"},
new Class{Name="JsString"},
new Class{Name="JsNumber"},
new Class{Name="JsContext"},
new Class{Name="Delegate", FullName = "System.Delegate"},
}
};
Context.Assemblies.Add( asm );
ObjectClass = Context.GetClass( "object" );
VoidClass = Context.GetClass( "void" );
}
static bool InterfaceMemberIsImplementedBySelfOrBaseClass( Element el, Class cls )
{
var baseCls = cls;
while ( baseCls != null )
{
//Last check is because (ej) Ext.Base implements all "basic" members requied by interfaces but doesn't implement any interface so members are private there, that shouldn't happen...
if ( !baseCls.IsInterface && baseCls.IsDeclared( el, true ) /*&& baseCls.Interfaces.Any( i => i.Members.Any( m => m == el ) )*/ )
return true;
baseCls = baseCls.BaseClass;
}
return false;
}
static Class GetClass( string name, bool? autoCreate = null )
{
if ( name.IsNullOrEmpty() )
return null;
name = name.Trim( '[', ']', '.' );
var ce = Context.GetClass( name );
if ( ce == null )
{
if ( name.Contains( "/" ) || name.Contains( "|" ) )
return ObjectClass;
}
name = Context.ClassMappings.TryGetValue( name ) ?? name;
if ( ce == null && autoCreate.GetValueOrDefault( true ) )
{
if ( autoCreate == null )
{
}
ce = new Class { FullName = name };
Assembly.Classes.Add( ce );
}
return ce;
}
private static Class GenerateClass(Dictionary<string, object> obj)
{
var ce = new Class();
Assembly.Classes.Add(ce);
foreach (var pair in obj)
{
var name = pair.Key;
var value = pair.Value;
var pe = new Property { Name = pair.Key };
pe.Type = GenerateClass(value);
ce.Members.Add(pe);
if (pe.Type == null)
{
}
}
ce.Members = ce.Members.OrderBy(t => t.Name).ToList();
return ce;
}
public Class MakeGenericClass( Class ce, List<Class> genericArgs )
{
return new Class { Name = ce.Name, Namespace = ce.Namespace, GenericArguments = genericArgs };
}
private void GenerateMember(Class ce, object node)
{
var signatures = node.GetValues("signatures");
if (signatures.IsNullOrEmpty())
{
GenerateMember(ce, node, null);
}
else
{
foreach (var signature in signatures)
{
GenerateMember(ce, node, signature);
}
}
}
private void GenerateMember(Class ce, object node, object signature)
{
var names = node.GetNames();
var itemType = node.Get<string>("type");
var name = node.Get<string>("name");
var access = node.Get<string>("access");
if (name.IsNullOrEmpty())
{
Console.WriteLine("Warning: empty name " + name);
return;
}
var className = node.Get<string>("class");
var type = "object";// node.Get<string>("type");
//var ce = FindClass(className);
if (ce == null)
{
Console.WriteLine("Warning: Can't find class: " + className);
return;
}
Element me2 = null;
if (itemType == "attribute" || itemType == "property")
{
var isReadOnly = node.Get<string>("readonly") != null;
if (type.IsNullOrEmpty())
{
type = "object";
Console.WriteLine("Warning: type is null: " + className + "." + name + " assuming object");
//return;
}
var pe = new Property
{
Name = name,
Type = FindClass(type),
};
pe.IsReadOnly = isReadOnly;
if (Char.IsDigit(pe.Name[0]))
{
Console.WriteLine("Warning: Invalid name " + pe.Name);
return;
}
if (pe.Type == null)
{
Console.WriteLine("Warning: type is null");
return;
}
ce.Members.Add(pe);
if (itemType == "attribute")
{
var ctor = ce.GetEmptyConstructor();
if (ctor == null)
{
ctor = new Method
{
IsConstructor = true,
Name=".ctor",
};
ce.Members.Add(ctor);
}
var att = ctor.Attributes.Where(t => t.Name == "JsMethod").FirstOrDefault();
if (att == null)
{
att = new SharpKit.ExtJs4.Generator.Attribute
{
Name = "JsMethod",
NamedParamters = new Dictionary<string, string> { { "JsonInitializers", "true" } },
};
ctor.Attributes.Add(att);
}
}
me2 = pe;
}
else if (itemType == "method")
{
var prms = signature.GetValues("params");
var returnType = "object";// node.GetValues("return");
var me = new Method
{
Name = name,
//Type = FindClass(node.Get<string>("desc"))
//Type = FindClass(type),
};
if (me.Name == ce.Name)
{
me.IsConstructor = true;
returnType = null;
}
if (prms != null)
me.Parameters = prms.Select(GenerateParameter).ToList();
if (me.Parameters.Contains(null))
{
Console.WriteLine("Warning: prms contains nulls:" + className + "." + name);
return;
}
if (returnType != null)
{
//var returnType = returns.LastOrDefault() as string;
//returnType = returnType.Split('|').FirstOrDefault().Trim();
me.Type = FindClass(returnType);
if (me.Type == null)
{
Console.WriteLine("Cannot resolve method return type: " + className + "." + name);
me.Type = ObjectClass;
}
}
ce.Members.Add(me);
me2 = me;
}
if (me2 != null)
{
if (access.IsNullOrEmpty())
{
}
else if (access == "protected")
me2.IsProtected = true;
else if (access == "private")
me2.IsPrivate = true;
else if (access == "public")
{
}
else
{
}
ImportDocumentation(me2, node);
}
}
