dry-rb एक्सप्लोर करें: मजबूत, पुन: प्रयोज्य कोड के लिए 18+ रूबी जेम्स

कुछ नए और दिलचस्प जेम्स आज़माने के लिए ढूंढ रहे हैं?

तब dry-rb पर एक नज़र डालें, जेम्स का एक सेट जो सामान्य समस्याओं का समाधान लाता है। Dry-rb 18 से अधिक रूबी जेम्स से बना है जो एक साथ या स्वतंत्र रूप से काम कर सकते हैं।

इनमें से कुछ जेम्स शामिल हैं:

• dry-initializer
• dry-struct
• dry-validations
• dry-events
• dry-transaction

इस पोस्ट में, आप इनमें से 3 जेम्स के बारे में जानेंगे ताकि आप dry-rb की पेशकश का स्वाद ले सकें!

dry-struct के साथ बेहतर स्ट्रक्ट्स कैसे बनाएं

एक रूबी Struct एक प्रकार का ऑब्जेक्ट है जिसे आप Struct क्लास से बना सकते हैं, लेकिन उनकी कुछ सीमाएं हैं।

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

आप कई लापता आर्गुमेंट्स के साथ एक स्ट्रक्ट बना सकते हैं और रूबी से कोई शिकायत नहीं मिलेगी।

dry-struct जेम के साथ आप सख्त स्ट्रक्ट्स बना सकते हैं।

यहाँ बताया गया है:

require 'dry-struct'
module Types
  include Dry::Types.module
end
class Video < Dry::Struct
  attribute :title, Types::String
  attribute :views, Types::Views
  attribute :comments, Types::Array
end
Video.new(title: "abc", views: 10, comments: [])

अब यदि आप किसी एट्रिब्यूट को मिस करते हैं, तो आपको यह एरर मिलती है:

[Video.new] :comments is missing in Hash input

सबसे उपयोगकर्ता के अनुकूल एरर मैसेज नहीं, लेकिन यह काम पूरा करता है।

आप अपने खुद के प्रकार बना सकते हैं और उन पर कंस्ट्रेंट्स जोड़ सकते हैं:

module Types
  include Dry::Types.module
  Age = Integer.constrained(gt: 0)
end

इस "gt" का अर्थ है "ग्रेटर दैन"।

इसलिए Age 0 से बड़ा एक इंटीजर होना चाहिए।

क्या आपके पास डिफ़ॉल्ट मान हो सकते हैं?

हाँ, यहाँ बताया गया है:

module Types
  include Dry::Types.module
  Name = String.default('')
end

रेगुलर रूबी स्ट्रक्ट्स जैसा दिखने वाला Dry स्ट्रक्ट्स बनाने का एक छोटा संस्करण है।

उदाहरण:

Book = Dry::Struct(title: Dry::Types["string"])
Book.new(title: "Computer Science 101")

dry-events के साथ ऑब्जर्वर पैटर्न लागू करना

ऑब्जर्वर डिज़ाइन पैटर्न तब होता है जब एक स्रोत कई श्रोताओं को एक अपडेट प्रकाशित करता है, यह एक समाचार अपडेट, स्टॉक अलर्ट, ग्रुप चैट में नया संदेश, आदि हो सकता है।

यह एक सामान्य पैटर्न है।

रूबी में एक ऑब्जर्वेबल मॉड्यूल शामिल है जो इसे लागू करने में आपकी मदद करता है।

लेकिन dry-events एक और विकल्प है।

आप इस तरह एक पब्लिशर बना सकते हैं:

require 'dry/events/publisher'
class Blog
  include Dry::Events::Publisher[:blog]
  register_event('article.published')
  register_event('article.upated')
end

अब:

कोई भी क्लास खुद को रजिस्टर कर सकती है ताकि जब ये घटनाएं हों तो उन्हें प्राप्त कर सके।

यहाँ बताया गया है:

class Reader
  def on_article_published(event)
    puts "New article published: #{event[:title]}"
  end
  def on_article_updated(event)
    puts "Article has been updated: #{event[:title]}"
  end
end
blog = Blog.new
reader = Reader.new
blog.subscribe(reader)

आप publish मेथड के साथ एक इवेंट ब्रॉडकास्ट कर सकते हैं:

blog.publish('article.published', title: 'How to Use The dry-events Gem')

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

dry-auto_inject के साथ डिपेंडेंसी इंजेक्शन

डिपेंडेंसी क्या है?

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

आप इन ऑब्जेक्ट्स को सीधे अपनी क्लास में बना सकते हैं...

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

डिपेंडेंसी इंजेक्शन तब होता है जब डिपेंडेंसीज को "इंजेक्ट" किया जाता है। दूसरे शब्दों में, उन्हें पैरामीटर्स के रूप में पास किया जाता है।

उदाहरण:

require 'faraday'
class GitHubAPI
  def initialize(http_client = Faraday.new)
    @http_client = http_client
  end
end

ऐसा करने से आप डिपेंडेंसी को नियंत्रित कर सकते हैं और टेस्टिंग को आसान बना सकते हैं।

अब:

dry-auto_inject ये ऑब्जेक्ट्स आपके लिए बनाता है। आपको बस यह घोषित करना है कि कौन सी डिपेंडेंसीज आवश्यक हैं।

इस उदाहरण में Fruit Store पर निर्भर करता है:

require 'dry/auto_inject'
class Store
  def bananas
    puts 'Have some organic bananas!'
  end
end
Import = Dry::AutoInject({ 'store' => Store.new })
class Fruit
  include Import['store']
  def eat
    store.bananas
  end
end
fruit = Fruit.new
fruit.eat

आपको यह कहना होगा कि ऑब्जेक्ट कैसे बनाया जाता है:

Import = Dry::AutoInject({ 'store' => Store.new })

और इसे क्लास के लिए उपलब्ध कराएं:

include Import['store']

तब आप एक अलग Store के साथ Fruit बना सकते हैं:

Fruit.new(store: MyStore.new)

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

सारांश

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

अब आपकी बारी है अभ्यास करें और इसे आज़माएं!

पढ़ने के लिए धन्यवाद।