Back Matter

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Appendix A: Databases 101

Let’s begin with some simple definitions. A database is a piece of software that governs the storage, retrieval, deletion, and integrity of data. Databases are organized into tables. Tables have columns (or, if you prefer, fields), and data are stored in rows. If you’re familiar with spreadsheets, then the idea is fairly similar. Of course, databases blow spreadsheets out of the water in terms of power and performance.

Some databases are relational—meaning they model their data in a way that makes use of relationships between tables. In this book, we use SQLite and Postgres, both of which are relational databases, and you may have seen already how we use these relationships to associate users with articles, for example. Other databases may model their data with other, non-relational approaches, such as simple key-value pairs.

Structured Query Language (SQL) is the standard way of communicating with relational databases. Using SQL, you can view column information, fetch a particular row or a set of rows, and search for rows containing certain criteria. You also use SQL to create, drop, and modify tables, as well as insert, update, and destroy the information stored in those tables. SQL is a fairly large topic, so a complete treatment is beyond the scope of this book. That said, you need to know the basics, so consider this a crash course.

Note

The output in this appendix assumes you’ve followed the code in the book up to Chapter 5. If you read this appendix at a different point and implement the code, you may get different output.

Examining a Database Table

The examples in this chapter will use SQLite, as they do throughout this book. If you’re following along using a different piece of database software or depending on the state of your database according to your progress throughout this book, some commands may not work, or the responses you see may be slightly different. While SQLite commands differ from those offered by other databases, the same general concepts apply.

To start the SQLite utility tool , run the rails dbconsole command from the book’s project folder on your computer:

$ rails dbconsole

SQLite version 3.28.0 2019-04-15 14:49:49

Enter ".help" for usage hints.

sqlite>

As you can see, you can enter the .help command at the SQLite prompt to see a helpful list of commands. Knowing how to exit any command-line interface is helpful too; simply type .exit and press Enter. If that doesn’t work, perhaps your prompt is in a strange state from an unbalanced quote or something; Ctrl+D will generally allow you to exit your prompt as well.

To list the tables present in your database, you can use the SQLite .tables command:

sqlite> .tables

articles schema_migrations

As you can see, the database has two tables: articles and schema_migrations. You don’t get a lot of information about the tables from the .tables command, but that can be achieved by using the SQLite .schema command:

sqlite> .schema articles

CREATE TABLE IF NOT EXISTS "articles" ("id" integer NOT NULL PRIMARY KEY, "title" varchar DEFAULT NULL, "body" text, "published_at" datetime DEFAULT NULL, "created_at" datetime(6) NOT NULL, "updated_at" datetime(6) NOT NULL, "excerpt" varchar DEFAULT NULL, "location" varchar DEFAULT NULL);

The result of this command is an SQL statement that describes all the fields in the articles table. Each field has a type, which defines the kind of data it can store. The id field has a type of integer, title has a type of varchar, and body is a text field. Although it may sound strange, a type of varchar means the field has a variable number of characters up to a defined maximum.

The id column is the one to pay attention to here. It’s the primary key—a unique identifier for a particular row. Because this key is essential, it absolutely needs to be not null, and it must be unique; instead of managing these requirements in our application code, we let the database manage its value by automatically incrementing its number each time a new row is created. Many databases also choose to index records by their primary key, which makes retrieving the record much quicker. Notice how this is specified in the articles table column description: NOT NULL PRIMARY KEY. These are special commands that tell SQLite how to handle this particular field.

Let’s look at some data from the articles table:

sqlite> SELECT * FROM articles;

1|Advanced Active Record|2020-04-19 00:00:00|2020-04-19...

2|One-to-many associations|2020-04-19 00:00:00|2020-04-19...

3|Associations|2020-04-19 00:00:00|2020-04-19 23:10:10.283152...

Here, instead of using an SQLite command (which starts with a “ . ”), we’re using the SQL SELECT statement to view this table’s data. SQL statements are largely compatible between different database engines. As you can see in this example, this table has three records. You probably have different records in your database; the main point here is understanding the commands to see the data, not the data itself.

Working with Tables

The most common use of databases (not only in the context of Rails) is to implement CRUD functionality: create, read, update, and delete. Corresponding to the CRUD components are the most commonly used SQL commands : INSERT, SELECT, UPDATE, and DELETE, as shown in Table A-1.

Table A-1

Common SQL Commands

Operation	SQL Command
Create	INSERT
Read	SELECT
Update	UPDATE
Delete	DELETE

The following sections use the articles table presented in the previous section to show some examples of how these commands work. Remember that it’s not necessary to have a complete understanding of SQL to work with Rails. The whole point of Active Record is to alleviate the tedium of needing to construct complex SQL statements to view and otherwise manipulate your data.

Selecting Data

The SELECT statement is a powerful and useful SQL command. Using SELECT, you can query (or request information from) the database and mine it for information. You can give SELECT any number of fields, a set of conditions to be applied to the data to be returned, a limit on the number of rows it returns, and instructions on how to order its results.

Earlier, you used the SELECT statement to see the data in the articles table:

SELECT * FROM articles;

The asterisk (*) character is a wildcard that means every column. This statement says, “Show me the values in every column for every row in the articles table.” This is the easiest way to look at the contents of a table. But you don’t often need to see every single row; and for tables with a lot of data, you could end up with a really large list. So, sometimes it isn’t very efficient to select everything. Fortunately, you can also select specific columns by name. For example, to select only the title column, do this:

sqlite> SELECT title FROM articles;

Advanced Active Record

One-to-many associations

Associations

Instead of returning all fields, this command returns only the one requested: title. To return both the title and the published_at fields, add published_at to the list of columns to select:

sqlite> SELECT title, published_at FROM articles;

Advanced Active Record|2020-04-19 00:00:00

One-to-many associations|2020-04-19 00:00:00

Associations|2020-04-19 00:00:00

In both cases, the command returns all rows. If there were 100 rows in the table, they would all be returned. But what if you need to find a particular row? This is where conditions come into play. To supply conditions to a SELECT statement , you use the WHERE clause:

SELECT fields FROM table WHERE some_field = some_value;

Let’s apply this to the articles table by finding a row by its primary key:

sqlite> SELECT * FROM articles WHERE id = 1;

1|Advanced Active Record|2020-04-19 00:00:00|2020-04-19 23:10:10.223714...

This query returns only the row whose primary key, id, matches the condition. You can use this technique on any field—id, title, or published_at—or all of them combined. Conditions can be chained together using AND and further modified using OR. For example, the following query returns only records whose titles match the word “associations” and whose published_at date is after a certain value:

SELECT * FROM articles WHERE title LIKE "%active%" AND published_at > "2020-04-01"

