Wheels-The Fast & Fun
CFML Framework!

Build apps quickly with an organized, Ruby on Rails-inspired
structure. Get up and running in no time!

Latest From the Wheels Dev Blog

CFWheels Fully Embraces ForgeBox Packages

As you may know, many years ago CFWheels embraced the distribution of Plugins via ForgeBox packages instead of maintaining our own directory. But the framework itself remains illusive. There was some work done in the last few months to put up packages for the framework but those packages were being maintained by hand which made them a show stopper for a long term solution.

Well, thanks to a new CI workflow based on GitHub Actions we now have the building and publishing of the packages fully automated. Giving credit where credit is due, the new workflow borrows heavily from the ColdBox workflow. It used GitHub Actions, Ant, and CommandBox to automate the process.

So what does all this mean for you, let's cut to the chase. This means you can now install a fresh copy of the framework using the following command:

box install cfwheels-base-template

This will pull down a copy of the latest stable release of the template files and then pull down a copy of the latest stable release of the framework via package dependencies. In fact the CI workflow mentioned about publishes two packages cfwheels which is the core framework directory and cfwheels-base-template which is all the other files you need to scaffold the framework.

We've even backfilled all the prior released versions of the framework all the way back to version 1.0.0. So you can install a particular version of the framework using the following command:

box install cfwheels-base-template@2.0.2

In addition you can install the bleeding edge which includes all the work in process towards the next major release using:

box install cfwheels-base-template@be

And if you ever just need to get a copy of the latest framework files simply use the following command:

box install cfwheels

All this means that upgrading to a newer version of the framework should be much easier going forward. Frankly you should just need to modify the version of the dependency in the box.json file and issue a box update command. But we'll document that more fully when we make our next release.

For now please feel free to play with all this package goodness and let us know if we fumbled anything.

April 29, 2022 by Peter Amiri

Upcoming (and Previous) Wheels Presentations

Thanks to the ColdFusion Community for supporting Wheels. Hat-tips to upcoming ColdFusion Conferences cf.Objective() and CFUnited for accepting and expressing interest in Wheels sessions. Individual thanks to Sean Corfield for asking people to submit Wheels topics to CFUnited and Charlie Arehart for hosting Wheels topics on the Online ColdFusion Meetup.

Upcoming

Previous

Screencasts (each under 10 minutes)

Screencast page Postcast feed

Call for Speakers and Audiences

If you are interesting in presenting or have someone present for your event, please contact Wheels via the Google Group. The group will be glad to help.

December 11, 2010 by Mike Henke

CFWheels Joins Open Source Collective

We are happy to announce that CFWheels has joined Open Source Collective. According to their website, Open Collective enables all kinds of groups to raise, manage, and spend money transparently. We’re also in good company in the collective. Other projects hosted by the Open Source Collective include Lucee, WebPack, PHP Foundation, Vue, LinuxServer, ESLint, Bower, Svelte, and the list literally goes on and on.

So what does this mean for CFWheels. Well, it allows us to finally be able to accept donations from our community. Many of you have offered your donations to us in the past but we really had no good way to do accept them legally. Plus we felt strongly that as an open source project we needed to adopt an open and transparent accounting practices. As a member of the collective, you’ll be able to donate and see every dollar we raise and what it is spent on. Creating a sustainable ecosystem is important for the long term viability of the CFWheels project. So how do you donate, visit Open Source Collective directly or any of our GitHub projects and look for the Sponsor this project link in the right side bar.

We’ve already received our first monthly donation and we are truly grateful. These funds will allow us to offer bounties for small issues or bugs, commission larger works, and pay for marketing, logo, or branding services.

April 25, 2022 by Peter Amiri

Another great cf.Objective() is over - Wheels

