पेश है रूबी ऑन रेल्स (भाग 2)

" रूबी पर रूबी से परिचित होना " लेख की निरंतरता में, हम सीखेंगे कि डेटाबेस के साथ कैसे काम करें और लेखों की एक सूची बनाएं।

हम सीखेंगे कि प्लगइन कैसे लिखा जाता है, AJAX का उपयोग करने का प्रयास करें और होस्टिंग पर एप्लिकेशन को तैनात करते समय कुछ समस्याओं पर विचार करें।

डेटाबेस से शुरू करते हैं।

मैं MySQL के साथ काम करता हूं, इसलिए इंस्टॉलेशन उदाहरण इसके लिए होंगे।



विंडोज उपयोगकर्ताओं को MySQL-5.0 को डाउनलोड और इंस्टॉल करना होगा।



लिनक्स (उबंटू) उपयोगकर्ताओं के लिए, यह और भी आसान है:

  <code class = 'sh' lang = 'sh'> $> sudo apt-get install mysql-server-5.0 libmysql-ruby </ code> 

स्थापना के बाद, जांचें कि सर्वर काम कर रहा है:

  <code class = 'sh' lang = 'sh'> $> mysqladmin ping -u root
 mysqld जीवित है </ code> 

यह सही डेटाबेस बनाने का समय है। उनमें से दो की आवश्यकता होगी - एक विकास के लिए और एक परीक्षण के लिए:

  <code class = 'sh' lang = 'sh'> $> mysqladmin example_development -u root बनाएँ
 $> mysqladmin example_test -u root </ code> बनाएँ 

अब हम config/database.yml



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



यह डेटाबेस के साथ एप्लिकेशन के कनेक्शन का परीक्षण करने के लिए बना हुआ है। हम एप्लिकेशन फ़ोल्डर में जाते हैं और टाइप करते हैं

  <code class = 'sh' lang = 'sh'> $> रेक </ code> 

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

डेटाबेस के साथ काम करने का परिचय।

रेल में वस्तुओं और डेटाबेस का कनेक्शन OR मैपर का उपयोग करके किया जाता है, जिसे ActiveRecord कहा जाता है। वह डेटाबेस तालिका से फ़ील्ड्स को ऑब्जेक्ट के फ़ील्ड्स में मैप करने, सहेजने से पहले ऑब्जेक्ट्स का सत्यापन, ऑब्जेक्ट्स के साथ संबंधों का प्रतिनिधित्व करने के लिए कोड जनरेशन से संबंधित है।



एक नया मॉडल बनाने के लिए, यह ActiveRecord::Base



वर्ग से वारिस करने के लिए पर्याप्त है

  <code class = 'ruby' lang = 'ruby'> वर्ग आलेख <ActiveRecord :: Base
 अंत </ code> 

डिफ़ॉल्ट रूप से, ActiveRecord एक तालिका के साथ भी काम करेगा, जिसका नाम एक वर्ग है, केवल बहुवचन में। हमारे मामले में, लेख।



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

  <code class = 'ruby' lang = 'ruby'> # लेख तालिका में शीर्षक फ़ील्ड हो
 Article.create (: शीर्षक => 'हैलो वर्ल्ड!')
 आलेख = Article.find (1)
 लेख को प्रिंट करें
 # => हैलो वर्ल्ड! </ Code> 

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

• आपको एक अलग नाम के साथ एक तालिका का उपयोग करने की आवश्यकता है - कक्षा में लाइन set_table_name "mytablename"
  
  
  
  जोड़ें
• फ़ील्ड तालिका में कुटिल हैं - शायद खेतों के लिए सामान्य नामों के साथ एक्सेस विधियों को लिखना बेहतर है
• एक ऑब्जेक्ट को कई तालिकाओं पर मैप किया जाता है - आपको अपना ORM लिखना होगा :)

ActiveRecord कई उपयोगी सुविधाएँ प्रदान करता है, यहाँ उनमें से कुछ हैं:

