it’s completely customizable by giving an option object to it. a little how-to is included in the js-file.

you can also get it from aurora’s plugin repository².

a little demo can be found here: http://ok.ryotic.de/flobu_demo/

‘hope you’ll find it useful

–

1. jquery flower bubble plugin
2. aurora framework

things we use for this are:

• ext.mod call style
• config/boot/extmod_drop_duplicates
• signals
• some helpers

note: i’m normally using tabs instead of spaces but the syntax highlight plugin replaces them with spaces. it also messes up single quotes - you should replace them with normal single quotes instead.

so let’s start by making out where to drop our new project. my installation uses ~/Sites as my docroot. i have a test folder in ~/Sites/test which is my starting point.

let’s create a project. open up your console, go into your test-folder ( or whatever ) and do:

$> ama -cp fileconv -ca -cli

this will create a project, a simple application and a cli file.

$> cd fileconv/module/fileconv.appl/

now we create two extensions for reading and writing files:

$> ama -ce xml -ce yaml

now open up the xml extension with your favorite text editor and flesh it out with some methods for reading and writing:

do the same with the yaml extension:

setup the $data var in your appl file right into the class:

replace all cli routes ( cli file ) with these ( no tabs - just 2 leading spaces! ):

and finally go to ../../ ( your project’s root folder ), edit config/boot.yml, set extmod_drop_duplicates to yes and try this:

$> ./run

fileconv v0.1 ( development )

USAGE: ./run option argument(s)

OPTIONS:
  --clear-cache
  --shell
  --create-manpages
  --web-access-deactivate message
  --web-access-activate
  --htaccess-write
  --read-xml filename
  --write-xml filename
  --read-yaml filename
  --write-yaml filename

now guess what? your file converter is ready for work :). try these and check the outputted files:

$> ./run --read-yaml config/boot.yml --write-xml output.xml
$> ./run --read-xml output.xml --write-yaml output.yml
$> ./run --read-xml output.xml --write-xml output2.xml
$> diff output.xml output2.xml
$> ./run --read-yaml output.yml --write-yaml output2.yml
$> diff output.yml output2.yml
$> ./run --read-yaml output.yml --write-xml output2.xml
$> diff output.xml output2.xml

you should not encounter any errors. if you do please let me know.

now what have we seen?

• we used ama to create multiple things in one run
• we created extensions for our application
• saw what the xml and yaml helper can simplify
• how cli files can easily extend your command line

“signals?” you might ask.. yeah.. how do we utilize signals in this simple app? well, what does this command line util not do? feedback - right - we don’t see any feedback!
so what can we do? we could insert some error handling and “doing this”, “doing that” messages. signals are not good at catching errors - that chapter is not written, yet. but signals can interfere application and library calls. so we could output some “doing this” and “doing that” messages without changing the code in the extensions. you might also do some user authentication within a web app, but we keep it simple.

$> cd module/fileconv.appl/

$> ama -cs

edit fileconv.sgn and replace present signals with this:

add the following to the fileconv.appl:

$> cd ../..

$> ./run --read-yaml output.yml --write-xml output2.xml
MSG:  fileconv -> yaml reads output.yml
MSG:  fileconv -> xml writes output2.xml

that’s it.

have fun

–

1. you’ll need to have aurora 0.9.6 properly installed to walk through this tutorial

.htaccess won’t be written automatically anymore
use ./run –htaccess-write to do this manually.

auth, db, model and validation have been extracted into a plugin
this was a necessary first step to make way for the upcoming shiny new db-api along auth and validation modules. i’ll write something about them as soon as possible. use “ama -pur -pi db1_with_auth” within your project to get the old stuff back.

optional extension.method call style
in order to easily know which extension holds which method when looking at a cli or url file, extmod now understands an optional extension.method style ( instead of naming the method only ). application::run (), the cli- and url-wrapper are aware of this and work hand in hand with extmod. to close the last hole, extmod provides you a __call ( $func, $args ) method which you can use to call methods with the $ext_name.$method style, too. appls and libs extend from extmod so this functionality is always right at your hand.

