[git] मैं गिट भंडार में एक खाली निर्देशिका कैसे जोड़ सकता हूं?



Answers

आप नहीं कर सकते गिट एफएक्यू देखें।

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

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

आप " git add <dir> " कह सकते हैं और यह वहां फाइलें जोड़ देगा।

यदि आपको वास्तव में चेकआउट में मौजूद निर्देशिका की आवश्यकता है तो आपको इसमें एक फ़ाइल बनाना चाहिए। .gitignore इस उद्देश्य के लिए अच्छी तरह से काम करता है; आप इसे खाली छोड़ सकते हैं, या उन फ़ाइलों के नाम भर सकते हैं जिन्हें आप निर्देशिका में दिखाना चाहते हैं।

Question

मैं एक गिट भंडार में एक खाली निर्देशिका (जिसमें कोई फाइल नहीं है) कैसे जोड़ सकता हूं?




The solution of Jamie Flournoy works great. Here is a bit enhanced version to keep the .htaccess :

# Ignore everything in this directory
*
# Except this file
!.gitignore
!.htaccess

With this solution you are able to commit a empty folder, for example /log , /tmp or /cache and the folder will stay empty.




आप निर्देशिका में एक रीडमे फ़ाइल हमेशा एक स्पष्टीकरण के साथ डाल सकते हैं कि आप इसे क्यों चाहते हैं, अन्यथा खाली, भंडार में निर्देशिका।




गिट खाली निर्देशिकाओं को ट्रैक नहीं करता है। अधिक स्पष्टीकरण के लिए गिट एफएक्यू देखें। सुझाया गया कामकाज खाली निर्देशिका में एक .gitignore फ़ाइल डालना है। मुझे वह समाधान पसंद नहीं है, क्योंकि .gitignore कन्वेंशन द्वारा .gitignore "छुपा" है। इसके अलावा कोई स्पष्टीकरण नहीं है कि निर्देशिका खाली क्यों हैं।

मैं खाली निर्देशिका में एक README फ़ाइल डालने का सुझाव देता हूं कि यह बता रहा है कि निर्देशिका खाली क्यों है और इसे गिट में क्यों ट्रैक किया जाना चाहिए। रीडमे फ़ाइल के साथ, जहां तक ​​गिट का संबंध है, निर्देशिका अब खाली नहीं है।

असली सवाल यह है कि आपको गिट में खाली निर्देशिका क्यों चाहिए? आमतौर पर आपके पास कुछ प्रकार की बिल्ड स्क्रिप्ट होती है जो संकलन / चलने से पहले खाली निर्देशिका बना सकती है। यदि नहीं तो एक बनाओ। गिट में खाली निर्देशिका डालने से यह एक बेहतर समाधान है।

तो आपके पास कुछ कारण है कि आपको गिट में खाली निर्देशिका क्यों चाहिए। रीडमे फ़ाइल में उस कारण को रखें। इस तरह अन्य डेवलपर्स (और भविष्य आप) ​​जानते हैं कि खाली निर्देशिका क्यों होनी चाहिए। आपको यह भी पता चलेगा कि खाली निर्देशिका को हल करने की समस्या को हल करने के दौरान आप खाली निर्देशिका को हटा सकते हैं।

प्रत्येक खाली निर्देशिका को सूचीबद्ध करने के लिए निम्न आदेश का उपयोग करें:

find -name .git -prune -o -type d -empty -print

प्रत्येक खाली निर्देशिका में प्लेसहोल्डर READMEs बनाने के लिए:

find -name .git -prune -o -type d -empty -exec sh -c \
  "echo this directory needs to be empty because reasons > {}/README.emptydir" \;

README फ़ाइल को छोड़कर निर्देशिका में सब कुछ अनदेखा करने के लिए निम्न पंक्तियों को अपने .gitignore में डालें:

path/to/emptydir/*
!path/to/emptydir/README.emptydir
path/to/otheremptydir/*
!path/to/otheremptydir/README.emptydir

वैकल्पिक रूप से, आप केवल हर रीडमे फ़ाइल को अनदेखा होने से बाहर कर सकते हैं:

path/to/emptydir/*
path/to/otheremptydir/*
!README.emptydir

प्रत्येक README को पहले से बनाए जाने के बाद सूचीबद्ध करने के लिए:

find -name README.emptydir



If you want to add a folder that will house a lot of transient data in multiple semantic directories, then one approach is to add something like this to your root .gitignore...

/app/data/**/*.* !/app/data/**/*.md