Inserting Data

To insert a row into a table, you use the INSERT command . INSERT requires a table name, a list of fields, and a list of values to insert into those fields. Here’s a basic INSERT statement for the articles table:

sqlite> INSERT INTO articles(title, created_at, updated_at) VALUES('Intro to SQL', datetime("now"), datetime("now"));

This INSERT command creates a new record in the articles table with the title “Intro to SQL” and the created_at and updated_at columns set to the current timestamp, since we used the SQLite function datetime("now") for those values.

SQLite doesn’t give any indication that any happened, which means your command was accepted and didn’t generate any errors. To see what was inserted, you again use the SELECT command :

sqlite> SELECT * FROM articles;

1|Advanced Active Record|2020-04-19 00:00:00|2020-04-19 23:10:10.223714...

2|One-to-many associations|2020-04-19 00:00:00|2020-04-19 23:10:10.270343...

3|Associations|2020-04-19 00:00:00|2020-04-19 23:10:10.283152|2020-04-19...

4|Intro to SQL||2020-04-26 20:57:35|2020-04-26 20:57:35|||

We now have four rows in our table. Notice that in the INSERT statement, we didn’t specify the id field. That’s because, as you recall, it’s handled automatically by the database. If we were to specify a value for the id, we wouldn’t have a reliable way to guarantee its uniqueness and could cause an error if we attempted to insert a duplicate value. The database automatically inserts an id value into the field that’s greater than the largest existing id.

Updating Data

If you want to change the values in a row, you use the UPDATE statement . UPDATE is similar to INSERT, except that like SELECT, it can be modified (or constrained) by conditions. If you want to change the title for the “Intro to SQL” article, you can do so like this:

sqlite> UPDATE articles SET title = 'Introduction to SQL' WHERE id = 4;

Again, SQLite is silent, which means the command has been accepted. The fact that you use the primary key to find and update the row is significant. Although you can match any value in any column, the only surefire way to ensure you’re updating the row you want is to use the primary key. You can confirm that the value was updated with another query:

sqlite> SELECT title FROM articles WHERE id = 4;

Introduction to SQL

Sure enough, the title field has been updated.

Deleting Data

Of course, not all information in a database will stay there forever. Sometimes you need to delete records, such as when a product goes out of stock or a user cancels their account. That’s the purpose of the DELETE statement . It works a lot like the UPDATE statement, in that it accepts conditions and deletes the rows for any records that match the conditions. If you want to delete the article with the id of 4, the DELETE statement is as follows:

sqlite> DELETE FROM articles WHERE id = 4;

SQLite receives the command and deletes the record identified by the id you specified. And, of course, if you subsequently search for the record, you find that it no longer exists:

sqlite> SELECT * FROM articles WHERE id = 4;

sqlite>

Caution

When you use either the UPDATE or DELETE command, you’re making changes to existing data; so be careful to use a WHERE clause to limit the records you’re updating or deleting. A good practice is to always run a SELECT command first to make sure your query returns the records you’re expecting; then, later run the UPDATE or DELETE command with the same conditions.

Understanding Relationships

It’s good practice to avoid duplication in your database by creating distinct tables to store certain kinds of information. Then, you can relate records from these two tables to each other using an association. This makes more sense when you see it in action, so let’s use the articles table for our example again.

First, let’s add a new column to the articles table named author. First, we’ll use it to store the author name, so we’ll make it a varchar data type:

sqlite> ALTER TABLE articles ADD COLUMN author varchar;

sqlite> SELECT id, title, author FROM articles;

1|Advanced Active Record|

2|One-to-many associations|

3|Associations|

We don’t have any data for our authors, so let’s change that:

sqlite> UPDATE articles SET author = "Brady Summerville";

sqlite> SELECT id, title, author FROM articles;

1|Advanced Active Record|Brady Summerville

2|One-to-many associations|Brady Summerville

3|Associations|Brady Summerville

There’s quite a bit of duplication in the author field. This can potentially create problems. Although you could search for all articles by a particular author using a standard SELECT query , what would happen if someone’s name were misspelled? Any articles by the misspelled author wouldn’t show up in the query. And if there were such a typo, you’d need to update a lot of records in order to fix it. Moreover, searching on a text field like "author" is rather slow when compared with searching using an integer type.

We can improve this design significantly by putting authors in their own table and referencing each author’s unique id (primary key) in the articles table instead of the name. Let’s do that now. Let’s create a new table called authors and add the author_id field to the articles table so it can store an integer instead of text.:

sqlite> CREATE TABLE "authors" ("id" integer NOT NULL PRIMARY KEY, "name" varchar);

sqlite> ALTER TABLE articles ADD COLUMN author_id integer;

At this point, our articles table has both an author field (for the author’s name) and an author_id field (to point to a record in the authors table), and we have an empty authors table. First, let’s populate the authors table from the data in the articles table:

sqlite> INSERT INTO authors SELECT NULL, author FROM articles GROUP BY author;

This command is a little more complex; instead of specifying values for the INSERT statement to use, we supplied a SELECT statement to dynamically get those values. The authors table expects an id and a name, so we SELECT NULL (a keyword for nothing) for the id, so that the primary key will be generated automatically, and we select the author field from articles. To make sure we don’t create duplicate records in the authors table, we used “GROUP BY author” in our SELECT statement to ensure each author’s name is only used once. Now, we can verify our authors table has the data we expect:

sqlite> select * from authors;

1|Brady Summerville

Next, we would want to get rid of the author field from the articles table, but we shouldn’t do that yet since we haven’t yet populated our author_id column to store the associations. So let’s do that next:

sqlite> UPDATE articles SET author_id = (SELECT id FROM authors WHERE name = author);

sqlite> SELECT id, title, author, author_id FROM articles;

1|Advanced Active Record|Brady Summerville|1

2|One-to-many associations|Brady Summerville|1

3|Associations|Brady Summerville|1

First, we set the author_id column for each record in the articles table using the UPDATE command combined with a subquery. Instead of needing to hardcode which id to use for the author_id column, we selected the id from the authors table where its name value matched the article’s author value.

Then, to verify our work, we selected the fields we’re interested in and saw that our articles table now has the correct author_id values for each articles record.

Now that our articles table has the author_id field, it no longer needs to store the name of the author, since the authors table now stores that. So let’s remove the author column from the articles table:

sqlite> CREATE TABLE "articles_temp" ("id" integer NOT NULL PRIMARY KEY, "title" varchar DEFAULT NULL, "published_at" datetime DEFAULT NULL, "created_at" datetime(6) NOT NULL, "updated_at" datetime(6) NOT NULL, "excerpt" varchar DEFAULT NULL, "location" varchar DEFAULT NULL, author_id integer);

