रूबी ऑन रेल्स - क्विक गाइड

रूबी क्या है?

इससे पहले कि हम रेल पर सवार हों, हम रूबी के कुछ बिंदुओं को याद करें, जो रेल का आधार है।

रूबी का सफल संयोजन है -

स्मालटाक की वैचारिक लालित्य,
पायथन के उपयोग और सीखने में आसानी, और
पर्ल की व्यावहारिकता।

रूबी है -

एक उच्च स्तरीय प्रोग्रामिंग भाषा।
Perl, Python, Tcl / TK की तरह व्याख्या की गई।
स्मॉलटॉक, एफिल, एडा, जावा जैसी ऑब्जेक्ट-ओरिएंटेड।

क्यों रूबी?

रूबी की उत्पत्ति जापान में हुई थी और अब यह अमेरिका और यूरोप में भी लोकप्रियता हासिल कर रही है। निम्नलिखित कारक इसकी लोकप्रियता के लिए योगदान करते हैं -

सीखने में आसान
खुला स्रोत (बहुत उदार लाइसेंस)
समृद्ध पुस्तकालय
विस्तारित करने के लिए बहुत आसान है
सचमुच वस्तु उन्मुख
कम बग के साथ कम कोडिंग
मददगार समुदाय

हालांकि हमारे पास रूबी का उपयोग करने के कई कारण हैं, लेकिन कुछ कमियां भी हैं जिन्हें आपको रूबी लागू करने से पहले विचार करना पड़ सकता है -

Performance Issues - हालांकि यह पर्ल और पायथन को टक्कर देता है, यह अभी भी एक व्याख्या की गई भाषा है और हम इसकी उच्च स्तरीय प्रोग्रामिंग भाषाओं जैसे C या C ++ से तुलना नहीं कर सकते हैं।
Threading model- रूबी में देशी धागों का इस्तेमाल नहीं किया गया है। रूबी थ्रेड्स को देशी OS थ्रेड्स के रूप में चलाने के बजाय VM में सिम्युलेटेड किया जाता है।

नमूना रूबी कोड

यहाँ "हैलो रूबी" प्रिंट करने के लिए एक नमूना रूबी कोड है

# The Hello Class
class Hello
   
   def initialize( name )
      @name = name.capitalize
   end

   def salute
      puts "Hello #{@name}!"
   end
   
end

# Create a new object
h = Hello.new("Ruby")

# Output "Hello Ruby!"
h.salute

Output - यह निम्नलिखित परिणाम का उत्पादन करेगा -

Hello Ruby!

रूबी एंबेडेड

रूबी एक प्रोग्राम प्रदान करता है जिसे ईआरबी (एंबेडेड रूबी) कहा जाता है, जिसे सेकी मासातोशी ने लिखा है । ईआरबी आपको एक HTML फ़ाइल के अंदर रूबी कोड डालने की अनुमति देता है। ईआरबी साथ-साथ पढ़ता है, शब्द के लिए शब्द, और फिर एक निश्चित बिंदु पर, जब यह दस्तावेज़ में एम्बेडेड रूबी कोड का सामना करता है, तो यह रूबी कोड को निष्पादित करना शुरू कर देता है।

ईआरबी दस्तावेज तैयार करने के लिए आपको केवल दो चीजों को जानना होगा -

यदि आप कुछ रूबी कोड निष्पादित करना चाहते हैं, तो इसे बीच में संलग्न करें <% तथा %>.
यदि आप चाहते हैं कि आउटपुट के एक भाग के रूप में कोड निष्पादन का परिणाम प्रिंट हो जाए, तो कोड को बीच में संलग्न करें <%= तथा %>।

यहाँ एक उदाहरण है। Erbdemo.rb फ़ाइल में कोड सहेजें। ध्यान दें कि एक रूबी फ़ाइल में एक एक्सटेंशन होगा.rb -

<% page_title = "Demonstration of ERB" %>
<% salutation = "Dear programmer," %>

<html>

   <head>
      <title><%= page_title %></title>
   </head>
	
   <body>
      <p><%= salutation %></p>
      <p>This is an example of how ERB fills out a template.</p>
   </body>
	
</html>

अब, कमांड-लाइन उपयोगिता का उपयोग करके प्रोग्राम को चलाएं erb।

tp> erb erbdemo.rb

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

<html>

   <head>
      <title>Demonstration of ERb</title>
   </head>
	
   <body>
      <p>Dear programmer,</p>
      <p>This is an example  of how ERb fills out a template.</p>
   </body>
	
</html>

रेल क्या है?

एक अत्यंत उत्पादक वेब-अनुप्रयोग रूपरेखा।
डेविड हेनीमियर हैन्सन द्वारा रूबी में लिखा गया।
आप एक विशिष्ट जावा फ्रेमवर्क के साथ रेल से कम से कम दस गुना तेजी से एक वेब एप्लिकेशन विकसित कर सकते हैं।
डेटाबेस-समर्थित वेब अनुप्रयोगों के विकास के लिए एक खुला स्रोत रूबी ढांचा।
डेटाबेस स्कीमा के साथ अपने कोड को कॉन्फ़िगर करें।
कोई संकलन चरण की आवश्यकता नहीं है।

फुल स्टैक फ्रेमवर्क

मॉडल-व्यू-कंट्रोलर पैटर्न का उपयोग करके डेटाबेस-संचालित वेब एप्लिकेशन बनाने के लिए आवश्यक सभी चीजें शामिल हैं।
पूर्ण-स्टैक फ्रेमवर्क होने का मतलब है कि सभी परतें कम कोड के साथ एक साथ काम करने के लिए बनाई गई हैं।
अन्य रूपरेखाओं की तुलना में कोड की कम लाइनों की आवश्यकता होती है।

कॉन्फिगरेशन पर सम्मलेन

सम्मेलनों, प्रतिबिंब और गतिशील रनटाइम एक्सटेंशन के पक्ष में कॉन्फ़िगरेशन फ़ाइलों को दूर करता है।
आपके एप्लिकेशन कोड और आपके रनिंग डेटाबेस में पहले से ही वह सब कुछ है, जो रेल को पता होना चाहिए!

रेल की ताकत

पटरियों को उन विशेषताओं से भरा जाता है जो आपको अधिक उत्पादक बनाते हैं, जिनमें से कई निम्न विशेषताएं एक दूसरे पर निर्माण करती हैं।

Metaprogramming

जहां अन्य फ्रेमवर्क खरोंच से व्यापक कोड पीढ़ी का उपयोग करते हैं, रेल फ्रेमवर्क प्रोग्राम लिखने के लिए मेटाप्रोग्रामिंग तकनीकों का उपयोग करता है। रूबी मेटाप्रोग्रामिंग के लिए सबसे अच्छी भाषाओं में से एक है, और रेल इस क्षमता का अच्छी तरह से उपयोग करती है। रेल भी कोड पीढ़ी का उपयोग करती है, लेकिन भारी उठाने के लिए मेटाप्रोग्रामिंग पर बहुत अधिक निर्भर करती है।

सक्रिय रिकॉर्ड

रेल सक्रिय अभिलेख ढांचे का परिचय देती है, जो डेटाबेस में वस्तुओं को बचाता है। सक्रिय रिकॉर्ड के रेल संस्करण एक डेटाबेस स्कीमा में कॉलम को पता चलता है और स्वचालित रूप से मेटाप्रोग्रामिंग का उपयोग करके उन्हें आपके डोमेन ऑब्जेक्ट से जोड़ देता है।

कॉन्फिगरेशन पर सम्मलेन

.NET या Java के लिए अधिकांश वेब डेवलपमेंट फ्रेमवर्क आपको कॉन्फ़िगरेशन कोड के पेज लिखने के लिए मजबूर करते हैं। यदि आप सुझाए गए नामकरण सम्मेलनों का पालन करते हैं, तो रेल को बहुत अधिक कॉन्फ़िगरेशन की आवश्यकता नहीं है।

मचान

आप अक्सर एप्लिकेशन को जल्दी से प्राप्त करने में मदद करने के लिए विकास के शुरुआती चरणों में अस्थायी कोड बनाते हैं और देखते हैं कि प्रमुख घटक एक साथ कैसे काम करते हैं। रेल स्वचालित रूप से आप की जरूरत मचान के बहुत बनाता है।

अंतर्निहित परीक्षण

रेल सरल स्वचालित परीक्षण बनाती है जिसे आप बाद में बढ़ा सकते हैं। रेल्स को सहायक कोड और जुड़नार भी कहा जाता है जो परीक्षण मामलों को लिखने और चलाने में आसान बनाते हैं। रूबी तब रेक उपयोगिता के साथ अपने सभी स्वचालित परीक्षणों को निष्पादित कर सकती है।

तीन वातावरण

रेल आपको तीन डिफ़ॉल्ट वातावरण देती है: विकास, परीक्षण और उत्पादन। प्रत्येक थोड़ा अलग ढंग से व्यवहार करता है, जिससे आपका संपूर्ण सॉफ्टवेयर विकास चक्र आसान हो जाता है। उदाहरण के लिए, रेल प्रत्येक परीक्षण चलाने के लिए परीक्षण डेटाबेस की एक नई प्रतिलिपि बनाता है।

रूबी फ्रेमवर्क पर रूबी का उपयोग करके एक वेब एप्लिकेशन विकसित करने के लिए, आपको निम्न सॉफ़्टवेयर स्थापित करने की आवश्यकता है -

Ruby
रेल की रूपरेखा
एक वेब सर्वर
एक डेटाबेस सिस्टम

हम मानते हैं कि आपने पहले ही अपने कंप्यूटर पर एक वेब सर्वर और एक डेटाबेस सिस्टम स्थापित किया है। आप वेबब्रिक वेब सर्वर का उपयोग कर सकते हैं, जो रूबी के साथ आता है। हालाँकि अधिकांश वेबसाइटें उत्पादन में Apache या lightTPD वेब सर्वर का उपयोग करती हैं।

रेल कई डेटाबेस सिस्टम के साथ काम करता है, जिसमें MySQL, PostgreSQL, SQLite, Oracle, DB2 और SQL Server शामिल हैं। कृपया अपने डेटाबेस को सेट करने के लिए एक संबंधित डेटाबेस सिस्टम सेटअप मैनुअल देखें।

आइए विंडोज और लिनक्स पर रेल के लिए इंस्टॉलेशन निर्देशों को देखें।

विंडोज पर स्थापना अधिष्ठापन

रूबी ऑन रेल्स को स्थापित करने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: रूबी संस्करण की जाँच करें

पहले, जांचें कि क्या आपके पास पहले से ही रूबी स्थापित है। कमांड प्रॉम्प्ट खोलें और टाइप करेंruby -v। यदि रूबी जवाब देती है, और यदि यह 2.2.2 या उससे ऊपर के संस्करण की संख्या दिखाता है, तो टाइप करेंgem --version। यदि आपको कोई त्रुटि नहीं मिलती है, तो छोड़ेंInstall Rubyकदम। अन्यथा, हम एक ताजा रूबी स्थापित करेंगे।

चरण 2: रूबी स्थापित करें

यदि रूबी स्थापित नहीं है, तो से एक इंस्टॉलेशन पैकेज डाउनलोड करें rubyinstaller.org। का पालन करेंdownloadलिंक करें, और परिणामी इंस्टॉलर को चलाएं। यह एक exe फाइल हैrubyinstaller-2.2.2.x.exeऔर एक क्लिक में स्थापित हो जाएगा। यह एक बहुत छोटा पैकेज है, और आपको इस पैकेज के साथ रूबीगेम्स भी मिलेंगे। कृपया जाँच करेंRelease Notes अधिक विस्तार के लिए।

चरण 3: रेल स्थापित करें

Install Rails - रूबीमेम के लोड होने पर, आप कमांड लाइन के माध्यम से निम्न आदेश का उपयोग करके सभी रेल और उसकी निर्भरता को स्थापित कर सकते हैं -

C:\> gem install rails

Note- उपरोक्त आदेश सभी निर्भरताओं को स्थापित करने में कुछ समय ले सकता है। सुनिश्चित करें कि रत्न निर्भरता स्थापित करते समय आप इंटरनेट से जुड़े हैं।

चरण 4: रेल संस्करण की जाँच करें

रेल संस्करण की जाँच करने के लिए निम्नलिखित कमांड का उपयोग करें।

C:\> rails -v

Output

Rails 4.2.4

बधाई हो! अब आप विंडोज पर रेल पर हैं।

Linux पर स्थापना संस्थापन

हम लिनक्स पर रूबी ऑन रेल्स का उपयोग कर स्थापित कर रहे हैं rbenv। यह एक हल्का रूबी संस्करण प्रबंधन उपकरण है। rbenv रूबी के विभिन्न संस्करणों का प्रबंधन करने के लिए एक आसान स्थापना प्रक्रिया प्रदान करता है, और रूबी अनुप्रयोगों के विकास के लिए एक ठोस वातावरण।

रूबेन टूल का उपयोग करके रूबी को पटरियों पर स्थापित करने के लिए नीचे दिए गए चरणों का पालन करें।

चरण 1: पूर्वापेक्षाएँ निर्भरताएँ स्थापित करें

सबसे पहले, हमें स्थापित करना होगा git - coreऔर कुछ रूबी निर्भरता जो रूबी को पटरियों पर स्थापित करने में मदद करती है। रेल निर्भरता का उपयोग करने के लिए निम्नलिखित कमांड का उपयोग करेंyum।

tp> sudo yum install -y git-core zlib zlib-devel gcc-c++ patch readline readline-devel libyaml-devel libffi-devel openssl-devel make bzip2 autoconf automake libtool bison curl sqlite-devel

चरण 2: स्थापित rbenv

अब हम rbenv स्थापित करेंगे और उचित पर्यावरण चर सेट करेंगे। Git रिपॉजिटरी के लिए rbenv प्राप्त करने के लिए कमांड के निम्नलिखित सेट का उपयोग करें।

tp> git clone git://github.com/sstephenson/rbenv.git .rbenv
tp> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bash_profile
tp> echo 'eval "$(rbenv init -)"' >> ~/.bash_profile tp> exec $SHELL

tp> git clone git://github.com/sstephenson/ruby-build.git ~/.rbenv/plugins/ruby-build
tp> echo 'export PATH="$HOME/.rbenv/plugins/ruby-build/bin:$PATH"' << ~/.bash_profile
tp> exec $SHELL

चरण 3: रूबी स्थापित करें

रूबी स्थापित करने से पहले, निर्धारित करें कि रूबी का कौन सा संस्करण आप स्थापित करना चाहते हैं। हम रूबी 2.2.3 स्थापित करेंगे। रूबी को स्थापित करने के लिए निम्नलिखित कमांड का उपयोग करें।

tp> rbenv install -v 2.2.3

वर्तमान रूबी संस्करण को डिफ़ॉल्ट रूप से सेट करने के लिए निम्न कमांड का उपयोग करें।

tp> rbenv global 2.2.3

रूबी संस्करण को सत्यापित करने के लिए निम्न कमांड का उपयोग करें।

tp> ruby -v

Output

ruby 2.2.3p173 (2015-08-18 revivion 51636) [X86_64-linux]

रूबी एक कीवर्ड प्रदान करता है gemसमर्थित निर्भरता स्थापित करने के लिए; हम उन्हें फोन करते हैंgems। यदि आप रूबी-रत्नों के लिए प्रलेखन स्थापित नहीं करना चाहते हैं, तो निम्न कमांड का उपयोग करें।

tp> echo "gem: --no-document" > ~/.gemrc

इसके बाद, बंडलर मणि को स्थापित करना बेहतर है, क्योंकि यह आपके एप्लिकेशन निर्भरता को प्रबंधित करने में मदद करता है। बंडल मणि स्थापित करने के लिए निम्न कमांड का उपयोग करें।

tp> gem install bundler

चरण 4: रेल स्थापित करें

रेल संस्करण 4.2.4 को स्थापित करने के लिए निम्नलिखित कमांड का उपयोग करें।

tp> install rails -v 4.2.4

रेल्स को निष्पादन योग्य बनाने के लिए निम्नलिखित कमांड का उपयोग करें।

tp> rbenv rehash

रेल संस्करण की जाँच के लिए निम्न कमांड का उपयोग करें।