Then you can commit descriptive README.md files (or blank files, doesn't matter, as long as you can target them uniquely like with the *.md in this case) in each directory to ensure that the directories all remain part of the repo but the files (with extensions) are kept ignored. LIMITATION: . 's are not allowed in the directory names!

You can fill up all of these directories with xml/images files or whatever and add more directories under /app/data/ over time as the storage needs for your app develop (with the README.md files serving to burn in a description of what each storage directory is for exactly).

प्रत्येक नई निर्देशिका के लिए .gitignoreनया बनाकर अपने या विकेन्द्रीकरण को बदलने की कोई आवश्यकता नहीं है .gitignore। शायद सबसे बुद्धिमान समाधान नहीं है लेकिन यह गिटिनोरोर-वार है और हमेशा मेरे लिए काम करता है। अच्छा और सरल! ;)




हो सकता है कि एक खाली निर्देशिका जोड़ना ऐसा लगता है कि यह कम से कम प्रतिरोध का मार्ग होगा क्योंकि आपके पास ऐसी स्क्रिप्ट हैं जो निर्देशिका की मौजूदगी की अपेक्षा करते हैं (शायद क्योंकि यह उत्पन्न बाइनरी के लिए एक लक्ष्य है)। आवश्यकतानुसार निर्देशिका बनाने के लिए आपकी स्क्रिप्ट को संशोधित करना एक और तरीका होगा।

mkdir --parents .generated/bin ## create a folder for storing generated binaries
mv myprogram1 myprogram2 .generated/bin ## populate the directory as needed

इस उदाहरण में, आप निर्देशिका के लिए एक (टूटा) प्रतीकात्मक लिंक देख सकते हैं ताकि आप इसे "। जेनरेटेड" उपसर्ग के बिना एक्सेस कर सकें (लेकिन यह वैकल्पिक है)।

ln -sf .generated/bin bin
git add bin

जब आप अपना स्रोत पेड़ साफ़ करना चाहते हैं तो आप बस:

rm -rf .generated ## this should be in a "clean" script or in a makefile

यदि आप लगभग खाली फ़ोल्डर में जांच करने के लिए सुझाए गए दृष्टिकोण को लेते हैं, तो आपके पास ".gitignore" फ़ाइल को हटाए बिना सामग्री को हटाने की मामूली जटिलता है।

आप अपनी जड़ में निम्नलिखित जोड़कर अपनी सभी जेनरेट की गई फ़ाइलों को अनदेखा कर सकते हैं .gitignore:

.generated



मुझे भी खाली निर्देशिकाओं के साथ इस मुद्दे का सामना करना पड़ रहा है। प्लेसहोल्डर फ़ाइलों का उपयोग करने में समस्या यह है कि आपको उन्हें बनाने की आवश्यकता है, और उन्हें हटाएं, अगर वे अब आवश्यक नहीं हैं (क्योंकि बाद में वहां उप-निर्देशिका या फ़ाइलें शामिल की गई थीं। इन प्लेसहोल्डर फ़ाइलों को प्रबंधित करने वाले बड़े स्रोत पेड़ों के साथ बोझिल और त्रुटि हो सकती है होने का खतरा।

यही कारण है कि मैंने एक ओपन सोर्स टूल लिखने का फैसला किया जो स्वचालित रूप से ऐसी प्लेसहोल्डर फ़ाइलों के निर्माण / हटाना का प्रबंधन कर सकता है। यह .NET प्लेटफार्म के लिए लिखा गया है और मोनो (लिनक्स के लिए .NET) और विंडोज के तहत चलता है।

बस एक नज़र डालें: http://code.google.com/p/markemptydirs




Here is a hack, but it's funny that it works (Git 2.2.1). Similar to what @Teka suggested, but easier to remember:

  • Add a submodule to any repository ( git submodule add path_to_repo )
  • This will add a folder and a file .submodules . Commit a change.
  • Delete .submodules file and commit the change.

Now, you have a directory that gets created when commit is checked out. An interesting thing though is that if you look at the content of tree object of this file you'll get:

fatal: Not a valid object name b64338b90b4209263b50244d18278c0999867193

I wouldn't encourage to use it though since it may stop working in the future versions of Git. Which may leave your repository corrupted.




मुझे @ आर्टूर 7 9 और @ एमजेएस के उत्तरों पसंद हैं, इसलिए मैं दोनों के संयोजन का उपयोग कर रहा हूं और इसे हमारी परियोजनाओं के लिए मानक बना रहा हूं।

find . -type d -empty -exec touch {}/.gitkeep \;

हालांकि, हमारे कुछ डेवलपर्स मैक या लिनक्स पर काम करते हैं। विंडोज़ पर बहुत काम और मुझे वहां पूरा करने के लिए एक समान सरल एक-लाइनर नहीं मिला। कुछ भाग्यशाली थे कि Cygwin को अन्य कारणों से स्थापित किया गया था, लेकिन इसके लिए सिग्विन को निर्धारित करना बहुत अधिक लग रहा था।

इसलिए, चूंकि हमारे अधिकांश डेवलपर्स में पहले से ही Ant स्थापित है, इसलिए मैंने इसे प्लेटफॉर्म से स्वतंत्र रूप से पूरा करने के लिए एक बिल्ड फ़ाइल बनाई है।

<?xml version="1.0" encoding="ISO-8859-1"?>
<project name="Gitkeep" basedir="." default="keep">
    <!--Apply to all subdirs of this dir-->
    <target name="keep" description="-> Add a .gitkeep file to all empty subdir's of this dir.">

        <!--Create a ref to all the subdirs in the tree of this dir-->
        <dirset id="dirs.ref" dir="./" includes="**/*"/>
        <!--Create a list of the subdirs under this dir-->
        <property name="dirs.list" refid="dirs.ref" />

        <!--For each subdir-->
        <for list="${dirs.list}" delimiter=";" param="dir">
            <sequential>
                <!--If the subdir is empty this target will add a .gitkeep file to it-->
                <antcall target="gitkeep" inheritall="false">
                    <param name="dir" value="@{dir}"/>
                </antcall>
            </sequential>
        </for>
    </target>

    <!--Add a .gitkeep file to a directory if it's empty-->
    <target name="gitkeep" description="-> Add a .gitkeep file to a specific subdir of this dir. Use -Ddir=relative/path/to/dir">

        <!--Create a ref of the files inside this dir-->
        <fileset dir="${dir}" id="contents.ref"/>

        <!--Create a path to the contents of this directory, ONLY if it's not empty-->
        <pathconvert refid="contents.ref" property="contents.path" setonempty="false"/>

        <if>
            <!--If the dir is empty create the .gitkeep file-->
            <not><isset property="contents.path"/></not>
            <then>
                <!--Create the .gitkeep file-->
                <echo message="Version this dir in Git even if its empty." file="./${dir}/.gitkeep" force="true" append="false"/>
            </then>
        </if>
    </target>
</project>

Now I can simply run

ant -f gitkeep.xml

And this creates a .gitkeep file in any empty subdir. Even on Windows :) Note: This build file requires the Ant Contrib jar.

