אפליקצה ראשונה עם רובי און ריילס

זהו מדריך כללי על ההתקנה והעבודה עם רובי און ריילס

הדבר הראשון שיש לעשות, הוא להתקין את רובי ורובי און ריילס על מערכת ההפעלה שלך ולהתקין מסד נתונים. מסד הנתונים הרשמי של ריילס הוא SQLite, אך ניתן להשתמש במגוון רחב של מסדי נתונים אחרים. מדריכי התקנה מפורטים לרובי און ריילסלמקינטוש, לחלונות, ולינוקס.

- צור פרוייקט ריילס ע”י מתן הפקודה

$ rails myapp

בשורת הפקודה שלך. עבור לתיקיה החדשה שנוצרה ע”י הקשה של הפקודה

$ cd myapp

הפעל את שרת האפליקציה שלך

$ ruby script/server

Note: פקודה זו תריץ שרת אפליקציה המתאים לסביבות פיתוח בלבד - פתח את הדפדפן וגש אל הכתובת

http://localhost:3000

ואם הכל הלך כשורה, תוכל לראות את דף ברירת המחדל של האפליקציה שלך.

פתח את האפליקציה שלך בעורך לבחירתך וגש לקובץ

config/database.yml

זהו הקובץ בו נשמרות ההגדרות של הגישה למסד הנתונים של האפליקציה, הגדרות כמו שם משתמש וסיסמא, שרת וסוג מסד הנתונים. בדרך כלל תדרש לעשות שינויים כדי להפנות את האפליקציה למסד הרלוונטי, במקרה של האפליקציה הזו, אין צורך בשינויים. שים לב ששם מסד הנתונים הדיפולטי נגזר משם האפליקציה שבחרת קודם

פתח חלון שורת פקודה, גש לספרית הפרוייקט והקש את הפקודה

$ rake db:create

ריילס תיצור את מסד הנתונים שלך לסביבת הפיתוח, כפי שציינת בקובץ ההגדרות של מסד הנתונים

עכשיו ניצור את הטבלה הראשונה שלנו ואת הממשק הבסיסי לניהול הנתונים שלה, ממשק זה נקרא פיגום ומשמש למטרה הזו בלבד. הערה: למרות שזה מאוד מפתה, פיגומים נועדו למטרות תחזוקה ובניה ראשונית ולא מומלץ להשתמש בהם מעבר לשימושים הנוגעים למהלך הפיתוח של האפליקציה.

כדי לראות איך משתמשים בפיגומים, נראה למחולל הפיגומים ע”י הפקודה

$ ruby script/generate scaffold

נניח שברצוננו ליצור טבלת משתמשים, כדי ליצור טבלת משתמשים בעזרת פיגום נקיש את הפקודה הבאה

$ ruby script/generate scaffold user first_name:string last_name:string active:boolean

פקודה זו מייצרת לנו קונטרולר לניהול משתמשים, מודל לייצוג משתמש ממסד הנתונים, את מבנה הטבלה במסד הנתונים ואת דפי ה-html הנחוצים לנו לשם ביצוע פעולות על רשומות משתמשים. הערה: מחולל הפיגום לא יצר את הטבלה במסד הנתונים, אנו צריכים להקיש עוד פקודה בטרם הטבלה תיווצר במסד הנתונים

כדי ליצור את הטבלה נצטרך להריץ פקודת הגירה למסד הנתונים

$ rake db:migrate

עכשיו נוכל לגשת לדפדן ולהקיש את הכתובת הבאה כדי להתחיל לנהל את המשתמשים במערכת

http://localhost:3000/users

בממשק זה תוכל להוסיף משתמשים, לצפות באחד או בכולם, לערוך ואף למחוק משתמשים.

1. 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.

2. Now open the migration located in the /db/migrations/ directory. It should be the only file.
3. Notice how the migration has an up method to migrate up, and down method to migrate down.
4. We want to add that bio field, so after the t.boolean :active line, add:

   t.text :bio

5. Save the file, and run rake db:migrate again to migrate your database up:

   $ rake db:migrate

6. 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.
7. Lets open up the /app/views/users/new.html.erb file. This is what renders our New User form. We need to add a bio field using the following code below the active checkbox.

   <p>
     <%= f.label :bio %><br />
     <%= f.text_area :bio %>
   </p>

8. 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. For extra credit, you could use the same code if you wanted to update the edit view (in /app/views/users/edit.html.erb) so you can edit a user's bio.
9. 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:

   <p>
     <b>Bio:</b>
     <%=h @user.bio %>
   </p>

10. 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.

1. In Rails, we put our validations in our model files, so let's open /app/models/user.rb.
2. 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

3. Save the file, go to your browser, and attempt to create a user without a first name or last name.
4. Rails has many helper validation classes, and you can see a list on the right side of this API page.

For extra credit, add another validation to your app just for fun.

1. 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.
2. 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).
3. Let's add something to our layout just for fun. Open up the application.html.erb and add something like:

   <h2>Rails Rocks!</h2>

4. Save the file, go to your browser, and you should see the change you made reflected on ALL pages of the website.

1. Let's have some fun playing with our User Model. In your command prompt, type:

   $ ruby script/console

   You are now in a Ruby IRB session which has access to your models.

2. 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)

3. Let's try a simple Ruby statement to make sure everything is working:

   puts "Hello Dude!"

4. 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.

5. 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.

6. 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!

7. Now let's delete the user.

   u.destroy

8. 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.

9. Let's print out all the users in your system in upper case:

   User.all.each {|user| puts user.first_name.upcase }

10. 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.
11. 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.

12. Take a look at the API page here. Along the right you'll see all of the methods you can run on ActiveRecord objects. Try a few.

The Getting Started with Rails Guide contains another fun walkthrough, but with additional explanation of Rails architecture.