                 configuredRoutes = require '../config/routes'
 
                 # Let's loop through the routes file and do the appropriate mapping.
-                for route of configuredRoutes
+                # NOTE: I really hate that the value comes before the key. 
+                _.each configuredRoutes, (actionString, route) -> 
 
                         # This is just a handle on the string object so as to avoid square-bracket-hell
-                        actionString = configuredRoutes[route]
 
                         # routes are stored like METHOD /route, so we'll split on spaces. 
-                        routeComponent = route.split(' ')
+                        routeComponent = route.split ' '
 
                         # THe first item should be the method, so we'll grab that.  The toLowerCase
                         # function is there to make the routing a bit more dev friendly in case

                        # Thus, I thunk'd it: I passit it into the function as an argument, so as to
                        # guarantee that I'm getting a personalized "allroutes" variable.  The thunk
                        # then returns a function that we can use. 
                        wrapper = (allRoutes) ->
                                (req, res) ->
                                        # A quick holder for all the promises yet to come. 
                                        promiseArray = []


                                                return controllerObject[myController][myAction]

                                        # Once we've gotten all the handles on the functions we need
                                        # to call, we can concat it to all previous promises. Afterwards
                                        # we want these to run sequentially, so we use the reduce function
                                        # to run them, then converge into a single, final promise. 
                                        finalPromise =
                                                do
                                                        _.chain promiseArray
                                                        .concat actionHandles
                                                        .reduce (cur, next) ->
                                                                cur.then next
                                                        .value

                                        # Everything should be done.  We can finally render a template
                                        # or return back JSON depending on what they did on that last function
