איך לבנות יישומון של Ruby on Rails

Ruby

הקדמה

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

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

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

דרישות מוקדמות

כדי לעקוב אחר מדריך זה, תזדקק:

מכונה מקומית או שרת פיתוח הפועל על Ubuntu 18.04. מכונת הפיתוח שלך צריכה להכיל משתמש לא-שורתי עם הרשאות מנהל ודלפק מוגדר עם ufw. להוראות כיצד להגדיר זאת, עיין במדריך הגדרת שרת התחלתית עם Ubuntu 18.04 שלנו.
Node.js ו-npm מותקנים על המכונה המקומית שלך או שרת הפיתוח. מדריך זה משתמש בגרסת Node.js 10.16.3 ו-npm גרסה 6.9.0. להדרכה בהתקנת Node.js ו-npm על Ubuntu 18.04, בצע את ההוראות בסעיף "התקנה באמצעות PPA" של כיצד להתקין Node.js על Ubuntu 18.04.
Ruby, rbenv, ו-Rails מותקנים על המחשב המקומי שלך או על שרת הפיתוח, על פי שלבים 1-4 ב-כיצד להתקין Ruby on Rails עם rbenv ב-Ubuntu 18.04. מדריך זה משתמש ב-Ruby 2.5.1, rbenv 1.1.2, ו-Rails 5.2.0.

שלב 1 — התקנת SQLite3

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

ראשית, עדכן את רשימת החבילות שלך:

sudo apt update

לאחר מכן, התקן את החבילות sqlite3 ו-libsqlite3-dev:

sudo apt install sqlite3 libsqlite3-dev

זה יתקין גם את SQLite וגם את הקבצים הדרושים לפיתוח שלו.

בדוק את הגרסה כדי לאשר שההתקנה הצליחה:

sqlite3 --version

Output
3.22.0 2018-01-22 18:45:57 0c55d179733b46d8d0ba4d88e01a25e10677046ee3da1d5b1581e86726f2alt1

עם ההתקנת SQLite, אתה מוכן להתחיל לפתח את היישום שלך.

שלב 2 — יצירת פרויקט ראילס חדש

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

צור פרויקט בשם sharkapp עם הפקודה הבאה:

rails new sharkapp

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

Output     create  
     . . .
     create  Gemfile 
     . . .
      create  app 
      . . .
      create  app/controllers/application_controller.rb
      . . .
      create  app/models/application_record.rb
      . . .
      create  app/views/layouts/application.html.erb
      . . . 
      create  config
      create  config/routes.rb
      create  config/application.rb
      . . . 
      create  config/environments
      create  config/environments/development.rb
      create  config/environments/production.rb
      create  config/environments/test.rb
      . . .
      create  config/database.yml
      create  db
      create  db/seeds.rb
      . . . 
         run  bundle install
      . . . 
Bundle complete! 18 Gemfile dependencies, 78 gems now installed.
Use `bundle info [gemname]` to see where a bundled gem is installed.
      . . . 
* bin/rake: Spring inserted
* bin/rails: Spring inserted

הפלט המודגש כאן אומר לך שראילס יצר את הדברים הבאים:

Gemfile: קובץ זה מפרט את התלות בג'מי ליישום שלך. ג'מה היא חבילת תוכנה ברובי, ו-Gemfile מאפשר לך לנהל את צרכי התוכנה של הפרויקט שלך.
app: הספרייה app היא המקום בו קוד היישום העיקרי שלך חי. זה כולל את המודלים, הבקרים, התצוגות, הנכסים, העוזרים והדואר המהווים את היישום עצמו. ראילס נותן לך קוד תבנית ברמת היישום להתחיל במודל MCV בקבצים כמו app/models/application_record.rb, app/controllers/application_controller.rb, ו-app/views/layouts/application.html.erb.
config: מדריך זה מכיל את הגדרות התצורה של היישום שלך:
- config/routes.rb: הכרזות הנתיבים של היישום שלך נמצאות בקובץ זה.
- config/application.rb: הגדרות כלליות עבור רכיבי היישום שלך מוצאות בקובץ זה.
config/environments: מדריך זה הוא המקום שבו הגדרות התצורה עבור הסביבות שלך נמצאות. ריילס כוללת שלוש סביבות כברירת מחדל: development, production, ו-test.
config/database.yml: הגדרות התצורה של מסד הנתונים נמצאות בקובץ זה, שמחולק לארבע סעיפים: default, development, production, ו-test. הודות לקובץ Gemfile שהגיע עם הפקודה rails new, שכללה את הג'ם sqlite3, קובץ config/database.yml שלנו כבר מוגדר עם הפרמטר adapter שלו ל-sqlite3, מה שמציין שנשתמש במסד נתונים SQLite עם היישום הזה.
db: תיקייה זו כוללת ספריית עבור עדכוני מסד נתונים הנקראת migrate, יחד עם קבצי schema.rb ו-seeds.rb. schema.db מכיל מידע על מסד הנתונים שלך, בעוד ש-seeds.rb הוא המקום שבו תוכל להכניס נתוני זרעים למסד הנתונים.

