Ruby on Rails
रूटिंग

परिचय

टिप्पणियों

संसाधन रूटिंग (मूल)

रूट को config/routes.rb मार्गों में परिभाषित किया गया है। उन्हें अक्सर resources या resource विधियों का उपयोग करके संबंधित मार्गों के समूह के रूप में परिभाषित किया जाता है।

resources :users निम्नलिखित सात मार्गों का निर्माण करते हैं, सभी resources :users UsersController कार्यों की मैपिंग करते हैं:

get       '/users',          to: 'users#index'
post      '/users',          to: 'users#create'
get       '/users/new',      to: 'users#new'
get       '/users/:id/edit', to: 'users#edit'
get       '/users/:id',      to: 'users#show'
patch/put '/users/:id',      to: 'users#update'
delete    '/users/:id',      to: 'users#destroy'

कार्रवाई का नाम के बाद दिखाए जाते हैं # में to ऊपर पैरामीटर। उन्हीं नामों वाले तरीकों को app/controllers/users_controller.rb में निम्नानुसार परिभाषित किया जाना चाहिए:

class UsersController < ApplicationController
  def index
  end

  def create
  end

  # continue with all the other methods…
end

आप only या except उत्पन्न होने वाली क्रियाओं को सीमित कर सकते हैं:

resources :users, only:   [:show]
resources :users, except: [:show, :index]

आप किसी भी समय अपने आवेदन के सभी मार्गों को देख सकते हैं:

$ rake routes

$ rake routes
# OR
$ rails routes

users     GET    /users(.:format)          users#index
          POST   /users(.:format)          users#create
new_user  GET    /users/new(.:format)      users#new
edit_user GET    /users/:id/edit(.:format) users#edit
user      GET    /users/:id(.:format)      users#show
          PATCH  /users/:id(.:format)      users#update
          PUT    /users/:id(.:format)      users#update
          DELETE /users/:id(.:format)      users#destroy

केवल उन मार्गों को देखने के लिए जो किसी विशेष नियंत्रक को मैप करते हैं:

$ rake routes -c static_pages
static_pages_home    GET    /static_pages/home(.:format)    static_pages#home
static_pages_help    GET    /static_pages/help(.:format)    static_pages#help

$ rake routes -c static_pages
static_pages_home    GET    /static_pages/home(.:format)    static_pages#home
static_pages_help    GET    /static_pages/help(.:format)    static_pages#help

# OR

$ rails routes -c static_pages
static_pages_home    GET    /static_pages/home(.:format)    static_pages#home
static_pages_help    GET    /static_pages/help(.:format)    static_pages#help

आप -g विकल्प का उपयोग करके मार्गों के माध्यम से खोज कर सकते हैं। यह किसी भी मार्ग को दिखाता है जो आंशिक रूप से सहायक विधि के नाम, URL पथ या HTTP क्रिया से मेल खाता है:

$ rake routes -g new_user     # Matches helper method
$ rake routes -g POST         # Matches HTTP Verb POST 

$ rake routes -g new_user     # Matches helper method
$ rake routes -g POST         # Matches HTTP Verb POST 
# OR
$ rails routes -g new_user    # Matches helper method
$ rails routes -g POST        # Matches HTTP Verb POST 

इसके अतिरिक्त, जब विकास मोड में rails सर्वर चल रहा होता है, तो आप एक वेब पेज का उपयोग कर सकते हैं, जो आपके सभी मार्गों को खोज फ़िल्टर के साथ दिखाता है, प्राथमिकता में ऊपर से नीचे <hostname>/rails/info/routes मेल खाता है। यह इस तरह दिखेगा:

मार्गों केवल सदस्यों (न संग्रह) विधि का उपयोग कर के लिए उपलब्ध घोषित किया जा सकता resource के बजाय resources में routes.rb । resource साथ, एक index मार्ग डिफ़ॉल्ट रूप से नहीं बनाया जाता है, लेकिन केवल जब स्पष्ट रूप से इस तरह से एक के लिए पूछ रहा है:

resource :orders, only: [:index, :create, :show]

प्रतिबन्ध

आप फ़िल्टर कर सकते हैं कि कौन से मार्ग बाधाओं का उपयोग करके उपलब्ध हैं।

बाधाओं का उपयोग करने के कई तरीके हैं:

• खंड बाधाएं ,
• अनुरोध आधारित बाधाओं
• उन्नत बाधाओं

