शेल स्क्रिप्टिंग के लिए मैं रूबी का उपयोग कैसे करूं?

Question

मेरे पास कुछ सरल शेल स्क्रिप्टिंग कार्य हैं जो मैं करना चाहता हूं

उदाहरण के लिए: कुछ नियमित अभिव्यक्ति से मेल खाने वाली फ़ाइलों की सूची में से कार्यशील निर्देशिका में एक फ़ाइल का चयन करना।

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

मैंने इसे प्राप्त करने की कोशिश की, लेकिन इस बारे में भ्रमित हो गया कि मुझे वर्तमान निर्देशिका के संदर्भ में जानकारी कहां मिलनी चाहिए

तो सवाल यह है कि रूबी पुस्तकालयों के किन हिस्सों में मुझे रूबी शेल स्क्रिप्ट लिखने के लिए जानने की आवश्यकता है?

Comments

शायद एक अच्छा जवाब नहीं है, लेकिन सिस्टम एडमिनिस्ट्रेशन के लिए प्रैक्टिकल रूबी एक महान संदर्भ है। amazon.com/Practical-System-Administration-Experts-Source/dp/…

— exiquio

Answer 1

डिफ़ॉल्ट रूप से, आपके पास पहले से ही Dir और File तक पहुँच होती है , जो अपने आप में बहुत उपयोगी होते हैं।

Dir['*.rb'] #basic globs
Dir['**/*.rb'] #** == any depth of directory, including current dir.
#=> array of relative names

File.expand_path('~/file.txt') #=> "/User/mat/file.txt"
File.dirname('dir/file.txt') #=> 'dir'
File.basename('dir/file.txt') #=> 'file.txt'
File.join('a', 'bunch', 'of', 'strings') #=> 'a/bunch/of/strings'

__FILE__ #=> the name of the current file

इसके अलावा stdlib से उपयोगी है FileUtils