לבסוף, Rails מריץ את הפקודה bundle install כדי להתקין את התלות המופיעות ב-Gemfile שלך.

לאחר שהכל מוכן, נווט לתיקיית sharkapp:

cd sharkapp

עכשיו אתה יכול להפעיל את שרת Rails כדי לוודא שהיישום שלך פועל, באמצעות הפקודה rails server. אם אתה עובד על המחשב המקומי שלך, הקלד:

rails server

Rails מקשר ל-localhost כברירת מחדל, כך שתוכל כעת לגשת ליישום שלך על ידי ניווט לדפדפן שלך ל-locahost:3000, שם תראה את התמונה הבאה:

אם אתה עובד על שרת פיתוח, תחילה ודא שהחיבורים מורשים בפורט 3000:

sudo ufw allow 3000

לאחר מכן הפעל את השרת עם הדגל --binding, כדי לקשר ל-IP של השרת שלך:

rails server --binding=your_server_ip

נווט ל-http://your_server_ip:3000 בדפדפן שלך, שם תראה את הודעת הברוכים של Rails.

לאחר שתבדוק סביב, תוכל לעצור את השרת עם CTRL+C.

עם היישום שלך שנוצר ובמקום, אתה מוכן להתחיל לבנות מתבנית ה-Rails ליצירת יישום ייחודי.

שלב 3 — יצירת מבנה היישום

כדי ליצור את יישום מידע הכריזית שלנו, נצטרך ליצור מודל לניהול נתוני היישום שלנו, תצוגות לאפשר אינטראקציה משתמש עם הנתונים האלה, ובקר לניהול התקשורת בין המודל לתצוגות. כדי לבנות את הדברים האלה נשתמש בפקודה rails generate scaffold, שתיתן לנו מודל, העברת מסד נתונים לשינוי סכמת המסד הנתונים, בקר, ערכת מלאה של תצוגות לניהול יצירה, קריאה, עדכון ומחיקה (CRUD) עבור היישום, ותבניות לחלקים, עוזרים ובדיקות.

בגלל שהפקודה generate scaffold עושה כל כך הרבה עבודה עבורנו, נבחן בקפידה את המשאבים שהיא יוצרת כדי להבין את העבודה ש-Rails עושה מתחת למכסה המנוע.

הפקודה generate scaffold שלנו תכלול את שם המודל שלנו ואת השדות שאנו רוצים בטבלת המסד נתונים שלנו. ריילס משתמשת ב-Active Record כדי לנהל מערכות יחסים בין נתוני היישום, שמורכבים כאובייקטים עם מודלים, לבין מסד הנתונים של היישום. כל אחד מהמודלים שלנו הוא מחלקת Ruby, וכן גם יורשת מהמחלקה ActiveRecord::Base. זה אומר שאנחנו יכולים לעבוד עם מחלקת המודל שלנו באותו אופן שבו היינו עובדים עם מחלקת Ruby, תוך כדי שאנו משיגים גם שיטות מ-Active Record. Active Record יבטיח שכל מחלקה תמפה לטבלה במסד הנתונים שלנו, וכל מופע של מחלקה זו לשורה בטבלה זו.

הקלד את הפקודה הבאה כדי ליצור מודל Shark, בקר ותצוגות משויכות:

rails generate scaffold Shark name:string facts:text

