About the FuseBuilder Web Application
The Fusebox LifeCycle Process has made things much easier for developers of web applications using the Fusebox framework, and there have been several tools developed to help programmers work within these stages.
FuseBuilder is the next logical step from those tools. It gives the Fusebox developer the ability to Wireframe a project, generate static html prototype pages and output fully fusedoc'd application frameworks that can get their display fuses from the approved prototypes. You can even use the recordsets you define in your project to generate the SQL required to create your project's database tables.
FuseBuilder is customizable, extensible and can export projects to frameworks using Fusebox 3 for ColdFusion or PHP, and Fusebox 4 for ColdFusion or Coldfusion MX. The frameworks and prototypes generated come complete with clickable links in the display fuses, or submittable forms.
Import projects from Wireframetools or Mind Mapper
You can create a fully defined project from scratch, or you can import files from wireframetools (.wir) or Mindmapper / Visual Mind files (.txt). The import process will automatically convert wireframe information into fuseactions, xfas and fuses. Mind map files can contain essentially all the elements for a complete project, which will be imported and converted faithfully to recreate the project in FuseBuilder. You can use the customization form in FuseBuilder to define a directory location for Wireframetools / Mindmapper files for use when creating new projects, allowing for an unprecedented number of input paths.
Multiple ways to define project elements
There are two ways to develop the structure of your project: Wireframe Edit mode and Project View mode.
Using Wireframe Edit mode is a lot like working with other wireframing tools, with the exeption that when you enter a title for the pagestate, you're actually defining circuit/fuseaction names, and when you type in the description of the pagestate you're actually defining the <responsibility> section of that fuse's fusedoc. Additionally, any links that you define are treated as XFAs in that fuseaction. It's a terrific way of quickly defining all the function points for use in scoping out a project for a client, with the added benefit of continued usability after the wireframe is approved. Once the wireframe is frozen you simply go into each fuseaction and continue refining the structure using the Project View mode.
In Project View every element that can be defined in your project is visible and available for adding, editing or deleting. You can create settings or parameters on a circuit level (fbx_Settings) or on a fuseaction level (fbx_Switch or circuit.xml) You can edit the paths of the circuit and see visually how your circuits nest. You can create, rename or delete fuseactions in a circuit, create Remote Fuseactions (<do/> or FuseQ()), define XFAs' names and targets and whether they're accessed via link or form action, and define a cflocation at the end of the fuseaction. You can put a condition around the including of a fuse, which surrounds the <cfinclude> with <cfif> when the framework is generated. You can copy fuseactions or files to other circuits, copy circuits, or import circuits from other projects. With the use of Remote Fuseactions it's possible to define a full project structure using an MVC approach.
FuseBuilder and FLiP: Wireframe View
At any point in the development of your project's structure you can view the project in Wireframe View. If you're in Wireframe Edit mode, simply click on any of the "circuit.fuseaction" names to enter the pagestate view of that fuseaction. From here you can navigate around the application and simulate the view and access points from one pagestate to the next. You can even define a layout to use with the pagestate view - sort of a pre-prototype. In addition to the pagestate views, there is a summary sheet of all circuit.fuseactions with their possible exits called the Quickmap. You can continue to look at a project in Wireframe mode even after the fuseactions have been developed past the capability of Wireframe Edit mode, such as when you have split the fuseactions into MVC patterns and included them through Remote Fuseactions.
FuseBuilder and FLiP: Prototypes
FuseBuilder and FLiP: Architecting
Architecting the project takes place in the Project View. Every element that Fusebuilder is capable of generating in the framework is available in this view. You can create, edit and delete Circuits, including defining their path for a directory tree. You can copy circuits from within the project, or copy circuits from another project. You can define settings in the fbx_Settings for each circuit, either as settings (<cfset>) or as parameters (<cfparam>). You can create, edit, delete Fuseactions, or move them up and down in the circuit, or move them into another circuit completely. You can also define the fuseaction as a <pre or <postfuseaction> for use in FB4 applications. In a fuseaction you can also define settings (<cfset> or <cfparam>, though parameters are converted into settings within FB4 frameworks) You can define your XFAs, and identify each XFA as either a link or a form button, and choose the display area of the XFA links, such as "breadcrumb" or "general". You can specify the fuses to be included in the fuseaction, with conditions attached to their inclusion. You can define Remote Fuseactions in a fuseaction, that will be generated either as FuseQ elements in FB3, or as <do/> elements in FB4. The full features of both versions are available for definition, such as storing the Remote Fuseaction in a content variable. You can define a relocate call to take place after the fuseaction is complete (<cflocation> in FB3 and <relocate/> in FB4) The fuse files can be fully fusedoc'd, with the Responsibility, Notes and IN or OUT elements available. Any IN or OUT element defined is available to be imported into other fuses, making it extremely easy to populate the full set of fuses in a fuseaction. Additionally, any IO OUT elements that are scoped as "form" or "url" will automatically be rescoped to "attributes" when imported into the IO IN of another fuse.
FuseBuilder was developed with an eye towards making the fullest use possible of the wireframe and any defined fusedocs during the architecture of the project structure, with the goal being the least amount of "hand coding" possible in the generated framework. To that end, FuseBuilder has several advanced features that enable the developer to rapidly expand on a project that's had its Wireframe approved and use the Wireframe and any of the IO Elements in the fuses' Fusedocs in the architecture of the finished framework.
Generating your Frameworks from FuseBuilder
After your project is fully architected, you can export the project to framework. FuseBuilder comes with four "generators": FB3 for CF, FB3 for PHP, FB4 for CF5 and FB4 for CFMX. A framework generated from a FuseBuilder project will have all the necessary core files, and the switch file for each circuit will be populated with all the defined fuseactions. If you have enabled the Link Locations in your project settings, and set up FuseQueries and FuseForms for any fuses displaying form interfaces, about the only thing that will be left to hand-code is any programming logic in the display fuse, and any "act_" fuses. Because of this, you can generate a working and almost fully functional framework from a FuseBuilder project and have the project finished in record time. All of this in your web browser, using tools that you're already using to complete your Fusebox apps anyways, and at a licensing cost that will pay for itself within the first one or two client projects!