Well, another great cf.Objective() is over.  I am still in overdrive, so it is perfect time to post about the Wheels presentation. The first part focused on the ideas behind Wheels.  Convention Over Configuration (CoC), Don't Repeat Yourself (DRY), and Model View Controller (MVC), and Simplicity. The second part, went over how Wheels works, server request are handled, understanding the Operation Trail (URL), and the File Structure.  This part we started by creating the normal, say controller, hello action but starting from the view, then working to the controller.  This was done to show how easy prototyping can be accomplished. The next part, we worked on the Controller, View, and Model aspects of Wheels. This was helped by the scaffolding plugin.  We showed findOne() vs findAll(), and how to use their attributes to generate more complex sql. For the View, we modified some of the views like deleting id field from the index.cfm and talked about helpers. For the last part, we covered Associations and Validation in the model. The audience asked great questions which is expected from cf.Objective.  It was great to see faces like Sean Corfield (creator of fw1), Mark Mandel (creator of Transfer), John Mason, Andy Mathews (I am pretty sure he was in the far back), and Dan Wilson (managing director of model glue) in the crowd learning about Wheels.  I think it is really great other cf frameworks can gleam ideas from each other and maybe even help each other out. Like mentioned at the beginning of the presentation, I haven't contributed any code to the Wheels project except for a couple plugins.  I can't take credit for any their hard work.  I am someone who found a framework that works for  me after a long journey of trying cf frameworks.  Kudos to the Core Wheels development team and any others who have submitted code. As for the free t-shirts, we gave them all away but have had requests for more so we maybe able to work something out. I'll post the code links later. Slides - http://bit.ly/9nvTA1 (has recent speaker notes) Outline - http://bit.ly/cngIZQ Speaker Notes - http://bit.ly/bGEl82 (speaker notes not recent) Final Code Examples: http://bit.ly/dlbnJv

December 26, 2010 by Mike Henke

CFWheels 1.4.1 maintenance release

Today sees a small maintenance release for the 1.4.x series Download 1.4.1 today to fix the following:

Bug Fixes

  • Skip callbacks when running calculation methods  [Adam Chapman, Per Djurner]
  • Fixed rewrite rules so base URL is rewritten correctly on Apache  [Jeremy Keczan, Per Djurner]
  • Removed incorrect path info information set by Apache [David Belanger, Per Djurner]
  • Fixed routing bug when running from a sub folder on Adobe ColdFusion 10 - [Brant Nielsen, Per Djurner]
  • Made sure error emails never depend on application variables being set - [Per Djurner]

Miscellaneous

  • Removed tests folder - [Per Djurner]
  • Updates to framework utility pages - Update logo, Fix links on congrats page to point to new documentation site - [Chris Peters]
Also don't forget to check the upgrade notes

May 30, 2015 by Tom King

Testing Plugins on CFWheels 2.x and Travis CI via commandbox

One of the nicest things about CFWheels 2.x is the tighter integration with command-line tools such as Commandbox. We can take advantage of the new testing suite JSON return type and the new CFWheels CLI in Commandbox 2.x to easily build a Travis CI test. It's perhaps easiest to just show the .travis.yml file - this goes in the root of your gitHub plugin repository, and once you've turned on testing under Travis.org, will run your test suite on every commit. https://gist.github.com/neokoenig/504ce0108a1caf0f19d54e87c1a8193c In sum, this:

  1. Installs Commandbox
  2. Installs the CFWheels CLI
  3. Installs the master branch of the CFWheels repository
  4. Installs your plugin from your repository (rather than the forgebox version which will be the version behind)
  5. Starts the local server
  6. Runs the test suite, pointing only at your plugin's unit tests

Naturally, you could do more complex things with this, such as multiple CF Engines, and maybe even multiple CFWheels versions, but for a quick setup it's a good starting point!

May 31, 2017 by Tom King

10 years of CFWheels / Welcome Adam / CFWheels 2.x

A bit of history: It's slightly hard to put an exact date on it, but this year (probably) celebrates 10 years of CFWheels! Obviously, in the internet age, 10 years is an awfully long time. The first mention I can find if from Pete Freitag's "Get Wheelin" blog post celebrating CFWheels 0.1 in November 2005. Rob Cameron, the original author moved over to Rails full time a few years later: you can catch up with him at http://ridingtheclutch.com/. Over the years there have been a lot of contributors - whilst our GitHub repo hasn't quite got that (very) early history, since Jul 23, 2006, we've had:
  • 2825 commits (Per Djurner has the dubious claim to fame of the first commit, and at time of writing, the most recent too :))
  • 22 Branches
  • 43 Releases
  • 76 forks
  • 453 issues