עם name:string ו-facts:text אנו מספקים לריילס מידע על השדות שאנו רוצים בטבלת המסד נתונים שלנו ועל סוג הנתונים שהם צריכים לקבל. שניהם יספקו לנו מקום להזין מה שאנו רוצים, אם כי text יאפשר יותר תווים לעובדות על כרישים.

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

Output      invoke  active_record
      create    db/migrate/20190804181822_create_sharks.rb
      create    app/models/shark.rb
      . . .
      invoke  resource_route
       route    resources :sharks
      invoke  scaffold_controller
      create    app/controllers/sharks_controller.rb
      invoke    erb
      create      app/views/sharks
      create      app/views/sharks/index.html.erb
      create      app/views/sharks/edit.html.erb
      create      app/views/sharks/show.html.erb
      create      app/views/sharks/new.html.erb
      create      app/views/sharks/_form.html.erb
      . . .

ריילס יצרה את המודל ב-app/models/shark.rb וגרסת מסד נתונים שתלויה בו: db/migrate/20190804181822_create_sharks.rb. הזמן המדויק בקובץ הגרסה שלך יהיה שונה ממה שאתה רואה כאן.

היא גם יצרה מגבר, app/controllers/sharks_controller.rb, כמו גם את התצוגות המשויכות לפעולות ה-CRUD של יישום האפליקציה שלנו, שנאספו תחת app/views/sharks. בין התצוגות אלה נמצאת חלקית, _form.html.erb, המכילה קוד המשמש במסגרת תצוגות שונות.

לבסוף, ריילס הוסיפה נתיב משאב חדש, resources :sharks, ל-config/routes.rb. זה מאפשר לראוטר של ריילס להתאים בקשות HTTP נכנסות למגבר sharks ולתצוגות המשויכות לו.

למרות שריילס עשתה הרבה מאוד מהעבודה של בניית קוד האפליקציה שלנו בשבילנו, כדאי להתבונן בכמה קבצים כדי להבין מה קורה.

ראשית, בואו נביט בקובץ המגבר עם הפקודה הבאה:

cat app/controllers/sharks_controller.rb

Outputclass SharksController < ApplicationController
  before_action :set_shark, only: [:show, :edit, :update, :destroy]

  # GET /sharks
  # GET /sharks.json
  def index
    @sharks = Shark.all
  end

  # GET /sharks/1
  # GET /sharks/1.json
  def show
  end

  # GET /sharks/new
  def new
    @shark = Shark.new
  end

  # GET /sharks/1/edit
  def edit
  end

  # POST /sharks
  # POST /sharks.json
  def create
    @shark = Shark.new(shark_params)

    respond_to do |format|
      if @shark.save
        format.html { redirect_to @shark, notice: 'Shark was successfully created.' }
        format.json { render :show, status: :created, location: @shark }
      else
        format.html { render :new }
        format.json { render json: @shark.errors, status: :unprocessable_entity }
      end
    end
  end

  # PATCH/PUT /sharks/1
  # PATCH/PUT /sharks/1.json
  def update
    respond_to do |format|
      if @shark.update(shark_params)
        format.html { redirect_to @shark, notice: 'Shark was successfully updated.' }
        format.json { render :show, status: :ok, location: @shark }
      else
        format.html { render :edit }
        format.json { render json: @shark.errors, status: :unprocessable_entity }
      end
    end
  end

  # DELETE /sharks/1
  # DELETE /sharks/1.json
  def destroy
    @shark.destroy
    respond_to do |format|
      format.html { redirect_to sharks_url, notice: 'Shark was successfully destroyed.' }
      format.json { head :no_content }
    end
  end

  private
    # השתמש בקולבקים לשיתוף הגדרות או הגבלות נפוצות בין פעולות.
    def set_shark
      @shark = Shark.find(params[:id])
    end

    # אף פעם אל תסמכו על פרמטרים מהאינטרנט המפחיד, אפשר רק את הרשימה הלבנה.
    def shark_params
      params.require(:shark).permit(:name, :facts)
    end
end

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

לדוגמה, שקול את המתודה create:

~/sharkapp/app/controllers/sharks_controller.rb

