रेल्स में जेम्स का प्रबंधन: बंडलर और रूबीजेम्स कैसे एक साथ काम करते हैं

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

यदि आप नहीं जानते कि बंडलर कैसे काम करता है, तो जेम्स रेल्स में कैसे खींचे जाते हैं यह थोड़ा बहुत जादुई लग सकता है। Gemfile में एक लाइन जोड़ने से कोड आपके ऐप में कैसे आता है? बंडलर, रेल्स, और रूबीजेम्स निर्भरताओं को संभालना आसान बनाने के लिए एक साथ कैसे काम करते हैं?

क्यों बंडलर?

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

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

बंडलर से पहले, किसी प्रकार के सेटअप स्क्रिप्ट के साथ आपके जेम्स के सही वर्जन इंस्टॉल करना अभी भी काफी आसान था:

bin/setup

gem install rails -v 4.1.0
gem install rake -v 10.3.2
...

(वह है, जब तक रेल्स 4.1 की निर्भरताएं रेक 10.3.2 की निर्भरताओं के साथ विरोध नहीं करतीं!)

लेकिन क्या होता है जब आप कुछ अलग-अलग रेल्स ऐप्स पर काम कर रहे होते हैं, जिनमें से प्रत्येक जेम्स के अलग-अलग वर्जन पर निर्भर करता है? जब तक आप वास्तव में सावधान नहीं हैं, आप भयानक जेम एक्टिवेशन एरर में चले जाएंगे:

gem_error

Gem::Exception: can't activate hpricot (= 0.6.161, runtime), already activated hpricot-0.8.3

उफ़। वह संदेश अभी भी मुझे बुरे सपने देता है। इसका आमतौर पर मतलब था कि आप जेम्स इंस्टॉल और अनइंस्टॉल करने में एक दिन बिताने वाले हैं, ताकि आप उस मशीन पर सिर्फ सही वर्जन प्राप्त कर सकें। और एक आकस्मिक gem install rake आपकी सारी सावधानीपूर्वक योजना को पूरी तरह से खराब कर देता है।

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

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

रेल्स बंडलर का उपयोग कैसे करता है?

इसके मूल में, बंडलर आपके जेम्स को इंस्टॉल और अलग करता है। लेकिन यह सब नहीं है जो यह करता है। आपके Gemfile में जेम्स का कोड आपके रेल्स ऐप में कैसे आता है?

यदि आप bin/rails को देखते हैं:

bin/rails

#!/usr/bin/env ruby
begin
  load File.expand_path("../spring", __FILE__)
rescue LoadError
end
APP_PATH = File.expand_path('../../config/application', __FILE__)
require_relative '../config/boot'
require 'rails/commands'

आप देखेंगे कि यह ../config/boot को रिक्वायर करके रेल्स को लोड करता है। आइए उस फाइल को देखें:

config/boot

ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
require 'bundler/setup' # Set up gems listed in the Gemfile.

अरे, यह बंडलर है! (साथ ही, मैंने अभी सीखा कि आप BUNDLE_GEMFILE एनवायरनमेंट वेरिएबल सेट करके उपयोग करने के लिए एक अलग Gemfile चुन सकते हैं। यह बहुत अच्छा है।)

bundler/setup कुछ चीजें करता है:

यह $LOAD_PATH से जेम्स के सभी पथों को हटा देता है (जो रूबीजेम्स द्वारा किए गए किसी भी लोड पथ कार्य को उलट देता है)।
फिर, यह सिर्फ आपके Gemfile.lock में मौजूद जेम्स के लोड पथ को $LOAD_PATH पर वापस जोड़ता है।

अब, केवल वे जेम्स जिन्हें आप require कर सकते हैं, वे आपके Gemfile में हैं।

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

config/application.rb पर एक त्वरित नज़र डालें, जो रेल्स बूट होने के बाद चलता है:

config/application.rb

# Require the gems listed in Gemfile, including any gems
# you've limited to :test, :development, or :production.
Bundler.require(*Rails.groups)

यह फिर से बंडलर है! Bundler.require उन सभी जेम्स को रिक्वायर करता है जो आप इसे पास करते हैं उन सभी समूहों में। ( "समूह" से मेरा मतलब है आपके Gemfile में आपके द्वारा निर्दिष्ट समूह।)

Rails.groups में कौन से समूह हैं, हालांकि?

railties/lib/rails.rb

 # Returns all rails groups for loading based on:
 # # * The Rails environment;
 # * The environment variable RAILS_GROUPS;
 # * The optional envs given as argument and the hash with group dependencies;
 #
 # groups assets: [:development, :test]
 # #
 # # Returns
 # #
 # => [:default, :development, :assets] for Rails.env == "development"
 # # => [:default, :production] for Rails.env == "production"
 def groups(*groups)
   hash = groups.extract_options!
   env = Rails.env
   groups.unshift(:default, env)
   groups.concat ENV["RAILS_GROUPS"].to_s.split(",")
   groups.concat hash.map { |k, v| k if v.map(&:to_s).include?(env) }
   groups.compact!
   groups.uniq!
   groups
 end

खैर, यह बताता है। Rails.groups डेवलपमेंट मोड में रेल्स चलाने पर [:default, :development] होने जा रहा है, प्रोडक्शन मोड में [:default, :production], और इसी तरह।

तो, बंडलर आपके Gemfile में उन समूहों में से प्रत्येक से संबंधित जेम्स की तलाश करेगा, और उनमें से प्रत्येक जेम पर require कॉल करेगा जो इसे मिलता है। यदि आपके पास nokogiri जेम है, तो यह आपके लिए require "nokogiri" कॉल करेगा। और इसलिए आपके जेम्स आमतौर पर रेल्स में बिना किसी अतिरिक्त कोड के आपकी ओर से काम करते हैं।

अपने टूल्स को जानें

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

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