[Test]
public function testAssignmentExpressionNode():void
{
	var left:IExpressionNode = factory.newExpression("myAnswer");
	var right:IExpressionNode = factory.newExpression("4");
 
	var expression:IAssignmentExpressionNode = 
		factory.newAssignmentExpression(left, right);
 
	assertPrintExpression("myAnswer = 4", expression);
 
	// change right expression
	expression.rightExpression = factory.newExpression("otherAnswer = 4");
 
	assertPrintExpression("myAnswer = otherAnswer = 4", expression);
 
	// change left expression to an array access
	var target:IExpressionNode = factory.newExpression("myObject[42]");
	var subscript:IExpressionNode = factory.newExpression("2");
 
	var arrayAccessExpression:IArrayAccessExpressionNode = 
		factory.newArrayAccessExpression(target, subscript);
 
	expression.leftExpression = arrayAccessExpression;
 
	assertPrintExpression("myObject[42][2] = otherAnswer = 4", expression);
}
 
[Test]
public function testArrayLiteralNode():void
{
	var expression:IArrayLiteralNode = factory.newArrayLiteral();
 
	expression.add(factory.newSimpleNameExpressionNode("a"));
	expression.add(factory.newSimpleNameExpressionNode("b"));
	expression.add(factory.newSimpleNameExpressionNode("c"));
 
	assertPrintExpression("[a, b, c]", expression);
 
	expression.remove(2);
 
	var expression2:IArrayLiteralNode = factory.newArrayLiteral();
 
	expression2.add(factory.newNullLiteral());
	expression2.add(factory.newSimpleNameExpressionNode("foo"));
	expression2.add(factory.newStringLiteral("Hello World"));
	expression2.add(factory.newBooleanLiteral(true));
 
	expression.add(factory.newArrayAccessExpression(
		factory.newSimpleNameExpressionNode("abc"),
		factory.newNumberLiteral(0)));
 
	expression.add(expression2);
 
	assertPrintExpression("[a, b, abc[0], [null, foo, \"Hello World\", true]]", expression);
}
 
[Test]
public function testArrayAccessExpressionNode():void
{
	var target:IExpressionNode = factory.newExpression("myObject[42]");
	var subscript:IExpressionNode = factory.newExpression("0");
 
	var expression:IArrayAccessExpressionNode = 
		factory.newArrayAccessExpression(target, subscript);
 
	assertPrintExpression("myObject[42][0]", expression);
 
	// test changing the 'target'
	target = factory.newExpression("myObject");
	expression.target = target;
 
	assertPrintExpression("myObject[0]", expression);
 
	// test changing the 'subscript'
	subscript = factory.newExpression("42");
	expression.subscript = subscript;
 
	assertPrintExpression("myObject[42]", expression);
 
	// test changing the 'subscript' to a string literal
	subscript = factory.newExpression("'myProp'");
	// or you could use
	// subscript = factory.newStringLiteral("'myProp'");
	expression.subscript = subscript;
 
	assertPrintExpression("myObject['myProp']", expression);
}

var ast:IParserNode = AS3FragmentParser.parseCompilationUnit(source);
// convoluted example but shows nesting
trace(ast.getChild(0).getChild(0).stringValue); // my.domain
trace(ast.getChild(0).getLastChild().getChild(0).getChild(0).stringValue); // Test
trace(ast.getChild(0).getLastChild().getChild(0).getKind("mod").stringValue); // public

package my.domain
{
	public class Test
	{
	}
}
class InternalClass
{
}

<compilation-unit>
	<package>
		<name>my.domain</name>
		<content>
			<class>
				<name>Test</name>
				<mod-list>
					<mod>public</mod>
				</mod-list>
				<content></content>
			</class>
		</content>
	</package>
	<content>
		<class>
			<name>InternalClass</name>
			<content></content>
		</class>
	</content>
</compilation-unit>

var code:String =
	"package my.domain {" +
	"public class UnitTest {" +
	"protected const MY_CONSTANT:int = 42;" +
	"[Test]public function testMethod1():void{}" +
	"[Test]public function testMethod2():void{}" +
	"[Test]public function testMethod3():void{}" +
	"}}"
 
