panpsychism/ruby_rails_sql_resources/1.tweet_r_walkthrough

TWEET_R

Yep.

Walkthrough: Rails R app - R stands for Read (the 'R' in CRUD)

We will be making a new Rails R app with a single model called tweet, with routes, controllers, and views.

This app will use a database, postgresql. You will be doing migrations and filling out a schema. Don't worry about what the word 'migration' means in this context, or what it does. Just follow the instructions and all should become clear.

We will be making much of this manually without scaffolds or generators for our controllers and models. This way, you will develop some muscle memory and a greater understanding of each step of the process. Having said that, this app goes over only the most basic stuff that you need to know to display an index and show route, and nothing more. Once you have these fundamentals under your belt we can implement more advanced stuff later on.

Rails is a framework that favors convention over configuration, so it is important to name your folders, files, and classes with the correct combination of upper/lowercase letters and plural/singular business.

1. LET THERE BE LIGHT

1. Make a new Rails app called tweeter. Set postgresql as the database. Here is the command:
   rails new tweeter --database=postgresql

2. Go into your new directory

2. DATABASE AND MIGRATIONS

#####Let's walk through how to set up your database. This involves:

	1. Creating the database    
	2. Setting up a migration   
	3. Filling in a schema  
	4. Running the migration

• Create your database in your project directory by running this command: rake db:create

Rake is a helpful task manager in Rails that can do lots of things for us, including creating, migrating and seeding our database.

• Test that the db has been created by typing rails dbconsole. This opens a console for our database, in which we can type raw SQL commands. For now, just check that it opens, then quit the console with \q.

CONGRATULATIONS. You have successfully set up a database for Rails. 

#####Now it's time for Migrations

A migration is a proposed change to the database. You set up a migration, enter your changes, then run the migration to lock in the changes. Rails then keeps a record of all migrations so that you can see the full history of your database.

• Make a new migration
  Let's set up a migration. In terminal, inside your project folder, type: rails g migration CreateTweets. The g is short for generate. Create is a Rails keyword helper for making migration files for your database. Tweets must be plural and have a capital T. There is no space between Create and Tweets. It's CreateTweets.

• In your text editor project folder, look in the db folder. The migration command created another folder migrate, and you should see a migration file in there that looks like a bunch of numbers:

Click on the migration file, and you should see some code like this:

In here, you will add your model's columns and datatypes, as if making a schema.

A tweet should have an author, a title, content, and timestamps. Don't worry about why the syntax is the way it is, for now, just adapt your migration file to look like this:

class CreateTweets < ActiveRecord::Migration
  def change
    create_table :tweets do |t|
	    t.string   "title"
	    t.text     "content"
	    t.string   "author"
    end
  end
end

• Now, run the migration. In terminal, in your project folder as usual, enter rake db:migrate. We're using rake again to help us with our database. In this case, it's running our migrations. Thanks, rake.

What does the migration do? It adds the schema to our database, and also makes us a schema.rb file in the db folder. We never touch the schema.rb file.

IMPORTANT: Once a migration has run, you never edit your migration or schema file. The migration files are there forever as records of all your migrations. To edit a migration, you make a new migration to act on the previous one. To alter your schema, you also make a new migration.

• Test that your db has been schema-fied by going into the console and typing rails dbconsole. Perform a SELECT * FROM tweets to test that your db has the correct columns, then quit the dbconsole with \q.

CONGRATULATIONS. You have successfully created and run a migration.

3. MODELS

This is "relatively straightforward". :P

1. Create a model. In the app/models folder, NOT in concerns, create a file called tweet.rb. It has to be singular lower case or it will break.

2. Inside tweet.rb make a class called Tweet singular, uppcase T that inherits from ActiveRecord::Base.

class Tweet < ActiveRecord::Base

end

That's it!

4. SEED

• Seed your database with data for your models: two Tweet entries. In the db folder there is a file called seeds.rb wherein you can make seeds like the following:

Tweet.create({
  title: "Just found this", 
  content: "the square of the hypotenuse is equal to the sum of the squares of the other two sides",
  author: "Pythagoras570"
})

Tweet.create({
  title: "I'm walkin' here", 
  content: "Hey, I'm walkin' here!",
  author: "Nicky62"
})

• To import your seed into your database, run rake db:seed in terminal.

• Test that your seed worked by going into rails dbconsole, performing a SELECT query, and then quit.

• Test your model by opening up Rails console. Rails console is where you can make Active Record queries. Open it with rails console or just rails c. Query all of your tweets with Tweet.all. Quit rails console with exit.

4. ROUTES

1. In config/routes.rb add resources :tweets.
   Test your routes by typing rake routes in the console. You should get this:

      Prefix Verb   URI Pattern               Controller#Action
     tweets GET    /tweets(.:format)          tweets#index
           POST   /tweets(.:format)          tweets#create
  new_tweet GET    /tweets/new(.:format)      tweets#new
 edit_tweet GET    /tweets/:id/edit(.:format) tweets#edit
      tweet GET    /tweets/:id(.:format)      tweets#show
           PATCH  /tweets/:id(.:format)      tweets#update
           PUT    /tweets/:id(.:format)      tweets#update
           DELETE /tweets/:id(.:format)      tweets#destroy

You can delete all the extraneous comments in routes.rb

5. CONTROLLER

1. In your app/controllers folder, manually create a new file called tweets_controller.rb. Don't put it into the concerns folder. The word tweets must be lowercase and plural or the app will break.

2. Inside tweets_controller.rb make a new class called TweetsController that inherits from ApplicationController. The word Tweets here must be plural with an uppercase T, and Controller must have an uppercase C

3. Add the methods that correspond to your restful routes you'll be using: index and show.

*** Try running your app to see if it will break with rails s. The s is short for server. It won't show anything yet, but you should get it to where it won't break.***

6. VIEWS

1. In the app/views folder, make a folder for your tweets views. It should be called tweets lowercase plural.

2. In your views/tweets folder, start by making a view file called index.html.erb. This corresponds to your index method in your controller.

7. TEST

1. Make an instance variable in your tweets#index controller method. Set it to a string, such as @test = "gidday mate". Instance variable are accessible in the views. Regular variables are not.

2. In your tweets view folder, in index.html.erb, write some erb that will display the instance variable: <%=@test%>

3. When you go to access the url /tweets in your browser (the tweets index), you should see the value of @test on your screen.

8. MVC

INDEX

The index route in your controller is a GET route and wants to send information to the page for a user to see. For the index route, in your controller file:

  def index
    @tweets = Tweet.all
  end

Tweet.all queries your model for every tweet entry and sends back an array. We save this array into @tweets.

In our index.html.erb view, we can iterate over the @tweets array using Ruby, Let's use .each to display every individual tweet.

<% @tweets.each do |single_tweet| %>
    <%= single_tweet.title %>
    <%= single_tweet.author %>
    <%= single_tweet.content %>
<% end %>

Test this out and keep working at it until you get each tweet displayed

You can go ahead and make this legible on the page using html tags.

SHOW

  def show
    @tweet = Tweet.find(params[:id])
  end

9. ON YOUR OWN

1. Make a view for your show.

2. Make each tweet on your index page link to its corresponding show page.

3. Add a new Tweet with Active Record through rails console, rails c. See it appear in the view.

4. Edit a Tweet with Active Record through rails console. See that it changed in the view.

5. Delete a tweet with Active Record through rails console. See that it was deleted in the view.