कमांड लाइन, देशी स्क्रिप्ट और एप्लिकेशन पर बैश समाप्ति का उपयोग करना। भाग २

हाब पर पूरा होने के बारे में मैं पहले से ही यहाँ लिखा था , और यहां तक ​​कि अंत में खुद की स्क्रिप्ट के लिए स्वत: पूर्णता सेटअप के बारे में बताने का वादा किया।

हालांकि, यह पहले से ही डेढ़ साल था, और व्यक्तिगत रूप से, मेरे हाथ मेरी निरंतरता तक नहीं पहुंचे। लेकिन इस सम्मानजनक कर्तव्य को हेब्राइज़र इन्फेंटी द्वारा मान लिया गया था, मैं उनकी ओर से प्रकाशित करूंगा।



मैं उस मॉडल की समस्या पर विचार करूंगा, जिस पर मैंने ऑटो-पूर्ण होने की मूल बातें सीखी थीं। नीचे पंक्ति है:



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

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

complete -F _my_command script

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

COMPREPLY
यह एक ऐसा ऐरे है जिसमें से बैश को संभव जोड़ दिया जाता है।

COMP_WORDS
यह एक सरणी है जिसमें पहले से दर्ज किए गए तर्क हैं। उनका विश्लेषण करके, हम समझ सकते हैं कि किन अतिरिक्त विकल्पों की पेशकश की जानी चाहिए।

COMP_CWORD
यह पिछले सरणी में सूचकांक है, जो वर्तमान में संपादित किए जा रहे तर्क की स्थिति को दर्शाता है।