tp> rails -v

Output

tp> Rails 4.2.4

रेल ढांचे पर रूबी को रेल की विशेषताओं को प्रबंधित करने के लिए जावास्क्रिप्ट रनटाइम एनवायरनमेंट (Node.js) की आवश्यकता होती है। अगला, हम देखेंगे कि हम एसेट पाइप लाइन के प्रबंधन के लिए Node.js का उपयोग कैसे कर सकते हैं जो एक रेल सुविधा है।

चरण 5: जावास्क्रिप्ट रनटाइम इंस्टॉल करें

आइए हम यम भंडार से Node.js स्थापित करें। हम EPEL yum रिपॉजिटरी से Node.js लेंगे। यम भंडार में ईपीईएल पैकेज को जोड़ने के लिए निम्नलिखित कमांड का उपयोग करें।

tp> sudo yum -y install epel-release

Node.js पैकेज को स्थापित करने के लिए निम्न कमांड का उपयोग करें।

tp> sudo yum install nodejs

बधाई हो! अब आप लिनक्स पर रेल पर हैं।

चरण 6: डेटाबेस स्थापित करें

डिफ़ॉल्ट रूप से, रेल्स sqlite3 का उपयोग करती है, लेकिन आप MySQL, PostgreSQL या अन्य RDBMS इंस्टॉल करना चाहते हैं। यह वैकल्पिक है; यदि आपके पास डेटाबेस स्थापित है, तो आप इस चरण को छोड़ सकते हैं और यह अनिवार्य नहीं है कि आपके पास रेल सर्वर स्थापित करने के लिए डेटाबेस स्थापित हो। इस ट्यूटोरियल के लिए, हम PostgreSQL डेटाबेस का उपयोग कर रहे हैं। इसलिए PostgreSQL को स्थापित करने के लिए निम्न कमांड का उपयोग करें।

tp> sudo yum install postgresql-server postgresql-contrib

एक के साथ जवाब देकर, शीघ्र स्वीकार करें y। PostgreSQl डेटाबेस क्लस्टर बनाने के लिए निम्न आदेश का उपयोग करें।

tp> sudo postgresql-setup initdb

PostgreSQL शुरू करने और सक्षम करने के लिए निम्न कमांड का उपयोग करें।

tp> sudo systemctl start postgresql
tp> sudo systemctl enable postgresql

रेल को अप-टू-डेट रखना

यह मानते हुए कि आपने RubyGems का उपयोग करके रेल स्थापित की है, इसे अद्यतन रखना अपेक्षाकृत आसान है। हम विंडोज और लिनक्स दोनों प्लेटफॉर्म में एक ही कमांड का उपयोग कर सकते हैं। निम्नलिखित कमांड का उपयोग करें -

tp> gem update rails

Output

निम्न स्क्रीनशॉट एक विंडोज कमांड प्रॉम्प्ट दिखाता है। लिनक्स टर्मिनल भी एक ही आउटपुट प्रदान करता है।

यह स्वचालित रूप से आपके रेल स्थापना को अद्यतन करेगा। अगली बार जब आप अपना आवेदन पुनः आरंभ करेंगे, तो यह रेल के इस नवीनतम संस्करण को चुन लेगा। इस कमांड का उपयोग करते समय, सुनिश्चित करें कि आप इंटरनेट से जुड़े हैं।

स्थापना सत्यापन

आप यह सत्यापित कर सकते हैं कि सब कुछ आपकी आवश्यकताओं के अनुसार सेट है या नहीं। डेमो प्रोजेक्ट बनाने के लिए निम्न कमांड का उपयोग करें।

tp> rails new demo

Output

यह एक डेमो रेल परियोजना उत्पन्न करेगा; हम इसके बारे में बाद में चर्चा करेंगे। वर्तमान में हमें यह जांचना होगा कि पर्यावरण स्थापित है या नहीं। इसके बाद, अपने मशीन पर WEBrick वेब सर्वर को चलाने के लिए निम्न कमांड का उपयोग करें।

tp> cd demo
tp> rails server

यह सर्वर शुरू करने के लिए ऑटो-कोड जनरेट करेगा

अब अपना ब्राउज़र खोलें और निम्नलिखित टाइप करें -

http://localhost:3000

यह एक संदेश प्रदर्शित करना चाहिए, कुछ ऐसा है, जैसे "आपका स्वागत है" या "बधाई"।

एक फ्रेमवर्क एक प्रोग्राम, कार्यक्रमों का सेट और / या कोड लाइब्रेरी है जो आपके लिए आपके अधिकांश एप्लिकेशन को लिखता है। जब आप एक फ्रेमवर्क का उपयोग करते हैं, तो आपका काम एप्लिकेशन के उन हिस्सों को लिखना होता है जो इसे आपके द्वारा वांछित विशिष्ट चीजें करते हैं।

जब आप एक रैल एप्लिकेशन लिखने के लिए सेट करते हैं, तो कॉन्फ़िगरेशन और अन्य हाउसकीपिंग कामों को छोड़कर, आपको तीन प्राथमिक कार्य करने होंगे -

Describe and model your application's domain- डोमेन आपके एप्लिकेशन का ब्रह्मांड है। डोमेन एक म्यूज़िक स्टोर, एक विश्वविद्यालय, एक डेटिंग सेवा, एक पता पुस्तिका या एक हार्डवेयर सूची हो सकता है। इसलिए यहां आपको यह पता लगाना होगा कि इस ब्रह्मांड में क्या संस्थाएं मौजूद हैं, और इसमें मौजूद वस्तुएं एक-दूसरे से कैसे संबंधित हैं। यह संस्थाओं और उनके संबंधों को बनाए रखने के लिए एक डेटाबेस संरचना के मॉडलिंग के बराबर है।
Specify what can happen in this domain- डोमेन मॉडल स्थिर है; आपको इसे गतिशील बनाना होगा। पतों को एक एड्रेस बुक में जोड़ा जा सकता है। म्यूजिक स्टोर से म्यूजिक स्कोर खरीदा जा सकता है। उपयोगकर्ता एक डेटिंग सेवा में लॉग इन कर सकते हैं। छात्र एक विश्वविद्यालय में कक्षाओं के लिए पंजीकरण कर सकते हैं। आपको उन सभी संभावित परिदृश्यों या क्रियाओं की पहचान करने की आवश्यकता है जो आपके डोमेन के तत्व भाग ले सकते हैं।
Choose and design the publicly available views of the domain- इस बिंदु पर, आप वेब-ब्राउज़र शब्दों में सोचना शुरू कर सकते हैं। एक बार जब आप तय कर लेते हैं कि आपके डोमेन में छात्र हैं, और वे कक्षाओं के लिए पंजीकरण कर सकते हैं, तो आप एक स्वागत योग्य पृष्ठ, एक पंजीकरण पृष्ठ और एक पुष्टिकरण पृष्ठ आदि की कल्पना कर सकते हैं। इनमें से प्रत्येक पृष्ठ, या दृश्य, उपयोगकर्ता को दिखाता है कि कैसे चीजें हैं एक निश्चित बिंदु पर खड़े हो जाओ।

उपरोक्त तीन कार्यों के आधार पर, रूबी ऑन रेल एक मॉडल / व्यू / कंट्रोलर (एमवीसी) ढांचे से संबंधित है।

रेल MVC फ्रेमवर्क पर रूबी

MOdel View Controller सिद्धांत तीन अलग लेकिन बारीकी से सहकारी उप प्रणालियों में एक आवेदन के काम को विभाजित करता है।

मॉडल (ActiveRecord)

यह ऑब्जेक्ट और डेटाबेस के बीच संबंध बनाए रखता है और सत्यापन, एसोसिएशन, लेनदेन और बहुत कुछ संभालता है।

इस सबसिस्टम को ActiveRecord लाइब्रेरी में लागू किया गया है, जो एक रिलेशनल डेटाबेस में टेबल के बीच एक इंटरफ़ेस और बाइंडिंग प्रदान करता है और डेटाबेस रिकॉर्ड्स में हेरफेर करने वाले रूबी प्रोग्राम कोड। रूबी विधि नाम स्वचालित रूप से डेटाबेस तालिकाओं के क्षेत्र नामों से उत्पन्न होते हैं।

देखें (ActionView)

यह एक विशेष प्रारूप में डेटा की एक प्रस्तुति है, जो डेटा को प्रस्तुत करने के लिए एक नियंत्रक के फैसले से ट्रिगर होता है। वे JSP, ASP, PHP जैसे स्क्रिप्ट-आधारित टेम्पलेट सिस्टम हैं, और AJAX तकनीक के साथ एकीकृत करने के लिए बहुत आसान है।

यह सबसिस्टम एक्शन व्यू लाइब्रेरी में लागू किया गया है, जो डेटा प्रस्तुति के लिए प्रस्तुति टेम्पलेट्स को परिभाषित करने के लिए एक एंबेडेड रूबी (ईआरबी) आधारित प्रणाली है। एक दृश्य के प्रदर्शन में एक रेल अनुप्रयोग परिणाम के लिए हर वेब कनेक्शन।

नियंत्रक (एक्शन कंट्रोलर)

एप्लिकेशन के भीतर सुविधा जो ट्रैफ़िक को निर्देशित करती है, एक तरफ, विशिष्ट डेटा के लिए मॉडल को क्वेरी करना, और दूसरी ओर, उस डेटा को व्यवस्थित करना (खोज करना, सॉर्ट करना, उसे संदेश देना) जो एक दिए गए दृश्य की आवश्यकताओं को पूरा करता है।

यह सबसिस्टम एक्शनकंट्रोलर में कार्यान्वित किया जाता है, जो एक डेटा ब्रोकर ActiveRecord (डेटाबेस इंटरफ़ेस) और ActionView (प्रस्तुति इंजन) के बीच बैठा है।

MVC फ्रेमवर्क का सचित्र प्रतिनिधित्व

नीचे दिए गए रूबी फ्रेमवर्क पर रूबी का एक चित्रमय प्रतिनिधित्व है -

MVC फ्रेमवर्क का निर्देशिका प्रतिनिधित्व

लिनक्स पर एक मानक, डिफ़ॉल्ट स्थापना मानकर, आप उन्हें इस तरह पा सकते हैं -

tp> cd /usr/local/lib/ruby/gems/2.2.0/gems
tp> ls

आप निम्नलिखित सहित उपनिर्देशिका देखेंगे (लेकिन सीमित नहीं) -

actionpack-x.y.z
activerecord-x.y.z
rails-x.y.z

एक विंडोज़ इंस्टॉलेशन पर, आप उन्हें इस तरह पा सकते हैं -

tp>cd ruby\lib\ruby\gems\2.2.0\gems
ruby\lib\ruby\gems\2.2.0\gems\>dir

आप निम्नलिखित सहित उपनिर्देशिका देखेंगे (लेकिन सीमित नहीं) -

ActionPack के तहत ActionView और ActionController को एक साथ बंडल किया गया है।

ActiveRecord SQL डेटाबेस से डेटा में हेरफेर करने के लिए प्रोग्रामिंग तकनीकों और शॉर्टकट की एक श्रृंखला प्रदान करता है। ActionController और ActionView उस डेटा में हेरफेर और प्रदर्शित करने के लिए सुविधाएं प्रदान करता है। रेल यह सब एक साथ जोड़ता है।

जब आप अपने एप्लिकेशन को बनाने के लिए रेल हेल्पर स्क्रिप्ट का उपयोग करते हैं, तो यह एप्लिकेशन के लिए संपूर्ण निर्देशिका संरचना बनाता है। रेल को पता है कि इस ढांचे के भीतर किन चीजों को ढूंढना है, इसलिए आपको कोई इनपुट नहीं देना होगा।

एप्लिकेशन निर्माण के समय सहायक स्क्रिप्ट द्वारा बनाए गए डायरेक्टरी ट्री का शीर्ष-स्तरीय दृश्य यहां दिया गया है। रिलीज के बीच मामूली बदलाव को छोड़कर, हर रेल परियोजना में समान संरचना होगी, जिसमें समान नामकरण परंपराएं होंगी। यह स्थिरता आपको एक जबरदस्त फायदा देती है; आप परियोजना के संगठन को पुनः प्राप्त किए बिना रेल परियोजनाओं के बीच तेजी से आगे बढ़ सकते हैं।

इस निर्देशिका संरचना को समझने के लिए, आइए उपयोग करते हैं demoस्थापना अध्याय में बनाया गया अनुप्रयोग। यह एक साधारण सहायक कमांड का उपयोग करके बनाया जा सकता हैrails demo।

अब, निम्न के रूप में डेमो आवेदन रूट निर्देशिका में जाओ -

tp> cd demo
demo> dir

आपको विंडोज में एक निर्देशिका संरचना निम्नानुसार मिलेगी -

अब प्रत्येक निर्देशिका के उद्देश्य की व्याख्या करते हैं

app- यह आपके एप्लिकेशन घटकों को व्यवस्थित करता है। यह उपनिर्देशिकाएं हैं जो दृश्य (विचार और सहायक), नियंत्रक (नियंत्रक), और बैकेंड व्यवसाय तर्क (मॉडल) को पकड़ती हैं।
app/controllers- नियंत्रक उपनिर्देशिका वह जगह है जहां रेल नियंत्रक कक्षाओं को खोजने के लिए दिखता है। एक नियंत्रक उपयोगकर्ता से एक वेब अनुरोध संभालता है।
app/helpers- सहायक उपनिर्देशिका किसी भी सहायक वर्ग को मॉडल, दृश्य और नियंत्रक कक्षाओं की सहायता के लिए उपयोग करता है। यह मॉडल, दृश्य और नियंत्रक कोड को छोटा, केंद्रित और अशुद्ध रखने में मदद करता है।
app/models- मॉडल उपनिर्देशिका उन वर्गों को रखती है जो हमारे एप्लिकेशन के डेटाबेस में संग्रहीत डेटा को मॉडल करते हैं और लपेटते हैं। अधिकांश चौखटे में, आवेदन का यह हिस्सा बहुत गन्दा, थकाऊ, वर्बोज़ और त्रुटि-प्रवण हो सकता है। रेल इसे मृत सरल बना देती है!
app/view - हमारे एप्लिकेशन के डेटा के साथ भरने, HTML में कनवर्ट करने और उपयोगकर्ता के ब्राउज़र पर वापस जाने के लिए, उपनिर्देशिका डिस्प्ले टेम्प्लेट रखती है।
app/view/layouts- लेआउट के लिए टेम्पलेट फ़ाइलों को विचारों के साथ उपयोग किया जाता है। यह विचारों को लपेटने का सामान्य शीर्ष लेख / पाद लेख विधि है। आपके विचारों में, <tt> लेआउट: डिफ़ॉल्ट </ tt> का उपयोग करके एक लेआउट को परिभाषित करें और default.html.erb नामक एक फ़ाइल बनाएं। इस लेआउट का उपयोग करके दृश्य रेंडर करने के लिए default.html.erb के अंदर, <% उपज%> पर कॉल करें।
components - यह निर्देशिका घटक, छोटे स्व-निहित अनुप्रयोगों को रखती है जो मॉडल, दृश्य और नियंत्रक को बंडल करते हैं।
config- इस निर्देशिका में कॉन्फ़िगरेशन कोड की थोड़ी मात्रा होती है, जिसे आपके एप्लिकेशन की आवश्यकता होगी, जिसमें आपका डेटाबेस कॉन्फ़िगरेशन (database.yml में), आपका रेल वातावरण संरचना (environment.rb), और आने वाले वेब अनुरोधों का रूट करना शामिल है (path.rb)। आप परिवेश निर्देशिका में मिली फ़ाइलों के साथ परीक्षण, विकास और परिनियोजन के लिए तीन रेल वातावरण के व्यवहार को भी दर्जी कर सकते हैं।
db- आमतौर पर, आपके रेल एप्लिकेशन में मॉडल ऑब्जेक्ट होंगे जो रिलेशनल डेटाबेस टेबल तक पहुंचते हैं। इस निर्देशिका में आपके द्वारा बनाई गई स्क्रिप्ट और स्थान के साथ आप रिलेशनल डेटाबेस का प्रबंधन कर सकते हैं।
doc- रूबी के पास एक फ्रेमवर्क है, जिसे रूबीडोक कहा जाता है, जो आपके द्वारा बनाए गए कोड के लिए स्वचालित रूप से प्रलेखन उत्पन्न कर सकता है। आप अपने कोड में टिप्पणियों के साथ RubyDoc की सहायता कर सकते हैं। यह निर्देशिका सभी RubyDoc- जनरेटेड रेल और एप्लिकेशन प्रलेखन रखती है।
lib - आप यहाँ लाइब्रेरीज़ डालेंगे, जब तक कि वे स्पष्ट रूप से कहीं और न हों (जैसे वेंडर लाइब्रेरीज़)।
log- एरर लॉग यहां जाते हैं। रेल स्क्रिप्ट बनाती है जो आपको विभिन्न त्रुटि लॉग का प्रबंधन करने में मदद करती है। आपको सर्वर (सर्वर.लॉग) और प्रत्येक रेल पर्यावरण (विकास.लॉग, टेस्ट.लॉग और प्रोडक्शन.लॉग) के लिए अलग-अलग लॉग मिलेंगे।
public - एक वेब सर्वर के लिए सार्वजनिक निर्देशिका की तरह, इस निर्देशिका में ऐसी वेब फाइलें होती हैं जो बदल नहीं पाती हैं, जैसे जावास्क्रिप्ट फाइलें (सार्वजनिक / जावास्क्रिप्ट), ग्राफिक्स (सार्वजनिक / चित्र), स्टाइलशीट (सार्वजनिक / स्टाइलशीट), और HTML फाइलें (सार्वजनिक )।
script- यह निर्देशिका विभिन्न उपकरणों को लॉन्च करने और प्रबंधित करने के लिए स्क्रिप्ट रखती है, जिनका उपयोग आप रेल के साथ करेंगे। उदाहरण के लिए, कोड बनाने (उत्पन्न करने) और वेब सर्वर (सर्वर) को लॉन्च करने के लिए स्क्रिप्ट हैं।
test- आप जो परीक्षण लिखते हैं और जो आपके लिए रेल बनाते हैं, वे सभी यहां जाते हैं। आपको मॉक (मॉक), इकाई परीक्षण (यूनिट), फिक्स्चर (जुड़नार), और कार्यात्मक परीक्षण (कार्यात्मक) के लिए एक उपनिर्देशिका दिखाई देगी।
tmp - रेल इस निर्देशिका का उपयोग मध्यवर्ती प्रसंस्करण के लिए अस्थायी फ़ाइलों को रखने के लिए करती है।
vendor - थर्ड पार्टी वेंडर्स (जैसे सिक्योरिटी लाइब्रेरी या बेसिक रेल डिस्ट्रीब्यूशन डिस्ट्रीब्यूशन से परे डेटाबेस यूटिलिटीज) द्वारा दी गई लाइब्रेरी यहां जाती हैं।

