Rails Basics: Files & Directories of The Rails Framework

Rails is a robust, flexible, and beginner-friendly framework for creating web applications. It follows the MVC (Model-View-Controller) design pattern, which helps keep the application organized, modular, and maintainable. Let’s delve into the intricacies of the Rails directory structure, explaining the purpose of each folder and file.

Ruby on Rails: File and Directory Structure at a Glance

Once you generate a new Rails application using the rails new command, you will notice a number of directories and files created by default. The fundamental structure looks like this:

app/
bin/
config/
db/
lib/
log/
public/
test/
tmp/
vendor/
.gitignore
.ruby-version
Gemfile
Gemfile.lock
Rakefile
README.md
config.ru

Let’s unpack each of these directories and files in detail.

The app/ Directory

The app/ directory is where you will spend most of your time when developing a Rails application. It’s the heart of any Rails application, housing the MVC components (models, views, controllers), helpers, mailers, jobs, and assets. Here’s a breakdown of its subdirectories:

• models/: Contains files that define the data structure, validations, and logic of your application. Models interact with the database and encapsulate business logic.
• views/: Stores files that determine what the end-user sees and interacts with. In Rails, views are primarily ERB (Embedded Ruby) files, but you might also see other templating systems like Haml.
• controllers/: Contains files that act as the middleman between models and views. They handle user input, interact with models, and render appropriate views.
• helpers/: Holds modules with methods to be used in views. They help keep views clean by moving complex logic out of them.
• assets/: Contains images, stylesheets (CSS/SCSS), and JavaScript files. This directory further divides into images/, javascripts/, and stylesheets/ folders.
• mailers/: Stores mailer classes, which are used to send emails to users.
• channels/: Used for Action Cable, Rails’ real-time WebSockets feature. It includes files for setting up real-time features, like chat.
• jobs/: Holds files for background jobs, which are tasks to be run outside the regular flow of the program.

The bin/ Directory

The bin/ directory contains scripts that help setup, update, and run the application. Some of the important ones are:

• bundle: Ensures that the correct version of Bundler is running.
• rails: Lets you interact with your application from the command line.
• rake: Allows running rake tasks, which are scripts that automate certain aspects of development.
• yarn: Facilitates JavaScript package management.
• setup: Provides an easy way to get the application ready for development after cloning.

The config/ Directory

The config/ directory contains configuration files for your application, its routes, databases, and more. It is divided into several subdirectories and files:

• environments/: Stores configuration files for different environments (development, test, production).
• initializers/: Contains Ruby files that are run when the application starts.
• locales/: Contains localization files to internationalize your application.
• database.yml: Specifies the adapter and database configurations for different environments.
• routes.rb: Where all the application routes are defined.
• credentials.yml.enc: Contains encrypted application credentials.
• master.key or credentials.yml.key: The key to decrypt credentials.yml.enc.
• puma.rb: Contains Puma server’s configuration, which is the default web server for Rails.
• boot.rb, application.rb, environment.rb, and spring.rb: Are involved in setting up the load paths, initializing the application and setting up specific settings for the Rails environment.

The db/ Directory

The db/ directory contains files related to your database:

• migrate/: Holds migration files, which allow you to alter your database schema over time.
• schema.rb or structure.sql: Represents the current state of your database schema.
• seeds.rb: A file where you can put in sample data to populate your database during setup.

The lib/ Directory

The lib/ directory holds your own libraries/modules, tasks (added to Rake’s default set of tasks), and extensions that are not specific to Rails. This includes code that might be used by various applications or code that patches Ruby or Rails’ functionality.

The log/ Directory

The log/ directory contains log files generated by Rails for different environments. These files are invaluable for debugging.

The public/ Directory

The public/ directory holds static files and compiled assets. It includes 404.html and 500.html error pages, robots.txt, and favicon.

The test/ Directory

The test/ directory is where your tests reside, such as unit tests, fixtures, integration tests, etc. This is auto-generated if you use Rails’ default test suite, MiniTest.

The tmp/ Directory

The tmp/ directory contains temporary files like cache, pid, and session files.

The vendor/ Directory

The vendor/ directory is generally used for third-party code. In a typical Rails application, this might include vendored gems.

The .gitignore File

The .gitignore file specifies intentionally untracked files to ignore when using Git.

The .ruby-version File

The .ruby-version file specifies the version of Ruby that your application uses.

The Gemfile and Gemfile.lock Files

The Gemfile specifies the gem dependencies required by the application, and Gemfile.lock is a snapshot of all the exact gem versions used in the application.

The Rakefile File

The Rakefile file is where you can define tasks that can be run in the command line.

The README.md File

The README.md file is a documentation file where you explain what your application does, how to set it up, and any other information that users or other developers may find useful.

The config.ru File

The config.ru file is a Rack configuration file, used by Rack-based servers to start the application.

In conclusion, understanding the Rails directory structure can significantly improve your productivity and comfort level with Rails. Each file and folder in the structure has a purpose and knowing them can streamline your development process. The Rails framework is built around conventions, so once you become familiar with these directories and files, you will feel right at home in any Rails application.