अब आइए इन चरों पर आधारित इनपुट का विश्लेषण करने का प्रयास करें, और यदि पहला तर्क दर्ज किया गया है, तो इसे पूरक करने का प्रयास करें

  _my_command(){ # ,      COMPREPLY=() #    ,   ,    . cur="${COMP_WORDS[COMP_CWORD]}" #    subcommands_1="work history help" #    - .     . if [[ ${COMP_CWORD} == 1 ]] ; then #   ,     COMPREPLY=( $(compgen -W "${subcommands_1}" -- ${cur}) ) #some magic return 0 #COMPREPLY ,   fi } 

यदि अब हम इस फ़ंक्शन को कुछ स्क्रिप्ट में पूरा करने के लिए उपरोक्त कॉल के साथ लिखते हैं, उदाहरण के लिए ।/complete.sh, इसे वर्तमान कंसोल में निष्पादित करें (यह बेहतर है, निश्चित रूप से, प्रयोगों के लिए एक नया बैश लॉन्च करने और फिर इसे मारने के लिए)। ./ अपूर्ण श, और "स्क्रिप्ट" में प्रवेश करते हुए, टैब 2 बार दबाएं, बैश हमें परिवर्धन के विकल्प प्रदान करेगा:

 $ script help history work 

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

हालाँकि, मैंने अभी तक यह नहीं बताया है कि स्क्रिप्ट में प्रयुक्त जादू कैसे काम करता है, अर्थात्

  COMPREPLY=( $(compgen -W "${subcommands_1}" -- ${cur}) ) #some magic 

यहां हम बिल्ट-इन bash compgen उपयोगिता का उपयोग करके लौटे विकल्पों की सूची को भरते हैं।

यह उपयोगिता तर्क के सभी संभावित मूल्यों की एक सूची के रूप में लेती है, साथ ही वर्तमान में तर्क के भाग में प्रवेश करती है, और उन मानों का चयन करती है जिनमें प्रवेश किए गए भाग को पूरक किया जा सकता है। तर्क का इनपुट हिस्सा इसके बाद पारित किया जाता है - और संभावित मूल्यों की सूची के साथ, सब कुछ अधिक दिलचस्प है। इस स्थिति में, स्क्रिप्ट के लिए शब्दों की दी गई सूची के लिए संभावित मान (-W ध्वज द्वारा इंगित) लिया जाता है (जो उपरोक्त उदाहरण में, subcommands_1 = "कार्य इतिहास सहायता") से है। हालाँकि, वहाँ आप अन्य झंडे निर्दिष्ट कर सकते हैं - उदाहरण के लिए, -d - और फिर compgen मशीन पर मौजूदा निर्देशिकाओं के आधार पर पूरक होगा, या -f - तो यह फ़ाइलों का पूरक होगा।

आप देख सकते हैं कि यह क्या पैदा करता है:

 $ compgen -W "qwerty qweasd asdfgh" -- qwe qwerty qweasd 

तदनुसार, ऑटो-पूर्ति के लिए उम्मीदवारों की विभिन्न सूचियाँ उत्पन्न करना संभव है। उदाहरण के लिए, हाथ में काम के लिए, हमें (इतिहास के आयात और निर्यात के लिए) संभावित परियोजनाओं की एक सूची की आवश्यकता है। मेरे मामले में, प्रत्येक परियोजना में "$ {HOME} / प्रोजेक्ट्स" में एक निर्देशिका है, इसलिए उम्मीदवारों का चयन किया जा सकता है
COMPREPLY=($(compgen -W "`ls ${HOME}/projects`" -- ${cur}))

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

निष्कर्ष में - शुरुआत में संकेतित मॉडल के लिए ऑटो-समापन का मेरा अनाड़ी कार्यान्वयन:

 _my_command() { COMPREPLY=() cur="${COMP_WORDS[COMP_CWORD]}" subcommands_1="work history help" #    subcommands_history="import export" #   history if [[ ${COMP_CWORD} == 1 ]] ; then #         COMPREPLY=( $(compgen -W "${subcommands_1}" -- ${cur}) ) return 0 fi subcmd_1="${COMP_WORDS[1]}" #       ,        case "${subcmd_1}" in # ,      work) COMPREPLY=() #     return 0 ;; history) if [[ ${COMP_CWORD} == 2 ]] ; then # script history;   import  export COMPREPLY=( $(compgen -W "${subcommands_history}" -- ${cur}) ) return 0 fi #     ,  :    subcmd_2="${COMP_WORDS[2]}" if [[ ${COMP_CWORD} == 3 ]] ; then #        . COMPREPLY=($(compgen -W "`ls ${HOME}/projects`" -- ${cur})) return 0 fi case "${subcmd_2}" in #        .     ,      -    ,  -     . import) case "${COMP_WORDS[COMP_CWORD-1]}" in -src) COMPREPLY=($(compgen -d -- ${cur})) #      return 0 ;; -file) COMPREPLY=($(compgen -f -- ${cur})) #     return 0 ;; *) COMPREPLY=($(compgen -W "-src -file" -- ${cur})) #   return 0 ;; esac ;; export) #     -o,    -      ,  ,  -     if [[ ${COMP_WORDS[COMP_CWORD-1]} == "-o" ]] ; then COMPREPLY=($(compgen -f -- ${cur})) return 0 fi COMPREPLY=($(compgen -W "-o" -- ${cur})) return 0 ;; *) ;; esac ;; help) #    help      ,   . COMPREPLY=( $(compgen -W "${subcommands_1}" -- ${cur})) return 0 ;; esac return 0 } complete -F _my_command script 

अच्छी तरह से और सबसे महत्वपूर्ण बात - हमारी स्क्रिप्ट को निरंतर आधार पर बैश से जोड़ना। यह या तो (अनाड़ी) हमारे स्क्रिप्ट में .bashrc, या (यदि आपके पास ऐसी कोई फ़ाइल है) :) / / bash_completion के माध्यम से कॉल लिखते हुए किया जाता है। दूसरे मामले में, हमें अपनी स्क्रिप्ट /etc/bash_completion.d में डालनी चाहिए, जहाँ से / आदि / bash_completion हुक किए गए हैं, सभी स्क्रिप्ट।

पुनश्च: मुझे याद है कि उपयोगकर्ता इन्फेंटी के कर्म में एक सकारात्मक प्रतिक्रिया छोड़नी चाहिए