Rename a Rails app (including database, Github, and Heroku names)
Tags: rails, ruby, postgres, heroku
Published: 2020-07-10 01:13:32

Recently I started working on a Rails project without having a good name picked out, so I gave the application a temporary one for the time being. I ended up with a Github repository and a Heroku app that used that temporary name, but after finally thinking of the perfect name, I naturally wanted to update it everywhere. This is how I did it!

I'll go over how I changed the repository name on Github and the name of the app on Heroku, and how you can go about changing the name of the databases used by Rails.

For reference, this is the setup of my app:
- Rails 6.0.3.2
- Ruby 2.7.1
- Code on Github
- Deployment to Heroku
- PostgreSQL database in both production and development

## Rename the Github repository

To change the name on Github, simply go to the repository page online, navigate to repository's Settings page and change the name using the "Repository name" field.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/tvn6yu2lizm32hf3rbxl.png)

Github will take care of forwarding to the new URL whenever the old URL is accessed, for example when you push or pull, but I think it would be better to make sure the remote URLs on your local machine also match up. 

To update the remote on your computer, first, grab the new url from the repository page on Github, which you can get from the "Clone with SSH" button. 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/ff0b67biu15fb4ntjm95.png)

It should look something like this:

```
git@github.com:your-username/reponame.git
```

Next, navigate to the directory where your Rails app lives on your local machine.

You can check the currently registered remote URL that connects the git repository to Github with the following command (assuming remote is named "origin", which it should be unless you changed it):

```
git config --get remote.origin.url
``` 

At this point, it should still display the old remote URL, something like `git@github.com:your-username/old-repo-name.git`.

To update it, enter the following command using the URL you copied from Github:

```
git remote set-url origin git@github.com:your-username/new-reponame.git
```

You can double check that it got updated by running the `git config --get remote.origin.url` command again.

Okay! That should take care of the Github side! Next, let's update things on the Heroku side.

## Rename the app on Heroku

This is done easiest from the command line because it will also automatically update the remote URL for Heroku as well. Type the following command in the command line from within the app's directory, replacing `new-name` with new name of your app:

```
heroku apps:rename new-name
```

Simple as that! You can check to make sure the remote URL for Heroku has been updated with the following command:

```
git config --get remote.heroku.url
```

It should look something like `https://git.heroku.com/new-name.git`.

If you navigate to your Heroku dashboard online, you will see that everything has been updated! 

Well, almost everything... If you had the Github repository connected to Heroku under the "Deploy" settings, it will still have the old Github URL. Though Github will automatically redirect any access to this URL, you might want to update it here too. Just use the "disconnect" button to disconnect and then reconnect to the newly renamed repository.

## Rename the Rails databases

Although you don't technically have to rename the databases, you may want to anyways just to be consistent.

When you first ran `rails new` command, it creates a file for database configuration, the `config/database.yml` file. The databases are named after the app name you passed along to the `rails new` command, so in the `database.yml` file you will find settings that look something like this (where `app_name` is the name of the app):

```yaml
# config/database.yml

# ... other code

development:
  <<: *default
  database: app_name_development

test:
  <<: *default
  database: app_name_test

production:
  <<: *default
  database: app_name_production
  username: app_name
  password: <%= ENV['APP_NAME_DATABASE_PASSWORD'] %>
```

### Development/Test database configuration

Depending on how you set up your data for the development environment (if at all), you can run into a few different situations:

- You have a `db/seeds.rb` file that sets up all the data.
- You did not use the `db/seeds.rb` file, but the data created while testing out the app in development isn't that important and you don't care if it gets erased.
- You did not use the `db/seeds.rb` file, but you want to keep the data created while testing out the app in development, so it should NOT get erased.

### Situation 1: You have a `db/seeds.rb` file for all your data

First, drop (= destroy) the database with this rails command:

```
rails db:drop
```

If successful, you'll see the following output:

```
$ rails db:drop
Dropped database 'app_name_development'
Dropped database 'app_name_test'
```

Rename the development and test databases in the `config/database.yml` file, replacing `new_name` with the actual name you want to use:

```yaml
# config/database.yml

# ... other code

development:
  <<: *default
  database: new_name_development

test:
  <<: *default
  database: new_name_test

# ... more code
```

Run `rails db:setup` to recreate the databases and fill it with your seed data.

That's it! Everything should work like before.

### Situation 2: You don't have seed data, but don't care if everything is erased

First, drop (= destroy) the database with this rails command:

```
rails db:drop
```

If successful, you'll see the following output:

```
$ rails db:drop
Dropped database 'app_name_development'
Dropped database 'app_name_test'
```

Rename the test and development databases in the `config/database.yml` file as described above.