. . .
  def create
    @shark = Shark.new(shark_params)

    respond_to do |format|
      if @shark.save
        format.html { redirect_to @shark, notice: 'Shark was successfully created.' }
        format.json { render :show, status: :created, location: @shark }
      else
        format.html { render :new }
        format.json { render json: @shark.errors, status: :unprocessable_entity }
      end
    end
  end
. . .

אם מופע חדש של מחלקת Shark נשמר בהצלחה, redirect_to ייצור בקשה חדשה שאז תופנה לבקר. זו תהיה בקשת GET, והיא תטופל על ידי המתודה show, שתראה למשתמש את הכריש שהם פשוט הוסיפו.

אם יש כישלון, אז ריילס יעביר את התבנית app/views/sharks/new.html.erb שוב במקום לבצע בקשה נוספת לראוטר, וזה ייתן למשתמשים עוד סיכוי לשלוח את הנתונים שלהם.

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

הקלד את הדברים הבאים כדי להדפיס את הקובץ:

cat app/views/sharks/index.html.erb

Output<p id="notice"><%= notice %></p>

<h1>Sharks</h1>

<table>
  <thead>
    <tr>
      <th>Name</th>
      <th>Facts</th>
      <th colspan="3"></th>
    </tr>
  </thead>

  <tbody>
    <% @sharks.each do |shark| %>
      <tr>
        <td><%= shark.name %></td>
        <td><%= shark.facts %></td>
        <td><%= link_to 'Show', shark %></td>
        <td><%= link_to 'Edit', edit_shark_path(shark) %></td>
        <td><%= link_to 'Destroy', shark, method: :delete, data: { confirm: 'Are you sure?' } %></td>
      </tr>
    <% end %>
  </tbody>
</table>

<br>

<%= link_to 'New Shark', new_shark_path %>

תצוגת index עוברת על מופעים של מחלקת Shark שלנו, שהושוו לטבלת sharks במסד הנתונים שלנו. באמצעות ERB templating, התצוגה מוציאה כל שדה מהטבלה שמשויך למופע בודד של כריש: name ו-facts.

התצוגה משתמשת אז בסייעת link_to כדי ליצור קישור עם המחרוזת הנתונה כטקסט לקישור והנתיב הנתון כיעד. הנתיבים עצמם נעשים אפשריים בזכות helpers שהפכו לזמינים לנו כשהגדרנו את הנתיב המשאבי sharks עם הפקודה rails generate scaffold.

בנוסף לבדיקת תצוגת index שלנו, נוכל גם להתבונן בתצוגת new כדי לראות איך Rails משתמשת בחלקיות בתצוגות. הקלד את הדברים הבאים כדי להדפיס את תבנית app/views/sharks/new.html.erb:

cat app/views/sharks/new.html.erb

Output<h1>New Shark</h1>

<%= render 'form', shark: @shark %>

<%= link_to 'Back', sharks_path %>

למרות שהתבנית הזו עשויה להיראות כאילו אין בה שדות קלט לכניסה חדשה של כריש, התייחסות ל-render 'form' מגלה לנו שהתבנית משתמשת בחלק המקומי _form.html.erb, שמוציא קוד שחוזר על עצמו במספר חלונות.

הסתכלות על הקובץ הזה תיתן לנו הבנה מלאה על איך מופק מופע חדש של כריש:

cat app/views/sharks/_form.html.erb

Output<%= form_with(model: shark, local: true) do |form| %>
  <% if shark.errors.any? %>
    <div id="error_explanation">
      <h2><%= pluralize(shark.errors.count, "error") %> prohibited this shark from being saved:</h2>

      <ul>
      <% shark.errors.full_messages.each do |message| %>
        <li><%= message %></li>
      <% end %>
      </ul>
    </div>
  <% end %>

  <div class="field">
    <%= form.label :name %>
    <%= form.text_field :name %>
  </div>

  <div class="field">
    <%= form.label :facts %>
    <%= form.text_area :facts %>
  </div>

  <div class="actions">
    <%= form.submit %>
  </div>
<% end %>

התבנית הזו משתמשת בסייעת הטופס form_with ליצירת טופס. סייעות הטופסים מיועדות להקל על יצירת אובייקטים חדשים מקלט המשתמש באמצעות השדות והיקף של מודלים מסוימים. כאן, form_with מקבל כארגומנט model: shark, ואובייקט בונה הטופס החדש שהוא יוצר כולל שדות קלט המתאימים לשדות בטבלת sharks. לכן למשתמשים יש שדות טופס להזנת שם ועובדות על כריש.