इन निर्देशिकाओं के अलावा, डेमो निर्देशिका में दो फाइलें उपलब्ध होंगी।

README - इस फ़ाइल में रेल एप्लिकेशन के बारे में एक बुनियादी विवरण है और ऊपर बताई गई निर्देशिका संरचना का विवरण है।
Rakefile- यह फाइल यूनिक्स मेकफाइल के समान है, जो रेल्स कोड के निर्माण, पैकेजिंग और परीक्षण में मदद करती है। इसका उपयोग रूबी स्थापना के साथ आपूर्ति की गई रेक उपयोगिता द्वारा किया जाएगा।

इस अध्याय में, हम किताबों को रखने और प्रबंधित करने के लिए एक सरल लेकिन परिचालन ऑनलाइन पुस्तकालय प्रणाली बनाएंगे।

इस एप्लिकेशन के पास एक बुनियादी वास्तुकला है और इसे संग्रहीत किए गए डेटा के प्रकारों का वर्णन करने के लिए दो ActiveRecord मॉडल का उपयोग करके बनाया जाएगा -

पुस्तकें, जो एक वास्तविक सूची का वर्णन करती हैं।
विषय, जिसका उपयोग पुस्तकों को एक साथ करने के लिए किया जाता है।

रेल अनुप्रयोग बनाने के लिए वर्कफ़्लो

रेल एप्लिकेशन बनाने के लिए एक अनुशंसित कार्य प्रवाह इस प्रकार है -

अनुप्रयोग के मूल कंकाल बनाने के लिए रेल कमांड का उपयोग करें।
अपना डेटा रखने के लिए PostgreSQL सर्वर पर एक डेटाबेस बनाएँ।
आपके डेटाबेस में कहां स्थित है, यह जानने के लिए एप्लिकेशन को कॉन्फ़िगर करें और इसके लिए लॉगइन क्रेडेंशियल्स।
रेल एक्टिव रिकॉर्ड्स (मॉडल) बनाएं, क्योंकि वे आपके द्वारा अपने नियंत्रकों के साथ काम करने वाली व्यावसायिक वस्तुएं हैं।
डेटाबेस टेबल और कॉलम बनाने और बनाए रखने को सरल बनाने वाले माइग्रेशन उत्पन्न करें।
अपने आवेदन में जान डालने के लिए कंट्रोलर कोड लिखें।
उपयोगकर्ता इंटरफ़ेस के माध्यम से अपना डेटा प्रस्तुत करने के लिए दृश्य बनाएं।

तो, चलिए अपनी लाइब्रेरी एप्लिकेशन बनाने के साथ शुरू करते हैं।

एक खाली रेल वेब अनुप्रयोग बनाना

रेल एक रनटाइम वेब एप्लीकेशन फ्रेमवर्क और हेल्पर स्क्रिप्ट का एक सेट है जो वेब एप्लिकेशन विकसित करते समय आपके द्वारा की जाने वाली कई चीजों को स्वचालित करता है। इस चरण में, हम अपने लाइब्रेरी सिस्टम एप्लिकेशन को शुरू करने के लिए संपूर्ण निर्देशिका संरचना और प्रारंभिक सेट बनाने के लिए एक ऐसी सहायक स्क्रिप्ट का उपयोग करेंगे।

अपना एप्लिकेशन बनाने के लिए माणिक इंस्टॉलेशन डायरेक्टरी में जाएं।
लाइब्रेरी एप्लिकेशन के लिए एक कंकाल बनाने के लिए निम्न कमांड चलाएँ। यह वर्तमान निर्देशिका में निर्देशिका संरचना बनाएगा।

tp> rails new library

यह लाइब्रेरी एप्लिकेशन के लिए एक उपनिर्देशिका बनाएगा जिसमें फ़ोल्डर और फ़ाइलों की एक पूरी निर्देशिका ट्री होगी जिसमें एक खाली रेल एप्लिकेशन होगा। आवेदन की एक पूरी निर्देशिका संरचना की जाँच करें। अधिक विवरण के लिए रेल निर्देशिका संरचना की जाँच करें ।

हमारे अधिकांश विकास कार्य फाइलों को बनाने और संपादित करने में होंगे library/appउपनिर्देशिका। यहां बताया गया है कि उनका उपयोग कैसे किया जाए -

नियंत्रकों उपनिर्देशिका है, जहां दिखता रेल नियंत्रक वर्गों मिल रहा है। एक नियंत्रक उपयोगकर्ता से एक वेब अनुरोध संभालता है।
विचारों उपनिर्देशिका प्रदर्शन टेम्पलेट्स रखती है हमारे आवेदन, एचटीएमएल करने के लिए परिवर्तित, और उपयोगकर्ता के ब्राउज़र के लिए वापसी से डेटा के साथ भरने के लिए।
मॉडल उपनिर्देशिका कक्षाएं आयोजित करता है कि मॉडल और हमारे आवेदन के डेटाबेस में संग्रहीत डेटा लपेट दें। अधिकांश चौखटे में, आवेदन का यह हिस्सा बहुत गन्दा, थकाऊ, वर्बोज़ और त्रुटि-प्रवण हो सकता है। रेल इसे मृत सरल बना देती है।
सहायकों उपनिर्देशिका मॉडल, दृश्य और नियंत्रक वर्गों की सहायता के लिए प्रयोग किया जाता है किसी भी सहायक कक्षाएं आयोजित करता है। यह मॉडल, दृश्य और नियंत्रक कोड को छोटा, केंद्रित और अशुद्ध रखने में मदद करता है।

वेब सर्वर शुरू करना

रेल वेब एप्लिकेशन वस्तुतः किसी भी वेब सर्वर के तहत चल सकता है, लेकिन रेल वेब एप्लिकेशन को विकसित करने का सबसे सुविधाजनक तरीका अंतर्निहित वेब सर्वर का उपयोग करना है। आइए इस वेब सर्वर को शुरू करें और फिर अपने खाली पुस्तकालय एप्लिकेशन में ब्राउज़ करें -

इस सर्वर को एप्लिकेशन डायरेक्टरी से निम्नानुसार शुरू किया जाएगा। यह पोर्ट नंबर 3000 पर चलता है।

tp> cd ruby\library 
tp\ruby\library\> Rails server

यह सर्वर को शुरू करने के लिए ऑटो कोड बनाता है जैसा कि नीचे दिखाया गया है -

इससे आपका WEBrick वेब सर्वर शुरू हो जाएगा।

अब अपना ब्राउज़र खोलें और ब्राउज़ करें http://127.0.0.1:3000। यदि सब कुछ ठीक हो गया है, तो आपको वेबब्रिक से एक बधाई संदेश देखना चाहिए, अन्यथा आपकी सेटिंग में कुछ गड़बड़ है। यदि सब कुछ ठीक हो जाता है तो यह आउटपुट को निम्नानुसार उत्पन्न करेगा।

आगे क्या है?

अगला अध्याय बताता है कि आपके आवेदन के लिए डेटाबेस कैसे बनाया जाए और इन बनाए गए डेटाबेस तक पहुंचने के लिए आवश्यक कॉन्फ़िगरेशन क्या है।

इसके अलावा, हम देखेंगे कि रेल प्रवासन क्या है और इसका उपयोग डेटाबेस तालिकाओं को बनाए रखने के लिए कैसे किया जाता है।

इस अध्याय के साथ शुरू करने से पहले, सुनिश्चित करें कि आपका डेटाबेस सर्वर ऊपर और चल रहा है। रूबी ऑन रेल्स तीन डेटाबेस बनाने की सिफारिश करती है - विकास, परीक्षण और उत्पादन पर्यावरण के लिए एक डेटाबेस। अधिवेशन के अनुसार, उनके नाम होने चाहिए -

library_development
library_production
library_test

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

डेटाबेस MySQL के लिए सेटअप

MySQL में, हम उपयोग कर रहे हैं rootहमारे आवेदन के लिए उपयोगकर्ता आईडी। MySQL कंसोल सत्र जिसमें आप ऐसा करते हैं, कुछ ऐसा दिखता है -

mysql> create database library_development;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on library_development.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

आप दो और डेटाबेस के लिए एक ही काम कर सकते हैं library_production तथा library_test।

डेटाबेस को कॉन्फ़िगर करना

इस बिंदु पर, आपको डेटाबेस के लिए उपयोगकर्ता नाम और पासवर्ड के बारे में पता होना चाहिए। आप इसे फ़ाइल में करेंdatabase.ymlमें उपलब्ध है library\configआपके द्वारा बनाए गए रेल एप्लिकेशन का उपनिर्देशिका। इस फ़ाइल में MySQL डेटाबेस के लिए लाइव कॉन्फ़िगरेशन अनुभाग हैं। आपके द्वारा उपयोग किए जाने वाले प्रत्येक अनुभाग में, आपके द्वारा बनाए गए डेटाबेस पर अनुमतियों को प्रतिबिंबित करने के लिए आपको उपयोगकर्ता नाम और पासवर्ड लाइनों को बदलना होगा।

जब आप पूरा कर लें, तो यह कुछ इस तरह दिखना चाहिए -

development:
   adapter: mysql
   database: library_development
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: library_test
   username: root
   password: [password]
   host: localhost
   
production:
   adapter: mysql
   database: library_production
   username: root
   password: [password]
   host: localhost

PostgreSQL के लिए डेटाबेस सेटअप

डिफ़ॉल्ट रूप से, PostgreSQL कोई उपयोगकर्ता प्रदान नहीं करता है। हमें नए उपयोगकर्ता बनाने होंगे। नाम के साथ उपयोगकर्ता बनाने के लिए निम्नलिखित कमांड का उपयोग करेंrubyuser।

tp> sudo -u postgres createuser rubyuser -s

यदि आप नए उपयोगकर्ता के लिए पासवर्ड बनाना चाहते हैं, तो निम्न कमांड का उपयोग करें।

tp> sudo -u postgres psql

postgres=# \password rubyuser

डेटाबेस बनाने के लिए निम्न कमांड का उपयोग करें library_development।

postgres=# CREATE DATABASE library_development OWNER rubyuser; 

CREATE DATABASE

डेटाबेस बनाने के लिए निम्न कमांड का उपयोग करें library_production।

postgres=# CREATE DATABASE library_production OWNER rubyuser; 

CREATE DATABASE

डेटाबेस बनाने के लिए निम्न कमांड का उपयोग करें library_test।

postgres=# CREATE DATABASE library_test OWNER rubyuser; 

CREATE DATABASE

दबाएँ Ctrl+D PosgreSQL को समाप्त करने के लिए।

डेटाबेस को कॉन्फ़िगर करना

इस बिंदु पर, आपको रेल डेटाबेस के लिए उपयोगकर्ता नाम और पासवर्ड जानने की आवश्यकता है। आप इसे फ़ाइल में करेंdatabase.ymlमें उपलब्ध है library\configआपके द्वारा बनाए गए रेल एप्लिकेशन का उपनिर्देशिका। इस फ़ाइल में PostgreSQL डेटाबेस के लिए लाइव कॉन्फ़िगरेशन अनुभाग हैं। प्रत्येक अनुभाग में, आपके द्वारा बनाए गए डेटाबेस पर अनुमतियों को प्रतिबिंबित करने के लिए आपको उपयोगकर्ता नाम और पासवर्ड लाइनों को बदलने की आवश्यकता है।

जब आप पूरा कर लें, तो यह इस प्रकार दिखना चाहिए -

default: &default
   adapter: postgresql
   encoding: unicode
  
development:
   adapter: postgresql
   encoding: unicode
   database: library_development
   username: rubyuser
   password: <Password for rubyuser>

test:
   adapter: postgresql
   encoding: unicode
   database: library_test
   username: rubyuser
   password: <Password for rubyuser>
 
production:
   adapter: postgresql
   encoding: unicode
   database: library_production
   username: rubyuser
   password: <Password for rubyuser>

आगे क्या है?

अगले दो अध्याय बताते हैं कि अपने डेटाबेस तालिकाओं को कैसे बनाया जाए और रेल के माइग्रेशन का उपयोग करने वालों को कैसे प्रबंधित किया जाए।

रेल एक्टिव रिकॉर्ड, रेल्स के साथ आपूर्ति की जाने वाली वस्तु / संबंधपरक मैपिंग (ओआरएम) परत है। यह मानक ORM मॉडल का बारीकी से अनुसरण करता है, जो इस प्रकार है -

तालिकाओं का मानचित्र कक्षाओं के लिए,
पंक्तियों का नक्शा वस्तुओं और
कॉलम का नक्शा ऑब्जेक्ट विशेषताओं के लिए।

रेल एक्टिव रिकॉर्ड्स एक रिलेशनल डेटाबेस में टेबल के बीच एक इंटरफेस और बाइंडिंग प्रदान करते हैं और रूबी प्रोग्राम कोड जो डेटाबेस रिकॉर्ड्स में हेरफेर करता है। रूबी विधि नाम स्वचालित रूप से डेटाबेस तालिकाओं के क्षेत्र नामों से उत्पन्न होते हैं।

प्रत्येक सक्रिय रिकॉर्ड ऑब्जेक्ट में CRUD है (Create, READ, Update, और Dडेटाबेस पहुंच के लिए elete) के तरीके। यह रणनीति डेटाबेस टेबल और एप्लिकेशन ऑब्जेक्ट्स के बीच सरल डिज़ाइन और सीधे आगे मैपिंग की अनुमति देती है।

एसक्यूएल में एक डोमेन मॉडल का अनुवाद