var file:AS3SourceFile = new AS3SourceFile(null, new SourceCode(code, "", ""));
file.buildAst();
var typeNode:ITypeNode = file.compilationNode.typeNode;
var method:IMethodNode = typeNode.getMethod("testMethod2");
method.description = "See, this editing a string with code is fun!";
method.newDocTag("author", "Yeah me");
var meta:IMetaDataNode = method.getMetaData("Test");
meta.description = "Just in case you didn't know, I unit test.";
 
typeNode.removeMethod(typeNode.getMethod("testMethod1"));
typeNode.newMetaData("TestSuite");
 
typeNode.description = "Class documentation is good also, but I am lazy!"
 
var result:String = BuilderFactory.instance.buildFile(file);

package my.domain {
    [TestSuite]
    /**
     * Class documentation is good also, but I am lazy!
     */
    public class UnitTest {
        protected const MY_CONSTANT:int = 42;
        /**
         * Just in case you didn't know, I unit test.
         */
        [Test]
        /**
         * See, this editing a string with code is fun!
         * 
         * @author Yeah me
         */
        public function testMethod2():void {
        }
        [Test]
        public function testMethod3():void {
        }
    }
}

// create the file
var file:ISourceFile = project.newClass("my.domain.MyClass");
var packageNode:IPackageNode = file.compilationNode.packageNode;
var typeNode:IClassTypeNode = packageNode.typeNode as IClassTypeNode;
// add a package block comment
packageNode.newBlockComment("A package block comment.", false);
// add imports
packageNode.newImport("my.api.IInterfaceA");
packageNode.newImport("my.api.IInterfaceB");
packageNode.newImport("my.domain.sub.SubTest");
packageNode.newImport("mx.core.mx_internal");
// add and include
packageNode.newInclude("../som/folder/includeFile.as");
// addd a use namepsace
packageNode.newUse("mx_internal");
// make class dynamic
typeNode.isDynamic = true;
// add a superclass
typeNode.superClass = IdentifierNode.createType("ClassA");
// add implementors
typeNode.addImplementation(IdentifierNode.createType("IInterfaceA"));
typeNode.addImplementation(IdentifierNode.createType("IInterfaceB"));
// add a [Bindable] meta to class
typeNode.newMetaData("Bindable");
// add a style
var style:IMetaDataNode = typeNode.newMetaData("Style");
style.addNamedStringParameter("name", "myStyle");
style.addNamedStringParameter("type", "Number");
style.addNamedStringParameter("inherit", "no");
// add a comment to the style
style.description = "A new style.";
style.newDocTag("see", "#style:theOtherStyle");
// add a class description
typeNode.description = "A groovy class generated by as3builder-framework!";
typeNode.newDocTag("author", "Michael Schmalle");
typeNode.newDocTag("date", "08-19-2010");
 
// add a constant
var constant:IConstantNode = typeNode.newConstant("MY_CONSTANT", Modifier.PUBLIC, 
	IdentifierNode.createType("String"), "\"value\"");
constant.description = "My constant.";
 
// add an attribute
var attribute:IAttributeNode = typeNode.newAttribute("myAttribute", Modifier.PROTECTED, 
	IdentifierNode.createType("IModel"), "null");
attribute.description = "My attribute.";
attribute.newDocTag("private");
attribute.newMetaData("Inject");
 
// add an accessor
var vo:IIdentifierNode = IdentifierNode.createType("ValueObject");
 
var getter:IAccessorNode = typeNode.newAccessor(
	"myProperty", Modifier.PUBLIC, Access.READ, vo);
 
getter.description = "A property.";
getter.newMetaData("Bindable");
var inject:IMetaDataNode = getter.newMetaData("Inject");
inject.addNamedStringParameter("source", "model.property");
 
 
// add constructor
var constructor:IMethodNode = typeNode.newMethod("MyClass", Modifier.PUBLIC, null);
constructor.description = "Constructor.";
 