הגשת הטופס הזה תיצור תגובת JSON עם נתוני המשתמש ששאר היישום יכול לגשת אליהם באמצעות שיטת הפרמטרים, שיוצרת אובייקט ActionController::Parameters עם הנתונים הללו.

עכשיו כשאתה יודע מה rails generate scaffold יצר בשבילך, אתה יכול לעבור להגדרת התצוגה הראשית עבור היישום שלך.

שלב 4 – יצירת תצוגת השורש של היישום ובדיקת פונקציונליות

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

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

כדי להגדיר זאת, תצטרך לשנות את הגדרות הניתוב בקובץ config/routes.rb כדי לציין את שורש היישום.

פתח את config/routes.rb לעריכה, באמצעות nano או העורך המועדף עליך:

nano config/routes.rb

הקובץ יראה כך:

~/sharkapp/config/routes.rb

Rails.application.routes.draw do
  resources :sharks
  # לפרטים על DSL הזמין בתוך קובץ זה, ראה http://guides.rubyonrails.org/routing.html
end

בלי להגדיר משהו ספציפי יותר, התצוגה הדיפולטיבית בכתובת http://localhost:3000 או http://your_server_ip:3000 תהיה דף הברוכים הדיפולטיבי של Rails.

כדי למפות את תצוגת השורש של היישום לתצוגת index של בקר הכרישים, תצטרך להוסיף את השורה הבאה לקובץ:

~/sharkapp/config/routes.rb

Rails.application.routes.draw do
  resources :sharks

  root 'sharks#index' 
  # לפרטים על ה-DSL הזמין בתוך הקובץ הזה, ראה http://guides.rubyonrails.org/routing.html
end

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

שמור את הקובץ וצא מהעורך שלך כשתסיים לערוך. אם השתמשת ב-nano לעריכת הקובץ, תוכל לעשות זאת על ידי הקשה על CTRL+X, Y, ואז ENTER

עכשיו תוכל להריץ את המיגרציות שלך עם הפקודה הבאה:

rails db:migrate

תראה פלט המאשר את המיגרציה.

הפעל שוב את שרת Rails שלך. אם אתה עובד מקומית, הקלד:

rails s

בשרת פיתוח, הקלד:

rails s --binding=your_server_ip

נווט ל-localhost:3000 אם אתה עובד מקומית, או ל-http://your_server_ip:3000 אם אתה עובד בשרת פיתוח.

דף הנחיתה של היישום שלך יראה ככה:

כדי ליצור כריש חדש, לחץ על הקישור New Shark בתחתית הדף, שיקח אותך לנתיב sharks/new:

בואו נוסיף מידע הדגמה כדי לבדוק את היישום שלנו. הזן "כריש לבן גדול" לתוך שדה Name ו-"מפחיד" לתוך שדה Facts:

לחץ על כפתור Create כדי ליצור את הכריש.

פעולה זו תכוון אותך לנתיב show, אשר, בזכות מסנן before_action, מוגדר עם שיטת set_shark, אשר מחזיק את ה-id של הכריש שיצרנו זה עתה:

~/sharkapp/app/controllers/sharks_controller.rb

class SharksController < ApplicationController
  before_action :set_shark, only: [:show, :edit, :update, :destroy]

  . . . 

  def show
  end

  . . . 

  private
    # השתמש בקולבקים לשיתוף הגדרות נפוצות או מגבלות בין פעולות.
    def set_shark
      @shark = Shark.find(params[:id])
    end
  . . .

אתה יכול לבדוק את הפונקציות של עריכה עכשיו על ידי לחיצה על Edit על ערכ הכריש שלך. זה יוביל אותך לנתיב edit עבור אותו כריש:

שנה את facts על הגדול הלבן לקרוא "גדול" במקום "מפחיד" ולחץ על Update Shark. זה יחזיר אותך לנתיב show:

לבסוף, לחיצה על Back תוביל אותך לתצוגת index המעודכנת שלך:

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

שלב 5 — הוספת אימותים

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