I continue to work on this concept here .

here




You can save this code as create_readme.php and run the PHP code from the root directory of your Git project.

> php create_readme.php

It will add README files to all directories that are empty so those directories would be then added to the index.

<?php
    $path = realpath('.');
    $objects = new RecursiveIteratorIterator(new RecursiveDirectoryIterator($path),       RecursiveIteratorIterator::SELF_FIRST);
    foreach($objects as $name => $object){
        if ( is_dir($name) && ! is_empty_folder($name) ){
            echo "$name\n" ;
            exec("touch ".$name."/"."README");
        }
    }

    function is_empty_folder($folder) {
        $files = opendir($folder);
        while ($file = readdir($files)) {
            if ($file != '.' && $file != '..')
                return true; // Not empty
            }
        }
?>

Then do

git commit -m "message"
git push



Adding one more option to the fray.

Assuming you would like to add a directory to git that, for all purposes related to git , should remain empty and never have it's contents tracked, a .gitignore as suggested numerous times here, will do the trick.

The format, as mentioned, is:

*
!.gitignore

Now, if you want a way to do this at the command line, in one fell swoop, while inside the directory you want to add, you can execute:

$ echo "*" > .gitignore && echo '!.gitignore' >> .gitignore && git add .gitignore

Myself, I have a shell script that I use to do this. Name the script whatever you whish, and either add it somewhere in your include path, or reference it directly:

#!/bin/bash

dir=''

if [ "$1" != "" ]; then
    dir="$1/"
fi

echo "*" > $dir.gitignore && \
echo '!.gitignore' >> $dir.gitignore && \
git add $dir.gitignore

With this, you can either execute it from within the directory you wish to add, or reference the directory as it's first and only parameter:

$ ignore_dir ./some/directory

Another option (in response to a comment by @GreenAsJade), if you want to track an empty folder that MAY contain tracked files in the future, but will be empty for now, you can ommit the * from the .gitignore file, and check that in. Basically, all the file is saying is "do not ignore me ", but otherwise, the directory is empty and tracked.

Your .gitignore file would look like:

!.gitignore

That's it, check that in, and you have an empty, yet tracked, directory that you can track files in at some later time.

The reason I suggest keeping that one line in the file is that it gives the .gitignore purpose. Otherwise, some one down the line may think to remove it. It may help if you place a comment above the line.




हमें खाली संस्करण वाले फ़ोल्डरों की आवश्यकता क्यों होगी