// add a method
var method:IMethodNode = typeNode.newMethod(
	"myMethod", Modifier.PUBLIC, IdentifierNode.createType("void"));
method.description = "Mediates a Swiz framework [Mediate] tag.";
var param:IParameterNode = method.newParameter(
	"data", IdentifierNode.createType("Object"), "null");
method.newDocTag("param", "data A mediated data object");
var mediate:IMetaDataNode = method.newMetaData("Mediate");
mediate.addNamedStringParameter("event", "MyEvent.DATA_CHANGE");
method.addReturnDescription("Returns nothing.");
 
BuilderFactory.newlinesBeforeMembers = 1;
BuilderFactory.breakPackageBracket = true;
BuilderFactory.breakTypeBracket = true;
BuilderFactory.breakBlockBracket = true;
 
var result:String = BuilderFactory.instance.buildTest(compilationNode.node);

/**
 * A package block comment.
 */
package my.domain 
{
    import my.api.IInterfaceA;
    import my.api.IInterfaceB;
    import my.domain.sub.SubTest;
    import mx.core.mx_internal;
    include '../some/folder/includeFile.as'
    use namespace mx_internal;
    [Bindable]
    /**
     * A new style.
     * 
     * @see #style:theOtherStyle
     */
    [Style(name="myStyle",type="Number",inherit="no")]
    /**
     * A groovy class generated by as3builder-framework!
     * 
     * @author Michael Schmalle
     * @date 08-19-2010
     */
    public dynamic class MyClass extends ClassA implements IInterfaceA, IInterfaceB 
    {
 
        /**
         * My constant.
         */
        public static const MY_CONSTANT:String = "value";
 
        [Inject]
        /**
         * My attribute.
         * 
         * @private 
         */
        protected var myAttribute:IModel = null;
 
        [Bindable]
        [Inject(source="model.property")]
        /**
         * A property.
         */
        public function get myProperty():ValueObject 
        {
            return null;
        }
 
        /**
         * @private 
         */
        public function set myProperty(value:ValueObject):void 
        {
        }
 
        /**
         * Constructor.
         */
        public function MyClass() 
        {
        }
 
        [Mediate(eventc"MyEvent.DATA_CHANGE")]
        /**
         * Mediates a Swiz framework [Mediate] tag.
         * 
         * @param data A mediated data object
         * @return Returns nothing.
         */
        public function myMethod(data:Object c null):void 
        {
        }
    }
}

// where the project will be output
var output:File = File.desktopDirectory.resolvePath("project/src");
 
// create a factory that will create AST
var factory:AS3Factory = new AS3Factory();
// create a new project to hold .as files
var project:IAS3Project = factory.newASProject(output.nativePath);
 
// create a public class with package 'com.acme.core'
var file:ISourceFile = project.newClass("com.acme.core.HelloWorld");
var typeNode:IClassTypeNode = file.compilationNode.typeNode as IClassTypeNode;
// mark he class final (can do the same for IsDynamic)
typeNode.isFinal = true;
//add metadata to the class
var event:IMetaDataNode = typeNode.newMetaData("Event");
event.addNamedStringParameter("name", "myEvent");
event.addNamedStringParameter("type", "flash.events.Event");
 
var style:IMetaDataNode = typeNode.newMetaData("Style");
style.addNamedStringParameter("name", "myStyle");
style.addNamedStringParameter("type", "Number");
style.addNamedStringParameter("inherit", "no");
 
var bindable:IMetaDataNode = typeNode.newMetaData("Bindable");
 
// add class comment
typeNode.description = "A class comment.\n " +
	"<p>Long description documentation.</p>";
 
typeNode.addDocTag("author", "Michael Schmalle");
typeNode.addDocTag("copyright", "Teoti Graphix, LLC");
typeNode.addDocTag("productversion", "1.0");
typeNode.addDocTag("see", "MyOtherClass More details here.");
 
// add a method
var method:IMethodNode = typeNode.newMethod(
	"helloTest", Modifier.PUBLIC, IdentifierNode.createType("String"));