• Article.find(id)
  
  
  
  - आईडी द्वारा एक लेख ढूंढें (प्राथमिक रूप से डेटाबेस में, आमतौर पर यह पूर्णांक है)
• Article.find(:all)
  
  
  
  - सभी लेखों का चयन करें
• Article.find_by_title('Hello World!')
  
  
  
  - "हैलो वर्ल्ड!" शीर्षक के साथ एक लेख खोजें।
• Article.create(:title => 'Hello World!')
  
  
  
  - एक लेख बनाएं और इसे डेटाबेस में सहेजें
• article.update(:title => 'Goodbye World!')
  
  
  
  - डेटाबेस में लेख को अपडेट करें
• article.destroy
  
  
  
  - डेटाबेस से एक लेख हटाएं

ActiveRecord और अन्य स्थापित रत्नों के लिए प्रलेखन देखने के लिए आपको चलाने की आवश्यकता है

  <code class = 'sh' lang = 'sh'> `$> gem_server` </ code> 

और ब्राउज़र में खोलें



http: // लोकलहोस्ट: 8808 /

अब एक निर्देशिका बनाने की कोशिश करते हैं।

हम निर्देशिका के लिए मॉडल, नियंत्रक और विचार बनाने के लिए script/generate



का उपयोग करेंगे।

  <कोड> $> रूबी स्क्रिप्ट / जनरेट करें scaffold_resource लेख शीर्षक: string body_format: string body: text / a /> 

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



रेल ने कई फाइलें बनाईं, उनमें से कुछ को देखें:

• app/models/article.rb
  
  
  
  - लेख के लिए मॉडल
• app/controllers/articles\_controller.rb
  
  
  
  - लेख निर्देशिका के प्रबंधन के लिए नियंत्रक
• config/routes.rb
  
  
  
  - लाइन लाइन map.resources :articles
  
  
  
  
• app/views/articles/...
  
  
  
  - app/views/articles/...
  
  
  
  बनाने, संपादन और देखने के लिए विचार
• app/views/layouts/articles.rhtml
  
  
  
  - निर्देशिका के साथ काम करने के लिए पेज टेम्पलेट
• db/migrate/001_create_articles.rb
  
  
  
  - डेटाबेस में लेखों के लिए एक तालिका बनाएँ

मॉडल के साथ, मुझे लगता है कि सब कुछ स्पष्ट है, चलो नियंत्रक को देखें। नियंत्रक के 7 तरीके हैं:

• index
  
  
  
  - पृष्ठ लेखों के पूरे संग्रह को प्रदर्शित करता है
• show
  
  
  
  - पेज एक लेख प्रदर्शित करता है
• new
  
  
  
  - नया लेख बनाने के लिए पेज
• edit
  
  
  
  - किसी मौजूदा लेख को संपादित करने के लिए पेज
• create
  
  
  
  - create new article form का पोस्ट हैंडलर
• update
  
  
  
  - लेख संपादन के लिए पोस्ट हैंडलर
• destroy
  
  
  
  - लेख हटाने का अनुरोध हैंडलर

लाइन map.resources :articles



config/routes.rb



में map.resources :articles



आवश्यक URL रूटिंग नियम जोड़ता है। यहां बताया गया है कि बनाए गए url क्या हैं:

• /articles (GET)
  
  
  
  - सूचकांक
• /articles/:id (GET)
  
  
  
  - शो (: आईडी - लेख पहचानकर्ता)
• /articles;new (GET)
  
  
  
  - नया
• /articles/:id;edit (GET)
  
  
  
  - संपादित करें
• /articles (POST)
  
  
  
  - बनाएँ
• /articles/:id (PUT)
  
  
  
  - अद्यतन
• /articles/:id (DELETE)
  
  
  
  - नष्ट

PUT और DELETE HTTP तरीके हैं जैसे GET और POST।

