OK, my dream-idea is implemented. TODO: Some examples and doc.go is not updated yet, comments on the mvc/di subpackage, the tutorial/vuejs-todo-mvc is running but not finished yet (it's using browser's localstorage and it should be replaced by the http requests that are registered via iris mvc

Former-commit-id: 0ea7e01ce1d78bcb78b40f3b0f5c03ad7c9abaea

_examples/mvc/hello-world/main.go

@@ -3,13 +3,6 @@ package main
 import (
 	"github.com/kataras/iris"
 	"github.com/kataras/iris/mvc"
-	// auto-completion does not working well with type aliases
-	// when embedded fields.
-	// We should complete a report on golang repo for that at some point.
-	//
-	// Therefore import the "mvc" package manually
-	// here at "hello-world" so users can see that
-	// import path somewhere else than the "FAQ" section.
 
 	"github.com/kataras/iris/middleware/logger"
 	"github.com/kataras/iris/middleware/recover"
@@ -43,27 +36,18 @@ func main() {
 	app.Use(recover.New())
 	app.Use(logger.New())
 
-	app.Controller("/", new(ExampleController))
+	// Register a controller based on the root Router, "/".
+	mvc.New(app).Register(new(ExampleController))
 
 	// http://localhost:8080
 	// http://localhost:8080/ping
 	// http://localhost:8080/hello
+	// http://localhost:8080/custom_path
 	app.Run(iris.Addr(":8080"))
 }
 
 // ExampleController serves the "/", "/ping" and "/hello".
-type ExampleController struct {
-	// if you build with go1.8 you have to use the mvc package always,
-	// otherwise
-	// you can, optionally
-	// use the type alias `iris.C`,
-	// same for
-	// context.Context -> iris.Context,
-	// mvc.Result -> iris.Result,
-	// mvc.Response -> iris.Response,
-	// mvc.View -> iris.View
-	mvc.C
-}
+type ExampleController struct{}
 
 // Get serves
 // Method:   GET
@@ -89,6 +73,31 @@ func (c *ExampleController) GetHello() interface{} {
 	return map[string]string{"message": "Hello Iris!"}
 }
 
+// BeforeActivate called once, before the controller adapted to the main application
+// and of course before the server ran.
+// After version 9 you can also add custom routes for a specific controller's methods.
+// Here you can register custom method's handlers
+// use the standard router with `ca.Router` to do something that you can do without mvc as well,
+// and add dependencies that will be binded to a controller's fields or method function's input arguments.
+func (c *ExampleController) BeforeActivate(ca *mvc.ControllerActivator) {
+	anyMiddlewareHere := func(ctx iris.Context) {
+		ctx.Application().Logger().Warnf("Inside /custom_path")
+		ctx.Next()
+	}
+	ca.Handle("GET", "/custom_path", "CustomHandlerWithoutFollowingTheNamingGuide", anyMiddlewareHere)
+
+	// or even add a global middleware based on this controller's router,
+	// which in this example is the root "/":
+	// ca.Router.Use(myMiddleware)
+}
+
+// CustomHandlerWithoutFollowingTheNamingGuide serves
+// Method:   GET
+// Resource: http://localhost:8080/custom_path
+func (c *ExampleController) CustomHandlerWithoutFollowingTheNamingGuide() string {
+	return "hello from the custom handler without following the naming guide"
+}
+
 // GetUserBy serves
 // Method:   GET
 // Resource: http://localhost:8080/user/{username:string}
@@ -121,4 +130,14 @@ func (c *ExampleController) Trace() {}
 func (c *ExampleController) All() {}
 //        OR
 func (c *ExampleController) Any() {}
+
+
+
+func (c *ExampleController) BeforeActivate(ca *mvc.ControllerActivator) {
+	// 1 -> the HTTP Method
+	// 2 -> the route's path
+	// 3 -> this controller's method name that should be handler for that route.
+	ca.Handle("GET", "/mypath/{param}", "DoIt", optionalMiddlewareHere...)
+}
+
 */

_examples/mvc/overview/main.go

@@ -10,38 +10,52 @@ import (
 	"github.com/kataras/iris/_examples/mvc/overview/web/middleware"
 
 	"github.com/kataras/iris"
+	"github.com/kataras/iris/mvc"
 )
 
 func main() {
 	app := iris.New()
+	app.Logger().SetLevel("debug")
 
 	// Load the template files.
 	app.RegisterView(iris.HTML("./web/views", ".html"))
 
 	// Register our controllers.
-	app.Controller("/hello", new(controllers.HelloController))
+	mvc.New(app.Party("/hello")).Register(new(controllers.HelloController))
+	// You can also split the code you write to configure an mvc.Application
+	// using the `Configure` method, as shown below.
+	mvc.New(app.Party("/movies")).Configure(movies)
 
-	// Create our movie repository with some (memory) data from the datasource.
-	repo := repositories.NewMovieRepository(datasource.Movies)
-	// Create our movie service, we will bind it to the movie controller.
-	movieService := services.NewMovieService(repo)
-
-	app.Controller("/movies", new(controllers.MovieController),
-		// Bind the "movieService" to the MovieController's Service (interface) field.
-		movieService,
-		// Add the basic authentication(admin:password) middleware
-		// for the /movies based requests.
-		middleware.BasicAuth)
-
-	// Start the web server at localhost:8080
 	// http://localhost:8080/hello
 	// http://localhost:8080/hello/iris
 	// http://localhost:8080/movies
 	// http://localhost:8080/movies/1
 	app.Run(
+		// Start the web server at localhost:8080
 		iris.Addr("localhost:8080"),
+		// disables updates:
 		iris.WithoutVersionChecker,
+		// skip err server closed when CTRL/CMD+C pressed:
 		iris.WithoutServerError(iris.ErrServerClosed),
-		iris.WithOptimizations, // enables faster json serialization and more
+		// enables faster json serialization and more:
+		iris.WithOptimizations,
 	)
 }
+
+// note the mvc.Application, it's not iris.Application.
+func movies(app *mvc.Application) {
+	// Add the basic authentication(admin:password) middleware
+	// for the /movies based requests.
+	app.Router.Use(middleware.BasicAuth)
+
+	// Create our movie repository with some (memory) data from the datasource.
+	repo := repositories.NewMovieRepository(datasource.Movies)
+	// Create our movie service, we will bind it to the movie app's dependencies.
+	movieService := services.NewMovieService(repo)
+	app.AddDependencies(movieService)
+
+	// Register our movies controller.
+	// Note that you can register more than one controller
+	// you can alos create child mvc apps using the `movies.NewChild()` if you want.
+	app.Register(new(controllers.MovieController))
+}

_examples/mvc/overview/web/controllers/hello_controller.go

@@ -10,9 +10,7 @@ import (
 
 // HelloController is our sample controller
 // it handles GET: /hello and GET: /hello/{name}
-type HelloController struct {
-	mvc.C
-}
+type HelloController struct{}
 
 var helloView = mvc.View{
 	Name: "hello/index.html",
@@ -32,7 +30,7 @@ func (c *HelloController) Get() mvc.Result {
 	return helloView
 }
 
-// you can define a standard error in order to be re-usable anywhere in your app.
+// you can define a standard error in order to re-use anywhere in your app.
 var errBadName = errors.New("bad name")
 
 // you can just return it as error or even better

_examples/mvc/overview/web/controllers/movie_controller.go

@@ -9,17 +9,10 @@ import (
 	"github.com/kataras/iris/_examples/mvc/overview/services"
 
 	"github.com/kataras/iris"
-	"github.com/kataras/iris/mvc"
 )
 
 // MovieController is our /movies controller.
 type MovieController struct {
-	// mvc.C is just a lightweight lightweight alternative
-	// to the "mvc.Controller" controller type,
-	// use it when you don't need mvc.Controller's fields
-	// (you don't need those fields when you return values from the method functions).
-	mvc.C
-
 	// Our MovieService, it's an interface which
 	// is binded from the main application.
 	Service services.MovieService
@@ -53,9 +46,9 @@ func (c *MovieController) GetBy(id int64) (movie datamodels.Movie, found bool) {
 // PutBy updates a movie.
 // Demo:
 // curl -i -X PUT -F "genre=Thriller" -F "poster=@/Users/kataras/Downloads/out.gif" http://localhost:8080/movies/1
-func (c *MovieController) PutBy(id int64) (datamodels.Movie, error) {
+func (c *MovieController) PutBy(ctx iris.Context, id int64) (datamodels.Movie, error) {
 	// get the request data for poster and genre
-	file, info, err := c.Ctx.FormFile("poster")
+	file, info, err := ctx.FormFile("poster")
 	if err != nil {
 		return datamodels.Movie{}, errors.New("failed due form file 'poster' missing")
 	}
@@ -64,7 +57,7 @@ func (c *MovieController) PutBy(id int64) (datamodels.Movie, error) {
 
 	// imagine that is the url of the uploaded file...
 	poster := info.Filename
-	genre := c.Ctx.FormValue("genre")
+	genre := ctx.FormValue("genre")
 
 	return c.Service.UpdatePosterAndGenreByID(id, poster, genre)
 }