यदि मैं <programfile> निर्दिष्ट नहीं करता हूं तो मैं <arguments> आईआरबी कैसे पास कर सकता हूं?

Question

के बाद से:

irb --help 

उपयोग: irb.rb [विकल्प] [programfile] [तर्क]

---

मैं जानता हूँ कि मैं ARGV के लिए तर्क पारित कर सकते हैं अगर मैं एक programfile

शामिल

उदाहरण:

irb test.rb A B C 

जहां test.irb बस "पी ARGV"

का उत्पादन होता है:

[ "एक", "बी", "सी"]

---

programfile बनाना चोर में हो डॉस ... मैं निम्न कर सकते हैं

irb con A B C 
con(main):001:0> ARGV 

पैदा करता है:

ARGV
=> [ 'ए', 'बी', 'सी']

लेकिन इस प्रणाली निर्भर है और :-(

गूंज इनपुट के पक्ष प्रभाव पड़ता है क्या मैं सच की तरह कुछ है जैसे

irb -- a b c 

Btw: मैं जानता हूँ कि मैं आईआरबी अंदर ARGV सेट कर सकते हैं, लेकिन मैं मेरा इरादा उर्फ ​​करने के लिए है विशेष == आईआरबी -rSpecialLibrary "इसलिए मैं कुछ ऐसा कर सकते हैं:

special A B C 
<input goes here> 

कोई सुझाव? के स्रोत पर

#!/usr/bin/env ruby 
require "irb" 

if __FILE__ == $0 
    IRB.start(__FILE__) 
else 
    # check -e option 
    if /^-e$/ =~ $0 
    IRB.start(__FILE__) 
    else 
    IRB.setup(__FILE__) 
    end 
end 

:

Answer 1

काफी अजीब समाधान चर

# defaults.rb 
@a = "hello world" 

और

# terminal 
=> irb -r defaults.rb 
irb=> @a 
irb=> "hello world" 

Answer 2

irb निष्पादन के स्रोत को देखते हुए के साथ फ़ाइल बनाने के लिए है आईआरबी मॉड्यूल:

# File lib/irb/init.rb, line 15 
    def IRB.setup(ap_path) 
    IRB.init_config(ap_path) 
    IRB.init_error 
    IRB.parse_opts 
    IRB.run_config 
    IRB.load_modules 

    unless @CONF[:PROMPT][@CONF[:PROMPT_MODE]] 
     IRB.fail(UndefinedPromptMode, @CONF[:PROMPT_MODE]) 
    end 
    end 

parse_opts के नीचे, हमारी समस्या विधि:

# File lib/irb/init.rb, line 126 
    def IRB.parse_opts 
    load_path = [] 
    while opt = ARGV.shift 
     case opt 
     when "-f" 
     @CONF[:RC] = false 
     when "-m" 
     @CONF[:MATH_MODE] = true 
     when "-d" 
     $DEBUG = true 
     when /^-r(.+)?/ 
     opt = $1 || ARGV.shift 
     @CONF[:LOAD_MODULES].push opt if opt 
     when /^-I(.+)?/ 
     opt = $1 || ARGV.shift 
     load_path.concat(opt.split(File::PATH_SEPARATOR)) if opt 
     when '-U' 
     set_encoding("UTF-8", "UTF-8") 
     when /^-E(.+)?/, /^--encoding(?:=(.+))?/ 
     opt = $1 || ARGV.shift 
     set_encoding(*opt.split(':', 2)) 
     when "--inspect" 
     @CONF[:INSPECT_MODE] = true 
     when "--noinspect" 
     @CONF[:INSPECT_MODE] = false 
     when "--readline" 
     @CONF[:USE_READLINE] = true 
     when "--noreadline" 
     @CONF[:USE_READLINE] = false 
     when "--echo" 
     @CONF[:ECHO] = true 
     when "--noecho" 
     @CONF[:ECHO] = false 
     when "--verbose" 
     @CONF[:VERBOSE] = true 
     when "--noverbose" 
     @CONF[:VERBOSE] = false 
     when /^--prompt-mode(?:=(.+))?/, /^--prompt(?:=(.+))?/ 
     opt = $1 || ARGV.shift 
     prompt_mode = opt.upcase.tr("-", "_").intern 
     @CONF[:PROMPT_MODE] = prompt_mode 
     when "--noprompt" 
     @CONF[:PROMPT_MODE] = :NULL 
     when "--inf-ruby-mode" 
     @CONF[:PROMPT_MODE] = :INF_RUBY 
     when "--sample-book-mode", "--simple-prompt" 
     @CONF[:PROMPT_MODE] = :SIMPLE 
     when "--tracer" 
     @CONF[:USE_TRACER] = true 
     when /^--back-trace-limit(?:=(.+))?/ 
     @CONF[:BACK_TRACE_LIMIT] = ($1 || ARGV.shift).to_i 
     when /^--context-mode(?:=(.+))?/ 
     @CONF[:CONTEXT_MODE] = ($1 || ARGV.shift).to_i 
     when "--single-irb" 
     @CONF[:SINGLE_IRB] = true 
     when /^--irb_debug=(?:=(.+))?/ 
     @CONF[:DEBUG_LEVEL] = ($1 || ARGV.shift).to_i 
     when "-v", "--version" 
     print IRB.version, "\n" 
     exit 0 
     when "-h", "--help" 
     require "irb/help" 
     IRB.print_usage 
     exit 0 
     when "--" 
     if opt = ARGV.shfit 
      @CONF[:SCRIPT] = opt 
      $0 = opt 
     end 
     break 
     when /^-/ 
     IRB.fail UnrecognizedSwitch, opt 
     else 
     @CONF[:SCRIPT] = opt 
     $0 = opt 
     break 
     end 
    end 
    if RUBY_VERSION >= FEATURE_IOPT_CHANGE_VERSION 
     load_path.collect! do |path| 
     /\A\.\// =~ path ? path : File.expand_path(path) 
     end 
    end 
    $LOAD_PATH.unshift(*load_path) 

    end 

यह स्क्रिप्ट नाम ([: स्क्रिप्ट] @CONF = ऑप्ट) के रूप में उस विकल्प को लेने के लिए hardcoded है। सौभाग्य से, यह रूबी है। मेरा पहला विचार आईआरबी लॉन्च करने के लिए एक अलग लिपि का उपयोग कर रहा था जो मॉड्यूल को पहले संशोधित करता है।

~/bin/कस्टम आईआरबी:

#!/usr/bin/env ruby 
require 'irb' 
module IRB 
    class << self 
    # sort of lame way to reset the parts we don't like about 
    # parse_opts after it does the parts we do like 
    def parse_opts_with_ignoring_script 
     arg = ARGV.first 
     script = $0 
     parse_opts_without_ignoring_script 
     @CONF[:SCRIPT] = nil 
     $0 = script 
     ARGV.unshift arg 
    end 
    alias_method :parse_opts_without_ignoring_script, :parse_opts 
    alias_method :parse_opts, :parse_opts_with_ignoring_script 
    end 
end 

if __FILE__ == $0 
    IRB.start(__FILE__) 
else 
    # check -e option 
    if /^-e$/ =~ $0 
    IRB.start(__FILE__) 
    else 
    IRB.setup(__FILE__) 
    end 
end 

आप custom-irb foo bar baz के साथ इस शुरू कर सकते हैं और ARGV ['foo', 'bar', 'baz'] हो जाएगा।

Answer 3

आप एक फ़ाइल है कि ARGV को संशोधित करता है और फिर इसे शामिल करने के लिए उपयोग करें '-r' कर सकते हैं।

$ echo 'ARGV = ["testing", "1","2","3"]' > ~/blah.rb && irb -r ./blah test.rb 
/home/me/blah.rb:1: warning: already initialized constant ARGV 
test.rb(main):001:0> require 'pp' 
=> true 
test.rb(main):002:0* pp ARGV 
["testing", "1", "2", "3"] 
=> ["testing", "1", "2", "3"] 
test.rb(main):003:0> 

आप इसे अपने ~/.irbrc पर भी रीडायरेक्ट कर सकते हैं और '-r ./blah' छोड़ सकते हैं।