fix naming conflicts

rex.go

 )
 
 var (
-	mux = New()
+	DefaultMux = New()
 
 	options = struct {
 		debug    bool
 // Get is a shortcut for mux.HandleFunc(pattern, handler).Methods("GET"),
 // it also fetch the full function name of the handler (with package) to name the route.
 func Get(pattern string, handler interface{}) {
-	mux.register("GET", pattern, handler)
+	DefaultMux.register("GET", pattern, handler)
 }
 
 // Head is a shortcut for mux.HandleFunc(pattern, handler).Methods("HEAD")
 // it also fetch the full function name of the handler (with package) to name the route.
 func Head(pattern string, handler interface{}) {
-	mux.register("HEAD", pattern, handler)
+	DefaultMux.register("HEAD", pattern, handler)
 }
 
 // Options is a shortcut for mux.HandleFunc(pattern, handler).Methods("OPTIONS")
 // it also fetch the full function name of the handler (with package) to name the route.
 // NOTE method OPTIONS is **NOT** cachable, beware of what you are going to do.
 func Options(pattern string, handler interface{}) {
-	mux.register("OPTIONS", pattern, handler)
+	DefaultMux.register("OPTIONS", pattern, handler)
 }
 
 // Post is a shortcut for mux.HandleFunc(pattern, handler).Methods("POST")
 // it also fetch the full function name of the handler (with package) to name the route.
 func Post(pattern string, handler interface{}) {
-	mux.register("POST", pattern, handler)
+	DefaultMux.register("POST", pattern, handler)
 }
 
 // Put is a shortcut for mux.HandleFunc(pattern, handler).Methods("PUT")
 // it also fetch the full function name of the handler (with package) to name the route.
 func Put(pattern string, handler interface{}) {
-	mux.register("PUT", pattern, handler)
+	DefaultMux.register("PUT", pattern, handler)
 }
 
 // Delete is a shortcut for mux.HandleFunc(pattern, handler).Methods("DELETE")
 // it also fetch the full function name of the handler (with package) to name the route.
 func Delete(pattern string, handler interface{}) {
-	mux.register("Delete", pattern, handler)
+	DefaultMux.register("Delete", pattern, handler)
 }
 
 // Group creates a new application group under the given path.
 func Group(path string) *Router {
-	return mux.Group(path)
+	return DefaultMux.Group(path)
 }
 
 // FileServer registers a handler to serve HTTP requests
 // with the contents of the file system rooted at root.
 func FileServer(prefix, dir string) {
-	mux.FileServer(prefix, dir)
+	DefaultMux.FileServer(prefix, dir)
 }
 
 // Use appends middleware module into the serving list, modules will be served in FIFO order.
 func Use(module func(http.Handler) http.Handler) {
-	mux.Use(module)
+	DefaultMux.Use(module)
 }
 
 func Run() {
-	mux.Use(modules.Logger)
-	mux.Run()
+	DefaultMux.Use(modules.Logger)
+	DefaultMux.Run()
 }
 
 func init() {

router.go

 }
 
 // build constructs all router/subrouters along with their middleware modules chain.
-func (self *Router) build() {
+func (self *Router) build() http.Handler {
 	if !self.ready {
 		self.ready = true
 		// * activate router's middleware modules.
 			sr.mod.Use(sr.mux)
 		}
 	}
+	return self.mod
 }
 
 // register adds the http.Handler/http.HandleFunc into Gorilla mux.
 // ServeHTTP dispatches the request to the handler whose
 // pattern most closely matches the request URL.
 func (self *Router) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-	self.build()
-	self.mod.ServeHTTP(w, r)
+	self.build().ServeHTTP(w, r)
 }
 
 // Run starts the application server to serve incoming requests at the given address.