// add a parameter
var param:IParameterNode = method.addParameter(
	"arg0", IdentifierNode.createType("String"), "''");
// add a comment to the method
method.description = "A hello test method.\n <p>Long description.</p>";
method.addDocTag("since", "1.0");
// add a description to the parameter
param.description = "The String argument at 0";
// add a return tag to the method
method.addReturnDescription("A String indicating the result.");
 
// add a method with rest
// add a method
var methodRest:IMethodNode = typeNode.newMethod(
	"helloRestTest", Modifier.create("mx_internal"), 
	IdentifierNode.createType("my.domain.ITest"));
 
// add a parameter
var arg0:IParameterNode = methodRest.addParameter(
	"arg0", IdentifierNode.createType("int"));
var rest:IParameterNode = methodRest.addRestParameter("theRest");
 
var result:String = BuilderFactory.instance.buildFile(file);
 
trace(result);

package com.acme.core {
    [Event(name="myEvent",type="flash.events.Event")]
    [Style(name="myStyle",type="Number",inherit="no")]
    [Bindable]
    /**
     * A class comment.
     * 
     * <p>Long description documentation.</p> 
     * 
     * @author Michael Schmalle
     * @copyright Teoti Graphix, LLC
     * @productversion 1.0
     * @see MyOtherClass More details here.
     */
    public final class HelloWorld {
        /**
         * A hello test method.
         * 
         * <p>Long description.</p> 
         * 
         * @since 1.0
         * @param arg0 The String argument at 0
         * @return A String indicating the result.
         */
        public function helloTest(arg0:String = ''):String {
        }
        mx_internal function helloRestTest(arg0:int, ...theRest):ITest {
        }
    }
}

public function loadBook():void
{
	var book:IAS3Book = BookFactory.instance.createBook();
 
	var mySourcePath:String = "C:\\dev\\workspace\\opensource\\as3parser-framework\\src";
	// create a source directory
	var srcDir:File = new File(mySourcePath);
 
	var sources:Array = [];
	// get all File instances in source path recursivly
	var files:Array = readFiles(srcDir);
	for each (var file:File in files)
	{
		var sourceFile:ISourceFile = 
			NodeFactory.instance.createSourceFile(
				FileUtil.readFile(file.nativePath),
				file.nativePath,
				mySourcePath);
		try
		{
			// build the source file's AST
			sourceFile.buildAst();
 
			// add the source file to the book
			book.addSourceFile(sourceFile);
		}
		catch (e:Error)
		{
			trace(e.message);
			trace("Error parsing " + sourceFile.fileName);
		}
	}
 
	// proccess all SourceFile trees
	book.process();
 
	// now you have access to all the book's accessor API
 
	// Vector.<IClassTypeNode>
	book.access.classTypes;
	// Vector.<IFunctionTypeNode>
	book.access.functionTypes;
	// Vector.<IInterfaceTypeNode>
	book.access.interfaceTypes;
	// Vector.<ISourceFileCollection>
	book.access.sourceFileCollections;
	// Vector.<ITypeNode> of class|interface|function
	book.access.types;
 
	// returns the IClassTypeNode or null
	book.access.findClassType("my.domain.Class");
	// returns the IFunctionTypeNode or null
	book.access.findFunctionType("my.domain.globalFunction");
	// returns the IInterfaceTypeNode or null
	book.access.findInterfaceType("my.domain.IInterface");
	// returns the ITypeNode or null
	book.access.findType("my.domain.Class");
	// Vector.<ITypeNode>
	book.access.getImplementedInterfaces(classAType);
	// Vector.<ITypeNode>
	book.access.getInterfaceImplementors(classAType);
	// Vector.<ISourceFileCollection>
	book.access.getSourceFileCollection("my.domain");
	// Vector.<ITypeNode>
	book.access.getSubClasses(classAType);
	// Vector.<ITypeNode>
	book.access.getSubInterfaces(iInterfaceAType);
	// Vector.<ITypeNode>
	book.access.getSuperClasses(classAType);
	// Vector.<ITypeNode>
	book.access.getSuperInterfaces(iInterfaceAType);
	// returns ITypeNode
	book.access.getType("my.domain.Class");
	// Vector.<ITypeNode> all types in package
	book.access.getTypes("my.domain");
	// Boolean
	book.access.hasType("my.domain.Class");
}
 