एक खाली निर्देशिका गिट संस्करण प्रणाली के तहत एक पेड़ का हिस्सा नहीं हो सकता है । लेकिन ऐसे कई परिदृश्य हैं जिनमें एक खाली निर्देशिका उपयोगी हो सकती है, उदाहरण के लिए:

  • उपयोगी प्रोजेक्ट फ़ोल्डर्स के लिए एक पूर्वनिर्धारित फ़ोल्डर संरचना का निर्माण करना, composer पैकेज के लिए vendor/ फ़ोल्डर की तरह, और यह संरचना भंडार के प्रत्येक उपयोगकर्ता / योगदानकर्ता को उपलब्ध कराती है; या, उपरोक्त के एक विशेष मामले के रूप में , अस्थायी फ़ाइलों के लिए एक फ़ोल्डर बनाते हैं, जैसे cache/ या logs/ निर्देशिका
  • कुछ प्रोजेक्ट्स बस कुछ फ़ोल्डर्स के बिना काम नहीं करेंगे (जो अक्सर खराब डिजाइन किए गए प्रोजेक्ट का संकेत होता है, लेकिन यह अक्सर वास्तविक दुनिया का परिदृश्य है और शायद कह सकता है, अनुमति समस्याएं हो सकती हैं)।

कुछ सुझाए गए कामकाज

कई उपयोगकर्ता सुझाव देते हैं:

  1. निर्देशिका को खाली करने के लिए, या कुछ सामग्री के साथ एक README फ़ाइल या किसी अन्य फ़ाइल को रखना, या
  2. एक .gitignore फ़ाइल को "रिवर्स लॉजिक" (यानी सभी फाइलों को शामिल करने के लिए) के साथ बनाना, अंत में, दृष्टिकोण # 1 के समान उद्देश्य परोसता है।

जबकि दोनों समाधान निश्चित रूप से काम करते हैं , उस पर कोई सवाल नहीं है, मैं उन्हें गिट संस्करण के सार्थक दृष्टिकोण के साथ असंगत पाते हैं।

  • आपको फर्जी फाइलें या रीडमेम्स क्यों डालना चाहिए जो शायद आप वास्तव में अपनी परियोजना में नहीं चाहते हैं?
  • एक चीज करने के लिए .gitignore का उपयोग क्यों करें (फ़ाइलों को रखते हुए ) जो कि इसका मतलब है (फ़ाइलों को छोड़कर ) के विपरीत है, भले ही यह संभव हो?

गिटकीप दृष्टिकोण

वर्जनिंग सिस्टम में फ़ोल्डर की उपस्थिति को मजबूर करने के लिए .gitkeep नामक एक खाली फ़ाइल का उपयोग करें।

हालांकि ऐसा कोई बड़ा अंतर नहीं लग सकता है:

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

    उदाहरण के लिए, आपको READMEs को READMEs के रूप में उपयोग करना चाहिए, फ़ोल्डर को रखने का बहाना नहीं।

    चिंताओं का पृथक्करण हमेशा एक अच्छी बात है, और आप अभी भी अवांछित फ़ाइलों को अनदेखा करने के लिए एक .gitignore जोड़ सकते हैं।

  • इसका नामकरण। .gitkeep इसे फ़ाइल नाम से ही स्पष्ट और सीधा बनाता है (और अन्य डेवलपर्स के लिए भी, जो साझा परियोजना के लिए अच्छा है और गिट भंडार के मुख्य उद्देश्यों में से एक है) कि यह फ़ाइल है

    • कोड से संबंधित एक फ़ाइल (प्रमुख बिंदु और नाम की वजह से)
    • एक फ़ाइल स्पष्ट रूप से गिट से संबंधित है
    • इसका उद्देश्य ( रखें ) स्पष्ट रूप से बताया गया है और अनदेखा करने के अर्थ में लगातार और अर्थात् विरोध किया गया है

दत्तक ग्रहण

मैंने .gitkeep , .gitkeep Angular-CLI जैसे बहुत महत्वपूर्ण ढांचे द्वारा अपनाई गई। .gitkeep दृष्टिकोण को देखा है।




एंडी लेस्टर सही है, लेकिन अगर आपकी निर्देशिका को खाली होने की जरूरत है, और खाली खाली नहीं है, तो आप वहां एक खाली .gitignore फ़ाइल को वर्कअराउंड के रूप में रख सकते हैं।

एक तरफ के रूप में, यह एक कार्यान्वयन मुद्दा है, न कि मौलिक गिट स्टोरेज डिजाइन समस्या। जैसा कि गिट मेलिंग सूची पर कई बार उल्लेख किया गया है, इसका कारण यह नहीं लगाया गया है कि किसी ने भी इसके लिए पैच जमा करने के लिए पर्याप्त देखभाल नहीं की है, न कि यह किया जा सकता है या नहीं किया जाना चाहिए।




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




Links