CSC/ECE 517 Fall 2013/ch1 1w27 ma
MVC architecture structure in Ruby on Rails
What is MVC
MVC is a design pattern and was developed in 1979 by Trygve Reenskaug. MVC dictates that the system be split into three distinct parts, a Model, View and Controller. This approach organizes the code into separate components, thereby achieving separation of concerns and facilitating maintainability.
Model
- The Model generally contains the data for the application and is usually linked to a database back-end. This is the data structure that the application uses.
- It contains the application state and also most of the business logic. The model has no knowledge of the user interfaces.
A central component of Rails is the class ActiveRecord, which maps relational tables to Ruby objects and thereby to the data manipulated by controllers and shown in views
View
- The view refers to the interface that is presented to the end-user. The view does not do any processing, but simply acts as the presentation layer, displaying the application data.
- Rails contains a very nice template language for .erb files that combines pure HTML with embedded Ruby code.
Controller
- The controller receives events from the outside world [ or through some view] and performs some processing
It interacts with the model and redirects to the appropriate view.
MVC Architecture Working
MVC Architecture working can be explained as follows:
- 1. The browser makes a request, such as http://mysite.com/video/show/10
- 2. The web server receives the request. It uses routes to find out which controller to use:the default route pattern is “/controller/action/id” as defined in config/routes.rb. In our case, it’s the “video” controller, method “show”, id “10″. Controllers do the work of parsing user requests, data submissions, cookies, sessions. In this case, the show method in the video controller knows it needs to lookup a video. It asks the model to get video 10, and will eventually display it to the user.
- 3. Model(ActiveRecord) maintains the relationship between Object and Database and handles validation, association, transactions, and more. They talk to the database, store and validate data, perform the business logic. This subsystem is implemented in ActiveRecord library which provides an interface and binding between the tables in a relational database and the Ruby program code that manipulates database records.
- 4. In this case, the model retrieves video 10 from the database.
- 5. Model sends the retrieved data ie video 10 in this case to the controller.
- 6. Views(ActionView) are what the user sees: HTML, CSS, XML, Javascript, JSON. Views are merely puppets reading what the controller gives them. This subsystem is implemented in ActionView library which is an Embedded Ruby (ERb) based system for defining presentation templates for data presentation. In our example, the controller gives video 10 to the “show” view.
- 7. The show view generates the HTML: divs, tables, text, descriptions, footers, etc and returns it to the controller.
- 8. The controller returns the response body(HTML, XML, etc.) & metadata (caching headers, redirects) to the server. Controller is the facility within the application that directs traffic, on the one hand querying the models for specific data, and on the other hand organizing that data (searching, sorting, massaging it) into a form that fits the needs of a given view. This subsystem is implemented in ActionController which is a data broker sitting between ActiveRecord (the database interface) and ActionView (the presentation engine). The server combines the raw data into a proper HTTP response and sends it to the user's browser.
MVC Rails
Directory Structure
app/
This folder organizes the different application components. These include view (views and helpers), controller (controllers), and the backend business logic (models). There are the following sub-directories
- app/controllers: This is the sub-directory where Rails looks for the controller classes.
- app/helpers: The helpers are used to assist the model, view, and controller classes. Helpers make it possible to keep rest of the MVC code uncluttered.
- app/models: The directory for the models
- app/view: The views subdirectory holds the display templates to fill in with data from our application, convert to HTML, and return to the user's browser.
- app/view/layouts: Layouts directory contains the template files for layouts to be used with views. Examples of layouts are the common header/footer for the views.
- app/mailers: This directory contains all the mailer files used to send emails
- app/helpers: These are the helper classes used to assist the MVC classes. The idea is to keep as much Ruby code out of the views, so helpers are mainly for use in that context. Helpers are the only methods you can access, other than instance methods for an instance you have access to.
- Asset [/assets]
config/
This directory contains the small amount of configuration code that your application will need, including your database configuration (in database.yml), your Rails environment structure (environment.rb), and routing of incoming web requests (routes.rb). You can also tailor the behavior of the three Rails environments for test, development, and deployment with files found in the environments directory.
- config/environments:
- config/initializers:
- routes.rb:
db/
Usually, your Rails application will have model objects that access relational database tables. You can manage the relational database with scripts you create and place in this directory.
- db/migrate:
test/
Other Directories
- public:
- tmp:
- vendor:
- script:
- lib:
- doc:
Gemfile
Gem requirements for this app
Rakefile
This file is similar to Unix Makefile which helps with building, packaging and testing the Rails code. This will be used by rake utility supplied along with Ruby installation.
README
This file contains a basic detail about Rail Application and description of the directory structure explained above
Naming conventions
References
Ruby on Rails for web application Rails Directory structure Ruby on Rails Tutorial What-are-the-benefits-of-MVC/