require 'fileutils' #I know, no underscore is not ruby-like
include FileUtils
# Gives you access (without prepending by 'FileUtils.') to
cd(dir, options)
cd(dir, options) {|dir| .... }
pwd()
mkdir(dir, options)
mkdir(list, options)
mkdir_p(dir, options)
mkdir_p(list, options)
rmdir(dir, options)
rmdir(list, options)
ln(old, new, options)
ln(list, destdir, options)
ln_s(old, new, options)
ln_s(list, destdir, options)
ln_sf(src, dest, options)
cp(src, dest, options)
cp(list, dir, options)
cp_r(src, dest, options)
cp_r(list, dir, options)
mv(src, dest, options)
mv(list, dir, options)
rm(list, options)
rm_r(list, options)
rm_rf(list, options)
install(src, dest, mode = <src's>, options)
chmod(mode, list, options)
chmod_R(mode, list, options)
chown(user, group, list, options)
chown_R(user, group, list, options)
touch(list, options)

जो बहुत अच्छा है

Answer 2

जैसा कि दूसरों ने पहले ही कहा है, आपकी पहली पंक्ति होनी चाहिए

#!/usr/bin/env ruby

और आपको इसे निष्पादन योग्य बनाना होगा: (शेल में)

chmod +x test.rb

फिर रूबी कोड का अनुसरण करता है। यदि आप कोई फ़ाइल खोलते हैं

File.open("file", "r") do |io|
    # do something with io
end

फ़ाइल उस वर्तमान निर्देशिका में खोली गई है जिसे आप pwdशेल में प्राप्त करेंगे ।

आपकी स्क्रिप्ट का मार्ग भी सरल है। आपके साथ $0शेल का पहला तर्क मिलता है, जो आपकी स्क्रिप्ट के सापेक्ष पथ है। पूर्ण पथ को इस तरह निर्धारित किया जा सकता है:

#!/usr/bin/env ruby
require 'pathname'
p Pathname.new($0).realpath()

फ़ाइल सिस्टम ऑपरेशन के लिए मैं लगभग हमेशा Pathname का उपयोग करता हूं। यह कई अन्य फाइल सिस्टम से संबंधित वर्गों के लिए एक आवरण है। इसके अलावा उपयोगी: Dir, File ...

Answer 3

यहां कुछ महत्वपूर्ण है जो अन्य उत्तरों से गायब है: ARGV (वैश्विक) सरणी के माध्यम से कमांड-लाइन पैरामीटर आपकी रूबी शेल स्क्रिप्ट के संपर्क में हैं।

तो, अगर आपके पास my_shell_script नामक एक स्क्रिप्ट थी:

#!/usr/bin/env ruby
puts "I was passed: "
ARGV.each do |value|
  puts value
end

... इसे निष्पादन योग्य बनाएं (जैसा कि अन्य ने उल्लेख किया है):

chmod u+x my_shell_script

और इसे कॉल करें:

> ./my_shell_script one two three four five

आपको यह मिलेगा:

I was passed: 
one
two
three
four
five

फ़ाइल नाम विस्तार के साथ तर्क अच्छी तरह से काम करते हैं:

./my_shell_script *

I was passed: 
a_file_in_the_current_directory
another_file    
my_shell_script
the_last_file

इसमें से अधिकांश केवल यूनिक्स (लिनक्स, मैक ओएस एक्स) पर काम करता है, लेकिन आप विंडोज में समान (हालांकि कम सुविधाजनक) चीजें कर सकते हैं।

Answer 4

यहाँ बहुत अच्छी सलाह है, इसलिए मैं थोड़ा और जोड़ना चाहता था।

1. बैकटिक्स (या बैक-टिक) आपको कुछ स्क्रिप्टिंग सामानों को बहुत आसान बनाने की सुविधा देते हैं। विचार करें

   puts `find . | grep -i lib`

2. यदि आप backticks का आउटपुट प्राप्त करने में समस्याओं में भाग लेते हैं, तो सामान मानक के बजाय मानक के रूप में मानक पर जा रहा है। इस सलाह का उपयोग करें

   out = `git status 2>&1`

3. Backticks स्ट्रिंग प्रक्षेप करते हैं:

   blah = 'lib'
   `touch #{blah}`

4. आप रूबी के अंदर भी पाइप कर सकते हैं । यह मेरे ब्लॉग की एक कड़ी है, लेकिन यह यहाँ वापस लिंक करता है तो यह ठीक है :) इस विषय पर संभवतः अधिक उन्नत चीजें हैं।

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

---

मैक पर, अधिक शक्ति के लिए रूबी के अंदर एप्सस्क्रिप्ट का उपयोग करें। यहाँ मेरी shell_hereस्क्रिप्ट है:

#!/usr/bin/env ruby
`env | pbcopy` 
cmd =  %Q@tell app "Terminal" to do script "$(paste_env)"@
puts cmd

`osascript -e "${cmd}"`

Comments

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

— छिपकली

@ छिपकली, हाँ, वह 'ट्रिक' थी जिसकी मुझे ज़रूरत थी: डबल इंडेंट्स। सहायता के लिए धन्यवाद।

— दान रोसेनस्टार्क

मुझे लगता है कि रश मर चुका है: groups.google.com/group/ruby-shell/browse_thread/thread/...

— दान Rosenstark

Answer 5

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

Comments

अच्छी पुस्तक, मैं इसे अभी पढ़ रहा हूं: यह ज़ेन कोड यात्रा की तरह लगता है। और यदि आप टीडीडी को नहीं जानते हैं, तो आप टीडीडी की मूल बातें सीखेंगे।

— सेबेस्टियन रोक्कासेरा

मुझे लगता है कि पुस्तक में कुछ अच्छी जानकारी है, लेकिन अनुभवी प्रोग्रामरों के लिए बहुत कुछ है।

— D मर्ज

Answer 6

यह भी मददगार हो सकता है: http://rush.heroku.com/