שים לב שלא נכסה כתיבת בדיקות אימות במדריך זה, אך תוכל ללמוד עוד על בדיקות על ידי ייעוץ במסמכי Rails.

אם עדיין לא עצרת את השרת, עשה זאת על ידי הקלדת CTRL+C.

פתח את קובץ המודל shark.rb שלך:

nano app/models/shark.rb

כרגע, הקובץ אומר לנו שהמחלקה Shark יורשת מ-ApplicationRecord, שבתורו יורשת מ-ActiveRecord::Base:

~/sharkapp/app/models/shark.rb

class Shark < ApplicationRecord
end

בואו נוסיף תחילה כמה אימות לשדה name שלנו כדי לוודא שהשדה מלא ושהערך הוא ייחודי, וכך נמנע כניסות כפולות:

~/sharkapp/app/models/shark.rb

class Shark < ApplicationRecord
  validates :name, presence: true, uniqueness: true
end

לאחר מכן, הוסף אימות לשדה facts כדי לוודא שגם הוא מלא:

~/sharkapp/app/models/shark.rb

class Shark < ApplicationRecord
  validates :name, presence: true, uniqueness: true
  validates :facts, presence: true
end

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

שמור וסגור את הקובץ כשתסיים.

הפעל את השרת שוב עם rails s או rails s --binding=your_server_ip, בהתאם לכך אם אתה עובד מקומית או עם שרת פיתוח.

נווט לשורש היישום שלך בכתובת http://localhost:3000 או http://your_server_ip:3000.

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

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

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

שלב 6 — הוספת אימות

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

ישנן מספר דרכים לאמת משתמשים עם Rails, כולל עבודה עם הbcrypt או devise gems. לעת עתה, עם זאת, נוסיף שיטה ל-application controller שלנו שתחול על פעולות ברחבי היישום שלנו. זה יהיה שימושי אם נוסיף עוד מספר פקודות ליישום בעתיד.

עצור את השרת שלך שוב עם CTRL+C.

פתח את הקובץ שמגדיר את ApplicationController שלך:

nano app/controllers/application_controller.rb

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

~/sharkapp/app/controllers/application_controller.rb

class ApplicationController < ActionController::Base
end

כדי לאמת משתמשים, נשתמש בשם משתמש וסיסמה קשיחים עם השיטה http_basic_authenticate_with. הוסף את הקוד הבא לקובץ:

~/sharkapp/app/controllers/application_controller.rb

class ApplicationController < ActionController::Base
  http_basic_authenticate_with name: 'sammy', password: 'shark', except: [:index, :show]
end

בנוסף לספק את שם המשתמש והסיסמה כאן, גם הגבלנו את האימות על ידי ציון הנתיבים שבהם אין לדרוש אימות: index ו-show. דרך נוספת להשיג זאת היתה לכתוב only: [:create, :update, :destroy]. בדרך זו, כל המשתמשים יוכלו להסתכל על כל הכרישים ולקרוא עובדות על כרישים מסוימים. כשזה מגיע לשינוי תוכן האתר, עם זאת, המשתמשים יצטרכו להוכיח שיש להם גישה.

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

שמור וסגור app/controllers/application_controller.rb כשתסיים לערוך. כעת תוכל לבדוק את האימות בפעולה.

הפעל את השרת עם rails s או rails s --binding=your_server_ip ונווט אל היישום שלך ב-http://localhost:3000 או http://your_server_ip:3000.

בדף הנחיתה, לחץ על כפתור New Shark. זה יפעיל את חלון האימות הבא:

אם תכניס את שילוב שם המשתמש והסיסמה שהוספת ל-app/controllers/application_controller.rb, תוכל ליצור כלים חדשים בצורה מאובטחת.

כעת יש לך יישום כלים פועל, עם אימות נתונים ותבנית אימות בסיסית.

מסקנה

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

תוכל גם ללמוד עוד על הוספת משאבים מקוננים לפרויקט שלך על ידי קריאת כיצד ליצור משאבים מקוננים עבור יישום Ruby on Rails, שיראה לך כיצד לבנות את מודלים ומסלולים של היישום שלך.

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

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

Source:
https://www.digitalocean.com/community/tutorials/how-to-build-a-ruby-on-rails-application