इस प्रकार, यह संग्रह के प्रबंधन के लिए आवश्यक सभी तरीकों को फिट करने के लिए निकला, जो कि यूआरएल के छोटे सेट में उपयोगकर्ता के लिए समझ में आता है।



किसी एप्लिकेशन को रिसोर्स सेट में विभाजित करने और संसाधनों तक पहुँचने के लिए एक सार्वभौमिक प्रारूप प्रदान करने का सिद्धांत (urls बनाने का एक तरीका) REST कहलाता है। संसाधनों के साथ काम करने के लिए एक विचारहीन प्रोटोकॉल का उपयोग करना है (सभी आवश्यक जानकारी url में निहित है), जो अनुप्रयोग की मापनीयता में सुधार करेगा और कैशिंग को सरल करेगा।



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



आइए परिणाम देखें, सर्वर शुरू करें

  <code class = 'sh' lang = 'sh'> `$> रूबी लिपि / सर्वर` </ code> 

और जाओ



http: // localhost: 3000 / लेख



मुझे यह त्रुटि मिली:

  <code> Mysql :: त्रुटि: तालिका 'example_development.articles' मौजूद नहीं है: लेखों का चयन करें * / ईमेल> 

डेटाबेस में कोई articles



तालिका नहीं है; आपको इसे बनाना होगा।



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