एक डोमेन मॉडल को एसक्यूएल में अनुवाद करना आम तौर पर सीधे आगे है, जब तक आपको याद है कि आपको रेल के अनुकूल एसक्यूएल लिखना होगा। व्यावहारिक रूप से, आपको कुछ नियमों का पालन करना होगा -

प्रत्येक इकाई (जैसे पुस्तक) को डेटाबेस में एक तालिका मिलती है जिसका नाम उसके नाम पर है, लेकिन बहुवचन (पुस्तकों) में।
प्रत्येक ऐसी इकाई-मिलान तालिका में आईडी नामक एक फ़ील्ड होता है, जिसमें तालिका में सम्मिलित प्रत्येक रिकॉर्ड के लिए एक अद्वितीय पूर्णांक होता है।
निकाय x और निकाय y को देखते हुए, यदि इकाई y इकाई x से संबंधित है, तो तालिका y में x_id नामक फ़ील्ड है।
किसी भी तालिका में फ़ील्ड के थोक उस इकाई के सरल गुणों (कुछ भी जो एक संख्या या एक स्ट्रिंग है) के लिए मूल्यों को संग्रहीत करते हैं।

सक्रिय रिकॉर्ड फ़ाइलें (मॉडल) बनाना

लाइब्रेरी एप्लिकेशन के लिए हमारी संस्थाओं के लिए सक्रिय रिकॉर्ड फ़ाइलों को बनाने के लिए, पिछले अध्याय में पेश किया गया है, आवेदन निर्देशिका के शीर्ष स्तर से निम्नलिखित आदेश जारी करें।

library\> ruby script/generate model Book
library\> ruby script/generate model Subject

ऊपर rails generate model book आदेश नीचे दिए गए अनुसार ऑटो कोड बनाता है -

आप जनरेटर को किताबों और विषयों के उदाहरणों को संग्रहीत करने के लिए बुक एंड सब्जेक्ट नामक मॉडल बनाने के लिए कह रहे हैं। ध्यान दें कि आप पुस्तक और विषय को कैपिटल कर रहे हैं और एकवचन फॉर्म का उपयोग कर रहे हैं। यह एक रेल प्रतिमान है जिसे आपको हर बार मॉडल बनाते समय पालन करना चाहिए।

जब आप जेनरेट टूल का उपयोग करते हैं, तो रेल वास्तविक मॉडल फ़ाइल बनाता है जो मॉडल के लिए अद्वितीय सभी तरीकों को रखती है और जिन व्यावसायिक नियमों को आप परिभाषित करते हैं, परीक्षण-संचालित विकास, एक नमूना डेटा फ़ाइल (जिसे जुड़नार कहा जाता है) का उपयोग करने के लिए एक इकाई परीक्षण फ़ाइल। इकाई परीक्षणों और रेल प्रवास के साथ जो डेटाबेस तालिकाओं और स्तंभों को आसान बनाता है।

कई अन्य फ़ाइलों और निर्देशिकाओं को बनाने के अलावा, यह नाम की फाइलें बनाएगा book.rb तथा subject.rb में एक कंकाल परिभाषा युक्त app/models निर्देशिका।

Book.rb में उपलब्ध सामग्री -

class Book < ActiveRecord::Base
end

विषय में उपलब्ध सामग्री।

class Subject < ActiveRecord::Base
end

मॉडल्स के बीच एसोसिएशन बनाना

जब आपके रेल के अनुप्रयोग में एक से अधिक मॉडल होते हैं, तो आपको उन मॉडलों के बीच संबंध बनाने की आवश्यकता होगी। आप संघों के माध्यम से ऐसा कर सकते हैं। सक्रिय रिकॉर्ड तीन प्रकार के संघों का समर्थन करता है -

one-to-one- एक-से-एक संबंध तब मौजूद होता है जब एक आइटम में किसी अन्य आइटम का वास्तव में एक होता है। उदाहरण के लिए, किसी व्यक्ति का ठीक एक जन्मदिन है या कुत्ते का ठीक एक मालिक है।
one-to-many- एक-से-कई संबंध तब होते हैं जब एक एकल वस्तु कई अन्य वस्तुओं का सदस्य हो सकती है। उदाहरण के लिए, एक विषय में कई किताबें हो सकती हैं।
many-to-many - कई-से-कई संबंध तब मौजूद होते हैं, जब पहली वस्तु किसी दूसरी वस्तु के एक या अधिक से संबंधित होती है, और दूसरी वस्तु पहली वस्तु के एक या कई से संबंधित होती है।

आप अपने मॉडल में घोषणाएँ जोड़कर इन संघों को इंगित करते हैं: has_one, has_many, अंतर्गत_to, और has_and_belongs_to_many।

अब, आपको यह बताने की आवश्यकता है कि लाइब्रेरी डेटा सिस्टम के भीतर आप कौन से रिश्ते स्थापित करना चाहते हैं। ऐसा करने के लिए, इस तरह दिखने के लिए book.rb और subject.rb को संशोधित करें -

class Book < ActiveRecord::Base
   belongs_to :subject
end

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

class Subject < ActiveRecord::Base
   has_many :books
end

हमने यहां बहुवचन पुस्तकों का उपयोग किया है, क्योंकि एक विषय में कई पुस्तकें हो सकती हैं।

मॉडल पर मान्यताओं को लागू करना

सत्यापन का कार्यान्वयन एक रेल मॉडल में किया जाता है। डेटाबेस में आपके द्वारा दर्ज किया गया डेटा वास्तविक रेल मॉडल में परिभाषित किया गया है, इसलिए यह केवल यह परिभाषित करने के लिए समझ में आता है कि एक ही स्थान पर वैध डेटा क्या होता है।

मान्यताएं हैं -

शीर्षक फ़ील्ड का मान NULL नहीं होना चाहिए।
मूल्य क्षेत्र का मूल्य संख्यात्मक होना चाहिए।

खुला हुआ book.rb में app\model उपखंड और निम्नलिखित मान्यताओं को रखा -

class Book < ActiveRecord::Base
   belongs_to :subject
   validates_presence_of :title
   validates_numericality_of :price, :message=>"Error Message"
end

validates_presence_of - गायब उपयोगकर्ता इनपुट के खिलाफ "NOT NULL" फ़ील्ड की सुरक्षा करता है।
validates_numericality_of - उपयोगकर्ता को गैर-संख्यात्मक डेटा दर्ज करने से रोकता है।

ऊपर उल्लिखित मान्यताओं के अलावा, अन्य सामान्य सत्यापन भी हैं। त्वरित गाइड की जाँच करें ।

आगे क्या है?

अगले अध्याय में, हम रेल प्रवासन सीखेंगे, जो आपको रूबी का उपयोग करके अपने डेटाबेस स्कीमा में परिवर्तन को परिभाषित करने की अनुमति देता है, जिससे वास्तविक कोड के साथ चीजों को सिंक्रनाइज़ रखने के लिए एक संस्करण नियंत्रण प्रणाली का उपयोग करना संभव हो जाता है।

रेल माइग्रेशन आपको रूबी का उपयोग अपने डेटाबेस स्कीमा में परिवर्तन को परिभाषित करने के लिए करने की अनुमति देता है, जिससे वास्तविक कोड के साथ चीजों को सिंक्रनाइज़ रखने के लिए एक संस्करण नियंत्रण प्रणाली का उपयोग करना संभव हो जाता है।

इसके कई उपयोग हैं, जिनमें शामिल हैं -

Teams of developers - यदि एक व्यक्ति एक स्कीमा परिवर्तन करता है, तो अन्य डेवलपर्स को बस अद्यतन करने की आवश्यकता है, और "रेक माइग्रेट" चलाएं।
Production servers - "रेक माइग्रेट" चलाएं जब आप डेटाबेस के साथ-साथ डेट तक लाने के लिए एक नया रिलीज़ रोल करते हैं।
Multiple machines - यदि आप एक डेस्कटॉप और एक लैपटॉप, या एक से अधिक स्थानों पर विकसित होते हैं, तो माइग्रेशन आपको उन सभी को सिंक्रनाइज़ रखने में मदद कर सकता है।

प्रवासन क्या कर सकता है?

create_table (नाम, विकल्प)
drop_table(name)
rename_table (old_name, new_name)
add_column (table_name, column_name, प्रकार, विकल्प)
rename_column (table_name, column_name, new_column_name)
change_column (table_name, column_name, प्रकार, विकल्प)
remove_column (table_name, column_name)
add_index (table_name, column_name, index_type)
remove_index (table_name, column_name)

Migrations support all the basic data types - निम्नलिखित डेटा प्रकारों की सूची है जो माइग्रेशन का समर्थन करता है -

string - एक टाइटल जैसे छोटे डेटा प्रकारों के लिए।
text - पाठ डेटा के लंबे टुकड़ों के लिए, जैसे विवरण।
integer - पूरे नंबरों के लिए।
float - दशमलव के लिए।
datetime and timestamp - दिनांक और समय को एक कॉलम में संग्रहीत करें।
date and time - या तो केवल तारीख या समय ही स्टोर करें।
binary - इमेज, ऑडियो या मूवी जैसे डेटा को स्टोर करने के लिए।
Boolean - सही या गलत मूल्यों के भंडारण के लिए।

Valid column options are - निम्नलिखित वैध कॉलम विकल्पों की सूची है।