उदाहरण के लिए, केवल मार्ग का उपयोग करने के लिए एक विशिष्ट आईपी पते की अनुमति देने के लिए एक अनुरोध आधारित बाधा:

constraints(ip: /127\.0\.0\.1$/) do
  get 'route', to: "controller#action"
end

इसी तरह के अन्य उदाहरण देखें ActionDispatch :: रूटिंग :: मैपर :: स्कोपिंग ।

यदि आप कुछ अधिक जटिल करना चाहते हैं तो आप अधिक उन्नत बाधाओं का उपयोग कर सकते हैं और तर्क को लपेटने के लिए एक वर्ग बना सकते हैं:

# lib/api_version_constraint.rb
class ApiVersionConstraint
  def initialize(version:, default:)
    @version = version
    @default = default
  end

  def version_header
    "application/vnd.my-app.v#{@version}"
  end

  def matches?(request)
    @default || request.headers["Accept"].include?(version_header)
  end
end

# config/routes.rb
require "api_version_constraint"

Rails.application.routes.draw do
  namespace :v1, constraints: ApiVersionConstraint.new(version: 1, default: true) do
    resources :users # Will route to app/controllers/v1/users_controller.rb
  end

  namespace :v2, constraints: ApiVersionConstraint.new(version: 2) do
    resources :users # Will route to app/controllers/v2/users_controller.rb
  end
end

एक फ़ॉर्म, कई बटन सबमिट करें

आप प्रपत्र की सबमिट टैग के मूल्य को एक भिन्न क्रिया के लिए एक बाधा के रूप में भी उपयोग कर सकते हैं। यदि आपके पास कई सबमिट बटन (जैसे "पूर्वावलोकन" और "सबमिट") के साथ एक फॉर्म है, तो आप प्रपत्र गंतव्य URL को बदलने के लिए जावास्क्रिप्ट लिखने के बजाय, सीधे अपने routes.rb में इस बाधा को पकड़ सकते हैं। साथ उदाहरण के लिए commit_param_routing मणि आप रेल का लाभ ले सकते submit_tag

पहले submit_tag आपको अपने फॉर्म कमिट पैरामीटर के मूल्य को बदलने देती हैं

