This is part 1 of the series of posts which will come in the near future describing DAssistA & its representation as User Experience.
First of all I should explain something for the in-deep workings within DAssistA. It is nekovm based haxe runtime compiled solution where there are two (at the moment) possible entry points: command prompt & web service interface. Every peace of DAssistA as itself is a MultiModule implementation, more on that in the future. But the important thingy is that every single module in DAssistA can be at runtime modified-re-compiled-re-executed. As such module implementations are the ActionPdml module which is responsible of parsing pdml files all around the repository to their proper analogue class->method invokes.
That was in-the-box into. Now on the front:
– on left you can see the repository or so called project swarm where everything involved in project development as material resides.
- on right , opened pdml file editor-like, but with drag & drop funcs for faster & better construction of pdmls.
- on bottom empty space there will be presented all possible modules supported within DAssistA & ActionPDML parser.
As there are already several kind of modules used all around it needs proper documentation from the beginning. And what better than exposing the source code docs at runtime?
Just try the new repo_0.0.4 and give it to your imagination (or try something like “parse.bat asdkjahda” and after that open up haxe.org.dassista.tools.Parser at method execute 
)
More to come:
- full code documentation during the following couple of releases
- ftp upload(scp)
- wget tight implementation
- a nice GUI…. 
/**
*
* @param context
* @return Bool
* @_root class path to root entry
* @_cmd haxe command arguments
* @_uses haxe.org.dassista.tools.proxy.Cmd
*/
public function execute(context:IMultiModuleContext):Dynamic
Now pdmls can contain something like this haxe.org.dassista._pdmls.export-as-repo entry:
<pdml parser="haxe.org.dassista.tools.parsers.ActionPdml">
<pdml parser="haxe.org.dassista.tools.parsers.ActionPdml">
<execute classname="haxe.org.dassista.tools.Parser">
<target>haxe.org.dassista._pdmls.module</target>
</execute>
<clean classname="haxe.org.dassista.tools.proxy.Dir">
<target>releases.org.dassista</target>
</clean>
<execute classname="haxe.org.dassista.tools.proxy.Copy">
<src>haxe.org.dassista</src>
<dest>releases.org.dassista.repo.haxe.org.dassista</dest>
<excludeDirs>.git</excludeDirs>
<excludeFiles>*.n</excludeFiles>
</execute>
<execute classname="haxe.org.dassista.tools.proxy.Copy">
<src></src>
<dest>releases.org.dassista.repo</dest>
<name>*.bat</name>
</execute>
<execute classname="haxe.org.dassista.tools.proxy.Zip">
<src>releases.org.dassista.repo</src>
<dest>releases.org.dassista</dest>
<name>repo_{version}_{major}_{minor}.zip</name>
</execute>
</pdml>
where haxe.org.dassista._pdmls.module contains:
<module parser="haxe.org.dassista.tools.parsers.MetadataPdml">
<gitCloneURL>git://github.com/outbounder/DAssista.git</gitCloneURL>
<author>Boris Filipov</author>
<version>0.0.3</version>
</module>
The above export-as-repo dpml executed via DAssistA’s parser will do the following:
1) read haxe.org.dassista._pdmls.module entry & store all found <tag>value</tag> pairs within the runtime hash as they are found.
2) copy all files & subdirs from haxe.org.dassista location to the release one
3) copy all *.bat files found within the current repository (or should be called project swarm
)
4) zip the exported repo using as name “repo_0.0.3_”, here the shell & restservice get in different ways. RestService could not interact with the browser unless using specific handshake & dialect. Such is not a matter of implementation for now.
. The Shell will ask for user input …
have a try it is now already 0.0.4, use
git clone (or …. later
I’m proud to announce that DAssistA finally get rolled out with proof-of-concept version which includes the following features:
- shell command line execution via nekovm
- restful-like execution via nekovm (or mod_neko)
- compile itself & any other haxe/neko based application or module
- release itself & any other project involving only (copy, compile) actions.
- compile php based application or module
- Several simple proxy tools (Copy, Cmd, Haxe, Dir, Git, WGet)
- Couple of pdml parsers (ActionPDML & MetadataPdml) module
- Generic Pdml Parser module
From the above here is a simple usage tutorial:
How to install dassista
1. Install haxe
2. Download the following repo_0.2 zip
3. Unzip to an empty folder (eg. D:\pd-repo\)
that’s all
How to compile dassista
1. Fire-up a console (usually in windows this is Start->Run->type cmd.exe and hit enter)
2. Navigate to the repo folder where dassista repo had been unzipted (eg. D:\pd-repo\)
3. Type “parse.bat haxe.org.dassista._pdml.compile” , and watch how DAssistA’s modules are been compiled.
How to export dassista as repo
1. Fire-up console pointing at the repo folder (eg. D:\pd-repo)
2. Type “parse.bat haxe.org.dassista._pdml.export-as-repo“, and watch how current DAssistA repository is been exported into single zip ready to be deployed
How to compile/export to php haxe written web implementation
1. Create an empty directory under dassista repo (eg. D:\pd-repo\php\org\test\)
2. Put php-compile as D:\pd-repo\php\org\test\_pdml\compile.pdml
3. Put Index as D:\pd-repo\php\org\test\Index.hx
3. Type in shell@pd-repo “parse.bat php.org.test._pdmls.compile“
As things go – soon or later DAssista will have its own full development compile – release process using itself. Where currently it releases itself as repository.
There are still a lot to be done (including cross-platform modules implementation), but finally a good proof-of-concept is ready. Here is how it works(for now):
DAssista runs under neko virtual machine. It does support a standard neko modules loading, where all action modules in dassista are compile – scriptable. This means that if you need additional action module you need to write it down in haxe & compile as neko module.
Because DAssista should work for anybody and do everything it is command based (for now, later GUI will be pushed in front) where there are two scripts responsible for command execution:
– compiler.bat %* which actually compiles DAssista’s compiler & compiles any target given as command arg. Target may be either single DAssista action module or directory path. The compiler understands repository based paths & file system onces.
- parser.bat %* which actually is used to parse pdml files passed as command arg.
And here are simple use cases:
c:\pd-repo> compile.bat haxe.org.dassista.module.*
will compile all *.hx found files to neko bytecode modules *.n
c:\pd-repo> parser.bat haxe.org.dasssista.release-repo
will parse & execute c:\pd-repo\haxe\org\dassista\release-repo.pdml , which actually will do a release of dassista in C:\pd-repo\releases\org\dassista\
More to be done including git clone-overlap integration.
Requirements:
Windows OS
installed haXe (with nekovm) & PATH env variable pointing to haxe.exe & neko.exe
Future versions will also contain self-download-install of git & its integrations.
Now for the fun here is the released repo v0.1
– on left you can see the repository or so called project swarm where everything involved in project development as material resides.