limit (: सीमा => "50")
default ((डिफ़ॉल्ट => "ब्ला")
null(: अशक्त => झूठी तात्पर्य नहीं NULL )

NOTE - रेल माइग्रेशन द्वारा की जाने वाली गतिविधियाँ किसी भी फ्रंट-एंड GUI या सीधे SQL प्रॉम्प्ट का उपयोग करके की जा सकती हैं, लेकिन रेल माइग्रेशन उन सभी गतिविधियों को बहुत आसान बना देता है।

इन पर विवरण के लिए रेल एपीआई देखें ।

माइग्रेशन बनाएँ

माइग्रेशन बनाने के लिए यहाँ जेनेरिक सिंटैक्स दिया गया है -

application_dir> rails generate migration table_name

यह फ़ाइल db / migrate / 001_table_name.rb बनाएगा। एक माइग्रेशन फ़ाइल में मूल रूबी सिंटैक्स होता है जो डेटाबेस तालिका की डेटा संरचना का वर्णन करता है।

NOTE - माइग्रेशन जनरेटर चलाने से पहले, मॉडल जनरेटर द्वारा उत्पन्न मौजूदा माइग्रेशन को साफ करने की सिफारिश की जाती है।

हम अपनी तीन तालिकाओं के अनुरूप दो माइग्रेशन बनाएंगे - books and subjects।

पुस्तकों का प्रवास इस प्रकार होना चाहिए -

tp> cd library
library> rails generate migration books

उपरोक्त कमांड निम्न कोड उत्पन्न करता है।

विषय प्रवास इस प्रकार होना चाहिए -

tp> cd library
library> rails generate migration subjects

उपरोक्त कमांड निम्न कोड उत्पन्न करता है।

ध्यान दें कि आप माइग्रेशन बनाते समय पुस्तक और विषय और बहुवचन के लिए निचले मामले का उपयोग कर रहे हैं। यह एक रेल प्रतिमान है जिसे आपको माइग्रेशन बनाते समय हर बार पालन करना चाहिए।

कोड संपादित करें

अपने आवेदन के db / माइग्रेट करें और किसी भी सरल पाठ संपादक का उपयोग करके एक-एक करके प्रत्येक फ़ाइल को संपादित करें।

निम्नानुसार 001_books.rb संशोधित करें -

आईडी कॉलम अपने आप बन जाएगा, इसलिए इसे यहां भी न करें।

class Books < ActiveRecord::Migration
   
   def self.up
      create_table :books do |t|
         t.column :title, :string, :limit => 32, :null => false
         t.column :price, :float
         t.column :subject_id, :integer
         t.column :description, :text
         t.column :created_at, :timestamp
      end
   end

   def self.down
      drop_table :books
   end
end

प्रक्रिया self.up नए संस्करण में माइग्रेट करते समय उपयोग किया जाता है, self.downयदि आवश्यक हो तो किसी भी परिवर्तन को वापस करने के लिए उपयोग किया जाता है। इस समय, उपरोक्त स्क्रिप्ट का उपयोग बनाने के लिए किया जाएगाbooks तालिका।

निम्नानुसार 002_subjects.rb संशोधित करें -

class Subjects < ActiveRecord::Migration
   def self.up
      
      create_table :subjects do |t|
         t.column :name, :string
      end
	
      Subject.create :name => "Physics"
      Subject.create :name => "Mathematics"
      Subject.create :name => "Chemistry"
      Subject.create :name => "Psychology"
      Subject.create :name => "Geography"
   end

   def self.down
      drop_table :subjects
   end
end

उपरोक्त स्क्रिप्ट बनाने के लिए उपयोग किया जाएगा subjects तालिका और विषय तालिका में पांच रिकॉर्ड बनाएगी।

माइग्रेशन चलाएं

अब जब आपने सभी आवश्यक माइग्रेशन फ़ाइलें बना ली हैं। यह डेटाबेस के खिलाफ उन्हें निष्पादित करने का समय है। ऐसा करने के लिए, कमांड प्रॉम्प्ट पर जाएं और लाइब्रेरी डायरेक्टरी में जाएं जिसमें एप्लिकेशन स्थित है, और फिर टाइप करेंrake migrate निम्नानुसार है -

library> rake db:migrate

यदि यह मौजूद नहीं है, तो यह एक "स्कीमा_इन्फो" तालिका बनाएगा, जो डेटाबेस के वर्तमान संस्करण को ट्रैक करता है - प्रत्येक नया माइग्रेशन एक नया संस्करण होगा, और किसी भी नए माइग्रेशन को तब तक चलाया जाएगा जब तक कि आपका डेटाबेस वर्तमान संस्करण पर न हो।

Rakeरूबी बिल्ड प्रोग्राम है, जो यूनिक्स मेक प्रोग्राम के समान है, जो रेल का लाभ उठाता है, जटिल कार्यों के निष्पादन को आसान बनाता है जैसे कि डेटाबेस की संरचना को अपडेट करना आदि।

उत्पादन और परीक्षण डेटाबेस के लिए माइग्रेशन चलाना

यदि आप यह निर्दिष्ट करना चाहते हैं कि माइग्रेशन के लिए कौन से रेल वातावरण का उपयोग करना है, तो RIDS_ENV शेल चर का उपयोग करें।

उदाहरण के लिए -

library> export RAILS_ENV = production
library> rake db:migrate
library> export RAILS_ENV = test
library> rake db:migrate
library> export RAILS_ENV = development
library> rake db:migrate

NOTE- विंडोज में, एक्सपोर्ट कमांड के बजाय "सेट R नाखून_ENV = उत्पादन" का उपयोग करें ।

आगे क्या है?

अब हमारे पास हमारा डेटाबेस और आवश्यक टेबल उपलब्ध हैं। बाद के दो अध्यायों में, हम नियंत्रक (एक्शनकंट्रोलर) और व्यू (एक्शन व्यू) नामक दो महत्वपूर्ण घटकों का पता लगाएंगे।

नियंत्रक (एक्शन कंट्रोलर) बनाना।
दृश्य बनाना (एक्शन दृश्य)।

रेल नियंत्रक आपके आवेदन का तार्किक केंद्र है। यह उपयोगकर्ता, विचार और मॉडल के बीच की बातचीत का समन्वय करता है। नियंत्रक कई महत्वपूर्ण सहायक सेवाओं का एक घर भी है।

यह आंतरिक अनुरोधों के लिए बाहरी अनुरोधों को रूट करने के लिए जिम्मेदार है। यह लोगों के अनुकूल URL को बहुत अच्छी तरह से संभालता है।
यह कैशिंग का प्रबंधन करता है, जो अनुप्रयोगों के आदेश-परिमाण प्रदर्शन को बढ़ावा दे सकता है।
यह हेल्पर मॉड्यूल का प्रबंधन करता है, जो अपने कोड को उभारे बिना व्यू टेम्प्लेट की क्षमताओं का विस्तार करता है।
यह सत्रों का प्रबंधन करता है, जिससे उपयोगकर्ताओं को हमारे अनुप्रयोगों के साथ चल रही बातचीत का आभास होता है।

एक नियंत्रक बनाने के लिए प्रक्रिया बहुत आसान है, और यह उस प्रक्रिया के समान है जो हमने पहले ही एक मॉडल बनाने के लिए उपयोग किया है। हम यहां सिर्फ एक कंट्रोलर बनाएंगे -

library\> rails generate controller Book

ध्यान दें कि आप बुक को कैपिटलाइज़ कर रहे हैं और एकवचन फॉर्म का उपयोग कर रहे हैं। यह एक रेल प्रतिमान है जिसे आपको नियंत्रक बनाते समय हर बार पालन करना चाहिए।

यह आदेश कई कार्यों को पूरा करता है, जिनमें से निम्नलिखित यहां प्रासंगिक हैं -

यह नामक एक फाइल बनाता है app/controllers/book_controller.rb

यदि आप book_controller.rb को देखते हैं, तो आप इसे इस प्रकार पाएंगे -

class BookController < ApplicationController
end

कंट्रोलर क्लासेस को ApplicationController से विरासत में मिला है , जो कंट्रोलर फ़ोल्डर की दूसरी फाइल है:application.rb।

ApplicationController कि आपके सभी नियंत्रकों में चलाया जा सकता है कोड होता है और यह रेल से विरासत ActionController :: बेस वर्ग।

आपको अभी तक ApplicationController के साथ चिंता करने की ज़रूरत नहीं है, तो चलो बस कुछ विधि स्टब्स को परिभाषित करते हैंbook_controller.rb। अपनी आवश्यकता के आधार पर, आप इस फ़ाइल में किसी भी फ़ंक्शन को परिभाषित कर सकते हैं।

निम्नलिखित की तरह दिखने और अपने परिवर्तनों को सहेजने के लिए फ़ाइल को संशोधित करें। ध्यान दें कि यह आप पर निर्भर है कि आप इन विधियों को क्या नाम देना चाहते हैं, लेकिन प्रासंगिक नाम देना बेहतर है।

class BookController < ApplicationController
   def list
   end
   
   def show
   end
   
   def new
   end
   
   def create
   end
   
   def edit
   end
   
   def update
   end
   
   def delete
   end
   
end

अब हम एक-एक करके सभी विधियों को लागू करते हैं।

सूची विधि को लागू करना

सूची विधि आपको डेटाबेस की सभी पुस्तकों की एक सूची प्रदान करती है। यह कार्यक्षमता कोड की निम्न पंक्तियों द्वारा प्राप्त की जाएगी। निम्नलिखित पंक्तियों को book_controller.rb फ़ाइल में संपादित करें।

def list
   @books = Book.all
end

@Books = Book.all सूची विधि में लाइन किताबें तालिका खोज और प्रत्येक पंक्ति यह @books उदाहरण वस्तु में पाता है स्टोर करने के लिए रेल बताता है।

शो विधि लागू करना

शो विधि एकल पुस्तक पर केवल और अधिक विवरण प्रदर्शित करती है। यह कार्यक्षमता कोड की निम्न पंक्तियों द्वारा प्राप्त की जाएगी।

def show
   @book = Book.find(params[:id])
end

शो विधि की @book = Book.find (params [: id]) लाइन रेल्स को केवल उस पुस्तक को खोजने के लिए कहती है जिसमें आईडी को params [: id] में परिभाषित किया गया है।

परमेस ऑब्जेक्ट एक कंटेनर है जो आपको विधि कॉल के बीच मानों को पारित करने में सक्षम बनाता है। उदाहरण के लिए, जब आप सूची विधि द्वारा बुलाए गए पृष्ठ पर होते हैं, तो आप किसी विशिष्ट पुस्तक के लिए एक लिंक पर क्लिक कर सकते हैं, और यह उस पुस्तक की आईडी को पाराम्स ऑब्जेक्ट के माध्यम से पास करता है ताकि शो विशिष्ट पुस्तक को ढूंढ सके।

नई विधि को लागू करना

नई विधि रेल्स को बताती है कि आप एक नई वस्तु बनाएंगे। तो बस इस विधि में निम्नलिखित कोड जोड़ें।

def new
   @book = Book.new
   @subjects = Subject.all
end

जब आप उपयोगकर्ता इनपुट लेने के लिए उपयोगकर्ता को एक पृष्ठ प्रदर्शित करेंगे, तो उपरोक्त विधि को बुलाया जाएगा। यहां दूसरी पंक्ति डेटाबेस से सभी विषयों को पकड़ती है और @subjects नामक एक सरणी में डालती है।

बनाने की विधि को लागू करना

एक बार जब आप HTML फॉर्म का उपयोग करके उपयोगकर्ता इनपुट लेते हैं, तो डेटाबेस में रिकॉर्ड बनाने का समय आ जाता है। इसे प्राप्त करने के लिए, निम्नलिखित से मिलान करने के लिए book_controller.rb में बनाएँ विधि को संपादित करें -

def create
   @book = Book.new(book_params)
	
   if @book.save
      redirect_to :action => 'list'
   else
      @subjects = Subject.all
      render :action => 'new'
   end
   
end

def book_params
   params.require(:books).permit(:title, :price, :subject_id, :description)
end

पहली पंक्ति में @ बुक नामक एक नया इंस्टेंस वेरिएबल है जो डेटा से निर्मित बुक ऑब्जेक्ट रखता है, जिसे यूजर ने सबमिट किया है। book_params विधि का उपयोग वस्तु से सभी क्षेत्रों को इकट्ठा करने के लिए किया जाता है :books। डेटा को परमेस ऑब्जेक्ट का उपयोग करने के लिए नई विधि से पारित किया गया था।

अगली पंक्ति एक सशर्त विवरण है जो उपयोगकर्ता को रीडायरेक्ट करता है listविधि यदि ऑब्जेक्ट डेटाबेस में सही ढंग से बचाता है। यदि यह सहेजता नहीं है, तो उपयोगकर्ता को नई विधि में वापस भेजा जाता है। रीडायरेक्ट_टो विधि एक वेब पेज पर मेटा रीफ्रेश करने के समान है: यह स्वचालित रूप से आपको बिना किसी उपयोगकर्ता सहभागिता के आपकी मंजिल तक पहुंचाता है।

तब @subjects = Subject.all की आवश्यकता होती है यदि यह डेटा को सफलतापूर्वक सहेजता नहीं है और नए विकल्प के साथ भी ऐसा ही हो जाता है।

संपादन विधि को लागू करना

शो मेथड शो विधि के समान है। दोनों तरीकों का उपयोग इसकी आईडी के आधार पर किसी एक वस्तु को प्राप्त करने और एक पृष्ठ पर प्रदर्शित करने के लिए किया जाता है। अंतर केवल इतना है कि शो विधि संपादन योग्य नहीं है।

def edit
   @book = Book.find(params[:id])
   @subjects = Subject.all
end

इस पद्धति को उपयोगकर्ता द्वारा संशोधित किए जाने के लिए स्क्रीन पर डेटा प्रदर्शित करने के लिए बुलाया जाएगा। दूसरी पंक्ति डेटाबेस से सभी विषयों को पकड़ती है और @subjects नामक एक सरणी में डालती है।

अद्यतन विधि को लागू करना

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

def update
   @book = Book.find(params[:id])
	
   if @book.update_attributes(book_param)
      redirect_to :action => 'show', :id => @book
   else
      @subjects = Subject.all
      render :action => 'edit'
   end
   
end

def book_param
   params.require(:book).permit(:title, :price, :subject_id, :description)
end

Update_attributes विधि बनाने के लिए उपयोग की गई बचत विधि के समान है, लेकिन डेटाबेस में एक नई पंक्ति बनाने के बजाय, यह मौजूदा पंक्ति की विशेषताओं को अधिलेखित करती है।

तब @subjects = Subject.all लाइन की आवश्यकता होती है यदि यह डेटा को सफलतापूर्वक सहेज नहीं पाता है, तो यह संपादन विकल्प के समान हो जाता है।

डिलीट मेथड को लागू करना

यदि आप डेटाबेस से कोई रिकॉर्ड हटाना चाहते हैं तो आप इस विधि का उपयोग करेंगे। इस विधि को इस प्रकार लागू करें।

def delete
   Book.find(params[:id]).destroy
   redirect_to :action => 'list'
end

पहली पंक्ति पैरामीटर ऑब्जेक्ट के माध्यम से पारित पैरामीटर के आधार पर वर्गीकृत को ढूंढती है और फिर नष्ट विधि का उपयोग करके इसे हटा देती है। दूसरी पंक्ति उपयोगकर्ता को पुनर्निर्देश_ कॉल का उपयोग करके सूची विधि में पुनर्निर्देशित करती है।

अतिरिक्त तरीके प्रदर्शित करने के लिए विषय

मान लें कि आप किसी विषय पर आधारित सभी पुस्तकों को ब्राउज़ करने के लिए अपने उपयोगकर्ताओं को एक सुविधा देना चाहते हैं। इसलिए, आप सभी विषयों को प्रदर्शित करने के लिए book_controller.rb के अंदर एक विधि बना सकते हैं। विधि नाम मान लिया गया हैshow_subjects -

def show_subjects
   @subject = Subject.find(params[:id])
end

अंत में आपका book_controller.rb फ़ाइल निम्नानुसार दिखाई देगी -

class BooksController < ApplicationController

   def list
      @books = Book.all
   end

   def show
      @book = Book.find(params[:id])
   end
  
   def new
      @book = Book.new
      @subjects = Subject.all
   end

   def book_params
      params.require(:books).permit(:title, :price, :subject_id, :description)
   end

   def create
      @book = Book.new(book_params)

      if @book.save
         redirect_to :action => 'list'
      else
         @subjects = Subject.all
         render :action => 'new'
      end
   end
   
   def edit
      @book = Book.find(params[:id])
      @subjects = Subject.all
   end
   
   def book_param
      params.require(:book).permit(:title, :price, :subject_id, :description)
   end
   
   def update
      @book = Book.find(params[:id])
      
      if @book.update_attributes(book_param)
         redirect_to :action => 'show', :id => @book
      else
         @subjects = Subject.all
         render :action => 'edit'
      end
   end
   
   def delete
      Book.find(params[:id]).destroy
      redirect_to :action => 'list'
   end
   
   def show_subjects
      @subject = Subject.find(params[:id])
   end

end

अब अपनी कंट्रोलर फाइल को सेव करें।

आगे क्या है?

आपने लगभग सभी तरीके बनाए हैं, जो बैकएंड पर काम करेंगे। आगे हम क्रियाओं के लिए मार्गों (URL) को परिभाषित करेंगे।

रूटिंग मॉड्यूल मूल रूबी में URL पुनर्लेखन प्रदान करता है। यह नियंत्रकों और कार्यों के लिए आने वाले अनुरोधों को पुनर्निर्देशित करने का एक तरीका है। यह mod_rewrite नियमों की जगह लेता है। सभी के सर्वश्रेष्ठ, रेल्स रूटिंग किसी भी वेब सर्वर के साथ काम करता है। रूट को ऐप / कॉन्फिगर / मार्गों में परिभाषित किया गया है।

अपने अनुरोधों के लिए एक मानचित्र बनाने के रूप में मार्ग बनाने के बारे में सोचें। नक्शा उन्हें बताता है कि कुछ पूर्वनिर्धारित पैटर्न के आधार पर कहाँ जाना है -

Rails.application.routes.draw do
   Pattern 1 tells some request to go to one place
   Pattern 2 tell them to go to another
   ...
end

उदाहरण

आइए विचार करें कि हमारे पुस्तकालय प्रबंधन अनुप्रयोग में बुककंट्रोलर नामक नियंत्रक है। हमें उन कार्यों के लिए मार्गों को परिभाषित करना होगा जिन्हें बुककंट्रोलर वर्ग में विधियों के रूप में परिभाषित किया गया है।

लाइब्रेरी / कॉन्फिग / डायरेक्टरी में मार्गों को खोलें।

Rails.application.routes.draw do
   get 'book/list'
   get 'book/new'
   post 'book/create'
   patch 'book/update'
   get 'book/list'
   get 'book/show'
   get 'book/edit'
   get 'book/delete'
   get 'book/update'
   get 'book/show_subjects'
end

Path.rb फ़ाइल अनुप्रयोगों में उपलब्ध क्रियाओं को परिभाषित करती है और प्रकार की कार्रवाई जैसे कि प्राप्त, पोस्ट और पैच।

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

library> rake routes

आगे क्या है?

अगला, हम डेटा प्रदर्शित करने और उपयोगकर्ता से इनपुट लेने के लिए स्क्रीन बनाने के लिए कोड बनाएंगे।

एक रेल दृश्य एक ईआरबी कार्यक्रम है जो पारस्परिक रूप से सुलभ चर के माध्यम से नियंत्रकों के साथ डेटा साझा करता है।

यदि आप लाइब्रेरी एप्लिकेशन के एप्लिकेशन / व्यू डायरेक्टरी में देखते हैं, तो आपको प्रत्येक नियंत्रक के लिए एक उपनिर्देशिका दिखाई देगी, हमने बनाया है: पुस्तक। इनमें से प्रत्येक उपनिर्देशिका स्वचालित रूप से बनाई गई थी, जब एक ही नामित नियंत्रक उत्पन्न स्क्रिप्ट के साथ बनाया गया था।

रेलें आपको बताती हैं कि आपको प्रत्येक नई पद्धति के लिए दृश्य फ़ाइल बनाने की आवश्यकता है। नियंत्रक में आपके द्वारा परिभाषित प्रत्येक विधि के लिए एक संगत होना आवश्यक हैerb फ़ाइल, विधि के समान नाम के साथ, डेटा को प्रदर्शित करने के लिए कि विधि एकत्रित कर रही है।

तो चलिए उन सभी तरीकों के लिए व्यू फाइल बनाते हैं, जिन्हें हमने book_controller.rb में परिभाषित किया है। इन विचारों को निष्पादित करते समय, एक साथ जाँचें कि ये क्रियाएँ डेटाबेस में लागू हैं या नहीं।

सूची विधि के लिए व्यू फाइल बनाना

नामक एक फ़ाइल बनाएँ list.html.erbअपने पसंदीदा टेक्स्ट एडिटर का उपयोग करें और इसे ऐप / विचार / पुस्तक में सहेजें। फ़ाइल बनाने और सहेजने के बाद, अपने वेब ब्राउज़र को ताज़ा करें। आपको एक खाली पृष्ठ देखना चाहिए; यदि आप नहीं करते हैं, तो अपनी फ़ाइल की वर्तनी की जाँच करें और सुनिश्चित करें कि यह आपके नियंत्रक की विधि के समान है।

अब, वास्तविक सामग्री प्रदर्शित करें। हम नीचे दिए गए कोड को list.html.erb में डालते हैं।

<% if @books.blank? %>
<p>There are not any books currently in the system.</p>
<% else %>
<p>These are the current books in our system</p>

<ul id = "books">
   <% @books.each do |c| %>
   <li><%= link_to c.title, {:action => 'show', :id => c.id} -%></li>
   <% end %>
</ul>

<% end %>
<p><%= link_to "Add new Book", {:action => 'new' }%></p>

निष्पादित किए जाने वाले कोड को यह जांचना है कि @books सरणी में कोई ऑब्जेक्ट है या नहीं। .blank?विधि सही है अगर सरणी खाली है, और गलत है अगर इसमें कोई ऑब्जेक्ट है। यह @books ऑब्जेक्ट सूची विधि के अंदर नियंत्रक में बनाया गया था।

<% =%> टैग के बीच कोड एक है link_toविधि कॉल। Link_to का पहला पैरामीटर टेक्स्ट है जो <a> टैग के बीच प्रदर्शित होता है। दूसरा पैरामीटर वह है जिसे लिंक पर क्लिक करने पर कार्रवाई कहा जाता है। इस मामले में, यह शो विधि है। अंतिम पैरामीटर उस पुस्तक की आईडी है जिसे परम ऑब्जेक्ट के माध्यम से पारित किया जाता है।

अब, अपने ब्राउज़र को रिफ्रेश करने का प्रयास करें और आपको निम्न स्क्रीन मिलनी चाहिए क्योंकि हमारी लाइब्रेरी में कोई पुस्तक नहीं है।

नई विधि के लिए व्यू फाइल बनाना

अब तक, हमारे पुस्तकालय में कोई पुस्तक नहीं है। हमें सिस्टम में कुछ किताबें बनानी होंगी। तो, आइए हम इसके अनुसार एक दृश्य डिज़ाइन करेंnew book_controller.rb में परिभाषित विधि।

अपने पसंदीदा पाठ संपादक का उपयोग करके new.html.erb नामक एक फ़ाइल बनाएं और इसे ऐप / विचार / पुस्तक में सहेजें। निम्न कोड को new.html.erb फ़ाइल में जोड़ें।

<h1>Add new book</h1>

<%= form_tag :action => 'create' do %>
<p><label for = "book_title">Title</label>:

<%= text_field 'books', 'title' %></p>
<p><label for = "book_price">Price</label>:

<%= text_field 'books', 'price' %></p>
<p><label for = "book_subject_id">Subject</label>:

<%= collection_select(:books, :subject_id, @subjects, :id, :name, prompt: true) %></p>
<p><label for = "book_description">Description</label><br/>

<%= text_area 'books', 'description' %></p>
<%= submit_tag "Create" %>

<% end -%>
<%= link_to 'Back', {:action => 'list'} %>

यहाँ form_tagविधि रूबी कोड को एक नियमित HTML <form> टैग में व्याख्या करती है जो उसे आपूर्ति की गई सभी सूचनाओं का उपयोग करती है। उदाहरण के लिए, यह टैग निम्न HTML आउटपुट करता है -

<form action = "/book/create" method = "post">

अगला तरीका है text_fieldयह एक <input> टेक्स्ट फ़ील्ड को आउटपुट करता है। Text_field के लिए पैरामीटर ऑब्जेक्ट और फ़ील्ड नाम हैं। इस मामले में, वस्तु पुस्तक है और नाम शीर्षक है ।

रेल विधि कहा जाता है collection_selectएक सरणी से निर्मित HTML चयन मेनू बनाता है, जैसे @books एक। पाँच पैरामीटर हैं, जो इस प्रकार हैं -

:book - जिस वस्तु से आप छेड़छाड़ कर रहे हैं। इस मामले में, यह एक पुस्तक वस्तु है।
:subject_id - पुस्तक सहेजे जाने पर आबादी वाला क्षेत्र।
@books - जिस ऐरे से आप काम कर रहे हैं।
:id- वह मान जो डेटाबेस में संग्रहीत होता है। HTML के संदर्भ में, यह <विकल्प> टैग का मान पैरामीटर है।
:name- उत्पादन जो उपयोगकर्ता पुल-डाउन मेनू में देखता है। यह <विकल्प> टैग के बीच का मान है।

अगला प्रयोग है submit_tag, जो एक <input> बटन को आउटपुट करता है जो फॉर्म को सबमिट करता है। अंत में, वहाँ हैend विधि जो केवल </ form> में अनुवाद करती है।

अपने ब्राउज़र पर जाएँ और जाएँ http://localhost:3000/book/new. यह आपको निम्न स्क्रीन देगा।

इस फॉर्म में कुछ डेटा डालें और फिर Create बटन पर क्लिक करें। यहाँ मैंने निम्नलिखित विवरण को खेतों में जोड़ा है -

Title: Advance Physics
Price: 390
Subject: Physics
Description: This is test to create new book

जब आप क्लिक करें Create बटन, यह कॉल करेगा create विधि, जिसे किसी भी दृष्टिकोण की आवश्यकता नहीं है क्योंकि यह विधि या तो उपयोग कर रही है list या newपरिणाम देखने के तरीके। इसलिए, जब आप Create बटन पर क्लिक करते हैं, तो डेटा को सफलतापूर्वक सबमिट करना चाहिए और आपको सूची पृष्ठ पर पुनः निर्देशित करना चाहिए, जिसमें अब आपके पास एक एकल आइटम निम्नानुसार सूचीबद्ध है -

यदि आप लिंक पर क्लिक करते हैं, तो आपको एक और खाका गायब होना चाहिए, क्योंकि आपने अभी तक शो विधि के लिए टेम्प्लेट फ़ाइल नहीं बनाई है।

शो मेथड के लिए व्यू फाइल बनाना

यह विधि पुस्तकालय में उपलब्ध किसी भी पुस्तक के बारे में पूर्ण विवरण प्रदर्शित करेगी। एप्लिकेशन / विचारों / पुस्तक के तहत एक शो.html.erb फ़ाइल बनाएँ और इसे निम्नलिखित कोड के साथ आबाद करें -

<h1><%= @book.title %></h1>

<p>
   <strong>Price: </strong> $<%= @book.price %><br />
   <strong>Subject :</strong> <%= @book.subject.name %><br />
   <strong>Created Date:</strong> <%= @book.created_at %><br />
</p>

<p><%= @book.description %></p>

<hr />

<%= link_to 'Back', {:action => 'list'} %>

यह पहली बार है जब आपने संघों का पूरा लाभ उठाया है, जो आपको संबंधित वस्तुओं से आसानी से डेटा खींचने में सक्षम बनाता है।

उपयोग किया गया प्रारूप है @variable.relatedObject.column। इस उदाहरण में, आप @book चर के माध्यम से विषय का नाम मान खींच सकते हैंbelongs_toसंघों। यदि किसी सूचीबद्ध रिकॉर्ड पर क्लिक करें तो यह आपको निम्न स्क्रीन दिखाएगा।

एडिट मेथड के लिए व्यू फाइल बनाना

Edit.html.erb नामक एक नई फ़ाइल बनाएं और इसे ऐप / विचार / पुस्तक में सहेजें। निम्नलिखित कोड के साथ इसे आबाद करें -

<h1>Edit Book Detail</h1>

<%= form_for @book, :url =>{:action => "update", :id =>@book} do |f| %>

<p>Title: <%= f.text_field 'title' %></p>
<p>Price: <%= f.text_field  'price' %></p>
<p>Subject: <%= f.collection_select :subject_id, Subject.all, :id, :name %></p>
<p>Description<br/>

<%= f.text_area 'description' %></p>
<%= f.submit "Save changes" %>
<% end %>

<%= link_to 'Back', {:action => 'list' } %>

यह कोड बहुत समान है new विधि एक आईडी बनाने और परिभाषित करने के बजाय अद्यतन करने के लिए छोड़कर।

इस परिदृश्य में, हमने उपयोग किया form_forप्रपत्र कार्रवाई के लिए टैग। इससे बेहतर प्रदर्शन होगाform_tag। क्यों कि यह आसानी से मॉडल के साथ बातचीत पैदा करेगा। इसलिए जब भी आपको मॉडल और फ़ॉर्म फ़ील्ड के बीच सहभागिता की आवश्यकता हो, तो form_for टैग का उपयोग करना बेहतर होता है।

इस बिंदु पर, हमें कुछ संशोधन की आवश्यकता है list method'sफाइल देखें। <Li> </ li> तत्व पर जाएं और इसे निम्न की तरह देखने के लिए संशोधित करें -

<li>
   <%= link_to c.title, {:action => "show", :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => "edit",
   :id => c.id} %></b>
</li>

अब, पुस्तकों का उपयोग करके ब्राउज़ करने का प्रयास करें http://localhost:3000/book/list. यह आपको सभी पुस्तकों की सूची प्रदान करेगा Editविकल्प। जब आप संपादन विकल्प पर क्लिक करते हैं, तो आपके पास अगली स्क्रीन इस प्रकार होगी -

अब, आप इस जानकारी को संपादित करते हैं और फिर परिवर्तन सहेजें बटन पर क्लिक करते हैं । यह करने के लिए एक कॉल में परिणाम होगाupdateनियंत्रक फ़ाइल में उपलब्ध विधि और यह सभी परिवर्तित विशेषता को अपडेट करेगा। गौर करें कि दupdate विधि को किसी भी दृश्य फ़ाइल की आवश्यकता नहीं है क्योंकि यह या तो उपयोग कर रहा है show या edit इसके परिणाम दिखाने के तरीके।

डिलीट मेथड के लिए व्यू फाइल बनाना

रूबी ऑन रेल्स का उपयोग कर डेटाबेस से जानकारी निकालना लगभग आसान है। आपको हटाने की विधि के लिए कोई दृश्य कोड लिखने की आवश्यकता नहीं है क्योंकि यह विधि उपयोग कर रही हैlistपरिणाम प्रदर्शित करने की विधि। तो, चलिए फिर से list.html.erb को फिर से संशोधित करते हैं और एक डिलीट लिंक जोड़ते हैं।

<Li> </ li> तत्व पर जाएं और इसे निम्न की तरह देखने के लिए संशोधित करें -

<li>
   <%= link_to c.title, {:action => 'show', :id => c.id} -%>
   <b> <%= link_to 'Edit', {:action => 'edit', :id => c.id} %></b>
   <b> <%= link_to "Delete", {:action => 'delete', :id => c.id},
   :confirm => "Are you sure you want to delete this item?" %></b>
</li>

:confirmपैरामीटर एक जावास्क्रिप्ट पुष्टिकरण बॉक्स प्रस्तुत करता है जो पूछ रहा है कि क्या आप वास्तव में कार्रवाई करना चाहते हैं। यदि उपयोगकर्ता ठीक क्लिक करता है, तो कार्रवाई आगे बढ़ती है, और आइटम हटा दिया जाता है।

अब, उपयोग करके पुस्तकों को ब्राउज़ करने का प्रयास करें http://localhost:3000/book/list. यह आपको सभी पुस्तकों की सूची प्रदान करेगा Edit तथा Delete विकल्प निम्नानुसार हैं -

अब Delete विकल्प का उपयोग करके, आप किसी भी सूचीबद्ध रिकॉर्ड को हटा सकते हैं।

Show_subjects विधि के लिए व्यू फ़ाइल बनाना

एप्लिकेशन / विचार / पुस्तक निर्देशिका में एक नई फ़ाइल, show_subjects.html.erb बनाएँ, और इसके लिए निम्न जोड़ें -

<h1><%= @subject.name -%></h1>

<ul>
   <% @subject.books.each do |c| %>
   <li><%= link_to c.title, :action => "show", :id => c.id -%></li>
   <% end %>
</ul>

आप एक ही विषय की कई पुस्तकों की सूची के माध्यम से पुनरावृत्ति करके संघों का लाभ ले रहे हैं।

अब सब्जेक्ट को संशोधित करें: show.html.erb की लाइन ताकि विषय सूची एक लिंक दिखाए।

<strong>Subject: </strong> <%= link_to @book.subject.name,
:action => "show_subjects", :id => @book.subject.id %><br />

यह इंडेक्स पेज पर विषय की एक सूची का उत्पादन करेगा, ताकि उपयोगकर्ता उन्हें सीधे एक्सेस कर सकें।

संशोधित list.html.erb फ़ाइल के शीर्ष पर निम्नलिखित जोड़ने के लिए -

<ul id = "subjects">
   <% Subject.find(:all).each do |c| %>
   <li><%= link_to c.name, :action => "show_subjects", :id => c.id %></li>
   <% end %>
</ul>

अब http: // localhost: 3000 / book / list का उपयोग करके पुस्तकों को ब्राउज़ करने का प्रयास करें। यह सभी विषयों को लिंक के साथ प्रदर्शित करेगा ताकि आप उस विषय से संबंधित सभी पुस्तकों को ब्राउज़ कर सकें।

आगे क्या है?

आशा है कि अब आप रेल के सभी परिचालनों के साथ सहज महसूस कर रहे हैं।

अगले अध्याय में बताया गया है कि कैसे उपयोग करना है Layoutsअपने डेटा को बेहतर तरीके से रखने के लिए। हम आपको दिखाएंगे कि अपने रेल अनुप्रयोगों में सीएसएस का उपयोग कैसे करें।

एक लेआउट एक HTML पृष्ठ के परिवेश को परिभाषित करता है। यह आपके अंतिम आउटपुट के सामान्य रूप और दृश्य को परिभाषित करने का स्थान है। लेआउट फाइलें ऐप / व्यू / लेआउट में रहती हैं।

इस प्रक्रिया में एक लेआउट टेम्पलेट को परिभाषित करना और फिर नियंत्रक को यह बताना कि यह मौजूद है और इसका उपयोग करना है। सबसे पहले, टेम्पलेट बनाते हैं।

ऐप / विचार / लेआउट के लिए standard.html.erb नामक एक नई फ़ाइल जोड़ें। आप नियंत्रकों को जानते हैं कि फ़ाइल के नाम से किस टेम्पलेट का उपयोग करना है, इसलिए उसी नामकरण योजना का पालन करने की सलाह दी जाती है।

निम्न कोड को नए standard.html.erb फ़ाइल में जोड़ें और अपने परिवर्तनों को सहेजें -

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns = "http://www.w3.org/1999/xhtml">

   <head>
      <meta http-equiv = "Content-Type" content = "text/html; charset = iso-8859-1" />
      <meta http-equiv = "Content-Language" content = "en-us" />
      <title>Library Info System</title>
      <%= stylesheet_link_tag "style" %>
   </head>

   <body id = "library">
      <div id = "container">
         
         <div id = "header">
            <h1>Library Info System</h1>
            <h3>Library powered by Ruby on Rails</h3>
         </div>

         <div id = "content">
            <%= yield -%>
         </div>

         <div id = "sidebar"></div>
         
      </div>
   </body>
   
</html>

आपके द्वारा अभी जोड़ी गई सभी चीजें दो लाइनों को छोड़कर मानक HTML तत्व थीं। stylesheet_link_tagसहायक विधि एक स्टाइलशीट <लिंक> आउटपुट करती है। इस उदाहरण में, हम style.css स्टाइल शीट को लिंक कर रहे हैं। yield कमांड रेल को बताती है कि उसे यहां बताई गई विधि के लिए html.erb डालना चाहिए।

अब खोलो book_controller.rb और पहली पंक्ति के ठीक नीचे निम्न पंक्ति जोड़ें -

class BookController < ApplicationController
layout 'standard'
def list
@books = Book.all
end
...................

यह नियंत्रक को निर्देश देता है कि हम standard.html.erb फ़ाइल में उपलब्ध लेआउट का उपयोग करना चाहते हैं। अब उन पुस्तकों को ब्राउज़ करने का प्रयास करें जो निम्न स्क्रीन का उत्पादन करेंगे।

स्टाइल शीट जोड़ना

अब तक, हमने कोई स्टाइल शीट नहीं बनाई है, इसलिए रेल डिफ़ॉल्ट शैली शीट का उपयोग कर रही है। अब हम एक नई फाइल बनाते हैं, जिसे style.css कहते हैं और इसे / public / स्टाइलशीट में सेव करते हैं। इस फ़ाइल में निम्न कोड जोड़ें।

body {
   font-family: Helvetica, Geneva, Arial, sans-serif;
   font-size: small;
   font-color: #000;
   background-color: #fff;
}

a:link, a:active, a:visited {
   color: #CD0000;
}

input { 
   margin-bottom: 5px;
}

p { 
   line-height: 150%;
}

div#container {
   width: 760px;
   margin: 0 auto;
}