Whilst there was a "bit of a break" around 2012/13, Wheels has been going from strength to strength. Contributors have changed and moved on, and so have core team members. Our thanks go out to all of them! Welcome Adam! We're very pleased that Adam Chapman (@chapmandu) has agreed to join the CFWheels core team! He’s been a long-time supporter of wheels, we're very glad to have him on board. We expect great things AC.... great things. :) You can find Adam's blog here. CFWheels 2.x: Lots of chat at the moment about the next major release of CFWheels - please do get involved on the Google group if you've got ideas. At the moment, amongst lots of micro improvements, we're looking at:
  • integrating the ColdRoute plugin into the core:  ColdRoute allows you to define RESTful resources through new expressive routing helpers and controller conventions. It also allows you to organize controllers and views into subfolders via "namespaces" or "modules."
  • improving wheels as a true RESTful service provider: you can already return JSON, XML and lots of other good stuff, but we're looking to improve things like setting custom headers, and really controlling your APIs response
  • improving the plugin architecture, and generally looking a more "modular" way of doing things.
  • dropping CF8/9 support; dropping Railo (as you should all be on Lucee now!!)
  • better Commandbox support: we'll be looking at CLI type stuff to make getting going with wheels even quicker.
Got an idea? Get on the Google Group and let us know!

March 23, 2016 by Tom King

Internal Documentation in CFWheels 2.0-beta

One of a developer's biggest time sinks is coming up with and writing accurate and engaging documentation. Even if it's an internal project with.. well, just you... it's still incredibly valuable to have: coming back to projects a few months or even years later can often lead to a bit of head scratching and screams of "why?", especially with your own code. Whilst we're not promising that CFWheels will write all your documentation for you, we have put some tools in place to hopefully make the process a little less painful. With a small amount of adjustment in how you document your core functions, documentation doesn't necessarily have to be such a time consuming process.

Browse the Core API

The first thing to notice is the new '[View Docs]' link in the debug section in the footer:
Following that link leads you to the internal documentation. This is a dynamically created set of documention created via javaDoc commenting in the main CFWheels Core. The three column layout is designed to allow for quick filtering by section or function name. On the left are the main CFWheels core categories, such as Controller and Model functions, which are then broken down into sub categories, such as Flash and Pagination functions etc. Clicking on a link in the first column will filter the list in the second  and third columns with all the functions which match (including child functions of that category). Filtering by function name is made simple by a "Filter as you type" search field in the second column, so getting to the right function should be very quick. The third column contains the main function definition, including tags, parameters and code samples.

How is it generated?

Each function in the core is now appropriately marked up with javaDoc style comments. This, combined with getMetaData() allows us to parse the markup into something useful. https://gist.github.com/neokoenig/8405738d398b8555532fe0d1f0e21cca The [section] and [category] tags categorise the function as appropriate, and the @html part describes the function's parameter. The additional parameter data, such as whether it's required, type and any defaults are automatically parsed too. This results in a display like:

Documenting your own functions

Any function which is available to Controller.cfc or Model.cfc is automatically included; if there's no javaDoc comment, then they'll appear in uncategorized. But of course, there's nothing stopping you creating your own [section] and [category] tags, which will then automatically appear on the left hand column for filtering: you're not restricted to what we've used in the core. As an example, if you wanted to document all your filters, you might want to have a [section: Application] tag, with [category: filters].  This way, your application documentation grows as you create it. Something as simple as a sublime text snippet for a new function which includes the basic javaDoc skeleton can get you in the habit pretty quickly!

Plugins too!