protected function readFiles(directory:File, result:Array = null):Array
{
	if (result == null)
		result = [];
 
	var directories:Array = directory.getDirectoryListing();
	for each (var file:File in directories)
	{
		if (file.isDirectory)
		{
			result = readFiles(file, result);
		}
		else if (file.extension == "as" || file.extension == "mxml")
		{
			result.push(file);
		}
	}
 
	return result;
}

var sourceFile:IAS3SourceFile = NodeFactory.instance.
	createSourceFile(source, "/home/src/my/domain/internal.as", "/home/src") as IAS3SourceFile;
 
var compilationNode:ICompilationNode = sourceFile.buildAst();
trace(sourceFile.fileName);
trace(sourceFile.compilationNode.packageNode.name);
trace(sourceFile.compilationNode.packageNode.qualifiedName);
trace(sourceFile.compilationNode.packageNode.typeNode.methods[0].name);
trace(sourceFile.compilationNode.packageNode.typeNode.methods[0].parameters[0].name);
trace(sourceFile.compilationNode.packageNode.typeNode.methods[0].comment.shortDescription);
trace(sourceFile.compilationNode.packageNode.typeNode.methods[0].comment.getDocTags("see"));

/*fpkg*/package foo.bar {
	import pkg.Stuff;
	import mx.core.mx_internal;
	use namespace mx_internal;
 
	/**
	 * Class meta.
	 */
	[Event(name="myEvent",type="flash.events.Event")]
 
	/**
	 * java doc
	 */
	public class /*f*/Blat extends Bing implements Febraz, Goo {
 
		private var data:String;
		private var data:* = womble();
 
		/** asdoc for property */
		public function get property():String{return null;}
		/** @private */
		public function set property(value:String):void{}
 
		public function Blat() {
			super();
			return;
		}
 
		[Annotate]
		[Basic()]
		/**
		 * Meta doccomment.
		 */
		[String("foo")]
		[Num(1)]
		[Bool(false)]
		[Arg(foo="bar")]
		[List(foo="bar", that=2)]
		[Event("alpha")]
		[Event("beta")]
		private var x:String = 1;
		/** javadoc? */
		public static function func(arg:Number, foo=null, ...rest):Boolean {
			default xml namespace = "http://example.com/";
			for (var b=1;b<=10;b++) { bar(); }
			for (;;) { break; }
			for (var g in blah) { r(); }
			for each (var g in blah) { r(); }
			if (h==undefined) { throw new Error(); } else { /* bar */ }
			if (a) b();
			while (false) v();
			do { continue; } while (m);
			switch (blah) {
				case 3: x(); y();
				case 4: next;
				default: x(); y();
			}
			try {
				with (scope) foo();
			} catch (e) {
				var a=b?(x+y):new Foo();
			} catch (f:Error) {
				const X=new Thing();
			}
			try {
				foo();
			} finally {
				ff = function(y, z) { };
			}
			l=[1,'2'];
			xx = doc.ns::name;
			m={a:null};
// TODO:			hex = 0x3;
			d = <foo bar="{blat}"/>;
			d = <foo>
					<bar/>
				</foo>;
			r = /regexp/;
			a = b.(@c);
			zz = a..b;
			zzz = a..@*;
			zzzz = a..@["foo"+b];
			/* unary expressions */
			--a; ++a; a--; a++; a = -a;
			return a.call(i.j*k, l[m]);
		}
	}
} // trailing comment
/**
 * internal class.
 */
class InternalClass {
	private var foo:int = {};
	public function InternalClass()
	{
	}
}
// trailing comment
 
/**
 * internal function.
 */
function myFunc(arg:int=0):Vector.<int> {
	return null;
}