तालिका ( db/migrate/001_create_articles.rb



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

  <code> $> rake db: माइग्रेट करें </ code> 

माइग्रेशन के परिणामस्वरूप, लेख तालिका डेटाबेस में बनाई गई थी, और अब हम F5 ब्राउज़र पर क्लिक कर सकते हैं और एप्लिकेशन के साथ खेल सकते हैं।

रेक के बारे में कुछ शब्द।

रेक make



, ant



, maven



जैसी उपयोगिताओं के लिए एक प्रतिस्थापन है।

यह जानने के लिए कि रेक हमारे लिए क्या कर सकता है, निम्न कार्य करें:

  <code class = 'sh' lang = 'sh'> $> rake -T </ code> 

उन कार्यों की एक लंबी सूची प्राप्त करें जो रेक कर सकता है। कार्य रूबी में लिखे गए हैं और राकफाइल फ़ाइल में स्थित हैं। प्रारंभ में, फ़ाइल में केवल require 'tasks/rails'



का उपयोग करके जुड़े कार्यों का एक मानक सेट होता है। यहां db:migrate



विवरण का एक उदाहरण दिया गया है db:migrate



कार्य:

  <code class = 'ruby' lang = 'ruby'> desc "डेटाबेस को स्क्रिप्ट्स के माध्यम से d / migrate में माइग्रेट करें। VERSION = x के साथ विशिष्ट संस्करण लक्षित करें।"
 कार्य: माइग्रेट =>: पर्यावरण करते हैं
   ActiveRecord :: Migrator.migrate ("db / migrate /", ENV ["संस्करण"]? ENV ["संस्करण"]। To_i: nil।
   रेक :: टास्क ["db: स्कीमा: डंप"]। यदि ActiveRecord :: Base.schema_format ==: माणिक आमंत्रित करें
 अंत </ code> 

रेक की सुंदरता यह है कि कार्य विवरण नियमित रूबी कोड है। यह ant



या maven



की तुलना में नए कार्यों को जोड़ने को बहुत सरल करता है।



मार्टिन फाउलर का रेक पर एक उत्कृष्ट लेख है।



हमें आवश्यकतानुसार रेक पता चलेगा। अब हम पहले से ही जानते हैं कि db:migrate



कार्य माइग्रेशन को ट्रिगर करता है, और आप वापस परिवर्तनों को लागू और रोल कर सकते हैं। यदि हम db/migrate/001_create_articles.rb



को देखते हैं, तो हम देखेंगे कि CreateArticles



वर्ग में दो विधियाँ हैं: ऊपर और नीचे। इन तरीकों को बुलाया जाता है जब माइग्रेशन लागू होता है और उसी के अनुसार वापस रोल किया जाता है। फ़ाइल नाम में नंबर 001



माइग्रेशन सीरियल नंबर है, इसका उपयोग माइग्रेशन के आवेदन के क्रम को निर्धारित करने के लिए किया जाता है, जबकि रेल डेटाबेस में इसके संस्करण को स्टोर करते हैं ताकि एक माइग्रेशन कई बार लागू न हो। डेटाबेस को किसी विशिष्ट संस्करण में माइग्रेट करने के लिए, आपको db:migrate



चलाने की आवश्यकता है db:migrate



VERSION पैरामीटर के साथ db:migrate



करें:

  <code> $> rake db: VERSION = 0 </ code> माइग्रेट करें 

नतीजतन, डेटाबेस संस्करण शून्य पर चला जाता है, जब कोई तालिका अभी तक नहीं बनाई गई है। एप्लिकेशन के साथ प्रयोग करने के बाद डेटाबेस को खाली करने का यह एक सुविधाजनक तरीका है। तब आप db:migrate



को कॉल कर सकते हैं db:migrate



मापदंडों के बिना फिर से db:migrate



करें, परिणामस्वरूप, सभी माइग्रेशन लागू होंगे।

कैटलॉग बहुत अच्छा है, लेकिन लेख प्रारूपित नहीं हैं।

मुझे आशा है कि आपने पहले ही कैटलॉग को देखा और इस बारे में सुनिश्चित किया। लेख के मुख्य कार्य से निपटने का समय - आलेखों को प्रारूपित करना।



हमारे पास पहले से ही प्रारूपण के लिए कोड है, अब हमें यह समझने की आवश्यकता है कि इसका उपयोग कैसे करें। पहले संस्करण में, हमारे पास केवल एक नियंत्रक था, इसलिए कोड सीधे इसमें स्थित था, Article



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

हम एक प्लगइन लिखेंगे।

पटरियों पर, यह अनुप्रयोग में कार्यक्षमता जोड़ने का प्राकृतिक तरीका है। इस मामले में, प्रारूपण कोड को मॉडल से अलग किया जाएगा, जो इसे अन्य अनुप्रयोगों में उपयोग करने की अनुमति देगा।



मैं इस तरह के उदाहरण के लिए अनावश्यक शब्दों के बिना स्वरूपण समर्थन प्रदान करने के लिए प्लगइन चाहता हूं:

  <code> वर्ग आलेख <ActiveRecord :: Base
   कृत्यों_स_रूपता: शरीर
 अंत </ code> 

इस स्थिति में, स्रोत पाठ body



फ़ील्ड में है, और लेख का स्वरूपित पाठ body_as_html



विधि का उपयोग करके प्राप्त किया जा सकता है। वह प्रारूप जिसमें लेख लिखा गया है, body_format



फ़ील्ड में है।



चलिए शुरू करते हैं। सबसे पहले, हम हमारे लिए प्लग-इन कंकाल बनाने के लिए रेल पर भरोसा करेंगे:

  <कोड> $> रूबी स्क्रिप्ट / प्लगइन एक्ट_स_फॉर्मटेड </ कोड> उत्पन्न करते हैं 

हमारा vendor/plugins



फ़ोल्डर में दिखाई दिया। अंदर क्या है:

• lib
  
  
  
  - इस फ़ोल्डर में कोड है
• lib/acts_as_formatted.rb
  
  
  
  - प्लगइन कोड होगा
• tasks
  
  
  
  - प्लगइन रेक के लिए कार्य जोड़ सकते हैं, वे सामान्य सूची में दिखाई देंगे
• test
  
  
  
  - प्लगइन अच्छी तरह से परीक्षण किया जाना चाहिए
• init.rb
  
  
  
  - इस फ़ाइल को बूट समय पर निष्पादित किया जाता है, यहां प्लग-इन फाइलें जो कि आवश्यक हैं, शामिल हैं
• install.rb
  
  
  
  , uninstall.rb
  
  
  
  - इन फाइलों को प्लगइन की स्थापना और हटाने के दौरान निष्पादित किया जाता है, हमें उनकी आवश्यकता नहीं होगी
• Rakefile
  
  
  
  - प्लगइन के लिए रेक कार्यों के साथ एक फ़ाइल (परीक्षण चल रहा है और प्रलेखन उत्पन्न करना)

अब यह फ़ॉर्मेटिंग के लिए कोड लिखने और ActiveRecord में समर्थन जोड़ने के लिए बना हुआ है।



यह कैसे करना है? कार्य ActiveRecord::Base



के acts_as_formatted



विधि को जोड़ना है। और इस विधि में, स्वरूपण का समर्थन करने के लिए आवश्यक कोड उत्पन्न करें। ऐसा करने के लिए, हमें यह जानना होगा कि रूबी में यह कैसे किया जा सकता है।

रूबी में एक मौजूदा वर्ग के लिए कार्यक्षमता कैसे जोड़ें।

रूबी में, इस सरल कार्यक्रम में सब कुछ एक वस्तु है।

  <code class = 'ruby' lang = 'ruby'> प्रिंट "हैलो वर्ल्ड!" </ code> 

वस्तु की विधि को कहा जाता है। कौन सी वस्तु? यह एक प्रकार का मॉड्यूल (नाम स्थान, पैकेज का एनालॉग) की एक वस्तु है, वैश्विक मॉड्यूल को कर्नेल कहा जाता है। मॉड्यूल कक्षाओं के समान हैं, इसमें भिन्नता है कि वे केवल विधियाँ, स्थिरांक और अन्य मॉड्यूल और कक्षाएं शामिल कर सकते हैं। उसी समय, रूबी आपको अन्य मॉड्यूल और कक्षाओं में (मिक्सिन) मॉड्यूल को मिलाने की अनुमति देता है, यह extend



और मॉड्यूल और कक्षाओं के तरीकों को include



करने के लिए किया जाता है, उदाहरण के लिए:

  <code class = 'ruby' lang = 'ruby'> वर्ग MyClass
   विस्तार योग्य
 अंत </ code> 

या

  <code class = 'ruby' lang = 'ruby'> वर्ग MyClass
 अंत

 MyClass.extend (Enumerable) </ code> 

उसी समय, Enumerable



मॉड्यूल में परिभाषित सभी विधियाँ, स्थिरांक, वर्ग और मॉड्यूल MyClass



वर्ग में दिखाई देंगे।

हम एक प्लगइन लिख रहे हैं।

प्लगइन कोड के लगभग सभी acts_as_formatted.rb



फ़ाइल में होंगे।



प्लगइन में दो मॉड्यूल होते हैं:

• ActiveRecord::Acts::ActsAsFormatted::Formatting
  
  
  
  - स्वरूपण के लिए जिम्मेदार कोड
• ActiveRecord::Acts::ActsAsFormatted::ClassMethods
  
  
  
  - इसमें एकमात्र तरीका ActiveRecord::Acts::ActsAsFormatted::ClassMethods
  
  
  
  है, यह मॉड्यूल ActiveRecord::Base
  
  
  
  जोड़ा जाता है

आइए देखते हैं कि क्या कार्य करता है acts_as_formatted



विधि।

पहले हमें पता चलता है कि कौन से प्रारूप समर्थित हैं और कौन से फ़ील्ड का उपयोग किया जाएगा (हमारे मामले में, body_format



, body_as_html



), फिर हम एक सत्यापन नियम जोड़ते हैं यह जाँचने के लिए कि प्रारूप फ़ील्ड में एक मान्य प्रारूप है (ऑब्जेक्ट को "सत्यापन विफल होने से नहीं बचाया जा सकता"), और कक्षा के लिए दो विधियों को जोड़ सकते हैं समर्थित प्रारूप और स्वरूपित फ़ील्ड्स body_as_html



( body_as_html



और body_as_html



)।



सभी स्वरूपण कार्य ActiveRecord::Acts::ActsAsFormatted::Formatting



मॉड्यूल में होता है। ऐसी विधियाँ हैं जो पाठ को प्रारूपित करती हैं: format



, format_markdown



और format_textile



, और format_markdown



विधि, जो समर्थित प्रारूप निर्धारित करती है, जो कि मॉड्यूल में मौजूद विधियों के आधार पर होती है।



अब init.rb



आरंभीकरण कोड जोड़ें:

  <code class = 'ruby' lang = 'ruby'> के लिए 'act_as_formatted' की आवश्यकता होती है

 ActiveRecord :: Base.extend (ActiveRecord :: Acts :: ActsAsFormatted :: ClassMethods) </ code> 

और आप व्यापार में प्लगइन की कोशिश कर सकते हैं। आपको स्वरूपित पाठ प्रदर्शित करने के लिए विचारों को सही करने की आवश्यकता है।

हम विचारों को कंघी करते हैं और पूर्वावलोकन करते हैं

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



सहायक विधियों के लिए, हेल्पर्स मॉड्यूल द्वारा रेल बनाए जाते हैं, हम कोड को app/helpers/application_helper.rb



। edit_form_for



विधि यह निर्धारित करती है कि क्या मॉडल पहले से ही सहेजा गया है और इस पर निर्भर करते हुए, मॉडल बनाने या अपडेट करने के लिए एक फॉर्म तैयार करता है। submit_edit



और cancel_edit



फ़ॉर्म सबमिट करने के लिए एक बटन बनाती हैं और फ़ॉर्म से लौटने के लिए एक लिंक बनाती हैं।



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



इस तरह के रिफैक्टरिंग के बाद, new



और edit



दृश्यों के लिए कोड बहुत सरल हो जाता है और एक पंक्ति में आ जाता है:

  <code class = 'ruby' lang = 'ruby'> <% = प्रस्तुत करना: आंशिक => 'लेख' ,: वस्तु => @ लेख%> </ code> 

यह पूर्वावलोकन जोड़ने के लिए बनी हुई है। ऐसा करने के लिए , नियंत्रक में एक preview



विधि बनाएं जो लेख के स्वरूपित पाठ को वापस कर देगा।

  <code class = 'ruby' lang = 'ruby'> def पूर्वावलोकन
   लेख = Article.new (परम: [लेख])
   रेंडर_टेक्स्ट लेख .body_as_html
 अंत </ code> 

फिर हम रूटिंग टेबल में नियम जोड़ते हैं।

  <code class = 'ruby' lang = 'ruby'> map.resource: लेख,
               : संग्रह => {: पूर्वावलोकन =>: कोई} </ code> 

दूसरी पंक्ति url /articles;preview



लिए एक नियम जोड़ती है /articles;preview



। :collection



अर्थ है कि संग्रह url ( /articles



) का उपयोग किया जाएगा, क्योंकि यह महत्वपूर्ण नहीं है कि किस लेख के लिए पूर्वावलोकन उत्पन्न होता है। इसके बजाय :collection



आप उपयोग कर सकते हैं :member



, फिर यूआरएल एक विशिष्ट लेख ( /articles/:id



) के लिए होगा, हमारे मामले में यह आपको बनाए गए लेखों का पूर्वावलोकन करने की अनुमति नहीं देगा। :any



इसका मतलब है कि आप कॉल करने के लिए किसी भी HTTP विधि का उपयोग कर सकते हैं, हमारे मामले में, पोस्ट करते समय POST का उपयोग किया जाएगा और संपादन करते समय PUT किया जाएगा।



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



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

  <code class = 'ruby' lang = 'ruby'> <% = javascript_include_tag 'प्रोटोटाइप'%> </ code> 

इस पर, दूसरे संस्करण की कार्यक्षमता को पूर्ण माना जा सकता है।



अब आप पहले संस्करण से बचे हुए कोड को हटा सकते हैं।

  <code> स्क्रिप्ट / नियंत्रक इनपुट पूर्वावलोकन को नष्ट करें </ code> 

और अंत में।

होस्टर पर एप्लिकेशन इंस्टॉल करने के बारे में थोड़ा सा।

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



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

  <कोड> $> रेक रेल: फ्रीज: रत्न </ कोड> 

नतीजतन, रेल की एक प्रति जिसके साथ आप अपना एप्लिकेशन विकसित कर रहे हैं, vendor/rails



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



रेल के अलावा, आवेदन अक्सर कुछ रत्नों पर निर्भर करता है, हमारे मामले में यह रेडक्लोथ और मारुकु है। इन निर्भरताओं के साथ समस्याओं को हल करने के लिए, डॉ निक ने एक महान प्लगइन - रेल्स पर रत्न लिखा। यह एक ही सिद्धांत पर काम करता है - यह रत्नों की स्थानीय प्रतियां बनाता है। आइए इसे स्थापित करें और इसका उपयोग करना सीखें:

  <code> $> मणि स्थापित करें gemonrails </ code> 

हम एप्लिकेशन के साथ फ़ोल्डर में जाते हैं और चलाते हैं

  <कोड> $> रत्नों का संग्रह
 रत्नों को____ स्थापित किया गया 0.6.4 ./vendor/plugins/gemsonrails </ code> पर 

अब हमारे पास Gems on Rails plugin स्थापित है, जिसने रेक के लिए उपयोगी कार्य जोड़े हैं।

  <कोड> $> रेक-टी
 ...
 रेक रत्नों: फ्रीज # रूबीगेम को इस रेल एप्लिकेशन में फ्रीज करें;  init.rb को स्टार्टअप पर लोड किया जाएगा।
 रेक रत्नों: लिंक # लिंक एक RubyGem इस रेल आवेदन में;  init.rb को स्टार्टअप पर लोड किया जाएगा।
 रेक रत्नों: इस रेल एप्लिकेशन से # अनफ़्रीज़ / अनफ़्रीज़ / एक रूबीगैम को अनलिंक करें
 ... </ code> 

• gems:link
  
  
  
  - vendor/gems
  
  
  
  के लिए एक कोड जोड़ता है जो अनुप्रयोग लोड होने पर मणि लोड करता है, अगर कोई मणि नहीं है, तो आवेदन लोड नहीं होगा (यह तुरंत रत्नों की अनुपस्थिति के बारे में पता लगाने के लिए सुविधाजनक है, और ऑपरेशन के दौरान नहीं)
• gems:freeze
  
  
  
  - मणि की एक स्थानीय प्रति बनाता है, इस प्रति का उपयोग आवेदन में किया जाएगा
• gems:unfreeze
  
  
  
  - gems:link
  
  
  
  द्वारा उत्पन्न स्थानीय प्रति और कोड को हटाता है gems:link
  
  
  
  

आइए हमारे आवेदन द्वारा आवश्यक रत्नों की स्थानीय प्रतियां बनाएं:

  <कोड> $> रेक रत्न: फ्रीज GEM = मारुकु
 $> रेक रत्न: GEM = redcloth </ code> फ्रीज करें 

मेरे vendor/gems



फ़ोल्डर में RedCloth-3.0.4



maruku-0.5.6



और RedCloth-3.0.4



फ़ोल्डर दिखाई दिए।



वह सब है। प्रश्न पूछें, प्रलेखन पढ़ें और पटरियों पर एक किताब ।

मुख्य बात यह है कि कोड लिखना है!

पुनश्च। अंतिम पंक्तियों को लिखते समय मैं रेल के बारे में एक दिलचस्प साइट के साथ आया था।