Ruby on Rails - Directory Structure

Quiz

When you use the Rails helper script to create your application, it creates the entire directory structure for the application. Rails knows where to find things it needs within this structure, so you don't have to provide any input.

Shown below is a top-level view of a directory tree created by the helper script at the time of application creation. Except for minor changes between releases, every Rails project will have the same structure, with the same naming conventions. This consistency gives you a tremendous advantage; you can quickly move between Rails projects without relearning the project's organization.

To understand this directory structure, let's use the application created in the Installation chapter. It can be created using a simple helper command −

rails new myapp

Directory Structure

Now, go into the myapp application root directory. You will find a directory structure in Windows as follows −

Folders and Files

Each subfolder and the file in the application directory is created for a specific purpose. Now let's explain the purpose of each directory.

Folder	Purpose
app/	It organizes your application components. It's got subdirectories that hold the view (views and helpers), controller (controllers), and the backend business logic (models).
bin/	Contains the rails script that starts your app and can contain other scripts you use to set up, update, deploy, or run your application.
config/	It organizes your application components. It's got subdirectories that hold the view (views and helpers), controller (controllers), and the backend business logic (models).
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.
lib/	You'll put libraries here, unless they explicitly belong elsewhere (such as vendor libraries).
log/	Error logs go here. Rails creates scripts that help you manage various error logs. You'll find separate logs for the server (server.log) and each Rails environment (development.log, test.log, and production.log).
public/	Like the public directory for a web server, this directory has web files that don't change, such as JavaScript files (public/javascripts), graphics (public/images), stylesheets (public/stylesheets), and HTML files (public).
script/	This directory holds scripts to launch and manage the various tools that you'll use with Rails. For example, there are scripts to generate code (generate) and launch the web server (server).
storage/	Contains SQLite databases and Active Storage files for Disk Service. This is covered in Active Storage Overview.
test/	The tests you write and those that Rails creates for you, all goes here. You'll see a subdirectory for mocks (mocks), unit tests (unit), fixtures (fixtures), and functional tests (functional).
tmp/	Rails uses this directory to hold temporary files (like cache and pid files) for intermediate processing.
vendor/	Libraries provided by third-party vendors (such as security libraries or database utilities beyond the basic Rails distribution) go here, this includes vendored gems.
.git/	Contains Git repository files.
.github/	Contains GitHub specific files.
.kamal/	Contains Kamal secrets and deployment hooks.

Apart from these directories, there will be the following files available in the application directory −

File	Purpose
config.ru	Rack configuration for Rack-based servers used to start the application.
Dockerfile	Configuration file for Docker.
Gemfile
Gemfile.lock	These files allow you to specify what gem dependencies are needed for your Rails application. These files are used by the Bundler gem.
Rakefile	This file locates and loads tasks that can be run from the command line. The task definitions are defined throughout the components of Rails. Rather than changing Rakefile, you should add your own tasks by adding files to the lib/tasks directory of your application.
README.md	This is a brief instruction manual for your application. You should edit this file to tell others what your application does, how to set it up, and so on.
.dockerignore	This file tells Docker which files it should not copy into the container.
.gitattributes	This file defines metadata for specific paths in a Git repository. This metadata can be used by Git and other tools to enhance their behavior.
.gitignore	This file tells Git which files (or patterns) it should ignore.
.rubocop.yml	This file contains the configuration for RuboCop.
.ruby-version	This file contains the default Ruby version.

The app subdirectory includes the following folders −

Folder	Purpose
app/controllers	The controllers subdirectory is where Rails looks to find the controller classes. A controller handles a web request from the user.
app/helpers	The helpers subdirectory holds any helper classes used to assist the model, view, and controller classes. This helps to keep the model, view, and controller code small, focused, and uncluttered.
app/models	The models subdirectory holds the classes that model and wrap the data stored in our application's database. In most frameworks, this part of the application can grow pretty messy, tedious, verbose, and error-prone. Rails makes it dead simple!
app/views	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/views/layouts	Holds the template files for layouts to be used with views. This models the common header/footer method of wrapping views. In your views, define a layout using the <tt>layout:default</tt> and create a file named default.html.erb. Inside default.html.erb, call <% yield %> to render the view using this layout.

Print Page