div#header {
   text-align: center;
   padding-bottom: 15px;
}

div#content {
   float: left;
   width: 450px;
   padding: 10px;
}

div#content h3 {
   margin-top: 15px;
}

ul#books {
   list-style-type: none;
}

ul#books li {
   line-height: 140%;
}

div#sidebar {
   width: 200px;
   margin-left: 480px;
}

ul#subjects {
   width: 700px;
   text-align: center;
   padding: 5px;
   background-color: #ececec;
   border: 1px solid #ccc;
   margin-bottom: 20px;
}

ul#subjects li {
   display: inline;
   padding-left: 5px;
}

अब अपने ब्राउज़र को रिफ्रेश करें और अंतर देखें -

आगे क्या है?

अगला अध्याय बताता है कि किसी भी डेटाबेस में रिकॉर्ड जोड़ने, हटाने और संशोधित करने के लिए उपयोगकर्ता को पहुंच प्रदान करने के लिए रेल स्कैफोल्डिंग का उपयोग करके एप्लिकेशन कैसे विकसित करें।

जब आप रेल एप्लिकेशन विकसित कर रहे हों, विशेष रूप से वे जो मुख्य रूप से आपको डेटाबेस में डेटा के लिए एक सरल इंटरफ़ेस प्रदान कर रहे हैं, तो यह अक्सर पाड़ विधि का उपयोग करने के लिए उपयोगी हो सकता है।