Then run `rails db:create` and `rails db:migrate` to set up a sparkling new database with a new name.

### Situation 3: You don't have seed data, but you want to make sure no data gets erased.

I am using a PostgreSQL database in my development environment and have PostgreSQL installed locally, so this explanation will be specific to this setup. If you're using a different database locally like Sqlite, you'll have to look up the specific methods for that database. 

#### Using a database dump (backup) file

If you do need to backup data you had for development, you can use the `pg_dump` tool provided by your PostgreSQL database.

I used this tutorial, [Backing Up and Restoring A Database](http://tutorials.jumpstartlab.com/topics/devops/backing_up_and_restoring_a_database.html), as a reference, so check it out for more in-depth explanation. 

##### Create the database dump file

Create the backup file with the following command on the command line from within the Rails app directory, replacing `app_name_development` with the actual name of your database listed in the `config/database.yml` file:

```
pg_dump -F t app_name_development > development_backup.tar
```

`-F t` formats the file into a `tar` file. `development_backup.tar` is the name for the backup file, which you can name it anything you want. 

Learn more about the `pg_dump` command in the [PostgreSQL documentation](https://www.postgresql.org/docs/9.1/app-pgdump.html)

After the running the above command, a database backup file should have been created in the root directory of your Rails app.

##### Drop the current database

Drop (= destroy) the database with the Rails command (this will erase everything, so make sure your backup was created):

```
rails db:drop
```

If successful, you'll see the following output:

```
$ rails db:drop
Dropped database 'app_name_development'
Dropped database 'app_name_test'
```

If you run the Rails server and try to access the app, you'll also see a `ActiveRecord::NoDatabaseError`.

##### Rename and recreate the database

Rename the development and test databases in the `config/database.yml` file, which still contains the old database names.

```yaml
# config/database.yml

# ... other code

development:
  <<: *default
  database: old_app_name_development

test:
  <<: *default
  database: old_app_name_test
```

Rename all the things with the `old_app_name` to the new app name.

After that, run `rails db:create` in the command line to create the newly named database. You will see output like this:

```
$ rails db:create
Created database 'new_name_development'
Created database 'new_name_test'
```

##### Restore the database from the backup file

To restore from the database backup, you can use `pg_restore` command, replacing `new_name_development` with actual name in your `database.yml`:

```
pg_restore -d new_name_development development_backup.tar
```

The `-d new_name_development` option lets you connect to given database (here it's `new_name_development`) and restore directly into it. `development_backup.tar` specifies the name and location of the dump file that you created earlier.

And there you go! Your development and test database are now renamed and the previous data has been restored for development.

### Production database configuration

The production database is the one that Heroku uses when running the deployed app. Rails generated the following production database configuration when I first created the app:

```yaml
# config/database.yml

# ... other code

production:
  <<: *default
  database: app_name_production
  username: app_name
  password: <%= ENV['APP_NAME_DATABASE_PASSWORD'] %>
```

In my case, I just have a basic Heroku setup and don't have any custom database configurations. If that is the case, then you don't actually need this configuration because Heroku uses it's own configuration through an environment variable set as `ENV["DATABASE_URL"]`, which will override the above configuration in the yaml file.

In other words, renaming the production database here doesn't do anything. Instead, I would recommend changing the configuration to explicitly say that you are using the environment variable (also recommended in the [Rails Guides](https://guides.rubyonrails.org/configuring.html#configuring-a-database)).

In fact, you may have a comment in your `database.yml` just above the `production` settings that tells you how to do this depending on how the Rails app was initially set up:

```yaml
# config/database.yml

# ... Other settings

# On Heroku and other platform providers, you may have a full connection URL
# available as an environment variable. For example:
#
#   DATABASE_URL="postgres://myuser:mypass@localhost/somedatabase"
#
# You can use this database configuration with:
#
#   production:
#     url: <%= ENV['DATABASE_URL'] %>
```

So, as a last step, change the production database configuration inside `database.yml` so that it looks like this:

```yaml
# config/database.yml

# ... Other settings

production:
  url: <%= ENV['DATABASE_URL'] %>
```

And we are finished! Everything should now be renamed to the correct app name :D

## References

- [Rails Guides: Configuring a database](https://guides.rubyonrails.org/configuring.html#configuring-a-database)
- [Backing Up and Restoring A Database](http://tutorials.jumpstartlab.com/topics/devops/backing_up_and_restoring_a_database.html)
- [PostgreSQL pg_dump documentation](https://www.postgresql.org/docs/9.1/app-pgdump.html)
- [PostgreSQL pg_restore documentation](https://www.postgresql.org/docs/9.2/app-pgrestore.html)