We also introspect plugins for the same markup. We encourage plugin authors to adjust their plugin code to include [section: Plugins] at the very least. We do appreciate it will take a while for the plugin eco-system to catch up with this though. More on plugins later.

Exports & Re-use

You can export the docs via JSON just by changing the URL string: i.e ?controller=wheels&action=wheels&view=docs&type=core&format=json You could also include the functions used to create the docs and create your own version (perhaps useful for a CMS or other application where you have internal documentation for authenticated users). Whilst this isn't officially supported (the main functions may be subject to change!) it is technically possible. The best example is the thing itself - see the main output if you're interested. Please note that the user interface isn't available in production mode (for obvious reasons we hope!), so if you wanted to expose this data to an end user, you would probably need to "roll your own" with this approach.

Updating

Note that the CFC introspection doesn't automatically happen on every request, so you will need to ?reload=true to see changes to your code. Additionally, Adobe ColdFusion is more aggressive in caching CFC metadata, so depending on your settings, you may not see changes until a server restart.

Code samples

Whilst the core has additional code samples which can be loaded from text files, there's no support for your application functions to take advantage of this yet.

Roadmap

Whilst this API/function explorer is a great first step, you'll notice your controller and model specific functions aren't included (only those shared amongst controllers, or in the /global/functions.cfm file. This is because we're only looking at the main Model.cfc and Controller.cfc and what it can access. In CFWheels 2.1, we'll look at adding a full Controller and Model metadata explorer using the same techniques, and map functions like show() to their respective routes too.  

May 08, 2017 by Tom King

Released: ColdFusion on Wheels 1.0.4

Today we're releasing ColdFusion on Wheels version 1.0.4. This release fixes another round of bugs and adds more stability improvements. Download it now, replace the wheels folder with the new one, and reload your application. If you're upgrading from a version earlier than 1.0, follow these instructions. From the change log at wheels/CHANGELOG:
  • Added missing support for passing in array of model objects as options to select() - #411
  • Fixed so "afterFind" callback methods are only called once during pagination - #435
  • Added "prependOnAnchor" and "appendOnAnchor" arguments to paginationLinks() to get around an issue where the "appendToPage" string was added on anchor pages - #434
  • Fixed bug in paginationLinks() when using "appendToPage" with single page result
  • Fixed bug with count() when using composite primary keys
  • Fixed concurrency issue related to setting the model name on associations - #419
  • Fix for skipping duplicate columns returned from cfdbinfo when using Oracle - #437 & #439
  • Fix for race conditions when setting the join clause in an application scoped model object - #432
  • Fixed so URLFor() is not duplicating controller and action when URL rewriting is off - #433
  • Added support to imageTag() for all image types that the CFML engine supports

December 21, 2010 by Chris Peters

CFWheels Announces a Bug Bounty

We are happy to launch a new program that we hope will lead to a more stable framework for all of us. Effective immediately we are launching our Bug Bounty program. When we first conceived of the bounty program we were looking at programs from IssueHunt and BountySource and the main goal was to widen the field of contributors to the CFWheels project as well as crush some of the long standing bugs in the framework.

Most of these bugs are edge cases that don’t effect the core functionality of the framework and for the most part users have found work arounds for. In the past it’s been difficult to dedicate our limited resources towards some of these bugs but now that we have a growing list of monthly sponsors we would like to launch out bounty program to compensate contributors who are willing to tackle some of these.

The easiest way to get started participating in this program is to visit the issues list and look for the $50 Bounty tag. Pick an issue that interests you, clone the repo, and start working on your solution. When you think you have a working solution create a PR and submit it for review. Please read the Contributing to CFWheels chapter in the guides or the contributing guidelines in the repository for details on how to contribute to the CFWheels project.

We look forward to see how the community responds to this bounty program. Depending on how things go, we can envision expanding this program to include enhancements as well as sponsorship of individual enhancements.

May 16, 2022 by Peter Amiri

Welcome to Our Community

Welcome to Our Community - a place where like-minded people connect, share ideas,
and grow together in a positive and supportive environment.

Explore community
Wheels.dev Community

Top Contributors