मचान सस्ते डेमो थ्रिल से अधिक प्रदान करता है। यहाँ कुछ लाभ दिए गए हैं -

आप प्रतिक्रिया के लिए अपने उपयोगकर्ताओं के सामने जल्दी से कोड प्राप्त कर सकते हैं।
आप तेज सफलता से प्रेरित हैं।
आप जनरेट किए गए कोड को देखकर जान सकते हैं कि रेल कैसे काम करती है।
आप अपने विकास को शुरू करने के लिए एक नींव के रूप में मचान का उपयोग कर सकते हैं।

मचान उदाहरण

मचान को समझने के लिए, आइए एक डेटाबेस बनाएंcookbook और एक मेज बुलाया recipes।

एक खाली रेल वेब अनुप्रयोग बनाना

एक कमांड विंडो खोलें और उस जगह पर नेविगेट करें जहां आप इसे बनाना चाहते हैं cookbookवेब एप्लीकेशन। इसलिए, एक पूर्ण निर्देशिका संरचना बनाने के लिए निम्नलिखित कमांड चलाएँ।

tp> rails new cookbook

डेटाबेस की स्थापना

यहाँ एक डेटाबेस बनाने का तरीका है -

mysql> create database cookbook;
Query OK, 1 row affected (0.01 sec)

mysql> grant all privileges on cookbook.*
to 'root'@'localhost' identified by 'password';
Query OK, 0 rows affected (0.00 sec)

mysql> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.00 sec)

डेटाबेस को खोजने के लिए रेल को निर्देश देने के लिए, कॉन्फ़िगरेशन फ़ाइल cookbook \ config \ database.yml को संपादित करें और डेटाबेस का नाम रसोई की किताब में बदलें। पासवर्ड खाली छोड़ दें। जब आप पूरा कर लें, तो यह इस प्रकार दिखना चाहिए -

development:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
test:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost
	
production:
   adapter: mysql
   database: cookbook
   username: root
   password: [password]
   host: localhost

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

उत्पन्न पाड़ कोड

पाड़ कार्रवाई के साथ, रेल गतिशील रूप से इसकी आवश्यकता वाले सभी कोड उत्पन्न करता है। स्क्रिप्ट के रूप में मचान को चलाकर , हम डिस्क पर लिखे गए सभी कोड प्राप्त कर सकते हैं, जहां हम इसकी जांच कर सकते हैं और फिर इसे अपनी आवश्यकताओं के अनुरूप बनाना शुरू कर सकते हैं।

तो अब, एक बार फिर से शुरू करते हैं कि स्कैफोल्ड हेल्पर स्क्रिप्ट का उपयोग करके मैन्युअल रूप से स्कैफोल्ड कोड उत्पन्न करें -

cookbook> rails generate scaffold recipe

यह नीचे दिखाए गए अनुसार ऑटो-फाइलें उत्पन्न करता है -

नियंत्रक

नियंत्रक के पीछे कोड को देखते हैं। इस कोड से उत्पन्न होता हैscaffoldजनरेटर। अगर आप ऐप / कंट्रोलर / रेसिपी_कंट्रोलर.आरबी खोलते हैं, तो आपको कुछ इस प्रकार मिलेगा -

class RecipesController < ApplicationController
   before_action :set_recipe, only: [:show, :edit, :update, :destroy]
   
   # GET /recipes
   # GET /recipes.json
   def index
      @recipes = Recipe.all
   end
   
   # GET /recipes/1
   # GET /recipes/1.json
   def show
   end
   
   # GET /recipes/new
   def new
      @recipe = Recipe.new
   end
   
   # GET /recipes/1/edit
   def edit
   end
   
   # POST /recipes
   # POST /recipes.json
   def create
      @recipe = Recipe.new(recipe_params)
      
      respond_to do |format|
         if @recipe.save
            format.html { redirect_to @recipe, notice: 'Recipe was successfully created.' }
            format.json { render :show, status: :created, location: @recipe }
         else
            format.html { render :new }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # PATCH/PUT /recipes/1
   # PATCH/PUT /recipes/1.json
   def update
      respond_to do |format|
         if @recipe.update(recipe_params)
            format.html { redirect_to @recipe, notice: 'Recipe was successfully updated.' }
            format.json { render :show, status: :ok, location: @recipe }
         else
            format.html { render :edit }
            format.json { render json: @recipe.errors, status: :unprocessable_entity }
         end
      end
      
   end
   
   # DELETE /recipes/1
   # DELETE /recipes/1.json
   def destroy
      @recipe.destroy
         respond_to do |format|
         format.html { redirect_to recipes_url, notice: 'Recipe was successfully destroyed.' }
         format.json { head :no_content }
      end
   end
   
   private
   
   # Use callbacks to share common setup or constraints between actions.
   def set_recipe
      @recipe = Recipe.find(params[:id])
   end
   
   # Never trust parameters from the scary internet, only allow the white list through.
   def recipe_params
      params.require(:recipe).permit(:tittle, :instructions)
   end
end

जब रेल एप्लिकेशन का उपयोगकर्ता एक क्रिया का चयन करता है, उदाहरण के लिए "शो" - नियंत्रक उपयुक्त अनुभाग में किसी भी कोड को निष्पादित करेगा - "शो दिखाएं" - और फिर डिफ़ॉल्ट रूप से उसी नाम का एक टेम्पलेट प्रस्तुत करेगा - "show.html।" ERB "। यह डिफ़ॉल्ट व्यवहार अधिलेखित किया जा सकता है।

नियंत्रक ActiveRecord विधियों का उपयोग करता है जैसे कि find, find_all, new, save, update_attributes, और डेटाबेस टेबल से डेटा को स्थानांतरित करने के लिए नष्ट करें। ध्यान दें कि आपको किसी भी एसक्यूएल स्टेटमेंट को लिखने की ज़रूरत नहीं है, रेल अपने आप इसका ख्याल रखेगा।

कोड की यह एकल पंक्ति जीवन के लिए डेटाबेस तालिका लाएगी। यह आपके डेटा, और के तरीकों के लिए एक सरल इंटरफ़ेस प्रदान करेगा -

नई प्रविष्टियां बनाना
वर्तमान प्रविष्टियों का संपादन
वर्तमान प्रविष्टियां देखना
वर्तमान प्रविष्टियों को नष्ट करना

प्रविष्टि बनाते या संपादित करते समय, मचान आपके लिए फ़ॉर्म जनरेशन और हैंडलिंग जैसे सभी कठिन कार्य करेगा, और निम्न प्रकार के इनपुट्स का समर्थन करते हुए, चतुर फ़ॉर्म जेनरेशन भी प्रदान करेगा -

सरल पाठ तार
पाठ क्षेत्र (या पाठ के बड़े ब्लॉक)
तिथि चयनकर्ता
तिथि-समय चयनकर्ता

तालिकाओं को बनाने और बनाए रखने के लिए आप रेल माइग्रेशन का उपयोग कर सकते हैं।

rake db:migrate RAILS_ENV=development

अब, कुकबुक डायरेक्टरी में जाएं और निम्न कमांड का उपयोग करके वेब सर्वर चलाएं -

cookbook> rails server

अब, एक ब्राउज़र खोलें और http://127.0.0.1:3000/recipe/new पर नेविगेट करें। यह आपको व्यंजनों तालिका में नई प्रविष्टियां बनाने के लिए एक स्क्रीन प्रदान करेगा। एक स्क्रीनशॉट नीचे दिखाया गया है -

एक बार दबाएं Create एक नया नुस्खा बनाने के लिए बटन, आपका रिकॉर्ड व्यंजनों की तालिका में जोड़ा गया है और यह निम्न परिणाम दिखाता है -

आप रिकॉर्ड को संपादित करने, दिखाने और नष्ट करने का विकल्प देख सकते हैं। इसलिए, इन विकल्पों के साथ खेलें।

आप URL http://127.0.0.1:3000/recipe/list का उपयोग करके रेसिपी टेबल में उपलब्ध सभी व्यंजनों को सूचीबद्ध कर सकते हैं।

मॉडल को बढ़ाना

रेल आपको फ्री में बहुत सी एरर हैंडलिंग प्रदान करती है। इसे समझने के लिए, खाली नुस्खा मॉडल में कुछ सत्यापन नियम जोड़ें -

एप्लिकेशन / मॉडल / रेसिपी को संशोधित करें। इस प्रकार से और फिर अपने आवेदन का परीक्षण करें -

class Recipe < ActiveRecord::Base
   validates_length_of :title, :within => 1..20
   validates_uniqueness_of :title, :message => "already exists"
end

ये प्रविष्टियाँ स्वचालित जाँच देगी।

validates_length_of - मैदान खाली नहीं है और बहुत लंबा नहीं है।
validates_uniqueness_of- डुप्लिकेट मान फंस गए हैं। डिफ़ॉल्ट रेल त्रुटि संदेश के बजाय, हमने यहां एक कस्टम संदेश दिया है।

मचान बनाने का वैकल्पिक तरीका

जैसा कि ऊपर दिखाया गया है एक एप्लिकेशन बनाएं और The Generated Scaffold Code जैसा की नीचे दिखाया गया

rails g scaffold Recipe tittle:string instructions:text

ऊपर दिए गए कोड छवि के नीचे दिखाए गए अनुसार tl औरite कॉलम के साथ sqlite3 का उपयोग करके डेटा बेस के साथ ऑटो फ़ाइलों को उत्पन्न करता है।

हमें सिंटैक्स का उपयोग करके डेटा बेस को माइग्रेट करने की आवश्यकता है।

$ rake db:migrate RAILS_ENV=development

अंत में निम्नलिखित कमांड लाइन का उपयोग करके एप्लिकेशन चलाएं -

rails server

यह आउटपुट छवियों के ऊपर दिखाए गए परिणाम उत्पन्न करेगा।

विचार

सभी व्यूअर और संबंधित सभी कंट्रोलर मेथड द्वारा बनाए गए हैं scaffold कमांड और वे ऐप / विचार / व्यंजनों निर्देशिका में उपलब्ध हैं।

कैसे मचान अलग है?

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

अजाक्स खड़ा है Aएक समय का JavaScript और Xएमएल। अजाक्स एक भी तकनीक नहीं है; यह कई तकनीकों का एक सूट है। अजाक्स में निम्नलिखित शामिल हैं -

वेब पृष्ठों के मार्कअप के लिए एक्सएचटीएमएल
स्टाइल के लिए सीएसएस
DOM का उपयोग करके डायनामिक डिस्प्ले और इंटरैक्शन
XML का उपयोग करके डेटा हेरफेर और इंटरचेंज
XMLHttpRequest का उपयोग करके डेटा पुनर्प्राप्ति
जावास्क्रिप्ट गोंद के रूप में कि यह सब एक साथ जाल

Ajax आपको पूरे पृष्ठ की सामग्री को ताज़ा करने के लिए बिना एक वेब पेज के लिए डेटा पुनः प्राप्त करने में सक्षम बनाता है। मूल वेब आर्किटेक्चर में, उपयोगकर्ता एक लिंक पर क्लिक करता है या एक फॉर्म सबमिट करता है। प्रपत्र सर्वर को सबमिट किया जाता है, जो तब प्रतिक्रिया भेजता है। प्रतिक्रिया तब एक नए पृष्ठ पर उपयोगकर्ता के लिए प्रदर्शित की जाती है।

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

AJAX के बारे में पूरी जानकारी के लिए आप हमारे AJAX ट्यूटोरियल के माध्यम से जा सकते हैं

कैसे अजाक्स लागू करता है

रेल का एक सरल, सुसंगत मॉडल है कि यह कैसे अजाक्स संचालन को लागू करता है। एक बार जब ब्राउज़र ने प्रारंभिक वेब पेज को प्रस्तुत और प्रदर्शित किया है, तो विभिन्न उपयोगकर्ता क्रियाएं इसका कारण एक नया वेब पेज प्रदर्शित करती हैं (जैसे कोई पारंपरिक वेब एप्लिकेशन) या एक अजाक्स ऑपरेशन को ट्रिगर करना -

Some trigger fires - यह ट्रिगर एक बटन या लिंक पर क्लिक करने वाला उपयोगकर्ता हो सकता है, उपयोगकर्ता प्रपत्र पर या किसी फ़ील्ड में या केवल आवधिक ट्रिगर (टाइमर पर आधारित) पर डेटा में परिवर्तन कर रहा है।
The web client calls the server- एक जावास्क्रिप्ट विधि, XMLHttpRequest , ट्रिगर से जुड़े डेटा को सर्वर पर एक एक्शन हैंडलर को भेजता है। डेटा एक चेकबॉक्स की आईडी, एक प्रविष्टि क्षेत्र में पाठ या एक संपूर्ण प्रपत्र हो सकता है।
The server does processing - सर्वर-साइड एक्शन हैंडलर (रेल कंट्रोलर एक्शन) - डेटा के साथ कुछ करता है और वेब क्लाइंट के लिए एक HTML टुकड़ा लौटाता है।
The client receives the response - क्लाइंट-साइड जावास्क्रिप्ट, जो रेल स्वचालित रूप से बनाता है, HTML टुकड़ा प्राप्त करता है और वर्तमान पृष्ठ के HTML के एक निर्दिष्ट हिस्से को अपडेट करने के लिए इसका उपयोग करता है, अक्सर <div> टैग की सामग्री।

ये कदम रेलगाड़ियों को रेल के अनुप्रयोग में उपयोग करने का सबसे सरल तरीका है, लेकिन थोड़े अतिरिक्त काम के साथ, अजाक्स अनुरोध के जवाब में आप सर्वर को किसी भी प्रकार का डेटा वापस कर सकते हैं, और अधिक प्रदर्शन करने के लिए ब्राउज़र में कस्टम जावास्क्रिप्ट बना सकते हैं सहभागिता की।

AJAX उदाहरण

यह उदाहरण स्कैफोल्ड पर आधारित कार्य करता है, नष्ट अवधारणा एंजेक्स पर आधारित कार्य करता है।

इस उदाहरण में, हम पोनीज़ टेबल पर ऑपरेशन प्रदान करेंगे, सूची देंगे, दिखाएँगे और बनाएँगे। यदि आप मचान प्रौद्योगिकी को नहीं समझते थे, तो हम आपको पहले के अध्यायों से गुजरने का सुझाव देंगे और फिर AJAX के साथ रेल जारी रखेंगे।

एक अनुप्रयोग बनाना

हमें एक आवेदन के निर्माण के साथ शुरू करते हैं यह निम्नानुसार किया जाएगा -

rails new ponies

उपरोक्त कमांड एक एप्लिकेशन बनाता है, अब हमें cd कमांड का उपयोग करके ऐप डायरेक्टरी को कॉल करना होगा। यह एक आवेदन निर्देशिका में प्रवेश करेगा फिर हमें एक पाड़ कमांड को कॉल करने की आवश्यकता है। इसे निम्नानुसार किया जाएगा -

rails generate scaffold Pony name:string profession:string

उपरोक्त आदेश नाम और पेशे के कॉलम के साथ पाड़ उत्पन्न करता है। हमें निम्नानुसार डेटा बेस को माइग्रेट करना होगा

rake db:migrate

अब आदेश के अनुसार रेल एप्लिकेशन को चलाएं

rails s

अब वेब ब्राउज़र खोलें और एक यूआरएल को http: // localhost: 3000 / ponies / new के रूप में कॉल करें, आउटपुट निम्नानुसार होगा।

अजाक्स बनाना

अब उपयुक्त टेक्स्ट एडिटर्स के साथ ऐप / व्यू / पोनीज़ / इंडेक्स.html.erb खोलें। अपनी विध्वंस पंक्ति को: दूरस्थ => सत्य, वर्ग => 'delete_pony' के साथ अपडेट करें। आखिरकार, यह इस प्रकार दिखता है।

एक फ़ाइल बनाएं, नष्ट करें ।js.erb, इसे अपनी अन्य .erb फ़ाइलों (एप्लिकेशन / विचारों / टट्टू के तहत) के बगल में रखें। यह इस तरह दिखना चाहिए -