sqlite> INSERT INTO articles_temp (id, title, published_at, created_at, updated_at, excerpt, location, author_id) SELECT id, title, published_at, created_at, updated_at, excerpt, location, author_id FROM articles;

sqlite> ALTER TABLE articles RENAME TO articles_old;

sqlite> ALTER TABLE articles_temp RENAME TO articles;

That was a lot, so let’s explain; many database engines support a simple command to drop a column, but SQLite does not—so our only option is to create a new table without the column we want.

So first, we created a new table called “articles_temp” with all the columns except for the author column we wanted to remove. Then, we used an INSERT …. SELECT statement to copy the data from articles to articles_temp. Next, we renamed articles to articles_old. (We could have used DROP TABLE articles, but maybe it’s a good idea to keep the original articles table until we make sure things went according to plan.) And finally, we renamed articles_temp to articles:

sqlite> SELECT * FROM articles;

1|Advanced Active Record|2020-04-19 00:00:00|2020-04-19 23:10:10.223714|2020-04-19 23:10:10.233432|||1

2|One-to-many associations|2020-04-19 00:00:00|2020-04-19 23:10:10.270343|2020-04-19 23:10:10.273669|||1

3|Associations|2020-04-19 00:00:00|2020-04-19 23:10:10.283152|2020-04-19 23:10:10.286340|||1

We can see now that our new articles table still has the data we expected—and our unwanted author field has been replaced with author_id. But how can we use the author_id to get the author’s name for each article?

The author_id column is considered to be a foreign key, because it references the primary key of the table it relates to: in this case, the author who wrote the article. If you now look at the data from both tables, you’ll see that we’ve eliminated the duplication:

sqlite> SELECT id, author_id, title FROM articles;

1|1|Advanced Active Record

2|1|One-to-many associations

3|1|Associations

sqlite> SELECT * FROM authors;

1|Brady Summerville

We can now use this relationship in our SELECT queries by joining the two tables together using their association. In this association, the author_id in the articles table is equal to the id column in the authors table. Adding the JOIN directive requires only a slight change to the SQL:

sqlite> SELECT articles.id, title, name FROM articles

JOIN authors ON articles.author_id = authors.id;

1|Advanced Active Record|Brady Summerville

2|One-to-many associations|Brady Summerville

3|Associations|Brady Summerville

By using JOIN, we’re able to combine the two tables and get the author names returned with the articles’ information. This is the crux of relational databases. Updating an author’s name is now easy because there is only one instance of a given author.

It turns out that our author name does have a typo; before we moved the author names to the authors table, we would’ve had to update every instance of the misspelled name in the articles table. But now, we can simply update the appropriate author record to correct the mistake:

sqlite> UPDATE authors SET name = 'Brady Somerville' WHERE id = 1;

This changes the name of the author with the id of 1 to "Brady Somerville." When we run the JOIN query again, we’ll see that all instances of the author’s name have been updated:

sqlite> SELECT articles.id, title, name FROM articles

JOIN authors ON articles.author_id = authors.id;

1|Advanced Active Record|Brady Somerville

2|One-to-many associations|Brady Somerville

3|Associations|Brady Somerville

SQL and Active Record

This brings this database crash course to a close. This was by no means a complete reference, nor was it intended to be. Its purpose was to illustrate the basics of how databases work and to introduce you to their native language: SQL. Now that you have a taste, you can safely enter the world of Active Record , where most of this tedious work is handled for us.

Why did we bother showing you this if Active Record takes care of most of it for you? Because it’s important to know what Active Record is doing behind the scenes. Although you can effectively use Active Record like a black box, you’ll eventually need to debug your programs and figure out why something isn’t working the way you expect. Having a basic understanding of SQL helps. Moreover, every bit of SQL that Active Record generates is logged by Rails. You can find the logs in the log/ directory of your application. Now, when you see these SQL commands in the logs, you’ll have a good idea what they mean.

Appendix B: The Rails Community

Rails development is driven by a vibrant and passionate community of open source developers. The Rails community encourages its members to participate actively in Rails development. You can start by asking questions and discussing new features. As your knowledge increases, you can help others by writing about your own experiences in a personal blog, answering questions on the mailing list, contributing to the Wiki, and fixing bugs and writing patches to make Rails even better. Whatever your intention, rest assured that participating in the community will help you get the most out of Rails.

Beginning Rails 6 Mailing List

As a companion to this book, we’re establishing a mailing list for those interested in exchanging ideas or asking questions to the authors or other Rails developers. You can discuss changes in the Rails framework; or, if you find a bug in the framework, you can discuss proposed solutions. You can subscribe to this list at https://groups.google.com/group/beginning-rails .

Rails Discussion Forums

You can browse and join several Rails-related discussion forums :

Ruby on Rails Discussions: A forum with categories for general discussion about using Rails, as well as discussion about technical aspects of Rails core. For more information, visit https://discuss.rubyonrails.org/ and become an active member of the community.
Ruby on Rails Security: A Google Group for those who want to keep abreast of Rails security concerns. You can subscribe to this group at https://groups.google.com/group/rubyonrails-security .
Ruby on Rails @ StackOverflow : View questions and answers tagged with ruby-on-rails on one of the most widely used forums by developers from around the world at https://stackoverflow.com/questions/tagged/ruby-on-rails .
Ruby Weekly: Sign up at https://rubyweekly.com/ and receive a weekly email with Ruby-related news, articles, job postings, and more.
reddit for rubyists: Visit www.reddit.com/r/ruby/ for an infinitely scrollable feed of all things pertaining to Ruby development.
Medium: While https://medium.com/ hosts articles on a wide range of topics, many useful guides and interesting articles about Ruby and Rails development are hosted there.

Rails Chat

If you prefer real-time discussions about Rails, you may want to check out

Ruby on Rails Link: A Slack channel which joins Rails developers from around the world, with dozens of channels for topic-specific conversations. For more information, visit www.rubyonrails.link .
#rubyonrails Internet Relay Chat (IRC) channel : Hosted on the Freenode IRC network, the #rubyonrails channel hosts discussion centered around the Rails framework.

Whether in forums, chat, StackOverflow posts, or wherever, remember to be kind when asking for help, or when helping others.

If asking for help, be sure to provide as much information as you can, and be patient while waiting for a response. Remember that help usually comes from volunteers who aren’t getting paid to help you, so show them the same courtesy you’d expect.

And if giving help, it’s equally important to be kind! We were all once beginners and sometimes didn’t even know how to ask the right question! Don’t discourage beginners by being harsh; gently correct them and encourage them.