मैंने इसका ज्यादा इस्तेमाल नहीं किया है, लेकिन बहुत अच्छा लग रहा है

साइट से:

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

Comments

रश: नहीं। क्यों? group.google.com/group/ruby-shell/browse_thread/thread/… यह बहुत अच्छा है, लेकिन पहिए पर कोई नहीं है।

— डैन रोसेन्स्टार्क

Answer 7

मान लीजिए कि आप अपनी script.rbस्क्रिप्ट लिखते हैं । डाल:

#!/usr/bin/env ruby

पहली पंक्ति के रूप में और एक chmod +x script.rb

Answer 8

जब आप अधिक जटिल रूबी स्क्रिप्ट लिखना चाहते हैं, तो ये उपकरण मदद कर सकते हैं:

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

• थोर (एक स्क्रिप्टिंग ढांचा)

• gli (इंटरफ़ेस जैसा गिट)

• मेथाडोन (सरल उपकरण बनाने के लिए)

वे आपको अपनी खुद की स्क्रिप्ट लिखने के लिए एक त्वरित शुरुआत देते हैं, खासकर 'कमांड लाइन ऐप'।

Answer 9

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

निष्पादन परिणाम के परीक्षण के लिए कुछ सहायक फ़ंक्शन का उपयोग किया जा सकता है

#!/usr/bin/env ruby
module ShellHelper
  def test(command)
    `#{command} 2> /dev/null`
    $?.success?
  end

  def execute(command, raise_on_error = true)
    result = `#{command}`
    raise "execute command failed\n" if (not $?.success?) and raise_on_error
    return $?.success?
  end

  def print_exit(message)
    print "#{message}\n"
    exit
  end

  module_function :execute, :print_exit, :test
end

सहायक के साथ, रूबी स्क्रिप्ट को समान रूप से मिटाया जा सकता है:

#!/usr/bin/env ruby
require './shell_helper'
include ShellHelper

print_exit "config already exists" if test "ls config"

things.each do |thing|
  next if not test "ls #{thing}/config"
  execute "cp -fr #{thing}/config_template config/#{thing}"
end

Comments

यार, यह बहुत अच्छा है, धन्यवाद!

— विक्टर मार्टिंस

Answer 10

"मैं माणिक कैसे लिखूं" एसओ के दायरे से थोड़ा परे है।

लेकिन इन रूबी स्क्रिप्ट को निष्पादन योग्य स्क्रिप्ट में बदलने के लिए, इसे अपनी रूबी स्क्रिप्ट की पहली पंक्ति के रूप में डालें:

#!/path/to/ruby

फिर फ़ाइल को निष्पादन योग्य बनाएं:

chmod a+x myscript.rb

और दूर तुम जाओ।

Answer 11

इसे अपनी script.rb की शुरुआत में रखें

#!/usr/bin/env ruby

फिर इसे निष्पादन योग्य के रूप में चिह्नित करें:

chmod +x script.rb

Answer 12

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

Answer 13

माणिक में, स्थिरांक __FILE__ आपको हमेशा उस स्क्रिप्ट का मार्ग देगा जो आप चला रहे हैं।

लिनक्स पर, /usr/bin/env आपका मित्र है:

#! /usr/bin/env ruby
# Extension of this script does not matter as long
# as it is executable (chmod +x)
puts File.expand_path(__FILE__)

विंडोज पर यह निर्भर करता है कि .rb फाइलें रूबी से जुड़ी हैं या नहीं। अगर वे हैं:

# This script filename must end with .rb
puts File.expand_path(__FILE__)

यदि वे नहीं हैं, तो आपको स्पष्ट रूप से उन पर रूबी को लागू करना होगा, मैं एक मध्यवर्ती .cmd फ़ाइल का उपयोग करता हूं:

my_script.cmd:

@ruby %~dp0\my_script.rb

my_script.rb:

puts File.expand_path(__FILE__)