$ rails myappThis will create the skeleton of your Rails app.
- Go into your directory, probably by typing: $ cd myapp
- Startup your Rails server by running: $ rails server OR ./script/server
- If it asks you to bundle/install, do it and then re-run "script/server".
- Call up a browser and go to http://localhost:3000. You should see that Rails is running; that's all there is to it! Pat yourself on the back, you deserve it.
===== Part 3 - Creating the Database & Scaffold =====
- Open the application in your editor of choice.
- Open the ''config/database.yml'' file. This is where you would typically configure different databases for your application, but for the sake of this example you shouldn't have to touch anything. The default database names, as you may have noticed, are taken from the name of your Rails app.
- Open up another command prompt (that way we can keep the server running in the background), and in your application directory run: $ rake db:create This will create your development database.
- Now we want to create our first table and interface. In Rails, this typically means we're going to create a [[http://guides.rubyonrails.org/getting_started.html#getting-up-and-running-quickly-with-scaffolding|scaffold]] to start from. A scaffold is simply a starting point, and we can add increasingly complex code from there. Let's first run the scaffold command without any parameters: $ script/generate scaffold Take a look at the output generated. It shows you how to use the command.
- Now let's go ahead and use scaffold to start generating our web application. We're going to create a users table:$ script/generate scaffold user first_name:string last_name:string active:boolean It's okay if you copy and paste this code, I won't tell anyone. So now your scaffold is created, which is just a bunch of template files.
- Let's [[http://guides.rubyonrails.org/getting_started_with_rails.html#_running_a_migration|run the migration]] it created for us (to create the database table). $ rake db:migrate
- Now go back to your browser (start your server back up if you killed it), and go to http://localhost:3000/users
- Create a few users, and play around with your Rails interface!
===== Part 4 - Adding Functionality =====
- We just realized that we forgot to add a bio field for a user - oops! We could either create a new migration to add that column, or roll back the migration that was created for us. Let's do the latter. To remove the table so we can add a column, run this command:$ rake db:rollback This will roll back one migration.
- Now open the migration located in the ''/db/migrations/'' or ''/db/migrate/'' directory. It should be the only file.
- Notice how the migration has an ''up'' method to migrate up, and ''down'' method to migrate down.
- We want to add that bio field, so after the ''t.boolean :active'' line, add: t.text :bio
- Save the file, and run ''rake db:migrate'' again to migrate your database up: $ rake db:migrate
- If you checked your browser at this point, you'd notice that the bio field isn't automatically showing up in our user's information or forms. We will need to add this ourselves. Yes, we could have erased the files and run the scaffold command to get this field, but then you wouldn't learn anything.
- Lets open up the ''/app/views/users/_form.html.erb'' file, This will help in adding Bio option in New User form. We need to add a bio field using the following code below the active checkbox.
<%= f.label :bio %>
<%= f.text_area :bio %>
- Now open up the New User page in your browser http://localhost:3000/users/new. You should see the bio field, and be able to add new users with a bio.
- When you create a user, you're brought automatically to his/her show page. Let's add the bio to the show page. You can do this by opening the ''/app/views/users/show.html.erb'' file, and underneath the Active field, adding:
Bio:
<%=h @user.bio %>
- Save the file and check it out in the browser. If you don't see your change at first, make sure you are on the ''show'' page (and not the ''index''). When you get to this part, let out a barbaric "woot!", you've made some great progress.
- You would have noticed that our recently added bio field should now appear when we try to edit one of the users entry. This is because ''/app/views/users/_form.html.erb'' is included in ''/app/views/users/new.html.erb'' and ''/app/views/users/edit.html.erb'' dynamically with the following line:
<%= render 'form' %>
Once you done with this try to edit one of the users entered values you will see a bio box, too, for editing.
===== Part 5 - Your First Validation =====
- In Rails, we put our validations in our model files, so let's open ''/app/models/user.rb''.
- We want to require that a user enter their first name and last name, so let's add validation to our User model, so it ends up looking like this:
class User < ActiveRecord::Base
validates_presence_of :first_name, :last_name
end
- Save the file, go to your browser, and attempt to create a user without a first name or last name.
- Rails has many helper validation classes, and you can see a list on the right side [[http://apidock.com/rails/ActiveRecord/Validations/ClassMethods|of this API page]].
{{:getting-started:installation:information.png|}}
For extra credit, add another validation to your app just for fun.
===== Part 6 - Modifying the Layout =====
- If you viewed the browser HTML source of your application, you may have noticed that your application is in some sort of layout. By default, when you ran the ''scaffold'' command, a ''/app/views/layouts/users.html.erb'' file was created, and used as your layout.
- You'll probably only want to use one layout for most of your controllers, so let's give this a more generic name. Rename ''users.html.erb'' to ''application.html.erb''. As a Rails convention, now that you have an ''application.html.erb'' file in your layouts directory, all controllers will use this by default (you can override this later if you want).
- Let's add something to our layout just for fun. Open up the ''application.html.erb'' and add something like: Rails Rocks!
$ rails console You are now in a Ruby IRB session which has access to your models.
- Before we start playing, run the following command so that we can see what SQL commands are going to be generated for us. $ ActiveRecord::Base.logger = Logger.new(STDOUT)
- Let's try a simple Ruby statement to make sure everything is working:puts "Hello Dude!"
- Now let's try having some fun with our model. Create a new model by doing something like this:
u = User.new
u.first_name = "Gregg"
u.last_name = "Pollack"
u.save Notice the SQL that is generated.
- Now try doing it all in a single line:
User.create(:first_name => "Joe", :last_name => "Blow")
If you hit any errors, check for syntax problems.
- Let's fetch the user with first name of Joe, and change his last name to "Johnson".
u = User.find_by_first_name("Joe")
u.last_name = "Johnson"
u.save
Notice the SQL that gets generated; nice!
- Now let's delete the user. u.destroy
- Have some fun trying the following commands to see what they do:
User.first
User.last
User.all
Feel free to set a variable with the values, and play around with changing attributes. Do note that ''.all'' returns an array, so you may want to use [0] or [2] to refer to a particular item in the array.
- Let's print out all the users in your system in upper case:
User.all.each {|user| puts user.first_name.upcase }
- You'll notice that it prints out the first names, and then it also returns the array of Users. Remember, every method in Ruby returns something, even if it's nil.
- Let's create an array of all of the last names in our system:
User.all.map {|user| user.last_name }
What we're interested in here is the return value, which should be an array of last names.
- Take a look at the [[http://apidock.com/rails/ActiveRecord/Base|API page here]]. Along the right you'll see all of the methods you can run on ActiveRecord objects. Try a few.
===== Additional Reading =====
The [[http://guides.rubyonrails.org/getting_started.html|Getting Started with Rails Guide]] contains another fun walkthrough, but with additional explanation of Rails architecture.