अब नीचे दिए गए कोड को दर्ज करें जैसा कि नीचे दिखाया गया है

$('.delete_pony').bind('ajax:success', function() {
   $(this).closest('tr').fadeOut();
});

अब अपनी कंट्रोलर फाइल खोलें जिसे ऐप / कंट्रोलर / ponies_controller.rb पर रखा गया है और निम्न कोड को नष्ट विधि में जोड़ें जैसा कि नीचे दिखाया गया है -

# DELETE /ponies/1
# DELETE /ponies/1.json
def destroy
   @pony = Pony.find(params[:id])
   @pony.destroy
   
   respond_to do |format|
      format.html { redirect_to ponies_url }
      format.json { head :no_content }
      format.js   { render :layout => false }
   end
   
end

अंत में नियंत्रक पृष्ठ छवि के रूप में दिखाया गया है।

अब एक एप्लिकेशन चलाएं, आउटपुट जिसे http: // localhost: 3000 / ponies / new से पुकारा गया है, यह निम्न छवि जैसा दिखेगा

पोनी बटन बनाएं पर दबाएं, यह परिणाम निम्नानुसार उत्पन्न करेगा

अब बैक बटन पर क्लिक करें, यह दिखाए गए चित्र के रूप में सभी टट्टू निर्मित जानकारी दिखाएगा

अब तक, हम मचान पर काम कर रहे हैं, अब नष्ट बटन पर क्लिक करें, यह एक पॉप-अप को बुलाएगा जैसा कि नीचे दी गई छवि में दिखाया गया है, अजाक्स पर आधारित पॉप-अप काम करता है।

यदि ओके बटन पर क्लिक करें, तो यह टट्टू से रिकॉर्ड हटा देगा। यहाँ मैंने ok बटन पर क्लिक किया है। अंतिम आउटपुट निम्नानुसार होगा -

आपके पास एक आवश्यकता हो सकती है जिसमें आप अपनी साइट के आगंतुकों को अपने सर्वर पर एक फ़ाइल अपलोड करना चाहते हैं। रेल इस आवश्यकता को संभालना बहुत आसान बनाता है। अब हम एक सरल और छोटी रेल परियोजना के साथ आगे बढ़ेंगे।

हमेशा की तरह, चलो एक नई रेल एप्लिकेशन के साथ शुरू करते हैं जिसे कहा जाता है testfile। आइए सरल रेल कमांड का उपयोग करके एप्लिकेशन की मूल संरचना बनाएं।

tp> rails new testfile

अनुप्रयोग विकास शुरू करने से पहले, हमें नीचे दिखाए गए अनुसार मणि फाइलें स्थापित करनी चाहिए -

gem install carrierwave
gem install bootstrap-sass

अपने रत्न को खोलें और नीचे दिए गए दो रत्नों को जोड़ दें जैसा कि निम्नलिखित छवि में दिखाया गया है -

रत्न फ़ाइल में रत्न जोड़ने के बाद, हमें कंसोल पर निम्नलिखित कमांड चलाने की आवश्यकता है -

bundle install

मॉडल बनाना

हमें नाम और लगाव के रूप में दो स्ट्रिंग्स के साथ एक मॉडल बनाने की आवश्यकता है जैसा कि नीचे दिखाया गया है -

rails g model Resume name:string attachment:string

हमें डेटाबेस माइग्रेशन बनाने की आवश्यकता है जैसा कि नीचे दिखाया गया है -

rake db:migrate

हमें नीचे दिखाए अनुसार नियंत्रक उत्पन्न करना होगा -

rails g controller Resumes index new create destroy

महान! अब हमारे पास आधारभूत संरचना है। अब हमें अपलोडर बनाने की आवश्यकता है। एक अपलोडर कैरियरवाहक मणि से आया था और यह वाहक को बताता है कि फाइलों को कैसे संभालना है। संक्षेप में, इसमें सभी फ़ाइल प्रोसेसिंग फ़ंक्शंस शामिल हैं। नीचे दिखाए अनुसार अपलोडर बनाने के लिए कमांड चलाएँ

rails g uploader attachment

अब फिर से शुरू होने वाले मॉडल को खोलें और नीचे दिखाए अनुसार अपलोडर को कॉल करें। रिज्यूम मॉडल को ऐप / मॉडल / फिर से शुरू किया गया है।

class Resume < ActiveRecord::Base
   mount_uploader :attachment, AttachmentUploader # Tells rails to use this uploader for this model.
   validates :name, presence: true # Make sure the owner's name is present.
end

नियंत्रक पर काम करने से पहले, हमें अपने config / मार्गों को संशोधित करना होगा।

CarrierWaveExample::Application.routes.draw do
   resources :resumes, only: [:index, :new, :create, :destroy]
   root "resumes#index"
end

नीचे दिए गए अनुसार हम नियंत्रक को संपादित करते हैं।

class ResumesController < ApplicationController
   def index
      @resumes = Resume.all
   end
   
   def new
      @resume = Resume.new
   end
   
   def create
      @resume = Resume.new(resume_params)
      
      if @resume.save
         redirect_to resumes_path, notice: "The resume #{@resume.name} has been uploaded."
      else
         render "new"
      end
      
   end
   
   def destroy
      @resume = Resume.find(params[:id])
      @resume.destroy
      redirect_to resumes_path, notice:  "The resume #{@resume.name} has been deleted."
   end
   
   private
      def resume_params
      params.require(:resume).permit(:name, :attachment)
   end
   
end

चलिए css file.css फ़ाइल में बूटस्ट्रैप कार्यान्वयन जोड़ते हैं / एप्लिकेशन / एसेट / स्टाइलशीट / रिज्यूमे।

@import "bootstrap";

अब एप्लिकेशन / विचार / लेआउट / application.html.erb खोलें और नीचे दिखाए अनुसार कोड जोड़ें -

<!DOCTYPE html>
<html>
   
   <head>
      <title>Tutorialspoint</title>
      <%= stylesheet_link_tag "application", media: "all", "data-turbolinks-track" => true %>
      <%= javascript_include_tag "application", "data-turbolinks-track" => true %>
      <%= csrf_meta_tags %>
   </head>
   
   <body>
      <div class = "container" style = "padding-top:20px;">
         <%= yield %>
      </div>
   </body>

</html>

अब हमें नीचे दिखाए अनुसार सूचकांक दृश्य सेट करने की आवश्यकता है -

<% if !flash[:notice].blank? %>
   <div class = "alert alert-info">
      <%= flash[:notice] %>
   </div>
<% end %>

<br />

<%= link_to "New Resume", new_resume_path, class: "btn btn-primary" %>
<br />
<br />

<table class = "table table-bordered table-striped">
   <thead>.
      <tr>
         <th>Name</th>
         <th>Download Link</th>
         <th> </th>
      </tr>
   </thead>
   
   <tbody>
      <% @resumes.each do |resume| %>
         
         <tr>
            <td><%= resume.name %></td>
            <td><%= link_to "Download Resume", resume.attachment_url %></td>
            <td><%= button_to "Delete",  resume, method: :delete, class: "btn btn-danger", confirm: "Are you sure that you wish to delete #{resume.name}?" %></td>
         </tr>
         
      <% end %>
   </tbody>
   
</table>

अब, new.html.erb को संपादित करने और हमारे फॉर्म कोड को जोड़ने देता है।

<% if [email protected]? %>
   <div class = "alert alert-error">
      
      <ul>
         <% @resume.errors.full_messages.each do |msg| %>
            <li><%= msg %></li>
         <% end %>
      </ul>
      
   </div>
<% end %>

<div class = "well">
   <%= form_for @resume, html: { multipart: true } do |f| %>
      <%= f.label :name %>
      <%= f.text_field :name %>
      <%= f.label :attachment %>
      <%= f.file_field :attachment %>
      <%= f.submit "Save", class: "btn btn-primary" %>
   <% end %>
</div>

अब सर्वर शुरू करें और http: // localhost: 3000 पर जाएँ। यह निम्नानुसार एक स्क्रीन का उत्पादन करेगा -

एक आखिरी चीज जो हमें करने की ज़रूरत है वह अनुमत फ़िलेपेट्स की सूची को फ़िल्टर करना है। इसके लिए हमें ऐप / अपलोडर्स / अटैचमेंट_अपलोडर.आरबी के नीचे दिए गए सरल कोड को जोड़ने की आवश्यकता है

class AttachmentUploader < CarrierWave::Uploader::Base
   storage :file
   
   def store_dir
      "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
   end
   
   def extension_white_list
      %w(pdf doc htm html docx)
   end
end

अब सर्वर शुरू करें और http: // localhost: 3000 पर जाएँ। अब एक गलत प्रारूप इनपुट; यह एक गलत संदेश उत्पन्न करेगा जैसा कि नीचे दिखाया गया है -

पर पूरी जानकारी के लिए File वस्तु, आप के माध्यम से जाने की जरूरत है Ruby Reference Manual।

Action Mailerरेल घटक है जो ईमेल भेजने और प्राप्त करने के लिए अनुप्रयोगों को सक्षम करता है। इस अध्याय में, हम देखेंगे कि रेल का उपयोग करके ईमेल कैसे भेजें। चलिए बनाना शुरू करते हैंemails निम्नलिखित आदेश का उपयोग कर परियोजना।

tp> rails new mailtest

यह आगे बढ़ने के लिए आवश्यक ढांचा तैयार करेगा। अब, हम ActionMailer को कॉन्फ़िगर करने के साथ शुरू करेंगे।

एक्शन मेलर - कॉन्फ़िगरेशन

वास्तविक कार्य के साथ आगे बढ़ने से पहले आपको अपने कॉन्फ़िगरेशन को पूरा करने के लिए निम्नलिखित चरणों का पालन करना होगा -

अपने ईमेल प्रोजेक्ट के कॉन्फिगर फ़ोल्डर में जाएं और environment.rb फ़ाइल खोलें और इस फ़ाइल के निचले भाग में निम्न पंक्ति जोड़ें।

config.action_mailer.delivery_method = :smtp

यह ActionMailer को बताता है कि आप SMTP सर्वर का उपयोग करना चाहते हैं। आप इसे सेट करने के लिए भी भेज सकते हैं: अगर आप यूनिक्स-आधारित ऑपरेटिंग सिस्टम जैसे मैक ओएस एक्स या लिनक्स का उपयोग कर रहे हैं, तो इसे भेजें।

अपने पर्यावरण के तल पर कोड की निम्नलिखित पंक्तियों को जोड़ें।

config.action_mailer.smtp_settings = {
   address:              'smtp.gmail.com',
   port:                 587,
   domain:               'example.com',
   user_name:            '<username>',
   password:             '<password>',
   authentication:       'plain',
   enable_starttls_auto: true  
}

प्रत्येक हैश मान को अपने सिंपल मेल ट्रांसफर प्रोटोकॉल (SMTP) सर्वर के लिए उचित सेटिंग्स से बदलें। यदि आप पहले से ही नहीं जानते हैं तो आप यह जानकारी अपने इंटरनेट सेवा प्रदाता से ले सकते हैं। यदि आप मानक SMTP सर्वर का उपयोग कर रहे हैं, तो आपको पोर्ट नंबर 25 और प्रमाणीकरण प्रकार बदलने की आवश्यकता नहीं है।

आप डिफ़ॉल्ट ईमेल संदेश प्रारूप भी बदल सकते हैं। यदि आप सादे पाठ प्रारूप के बजाय HTML में ईमेल भेजना पसंद करते हैं, तो निम्न पंक्ति को config / environment.rb पर भी जोड़ें -

ActionMailer::Base.default_content_type = "text/html"

ActionMailer :: Base.default_content_type को "text / plain", "text / html", और "text / समृद्ध" पर सेट किया जा सकता है। डिफ़ॉल्ट मान "पाठ / सादा" है।

एक मेलर बनाने के लिए अगला कदम होगा

एक मेलर उत्पन्न करें

एक मेलर बनाने के लिए निम्न आदेश का उपयोग करें: -

tp> cd emails
emails> rails generate mailer Usermailer

इससे app \ mailer डायरेक्टरी में एक user_mailer.rb फाइल बन जाएगी। इस फ़ाइल की सामग्री को निम्नानुसार जांचें -

class Emailer < ActionMailer::Base
end

आइये एक विधि बनाते हैं -

class UserMailer < ApplicationMailer
   default from: '[email protected]'
   
   def welcome_email(user)
      @user = user
      @url  = 'http://www.gmail.com'
      mail(to: @user.email, subject: 'Welcome to My Awesome Site')
   end
   
end

default Hash- यह इस मेलर द्वारा भेजे गए किसी भी ईमेल के लिए डिफ़ॉल्ट मानों का हैश है। इस स्थिति में हम इस श्रेणी के सभी संदेशों के लिए हेडर से मान के लिए सेट कर रहे हैं। इसे प्रति-ईमेल आधार पर ओवरराइड किया जा सकता है
mail - वास्तविक ई-मेल संदेश, हम इसमें और: विषय हेडर को पास कर रहे हैं।

App / views / user_mailer / में wel_email.html.erb नामक एक फ़ाइल बनाएँ। यह HTML में प्रारूपित ईमेल के लिए उपयोग किया जाने वाला टेम्पलेट होगा -

<html>
   
   <head>
      <meta content = 'text/html; charset = UTF-8' http-equiv = 'Content-Type' />
   </head>
   
   <body>
      <h1>Welcome to example.com, <%= @user.name %></h1>
      
      <p>
         You have successfully signed up to example.com,your username is: 
         <%= @user.login %>.<br>
      </p>
      
      <p>
         To login to the site, just follow this link: 
         <%= @url %>.
      </p>
      
      <p>Thanks for joining and have a great day!</p>
      
   </body>
</html>

आगे हम इस एप्लिकेशन के लिए एक पाठ भाग बनाएंगे, जो निम्नलिखित है -

Welcome to example.com, <%= @user.name %>
===============================================
 
You have successfully signed up to example.com,
your username is: <%= @user.login %>.
 
To login to the site, just follow this link: <%= @url %>.
 
Thanks for joining and have a great day!

मेलर को कॉल करना

सबसे पहले, आइए एक साधारण उपयोगकर्ता मचान बनाएं

$ bin/rails generate scaffold user name email login
$ bin/rake db:migrate

एक्शन मेलर सक्रिय रूप से जॉब के साथ एकीकृत है, इसलिए आप अनुरोध-प्रतिक्रिया चक्र के बाहर ईमेल भेज सकते हैं, इसलिए उपयोगकर्ता को इस पर इंतजार नहीं करना होगा -

class UsersController < ApplicationController
   # POST /users
   # POST /users.json
   def create
   @user = User.new(params[:user])
   
      respond_to do |format|
         if @user.save
            # Tell the UserMailer to send a welcome email after save
            UserMailer.welcome_email(@user).deliver_later
            
            format.html { redirect_to(@user, notice: 'User was successfully created.') }
            format.json { render json: @user, status: :created, location: @user }
         else
            format.html { render action: 'new' }
            format.json { render json: @user.errors, status: :unprocessable_entity }
         end
         
      end
      
   end
end

अब, http://127.0.0.1:3000/users/new का उपयोग करके अपने आवेदन का परीक्षण करें। यह निम्न स्क्रीन प्रदर्शित करता है और इस स्क्रीन का उपयोग करके, आप अपना संदेश किसी को भी भेज सकेंगे।

यह आपका संदेश भेजेगा और पाठ संदेश "संदेश सफलतापूर्वक भेजा गया" और आउटपुट निम्नानुसार प्रदर्शित करेगा -

sent mail to [email protected] (2023.Sms)
[ActiveJob] [ActionMailler::DeliveryJob] [2cfde3c-260e-4a33-1a6ada13a9b] Date: Thu, 09 Jul 2015 11:44:05 +0530
From: [email protected]
To: [email protected]
Message-Id: <[email protected]>
Subject: Welcome to My Awesome Site
Mime-Version: 1.0
Content-Type: multipart/alternative;
boundary="--mimepart_559e112d601c8_f1031e7f20233f5";
charset=UTF-8
Content-Transfer-Encoding:7bit

रेल का उपयोग करके ईमेल भेजने के बारे में अधिक जानकारी के लिए, कृपया ActionMailer पर जाएं ।