Note

Internet Relay Chat (IRC) is a type of real-time Internet chat, where users talk about their interests in topic-specific areas called channels. All you need to connect to IRC is IRC client software. The most commonly used IRC clients are the shareware mIRC (www.mirc.com/ ) for Windows and the open source Colloquy (https://colloquy.app/ ) for Mac.

Rails Blogs and Podcasts

The number of blogs dedicated to Rails information is rapidly growing, and most of the new Rails features are covered in blogs or podcasts even before they’re released to the public. You can subscribe to the blogs of your choice to keep up with news in the Rails world.

The following are some of the more rewarding Rails-related blogs you can visit, including the official Rails podcast :

https://weblog.rubyonrails.org : The official Rails blog. You’ll find information about upcoming releases, new functionality in Rails, and news that’s considered important (such as documentation updates and Rails adoption worldwide).
www.rubyflow.com : A Ruby community site where people post interesting and new things about Ruby or Rails.
https://5by5.tv/rubyonrails : A weekly podcast covering topics related to Ruby on Rails, open source programming, and development in general.

Rails Guides

The Rails community has an excellent set of documentation called Rails guides , which you can find at https://guides.rubyonrails.org . We’ve referred to it several times throughout this book. It’s a great effort to document various parts of the frameworks, from basic beginner-oriented documentation to more advanced material.

Rails APIs

It’s close to impossible to remember the names, methods, and possible parameters of all the functions and classes in Ruby and Rails. To help you with your coding tasks, we recommend that you keep the Ruby and Rails application programming interface (API) documentation open or at least that you put them in your favorites. The API documentation contains all the information about specific functions you’re trying to use, including the function source code.

You can find the Rails API documentation at https://api.rubyonrails.org . The Ruby API is at https://ruby-doc.org/core . For more user-friendly and searchable API documentation, go to https://apidock.com/rails .

Rails Source and Issue Tracking

The Rails source code can be found at https://github.com/rails/rails . It’s powered by the GitHub, a hosting service for projects using the Git revision control system. GitHub allows you to download the Rails source code using a web interface. You can subscribe to the Git change log using RSS to be notified about changes to the Rails source code.

You can also participate in the development of Rails by submitting bug reports and patches to the GitHub account at www.github.com/rails/rails or by looking at existing issues and trying to fix them. It might seem overwhelming, but don’t let that deter you; the more time you spend reading code you don’t understand, the more you begin to understand it. Soon, you could be a contributing member of the Rails project and not just a user of it!

Appendix C: Git

Developers normally work in teams. You write plenty of code; sometimes you test some and decide to delete it, and other times you decide to stick to it. Managing this can be a painful process, which is why you can use Source Control Management (SCM) software to help you focus on what you do best—writing beautiful code. Git is rapidly becoming the preferred SCM of developers everywhere.

What Is Source Control Management?

SCM software helps you keep track of code changes and gives you the ability to easily collaborate on that code with your teammates. The two main features of many SCMs are

Versioning: When you’re using SCM for your project, files and directories in the project are tracked. Every time you make changes to your files, you can save those changes as a new version. Your project then has several versions—one for every change set—giving you the ability to browse those changes and revert to any one at any time.
File merging: Let’s say you worked on a file and your colleague, John, worked on that same file and you both committed (submitted) your files to the SCM system. Both files are merged by SCM of your involvement; if SCM can’t handle the merge for any reason, it lets you know and gives you some useful information about how to manually merge conflicting changes yourself.

How Does It Work?

Generally, when you add your code base to an SCM system, a repository is created, which is the store of all the versions of your code base. Then, you can take a copy of that repository and work on it; this is normally called your working copy. You can add files, change or delete some, and then commit those changes and send them back to the repository as a new revision. If your colleague John is working with you on the same code base, he can check out or pull those changes from the repository to update his working copy, letting the SCM take care of any necessary file merging (Figure C-1).

../images/314622_4_En_BookBackmatter_Fig1_HTML.jpg — Figure C-1
SCM workflow

Git

The Git SCM was developed by Linus Torvalds for managing the Linux kernel source code . It’s also been used for several million open source projects, including Rails.

Git is different from other SCMs because it’s a distributed source control system. This means that instead of having a single repository on your server that all your teammates use to check out working copies (client-server or centralized SCM), each team member has their own repository along with a working copy, and you all push a copy of that repository to a remote repository.

This approach has some great benefits, such as the ability to work and commit your code, even if you’re offline, and being able to operate on your repository more quickly.

Now that you have a good understanding of what an SCM is and how it works, let’s install Git and try it.

Installing Git

Installing Git is relatively easy. Thanks to open source contributions, several Git installation packages are available to facilitate a quick installation for most platforms.

Installing on Windows

If you’re on Windows , one option for installing Git is from the official source: https://git-scm.com/download/win . Simply download the installer, accept the default options, and you’ll end up with Git Bash for command-line usage, as well as Git GUI for a graphical interface. Use the Git Bash tool for executing commands mentioned in this appendix.

Installing on macOS

To install Git on macOS, there are a few easy options .

If you’ve already installed the Xcode Command-Line Tools, you may already have it. Try running git --version from your terminal. It should either report the version of Git that’s already installed or offer to install it for you.

It’s also possible to install Git using the Homebrew package manager, via brew install git. If you don’t yet have Homebrew installed, visit https://brew.sh/ for installation instructions, or consult Chapter 2.

Installing on Linux

Most Linux distributions ship with a package manager. The most common one is the Debian package manager apt, and Git is part of its library.

To install Git using apt, run the following apt-get command from the terminal:

sudo apt-get install git

Accept if the package manager asks your permission to use additional disk space for this installation. When the installation is complete, Git is ready to use.

Setting Global Parameters

Every commit you make in your repository has flags for the user who executed the commit; those flags are the user’s name and email address. Now that you have Git installed on your system, it’s important to set a global username and email address for Git to use for any new repository you work on.

To set global parameters , you use the git config command with the --global option, followed by the parameters you want to set. Listing C-1 shows the command to set up both the user.name and user.email parameters.

git config --global user.name "dude"

git config --global user.email [email protected]

Listing C-1

Setting the Global Git Username and Email

These parameters can be set on a repository level as well; you can do that by using the same commands but without the --global option in your repository’s working directory.

Initializing a Repository

Often, we need to initialize a new repository for our application. Let’s begin by creating a test application, making sure to be outside of any directories which are already under version control:

$ rails new testapp

create

create README.md

create Rakefile

create .ruby-version

create config.ru

create .gitignore

create Gemfile

run git init from "."

Initialized empty Git repository in /Users/brady/Sites/testapp/.git/

create package.json

...

Notice that rails new took care of initializing a new Git repository for us! If it hadn’t or if we wanted to initialize a new Git repository for a project which didn’t already have one, we could have done the following:

$ cd testapp

$ git init

Initialized empty Git repository in /Users/brady/Sites/testapp/.git/

The git init command initializes an empty local repository for the application, but it doesn’t add any files to the repository. To determine which files we can add to the repository, we can use the git status command :

$ git status

On branch master

No commits yet

Untracked files:

(use "git add <file>..." to include in what will be committed)

.browserslistrc

.gitignore

.ruby-version

Gemfile

Gemfile.lock

README.md

Rakefile

app/

babel.config.js

bin/

config.ru

config/

db/

lib/

log/

package.json

postcss.config.js

public/

storage/

test/

tmp/

vendor/

yarn.lock

nothing added to commit but untracked files present (use "git add" to track)

As you can see, all the folders and files of the Rails application are in the untracked files list, which means that they’re not under Git’s control. To start tracking those files, we need to add them to the track list; as this indicates, we can do this by using the git add command. (While sometimes git may seem a bit perplexing to use, you’ll find it often includes helpful hints in its output—so read closely!)

Ignoring Files

Before we add those files , let’s think a little: Do we want all of our files to be tracked? Are there any files we don’t want to track? Normally, those would be configuration files that contain passwords, such as database.yml, the tmp folder, log files, and SQLite databases. If we add those files, our teammates will have this information, and it may even conflict with their files. A worst-case scenario involves our Git repository becoming public and sensitive secrets falling into the hands of malicious users.

To skip those files in any git add and git status commands and to tell Git to never bother you about them again, we must configure Git to ignore them. We can do that by declaring those files in a hidden configuration file called .gitignore, which is normally stored at the root of your working copy (in this case, at the root of the testapp directory). The .gitignore file is a regular text file; it is generated by Rails in all new projects. View it using the text editor of your choice, and you’ll see that it looks like the code in Listing C-2.

# Ignore bundler config.

/.bundle

# Ignore the default SQLite database.

/db/*.sqlite3

/db/*.sqlite3-journal

/db/*.sqlite3-*

# Ignore all logfiles and tempfiles.

/log/*

/tmp/*

!/log/.keep

!/tmp/.keep

# Ignore uploaded files in development.

/storage/*

!/storage/.keep

/public/assets

.byebug_history

# Ignore master key for decrypting credentials and more.

/config/master.key

/public/packs

/public/packs-test

/node_modules

/yarn-error.log

yarn-debug.log*

.yarn-integrity

Listing C-2

The .gitignore File Content in testapp/.gitignore : https://gist.github.com/nicedawg/085165a26189b3913ee1fdca860ae1e9

As you can see, the files and folders listed in the .gitignore file weren’t listed in the git status command you issued earlier. To help make sure we don’t commit any unwanted or sensitive information to our Git repository, Rails initializes new projects with a preconfigured .gitignore, especially made for Rails projects .

There may be times when we need to modify which files should or shouldn’t be tracked by Git; simply add a pattern to exclude the file(s) you wish to exclude, and that’s it!

Adding and Committing

We can add all of the untracked files to our repository by using the git add command and passing a dot to it, which refers to the current directory and all its content. Be cautious when using "git add ." to make sure you aren’t adding files that don’t belong in the repository:

$ git add .

Try the git status command again:

$ git status

On branch master

No commits yet

Changes to be committed:

(use "git rm --cached <file>..." to unstage)

new file: .browserslistrc

new file: .gitignore

new file: .ruby-version

new file: Gemfile

new file: Gemfile.lock

new file: README.md

new file: Rakefile

...

The git status command still shows all the files, because the git add command just added those files to be committed, but they aren’t committed yet. Notice how instead of being shown in the “untracked files” list, they’re now included in the “changes to be committed.” Another way of phrasing this using Git terminology is that these changes have been “staged.” (Notice the helpful command to unstage a file. Running this command won’t delete the file from your filesystem; it will simply remove the file from the list of changes to be committed.)

In order to commit the changes you added to the commit list, we use the git commit command. Use the –m argument to include a message describing the purpose of and the changes in this commit:

$ git commit -m "Empty Rails application"

master (root-commit) 15c012e] Empty Rails application

91 files changed, 9213 insertions(+)

create mode 100644 .browserslistrc

create mode 100644 .gitignore

create mode 100644 .ruby-version

create mode 100644 Gemfile

create mode 100644 Gemfile.lock

create mode 100644 README.md

create mode 100644 Rakefile

....

Congratulations! You’ve completed your first commit to your local repository! If we check the git status command now, we’ll see that there are no changes to be added or committed:

$ git status

On branch master

nothing to commit, working tree clean

Now, let’s change a file. For example, let’s edit app/views/layouts/application.html.erb to include <p>Hey!</p> in the body of the page. Save the file, and now let’s check our status again:

$ git status

On branch master

Changes not staged for commit:

(use "git add <file>..." to update what will be committed)

(use "git restore <file>..." to discard changes in working directory)

modified: app/views/layouts/application.html.erb

no changes added to commit (use "git add" and/or "git commit -a")

Git knows that we changed the file since the last time we committed changes, so shows the file as modified, but not yet staged for commit.

Instead of using “git add .”, like we did before, we can add this specific file:

$ git add app/views/layouts/application.html.erb

$ git status

On branch master

Changes to be committed:

(use "git restore --staged <file>..." to unstage)

modified: app/views/layouts/application.html.erb

Now, the file is still modified, but labeled as to be committed . You could then run the git command -m "Updated layout" command to commit the change. When reasonable, it’s best to carefully add specific files; using “git add .” without looking at your git status closely will inevitably lead to unwanted files being added to your repository.

Branching and Merging

Let’s say you decide to test out a major refactor on your project and you’re not sure if it will work out and don’t want to break the code for everyone else. Meanwhile, you need to be able to keep working on the main project without changes from your experiment breaking your application. To have a safe place to experiment with your project’s code, you need to create a branch. A branch is a duplicate of your project’s code that you can work on in parallel with the master copy of the same project.

When you called the git init command earlier, Git initialized a new repository for your application with a default branch called master. To create a new branch in the repository, use the git checkout –b command followed by the name of the new branch you want to create:

$ git checkout -b articles

This command creates a new branch named articles as a duplicate of the current branch—master—and then switches to the newly created branch. To see a list of the branches in your project, we can use the git branch command :

$ git branch

* articles

master

The output indicates we have two branches—articles and master. The asterisk in front of articles indicates that it’s the current branch you’re working on. To switch branches, use the git checkout command followed by the name of the branch you want to switch to:

$ git checkout master

Switched to branch 'master'

$ git checkout articles

Switched to branch 'articles'

The articles branch is the current branch again. We can confirm this by listing the branches again:

$ git branch

* articles

master

Now, let’s implement a new feature—an articles scaffold:

$ rails generate scaffold Article title:string body:text

invoke active_record

create db/migrate/20200427012944_create_articles.rb

create app/models/article.rb

invoke test_unit

create test/models/article_test.rb

create test/fixtures/articles.yml

invoke resource_route

route resources :articles

invoke scaffold_controller

create app/controllers/articles_controller.rb

invoke erb

create app/views/articles

create app/views/articles/index.html.erb

create app/views/articles/edit.html.erb

create app/views/articles/show.html.erb

create app/views/articles/new.html.erb

create app/views/articles/_form.html.erb

invoke test_unit

create test/controllers/articles_controller_test.rb

create test/system/articles_test.rb

invoke helper

create app/helpers/articles_helper.rb

invoke test_unit

invoke jbuilder

create app/views/articles/index.json.jbuilder

create app/views/articles/show.json.jbuilder

create app/views/articles/_article.json.jbuilder

invoke assets

invoke scss

create app/assets/stylesheets/articles.scss

invoke scss

create app/assets/stylesheets/scaffolds.scss

Let’s say we’re done with the new feature changes. It’s time to add the changes and commit them to the articles branch:

$ git add .

$ git commit -m "Adding Article scaffold"

[articles cb4bed1] Adding Article scaffold

19 files changed, 351 insertions(+)

create mode 100644 app/assets/stylesheets/articles.scss

create mode 100644 app/assets/stylesheets/scaffolds.scss

create mode 100644 app/controllers/articles_controller.rb

create mode 100644 app/helpers/articles_helper.rb

create mode 100644 app/models/article.rb

create mode 100644 app/views/articles/_article.json.jbuilder

create mode 100644 app/views/articles/_form.html.erb

create mode 100644 app/views/articles/edit.html.erb

create mode 100644 app/views/articles/index.html.erb

create mode 100644 app/views/articles/index.json.jbuilder

create mode 100644 app/views/articles/new.html.erb

create mode 100644 app/views/articles/show.html.erb

create mode 100644 app/views/articles/show.json.jbuilder

create mode 100644 db/migrate/20200427012944_create_articles.rb

create mode 100644 test/controllers/articles_controller_test.rb

create mode 100644 test/fixtures/articles.yml

create mode 100644 test/models/article_test.rb

create mode 100644 test/system/articles_test.rb

When you check the git status command now, you see that you have nothing to commit in the articles branch:

$ git status

On branch articles

nothing to commit, working tree clean

The articles branch now has an articles scaffold, and the master branch doesn’t. If you switch back to the master branch, notice that none of the articles scaffold files exist there:

$ git checkout master

Switched to branch 'master'

For fun, you could switch back to the articles branch and watch your articles scaffold files magically reappear. Hopefully the magic is a little clearer now; your branches can have different files in them, and depending on which branch is currently checked out, your filesystem will reflect the committed changes for that branch.

We could go on modifying the code in the master branch completely in isolation from the articles branch. But at some point, the feature being developed in the articles branch will be ready to be added to the “main” code branch, master. In Git terminology, that’s a merge. Let’s merge the articles branch into the master branch. We’ll do that using the git merge command followed by the branch name you want to merge into the current branch:

$ git checkout master

$ git merge articles

Updating 15c012e..cb4bed1

Fast-forward

app/assets/stylesheets/articles.scss | 3 +++

app/assets/stylesheets/scaffolds.scss | 65 +++++++++++++++++++++++++++

app/controllers/articles_controller.rb | 74 +++++++++++++++++++++++++++++

app/helpers/articles_helper.rb | 2 ++

app/models/article.rb | 2 ++

app/views/articles/_article.json.jbuilder | 2 ++

app/views/articles/_form.html.erb | 27 +++++++++++++++++++++++++++

app/views/articles/edit.html.erb | 6 ++++++

app/views/articles/index.html.erb | 29 +++++++++++++++++++++++++++++

app/views/articles/index.json.jbuilder | 1 +

app/views/articles/new.html.erb | 5 +++++

app/views/articles/show.html.erb | 14 ++++++++++++++

app/views/articles/show.json.jbuilder | 1 +

config/routes.rb | 1 +

db/migrate/20200427012944_create_articles.rb | 10 ++++++++++

test/controllers/articles_controller_test.rb | 48 ++++++++++++++++++++++++++++

test/fixtures/articles.yml | 9 +++++++++

test/models/article_test.rb | 7 +++++++

test/system/articles_test.rb | 45 +++++++++++++++++++++++++++++++

19 files changed, 351 insertions(+)

create mode 100644 app/assets/stylesheets/articles.scss

create mode 100644 app/assets/stylesheets/scaffolds.scss

create mode 100644 app/controllers/articles_controller.rb

create mode 100644 app/helpers/articles_helper.rb

create mode 100644 app/models/article.rb

create mode 100644 app/views/articles/_article.json.jbuilder

create mode 100644 app/views/articles/_form.html.erb

create mode 100644 app/views/articles/edit.html.erb

create mode 100644 app/views/articles/index.html.erb

create mode 100644 app/views/articles/index.json.jbuilder

create mode 100644 app/views/articles/new.html.erb

create mode 100644 app/views/articles/show.html.erb

create mode 100644 app/views/articles/show.json.jbuilder

create mode 100644 db/migrate/20200427012944_create_articles.rb

create mode 100644 test/controllers/articles_controller_test.rb

create mode 100644 test/fixtures/articles.yml

create mode 100644 test/models/article_test.rb

create mode 100644 test/system/articles_test.rb

The output shows the effects of our merge; it shows which files have been updated and how many lines in each file were added or removed. (In our case, they were all additions.)

The task is complete: we “developed” a new feature in a separate branch without affecting the master branch; and when we finished, we merged those changes back into master.

There’s much more to learn about these git commands; this is merely a brief introduction.

Remote Repositories and Cloning

As stated previously, Git is a distributed SCM; therefore, your repository is hosted locally on your machine, hidden inside your working copy directory. No one else has access to it.

However, if you want to set up a repository that you and your team can work on, you may want to create a remote repository that all of you can access and clone from. Your remote repository can be hosted on any machine that is available to all developers who need access to the repository and have Git installed. It can be hosted on your local network, online, or with a third-party Git hosting provider like the famous GitHub (https://github.com ), which hosts Rails, as well as many, many other projects.

We used Git for this book’s blog application, and we hosted the repository on GitHub. It’s publicly available for you to browse and use; simply point your browser at https://github.com/nicedawg/beginning-rails-6-blog . This means you can clone a copy of the blog repository to your machine and browse the code locally. To do that, you need the Public Clone URL, which you find from the “Clone or download” button on the GitHub page for the repo. Let’s clone the blog application repository using the git clone command:

$ git clone [email protected]:nicedawg/beginning-rails-6-blog.git

Cloning into 'beginning-rails-6-blog'...

remote: Enumerating objects: 499, done.

remote: Counting objects: 100% (499/499), done.

remote: Compressing objects: 100% (243/243), done.

remote: Total 1023 (delta 300), reused 424 (delta 253), pack-reused 524

Receiving objects: 100% (1023/1023), 265.83 KiB | 1.53 MiB/s, done.

Resolving deltas: 100% (537/537), done.

Now you have a local copy of the blog application repository cloned to your machine. You can change files and even commit them to your own local repository, but what you cannot do is share those commits with others. In order to push your changes, you need write access to the remote repository , which you don’t have.

If you want to try that, sign up for a free account on GitHub and create a repository of your own there. You then have two URLs: a public URL that everyone can see and your clone URL, which gives you full access to this remote repository.

The concept is simple: after you clone your own repository using your own URL, you can work normally in your working copy, commit changes, and add and remove files. Whenever you want to share those commits with the rest of the world, you push them to the remote repository on GitHub using the git push command. If you have teammates pushing changes to the same repository, you can retrieve those changes by using the git pull command.

To sum up, you create a remote repository to allow more than one developer to work on the same repository. Although all developers on the team have their own copies, they still need to push their copies to the remote repository to allow the rest to pull from it and stay in sync.

When you sign up for a free account on GitHub, the repositories you create can be made publicly available for everyone to clone from. Or, if you want your repositories to be private, so only you and your teammates can access them, you can choose to make them private on GitHub, or you could host them on your own server with your own setup.

Learning More

Git is a great tool and has a lot of commands; however, this appendix has covered only the basic features and commands. We highly encourage you to read more. You can see a list of the most used Git commands using the git help command :

$ git help

usage: git [--version] [--help] [-C <path>] [-c <name>=<value>]

[--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]

[-p | --paginate | -P | --no-pager] [--no-replace-objects] [--bare]

[--git-dir=<path>] [--work-tree=<path>] [--namespace=<name>]

<command> [<args>]

These are common Git commands used in various situations:

start a working area (see also: git help tutorial)

clone Clone a repository into a new directory

init Create an empty Git repository or reinitialize an existing one

work on the current change (see also: git help everyday)

add Add file contents to the index

mv Move or rename a file, a directory, or a symlink

restore Restore working tree files

rm Remove files from the working tree and from the index

sparse-checkout Initialize and modify the sparse-checkout

examine the history and state (see also: git help revisions)

bisect Use binary search to find the commit that introduced a bug

diff Show changes between commits, commit and working tree, etc

grep Print lines matching a pattern

log Show commit logs

show Show various types of objects

status Show the working tree status

grow, mark and tweak your common history

branch List, create, or delete branches

commit Record changes to the repository

merge Join two or more development histories together

rebase Reapply commits on top of another base tip

reset Reset current HEAD to the specified state

switch Switch branches

tag Create, list, delete or verify a tag object signed with GPG

collaborate (see also: git help workflows)

fetch Download objects and refs from another repository

pull Fetch from and integrate with another repository or a local branch

push Update remote refs along with associated objects

'git help -a' and 'git help -g' list available subcommands and some

concept guides. See 'git help <command>' or 'git help <concept>'

to read about a specific subcommand or concept.

See 'git help git' for an overview of the system.

To learn more about a specific command, you can use git help COMMAND, which shows that command’s documentation and how to use the command.

Other SCM Systems

Although Git is the most talked-about SCM nowadays, you may either be required to use a different SCM or may want to investigate the alternatives. Here’s a list of other SCMs you could choose :

Mercurial: Just like Git, Mercurial is a distributed SCM. Mercurial is often compared with Git because of their similarities; feel free to try it if you want to explore another option. You can find out more about Mercurial from its official website: www.mercurial-scm.org/ .
SVN (Subversion): This was the most prominent SCM for a while, but it has since been overtaken by Git. You can find out more about Subversion from its official website: https://subversion.apache.org/ .
CVS (Concurrent Versions System): This was one of the earliest SCM systems (initial release in 1990). It’s still popular, although because of some limitations, such as sparse Unicode support and expensive branching operations, developers have begun moving toward other version control systems like Subversion and Git. You can find out more about CVS from its official website: www.nongnu.org/cvs/ .

Online Resources

After the beta launch of GitHub, Git received huge interest from developers, including the Rails core team; they decided to switch from Subversion to Git and host the official Rails repository on GitHub. This attention to Git encouraged more developers to try it, and a number of tutorials and blog posts began to appear in the community.

The following are some resources you can visit to dig deeper and learn more about Git :

http://gitimmersion.com : A clean, organized step-by-step tutorial that shows how to use many of Git’s commands
https://learngitbranching.js.org : An interesting browser-based environment that helps you visualize what’s happening with Git branches while you execute commands on them.
https://git-scm.com/doc : An official list of resources, including a link to the excellent 2014 Apress book, Pro Git, by Scott Chacon and Ben Straub

Git is an amazing tool. It’s tempting to primarily focus on developing mastery of your preferred programming language or framework, but don’t neglect sharpening your Git skills; time you invest in learning Git will pay dividends through improving your efficiency and making your commits clearer and more understandable.

Index

Account model

Action Cable

broadcasting

channel

client side changes

configuration

connection

New article notification

Rails

server side changes

ApplicationCable

ArticlesChannel

streams

subscriptions

web development

WebSockets

ActionCable::Channel

ActionCable::Connection

Action Mailer

components

configuration

configuring application settings

SeeReceiving emails

ISP

rails app

server connection strings

storing sensitive settings

web-based email application

ActionMailer::MessageDelivery

Action Pack

action view helpers

adding edit controls

articles have owners

controllers/templates, improving

applying filters

article form

article index page

authentication, filters

collection_check_boxes

filters

custom helpers

formatting body field

generating controller

SeeController generator

HTML templates

layout

logging in user

logging out user

nested resources

SeeNested resources

session resources

adding session

path

sessions controller

named routes

state

style sheet

Action Pack

components

action controller

Action View library

ERb

helpers

RESTful resources

routing

controller

SeeController

request cycle

Action Text

blog

SeeBlog application

CSS

actiontext.scss file

excerpt from, main style sheet

node_modules directory

require_tree

database migrations

database storage

action_text_rich_texts table

db/schema.rb

record_id column

record_type column

sample data

installation

JavaScript

ActionText::Content class

action_text:install command

ActionText::RichText class

actiontext.scss file

Action View library

Active Job

ApplicationJob

blog

SeeBlog application

configuration

creation

failed

discarding

retrying

performing

perform_later

queue_as, default

Active Model

constructor

controllers/views

EmailAFriend model

error messages

modules

paint method

simple car class

source code

ActiveModel::Callbacks

ActiveModel::AttributeAssignment

ActiveModel::Dirty module

ActiveModel::ForbiddenAttributesError

ActiveModel::Model

ActiveModel::Validations

Active record

adding methods

advanced finding

array condition syntax

association proxies

default scope

methods

named scope

SQL fragment

using where method

applying validations

SeeBuilt-in validations

article

association

SeeAssociations

base class

benefits

books

callbacks

after_create method

email_article_author method

reviewing updated models

user model, updating

column_names class method

console command

conventions

creation

SeeNew records creation

CRUD

database abstraction

database software

errors

full_messages method

ORM

reading

SeeReading (finding) records

SQL

SQLite

updation

validations

Active Server Pages (ASP)

Active Storage

configuration

imagemagick

MacOS Catalina

Ubuntu Linux

Windows

upload images

SeeUploading images

after_create method

Agile Manifesto

Ajax

Ajax, delete comment

@article instance variable

Article model

adding, create test

assertions

CRUD operations

destroying

finding

fixtures creation

updating

Article page

articles branch

articles_categories

article_should_be_published method

assert_raise assertion

assert_response assertion

assert_selector

Asset locations

Asset Pipeline concatenates

Associations

applying options

declaration

foreign key reference

many-to-many

one-to-one

Association proxy

asterisk (*) character

author_id field

Automated testing

code quality

opening browser

sign-up procedure

before_save method

Berkeley Software Distribution (BSD)

Blog application

adding more fields

adding validations

Agile methodology

article model

article view

asynchronous delivery

comment added

config/database.yml file

controller generator

database creation

database management system

development mode

draft article created

flow

generating files

migration

action_text_rich_texts

Article.first.body

articles table

generation

rails command

rails console

rails db

run

sqlite commands

up and down methods

N+1 queries

ArticlesController

elimination

loading articles

SQL

tables

notify_friend request

rails directory structure

request time

response time

scaffolding

skeleton and base files

users

WordPress/Blogger

Built-in validations

attribute, format

confirmation

custom validation methods

default options

unique value

validating length, or size

value entered

Callback mechanisms

Capybara method

Cascading Style Sheets (CSS)

category_ids method

Code quality

Command-line interface (CLI)

Comment and Article models

Comment Form

Comment model

Complete mental model

config.active_job.queue_adapter

Control-flow statements

Controller

article form

edit and update actions

helpers

layouts

partials

redirects

rendering responses

request parameters

revisiting controller

revisiting views

scaffold generator

setting up routes

blog application

named routes

priority

RESTful and resources

templates

templates, displaying error messages

Controller generator

app/controllers/users_controller.rb

controller name

form partial

new user

params

routes file

syntax

templates

users controller

create.js.erb template

create_profile method

Create, read, update, and delete (CRUD)

create_table method

Cron jobs

current_user method

db:migrate Rails command

Delayed::Job

DELETE statement

Deleting records

DELETE method

delete_by class method

destroy method

instance

deliver_later method

destroy method

Document Object Model (DOM)

Ajax

elements

HTML

load elements

users comment

working

Domain-specific language (DSL).

Don’t repeat yourself (DRY)

Edge cases

controller test

fix bug

handling security

logged-in user

notify_friend

scenarios

Embedded Ruby (ERb)

encrypt_new_password method

en.yml

ERb templating library

Error message, display

fail_create.js.erb template

Fat models

File.read method

Files ignore

Framework

abstraction layer

cross-platform

definition

full stack

open source

Functional testing

adding login_as

assert_response

controllers

effects

test helper method

update setup method

Gherkin

git add command

git branch command

git committed command

git help command

git merge command

git status command

Global parameters

GuessANumberBetweenOneAndTenJob

GuessedWrongNumber

has_many :through

has_one declaration

helper_method method

I18n.default_locale= methods

I18n.locale method

I18n.translate method

Index records

Initialize method

INSERT command

INSERT statement

Installing Git

Linux

macOS

Windows

Integrated Development Environment (IDE)

Integration tests

Interactive Ruby (irb)

Internationalization

Bilingual Blog

definition

localize blog application, Brazilian Portuguese

rails

config/application.rb

config/locales

console

en.yml file

I18n module

pt-br.yml

translate method

setting up i18n, blog application

Internet Relay Chat (IRC) channel

Internet service provider (ISP)

JavaScript code

klass argument

language_selector

Linux, installation

apt-get update command

Node.js

package manager

Rails

Ruby

SQLite

Yarn

load_article method

long_title

macOS Catalina, installation

command line tools

Node.js

Rails

RVM

Yarn

Mailers

assertions

default_url_options setting

email_friend method

generated tests

NotifierMailer test

setup method

test

Many-to-Many associations

articles_categories

create_join_table

create_table

has_and_belongs_to_many declarations

seeding data

Massachusetts Institute of Technology (MIT)

member method

message_id

Migration

MixedCase

Model enhancement

Modifiers

MVC cycle

concept

control flow

controller layer

layers

library

model layer

view layer

MVC pattern

Nested resources

adding comments

application layout

@article.comments

Article partial

Article show page

comment partial

controller comments

named routes

new comment template

templates

New records creation

methods

new constructor

resetting database

notify_dmv method

NumberHelper module

Object-oriented programming

Object-relational mapping (ORM)

One-to-Many associations

between users and articles

create object

has_many options

One-to-one associations

belongs_to

db:migrate Rails

definition

has_one declaration

user and profile models

create the users Table

P, Q

Partial templates

arguments

definition

local variables

rendering collection

rendering object

password_confirmation attribute

Perform method

Plain Old Ruby Objects (POROs)

Platform as a Service. Services (PAAS)

PostgreSQL

installation

switching

Preprocessing assets

Previewing email

HTML and plain-text variations

HTML templates

NotifierMailer class

NotifierMailer#email_friend

Principle of least surprise (POLS)

Process method

Pseudolanguage

Rails

agility

application

basic principles

benefits

built-in web server

chat

command-line tool

convention over configuration

creating action

database abstraction layer

design pattern

Table of Contents for Back Matter

Create new playlist

Sign In

Sign Up

Table of Contents for
Back Matter