# app/views/orders/mass_order.html.erb
<%= form_for(@orders, url: mass_create_order_path do |f| %>
    <!-- Big form here -->
  <%= submit_tag "Preview" %>
  <%= submit_tag "Submit" %>
  # => <input name="commit" type="submit" value="Preview" />
  # => <input name="commit" type="submit" value="Submit" />
  ...
<% end %>

# config/routes.rb
resources :orders do
  # Both routes below describe the same POST URL, but route to different actions 
  post 'mass_order', on: :collection, as: 'mass_order',
    constraints: CommitParamRouting.new('Submit'), action: 'mass_create' # when the user presses "submit"
  post 'mass_order', on: :collection,
    constraints: CommitParamRouting.new('Preview'), action: 'mass_create_preview' # when the user presses "preview"
  # Note the `as:` is defined only once, since the path helper is mass_create_order_path for the form url
  # CommitParamRouting is just a class like ApiVersionContraint
end

स्कोपिंग रूट

रेल आपके मार्गों को व्यवस्थित करने के कई तरीके प्रदान करती है।

URL द्वारा स्कोप :

scope 'admin' do
  get 'dashboard', to: 'administration#dashboard'
  resources 'employees'
end

यह निम्नलिखित मार्ग उत्पन्न करता है

get       '/admin/dashboard',          to: 'administration#dashboard'
post      '/admin/employees',          to: 'employees#create'
get       '/admin/employees/new',      to: 'employees#new'
get       '/admin/employees/:id/edit', to: 'employees#edit'
get       '/admin/employees/:id',      to: 'employees#show'
patch/put '/admin/employees/:id',      to: 'employees#update'
delete    '/admin/employees/:id',      to: 'employees#destroy'

यह अधिक विचार कर सकता है, सर्वर साइड पर, कुछ विचारों को एक अलग सबफ़ोल्डर में रखने के लिए, उपयोगकर्ता के विचारों से व्यवस्थापक विचारों को अलग करने के लिए।

मॉड्यूल द्वारा स्कोप

scope module: :admin do
  get 'dashboard', to: 'administration#dashboard'
end

module दिए गए नाम के सबफ़ोल्डर के तहत नियंत्रक फ़ाइलों की तलाश करता है

get       '/dashboard',          to: 'admin/administration#dashboard'

आप एक पैरामीटर के as जोड़कर उपसर्ग सहायक का नाम बदल सकते हैं

scope 'admin', as: :administration do
  get 'dashboard'
end

# => administration_dashboard_path

रेल namespace विधि का उपयोग करके उपरोक्त सभी को करने का एक सुविधाजनक तरीका प्रदान करता है। निम्नलिखित घोषणाएं बराबर हैं

namespace :admin do
end

scope 'admin', module: :admin, as: :admin

नियंत्रक द्वारा स्कोप

scope controller: :management do
  get 'dashboard'
  get 'performance'
end

इससे ये मार्ग उत्पन्न होते हैं

get       '/dashboard',          to: 'management#dashboard'
get       '/performance',        to: 'management#performance'

उथला घोंसला

संसाधन मार्ग एक :shallow विकल्प को स्वीकार करते हैं जो URL को जहाँ संभव हो छोटा करने में मदद करता है। संसाधनों को एक से अधिक स्तर पर नेस्टेड नहीं किया जाना चाहिए। इससे बचने का एक तरीका उथले मार्ग बनाना है। लक्ष्य माता-पिता के संग्रह सेगमेंट को छोड़ना है जहां उनकी आवश्यकता नहीं है। अंतिम परिणाम यह है कि उत्पन्न केवल नेस्टेड मार्ग :index :create , और :new कार्य। बाकी अपने स्वयं के उथले URL संदर्भ में रखे गए हैं। कस्टम उथले मार्गों के लिए दो विकल्प हैं:

• : उथला_पथ : निर्दिष्ट पैरामीटर के साथ सदस्य पथ को उपसर्ग करता है

  scope shallow_path: "sekret" do
    resources :articles do
      resources :comments, shallow: true
    end
  end
  

• : shallow_prefix : नामित सहायकों के लिए निर्दिष्ट पैरामीटर जोड़ें

  scope shallow_prefix: "sekret" do
    resources :articles do
      resources :comments, shallow: true
    end
  end
  

हम shallow मार्गों को और अधिक करके भी बता सकते हैं:

resources :auctions, shallow: true do
  resources :bids do
   resources :comments
  end
end 

वैकल्पिक रूप से निम्नानुसार कोडित (यदि आप ब्लॉक-खुश हैं):

resources :auctions do
 shallow do
   resources :bids do
     resources :comments
   end
 end
end

परिणामी मार्ग निम्न हैं:

यदि आप ध्यान से उत्पन्न मार्गों का विश्लेषण करते हैं, तो आप देखेंगे कि URL के नेस्टेड भाग केवल तभी शामिल किए जाते हैं जब उन्हें यह निर्धारित करने की आवश्यकता होती है कि किस डेटा को प्रदर्शित करना है।

चिंताओं

नेस्टेड मार्गों में पुनरावृत्ति से बचने के लिए, चिंताओं को साझा करने वाले सामान्य संसाधनों को साझा करने का एक शानदार तरीका प्रदान करता है। बनाने के लिए एक चिंता का विषय विधि का उपयोग concern भीतर routes.rb फ़ाइल। विधि एक प्रतीक और ब्लॉक की उम्मीद करती है:

concern :commentable do
  resources :comments
end

किसी भी मार्ग का निर्माण न करते हुए, यह कोड संसाधन पर :concerns विशेषता का उपयोग करने की अनुमति देता है। सबसे सरल उदाहरण होगा:

resource :page, concerns: :commentable

समतुल्य नेस्टेड संसाधन इस तरह दिखेगा:

resource :page do
  resource :comments
end

यह, उदाहरण के लिए, निम्नलिखित मार्गों का निर्माण करेगा:

/pages/#{page_id}/comments
/pages/#{page_id}/comments/#{comment_id}

चिंताओं के सार्थक होने के लिए, ऐसे कई संसाधन होने चाहिए जो चिंता का उपयोग करें। अतिरिक्त संसाधन चिंता को बुलाने के लिए निम्नलिखित सिंटैक्स में से किसी का उपयोग कर सकते हैं:

resource :post, concerns: %i(commentable)
resource :blog do
  concerns :commentable
end

पुनर्निर्देशन

आप रेल मार्गों में पुनर्निर्देशन निम्नानुसार कर सकते हैं:

get '/stories', to: redirect('/posts')

match "/abc" => redirect("http://example.com/abc")

आप सभी अज्ञात मार्गों को किसी दिए गए पथ पर पुनर्निर्देशित कर सकते हैं:

match '*path' => redirect('/'), via: :get
# or
get '*path' => redirect('/')

match '*path' => redirect('/')

सदस्य और संग्रह मार्ग

किसी संसाधन के अंदर एक सदस्य ब्लॉक को परिभाषित करना एक ऐसा मार्ग बनाता है जो उस संसाधन-आधारित मार्ग के एक व्यक्तिगत सदस्य पर कार्य कर सकता है:

resources :posts do
  member do
    get 'preview'
  end
end

यह निम्नलिखित सदस्य मार्ग उत्पन्न करता है:

get '/posts/:id/preview', to: 'posts#preview'
# preview_post_path

संग्रह मार्ग वे मार्ग बनाने की अनुमति देते हैं जो संसाधन वस्तुओं के संग्रह पर कार्य कर सकते हैं:

resources :posts do
  collection do
    get 'search'
  end
end

यह निम्नलिखित संग्रह मार्ग उत्पन्न करता है:

get '/posts/search', to: 'posts#search'
# search_posts_path

एक वैकल्पिक वाक्यविन्यास:

resources :posts do
  get 'preview', on: :member
  get 'search',  on: :collection
end

एक अवधि के साथ URL पारमेस

यदि आप एक आईडी संख्या से अधिक जटिल यूआरएल का समर्थन करना चाहते हैं, तो मान अवधि में शामिल होने पर आप पार्सर के साथ परेशानी में पड़ सकते हैं। एक अवधि के बाद कुछ भी एक प्रारूप (यानी json, xml) माना जाएगा।

आप स्वीकृत इनपुट को व्यापक बनाने के लिए एक बाधा का उपयोग करके इस सीमा के आसपास काम कर सकते हैं।

उदाहरण के लिए, यदि आप url में ईमेल पते द्वारा उपयोगकर्ता रिकॉर्ड को संदर्भित करना चाहते हैं:

resources :users, constraints: { id: /.*/ }

रूट रूट

आप root विधि के साथ अपने ऐप में एक होम पेज रूट जोड़ सकते हैं।

# config/routes.rb
Rails.application.routes.draw do
  root "application#index"
  # equivalent to:
  # get "/", "application#index"  
end

# app/controllers/application_controller.rb
class ApplicationController < ActionController::Base
  def index
    render "homepage"
  end
end

और टर्मिनल में, rake routes ( rails routes 5 में रेल) का उत्पादन करेगा:

root     GET    /         application#index

क्योंकि मुखपृष्ठ आमतौर पर सबसे महत्वपूर्ण मार्ग है, और मार्गों को उनके द्वारा दिखाई देने वाले क्रम में प्राथमिकता दी जाती है, root रूट आमतौर पर आपके रूट फ़ाइल में पहले होना चाहिए।

अतिरिक्त उत्साहजनक कार्य

resources :photos do
  member do
    get 'preview'
  end
  collection do
    get 'dashboard'
  end
end

यह डिफ़ॉल्ट 7 रिस्टफुल मार्गों के अलावा निम्नलिखित मार्ग बनाता है:

get       '/photos/:id/preview',          to: 'photos#preview'
get       '/photos/dashboards',           to: 'photos#dashboard'

यदि आप एकल लाइनों के लिए ऐसा करना चाहते हैं, तो आप इसका उपयोग कर सकते हैं:

resources :photos do
  get 'preview',   on: :member
  get 'dashboard', on: :collection
end

आप /new पथ में एक क्रिया भी जोड़ सकते हैं:

resources :photos do
  get 'preview', on: :new
end

जो बनाएगा:

get       '/photos/new/preview',          to: 'photos#preview'

अपने Restful मार्गों पर कार्रवाई जोड़ते समय ध्यान रखें, शायद आप किसी अन्य संसाधन को याद कर रहे हैं!

स्कोप उपलब्ध स्थान

यदि आपका एप्लिकेशन विभिन्न भाषाओं में उपलब्ध है, तो आप आमतौर पर URL में वर्तमान स्थान दिखाते हैं।

scope '/(:locale)', locale: /#{I18n.available_locales.join('|')}/ do
    root 'example#root'
    # other routes
end

आपकी जड़ I18n.available_locales में परिभाषित स्थानों के माध्यम से सुलभ होगी।

एक और एप्लिकेशन माउंट करें

माउंट का उपयोग वर्तमान एप्लिकेशन के भीतर उपयोग किए जाने वाले किसी अन्य एप्लिकेशन (मूल रूप से रैक एप्लिकेशन) या रेल इंजन को माउंट करने के लिए किया जाता है

वाक्य - विन्यास:

mount SomeRackApp, at: "some_route"

अब आप रूट हेल्पर some_rack_app_path या some_rack_app_url का उपयोग करके माउंट किए गए एप्लिकेशन तक पहुंच सकते हैं।

लेकिन अगर आप इस सहायक नाम को बदलना चाहते हैं, तो आप इसे इस प्रकार कर सकते हैं:

mount SomeRackApp, at: "some_route", as: :myapp

यह myapp_path और myapp_url myapp_path को उत्पन्न करेगा जिसका उपयोग इस माउंटेड ऐप पर नेविगेट करने के लिए किया जा सकता है।

पुनर्निर्देश और वाइल्डकार्ड रूट

यदि आप अपने उपयोगकर्ता के लिए सुविधा से एक URL प्रदान करना चाहते हैं, लेकिन इसे सीधे उस दूसरे पर मैप करें जिसे आप पहले से उपयोग कर रहे हैं। एक रीडायरेक्ट का उपयोग करें:

# config/routes.rb
TestApp::Application.routes.draw do
  get 'courses/:course_name' => redirect('/courses/%{course_name}/lessons'), :as => "course"
end

खैर, यह तेजी से दिलचस्प हो गया। यहाँ मूल सिद्धांत सिर्फ एक मार्ग को दूसरे मार्ग पर भेजने के लिए #redirect विधि का उपयोग करना है। यदि आपका मार्ग काफी सरल है, तो यह वास्तव में सीधा तरीका है। लेकिन अगर आप मूल मापदंडों को भी भेजना चाहते हैं, तो आपको %{here} पैरामीटर को कैप्चर करके जिम्नास्टिक करने की आवश्यकता है। सब कुछ के आसपास एकल उद्धरण नोट करें।

ऊपर के उदाहरण में, हमने एक उपनाम के साथ: के रूप में पैरामीटर का उपयोग करके सुविधा के लिए मार्ग का नाम बदल दिया है। इससे हम उस नाम का उपयोग कर सकते हैं जैसे #_पथ सहायक। फिर से, प्रश्नों के साथ अपने $ rake routes परीक्षण करें।

एकाधिक फ़ाइलों में मार्गों को विभाजित करें

यदि आपकी रूट फ़ाइल बहुत बड़ी है, तो आप अपने रूट को कई फाइलों में डाल सकते हैं और प्रत्येक फाइल को रूबी की आवश्यकता के साथ require_relative :

YourAppName::Application.routes.draw do
  require_relative 'routes/admin_routes'
  require_relative 'routes/sidekiq_routes'
  require_relative 'routes/api_routes'
  require_relative 'routes/your_app_routes'
end

YourAppName::Application.routes.draw do
  namespace :api do
    # ...
  end
end

नेस्टेड रूट्स

आप नेस्टेड मार्गों को जोड़ना चाहते हैं आप में निम्न कोड लिख सकते हैं routes.rb फ़ाइल।

resources :admins do
  resources :employees
end

यह निम्नलिखित मार्ग उत्पन्न करेगा:

     admin_employees GET      /admins/:admin_id/employees(.:format)            employees#index
                     POST     /admins/:admin_id/employees(.:format)            employees#create
  new_admin_employee GET      /admins/:admin_id/employees/new(.:format)        employees#new
 edit_admin_employee GET      /admins/:admin_id/employees/:id/edit(.:format)   employees#edit
      admin_employee GET      /admins/:admin_id/employees/:id(.:format)        employees#show
                     PATCH    /admins/:admin_id/employees/:id(.:format)        employees#update
                     PUT      /admins/:admin_id/employees/:id(.:format)        employees#update
                     DELETE   /admins/:admin_id/employees/:id(.:format)        employees#destroy
              admins GET      /admins(.:format)                                admins#index
                     POST     /admins(.:format)                                admins#create
           new_admin GET      /admins/new(.:format)                            admins#new
          edit_admin GET      /admins/:id/edit(.:format)                       admins#edit
               admin GET      /admins/:id(.:format)                            admins#show
                     PATCH    /admins/:id(.:format)                            admins#update
                     PUT      /admins/:id(.:format)                            admins#update
                     DELETE   /admins/:id(.:format)                            admins#destroy