external calls with extmod
this means that calling $appl -> _call_external ( $callable, $args ) will initialize the appl as usual and then call the given callable ( same as in php itself ) with args. you may use this to mimic template rendering from a specific appl while actually being in a different lib or something like that. this also ensures proper direct template rendering from an url file without the need for a one-liner-method.

support colliding method names across extensions
enabling config/boot/extmod_drop_duplicates makes it possible to have the same method names accross extensions within the same appl or lib. this is especially neat when writing rest-like interfaces. the backdraw is that methods that collide won’t be callable thru the appl or lib as usual. you have to use the $ext_name.$method style in your url or cli files.

semi caching while in development environment
long time i thought about enabling some minimal caching while in development. some day i had an idea how to do this so that aurora and your project will startup much faster while always keeping track of changes in your files. this leaded me to semi-caching which does excactly that. while in production environment aurora won’t check the config files anymore after creating the cache.

calling methods from appl or lib emit signals
this can be handy to interfere with calls to appls, libs and their extension.methods to check for authentication or if a user may see a certain website. a kind of aspect oriented approach.
i’ve been using this to directly render templates from an url file ( mini-cms ) while always calling the auth lib and checking if the user may see the page or not. the latter case would simply redirect to the main page.
in another project i’m using signals to catch calls from an url file to certain extensions and present a login page or not. here complete extensions are blocked from the user if necessary.

adaptive template rendering
this sounds much more complicated than it is. the problem is that one method may not be equally good for rendering all template blocks. after some testing i found out that there can be mainly two methods in use, choosing one of them according to the size of the block to render. in the end this approch found use in many small places improving the overall rendering speed a bit.

user-definable open basedirs
copying the config/web.yml file into your project and taking a look into it will reveal an array called public_folders. this can be used to let nearly every folder be accessible from the web. –htaccess-write will write special rules for them. you may use this approach to share images, css, javascript or something else accross all your appls and libs in your project. i use it to provide a download folder.

pitfall: template’s $_ var
until recently i really thought $_ was broken. but then i logically investigated the situation just to find out that it’s perfectly fine. the thing is: you have to use at least $_/ and never forget the trailing slash. this way even if $_ is empty, a slash is available resulting in a valid base url.

notes and changelog
http://feedntrack.de/l/1/4xt80

download page
http://feedntrack.de/l/1/1587f

hopefully this has provided you a little overview of what is new and what has been improved so far.

now get coding :).

–

1. aurora framework

abhilfe schaffen hier die kürzlich eingeführten “public folders”. im prinzip ist das nichts anderes, als was die “open basedir”s in den url-dateien bisher auch taten - einen bestimmten ordner via .htaccess freigeben.

$> ama -cp joe -cwa
$> cd joe
$> mkdir -p public/css public/js
$> cp $AURORA_BASEDIR/config/web.yml config/
$> vi config/web.yml

im abschnitt “public_folders” dann die einträge für css und javascript aktivieren, “css” in “public/css” und “javascript” in “public/js” umtaufen. man kann hier beliebig viele pfade angeben. nun die datei abspeichern und vi beenden.

als nächstes erzeugen wir zwei dateien und füllen sie mit irgendwelchem inhalt:

$> vi public/css/main.css
body { background-color: gray ; }

$> vi public/js/main.js
alert ( “it works!” ) ;

damit die beiden dateien auch wirklich geladen werden, fügen wir zu dem inhalt im template-block “joe” ( vi module/joe.appl/joe.tpl ) folgendes hinzu:
@html:include:public/css/main.css
@html:include:public/js/main.js

zum beweis, dass es schon funktioniert, rufen wir joe nun im browser auf. daraufhin sollte die .htaccess-datei generiert und die “page not found”-seite angezeigt werden. klicken wir nun auf den link “» joe » main”, gelangen wir auf eine seite mit einem grauen hintergrund, worauf steht “hello world! :)” und ein popup-fenster uns die freudige nachricht “it works!” übermittelt.

da ich auch gerne alle skeptiker überzeugen würde, klicken wir nun auf “zurück” in der browser-navigation und widmen uns der zweiten appl.

$> cd module
$> ama -cwa garfield

mittels vi garfield.appl/garfield.tpl das wort “world” durch “garfield” ersetzen, die zwei include-zeilen von oben auch hier hinzufügen und im browser ein reload ausführen. nun sollte man den link zu garfield sehen und anklicken können. sofern alles funktioniert hat, bekommt man ein schwarzes “hello garfield! :)” auf grauem hintergrund mit der bekannten alert-box zu sehen.

das wars schon :).

ps die .htaccess wird nur erzeugt oder aktualisiert, wenn man die template-dateien ( rules ) im web.lib ordner ändert, die .htaccess leer oder nicht vorhanden ist. da das nicht unbedingt immer bequem ist, gibt es einen hilfreichen befehl, den man am besten direkt im projektrumpf ausführen sollte. also:

$> cd ..
$> ./run –htaccess-write

• Adblock Plus
• Deutsches Wörterbuch
• Download Statusbar
• Duplicate Tab
• FaviconizeTab
• Fetch Text URL
• Firebug
• Firecookie
• FireGestures
• FirePHP
• geoFlock
• Link Diagnosis
• Quartz PDF Plugin ( http://code.google.com/p/firefox-mac-pdf/ )
• Screen grab!
• Selenium IDE
• ShowIP
• Source Viewer Tab
• SQLite Manager
• Undo Closed Tabs Button
• Web Developer
• Xdebug Helper
• YSlow
• Zotero

da flock ja bekanntlich auf firefox basiert, kann der gro�?teil natürlich auch unter firefox verwendet werden.

$> ama -cp direct_rendering_test
$> cd direct_rendering_test/module
$> ama -cwa main

dann in module/main.appl/main.url alle beispiel-routen entfernen und folgende unter routes einfügen:

  # default to main-page
  - {
    url: "^"
    method: "template::render_template_to_screen"
    args:
    template: "main"
    start_block: "main"
    additional_vars:
    what: "world"
  }

zum spa�? im template ( module/main.appl/main.tpl ) das world durch ein $what ersetzen. die main () in main.appl kann natürlich entsorgt werden.

nun das ganze im browser öffnen und freuen

ps hab leider auch einen bug gefunden. in $$ steht der falsche caller “web” drinn. eigentlich sollte ja “main” ausgegeben werden, da die main.url auf die main.appl verweist. der bugfix ist für die nächste version 0.9.6 eingetragen.

wollte das prefix von meinem imap-postfach von meinem abgerauchten server hier so ändern, dass ich das postfach als treenode im baum links in mail hab. gemacht - mails weg. WTF?!!

nunja, er hat sie gelöscht, den pfad geändert und wollte synchronisieren - bong.

ich also gedacht “haha - bin ja ausgerüstet!”, postfach gewählt und time machine gestartet. nach einigem rödeln war das interface ( echt niedlich ) da und auch das postfach mit meinen mails. ich also auf “wiederherstellen” geklickt und gewartet. fertig.

nun liegen da in einem lokalen baum ein paar ordner - nicht alle - und irgendwie hab ich mir das anders vorgestellt. warum nicht im imap-postfach sondern als extra baum im lokalen system?? hmpf.

was geht noch..? hmm… man könnte ja das restore auf dateisystemebene versuchen. ich also in ~/Library/Mail rein und ordner durchstöbert. IMAP-${username}@${hostname} gefunden, reingegangen und time machine gestartet. nach 5 minuten waren auch alle dateien wiederhergestellt. ok. mail starten….. struktur da - keine emails - ARGH!!

also.. nachdenken.. was kanns sein… cache nicht synchron? bestimmt macht der das mit irgendwelchen caches.. index-caches… etwas gegoogled und was gefunden: “~/Library/Mail/Envelope Index ist eine sqlite db”. hmmmmm… man kann die also aufräumen lassen.. “sqlite3 ~/Library/Mail/Envelope\ Index vacuum” ausgeführt und mail gestartet - ging schnell - wieder keine mails :(.

also was noch… einige posts sprachen davon, dass wenn ich den envelope index lösche, wird er neu erstellt indem er alle emails erneut importiert - sprich scanned und den index daran aufbaut. danach soll er angeblich synchronisieren wo er kann und wo er nicht kann es in ruhe lassen. ok. index-datei gelöscht, mail aufgerufen, import gestartet und 15 minuten später sind alle mails wieder da.

YAY!!! <|:)