Git හි සිද්ධි සංවේදී පමණක් ගොනු නාම වෙනස් කිරීම් කරන්නේ කෙසේද?

පළමු අකුර ප්‍රාග්ධනීකරණය කිරීමෙන් මම ලිපිගොනු කිහිපයක් වෙනස් කර Name.jpgඇත name.jpg. Git මෙම වෙනස්කම් හඳුනා නොගන්නා අතර මට ගොනු මකා දමා නැවත උඩුගත කිරීමට සිදු විය. ලිපිගොනු නාමවල වෙනස්කම් පරික්ෂා කිරීමේදී Git සිද්ධි සංවේදී විය හැකි ක්‍රමයක් තිබේද? මම ගොනුවේ කිසිදු වෙනසක් කර නැත.

ඔබට git mv භාවිතා කළ හැකිය :

git mv -f OldFileNameCase newfilenamecase

Git හි වින්‍යාස සැකසීමක් ඇති අතර එය සිද්ධි සංවේදී හෝ සංවේදීද යන්න පවසයි : core.ignorecase. Git හට සිද්ධි සංවේදී බව පැවසීමට, මෙම සැකසුම පහත පරිදි සකසන්න false:

git config core.ignorecase false

ප්‍රලේඛනය

සිට git configප්රලේඛනය :

core.ignorecase

සත්‍ය නම්, FAT වැනි සිද්ධි සංවේදී නොවන ගොනු පද්ධති මත git වඩා හොඳින් ක්‍රියා කිරීමට මෙම විකල්පය විවිධ ක්‍රියාමාර්ගයන්ට ඉඩ සලසයි. උදාහරණයක් ලෙස, makefilegit අපේක්ෂා කරන විට නාමාවලි ලැයිස්තුගත කිරීමක් සොයාගත හොත් Makefile, git එය සැබවින්ම එකම ගොනුවක් යැයි උපකල්පනය කරයි , එය දිගටම මතක තබා ගන්න Makefile.

පෙරනිමිය වැරදියි, git-clone (1) හෝ git-init (1) හැර core.ignorecase, නිධිය නිර්මාණය කරන විට සුදුසු නම් එය විමර්ශනය කර සත්‍ය වේ.

සිද්ධි-සංවේදී නොවන ගොනු පද්ධති

මා දන්නා සිද්ධි-සංවේදී නොවන ගොනු පද්ධති ඇති වඩාත් ජනප්‍රිය මෙහෙයුම් පද්ධති දෙක වේ

• වින්ඩෝස්
• OS X.

SourceTree භාවිතා කරමින් මට UI වෙතින් මේ සියල්ල කිරීමට හැකි විය

1. ලෙස නම් FILE.ext කරන්නwhatever.ext
2. එම ගොනුව වේදිකා ගත කරන්න
3. දැන් නැවත නම් whatever.ext කරන්නfile.ext
4. එම ගොනුව නැවත වේදිකා ගත කරන්න

එය ටිකක් වෙහෙසකරයි, නමුත් ඔබට එය ගොනු කිහිපයකට පමණක් කිරීමට අවශ්‍ය නම් එය ඉතා ඉක්මන් වේ

OS X හි මා කළේ මෙයයි:

git mv File file.tmp
git mv file.tmp file

පියවර දෙකක් නිසා මට “ගොනුවක් තිබේ” දෝෂයක් තිබේ. සමහර විට එය එක් පියවරකින් එකතු කිරීමෙන් --cachedහෝ කළ හැකිය .

සමහර විට Git හි සිද්ධි සංවේදීතාව තාවකාලිකව වෙනස් කිරීම අවශ්‍ය වේ :

ක්රමය # 1 - තනි විධානයක් සඳහා සිද්ධි සංවේදීතාව වෙනස් කරන්න:

git -c core.ignorecase=true checkout mybranchතනි checkoutවිධානයක් සඳහා සිද්ධි සංවේදීතාව අක්‍රිය කිරීමට . හෝ ඊට වඩා වැඩි සාමාන්යයෙන්: . (අදහස් දැක්වීමේදී මෙය යෝජනා කිරීම සඳහා VonC වෙත ණය.)git -c core.ignorecase= <<true or false>> <<command>>

ක්රමය # 2 - බහු විධාන සඳහා සිද්ධි සංවේදීතාව වෙනස් කරන්න:

සැකසුම වැඩි කාලයක් වෙනස් කිරීම සඳහා (උදා: එය නැවත වෙනස් කිරීමට පෙර බහු විධානයන් ක්‍රියාත්මක කිරීමට අවශ්‍ය නම්):

1. git config core.ignorecase(මෙය වත්මන් සැකසුම ලබා දෙයි, උදා false).
2. git config core.ignorecase <<true or false>> - අපේක්ෂිත නව සැකසුම සකසන්න.
3. ... තවත් විධාන කිහිපයක් ධාවනය කරන්න ...
4. git config core.ignorecase <<false or true>> - වින්‍යාස අගය එහි පෙර සැකසුම වෙත නැවත සකසන්න.

ඕඑස්එක්ස් යටතේ, මෙම ගැටළුව මඟහරවා ගැනීමට සහ සිද්ධි සංවේදී නොවන ගොනු පද්ධතියක් සංවර්ධනය කිරීමේදී ඇතිවන වෙනත් ගැටළු මඟහරවා ගැනීමට, ඔබට සිද්ධි සංවේදී අථත්‍ය ධාවක / තැටි රූපයක් නිර්මාණය කිරීමට තැටි උපයෝගීතාව භාවිතා කළ හැකිය .

තැටි උපයෝගීතාව ධාවනය කරන්න, නව තැටි රූපයක් සාදන්න, සහ පහත සැකසුම් භාවිතා කරන්න (හෝ ඔබ කැමති පරිදි වෙනස් කරන්න, නමුත් එය සංවේදීව තබා ගන්න):

එය දැන් සංවේදී එෆ්එස් මත ඇති බව පැවසීමට වග බලා ගන්න:

git config core.ignorecase false

Ij සිජ්මන්ගේ පිළිතුරට සමානව, ඩිරෙක්ටරියක් නැවත නම් කිරීමේදී OSX හි මට වැඩ කළේ මෙයයි ( වෙනත් පිළිතුරකින් මෙම පිළිතුරෙන් දේවානුභාවයෙන් ):

git mv CSS CSS2
git mv CSS2 css

සරලවම කිරීමෙන් git mv CSS cssඅවලංගු තර්ක දෝෂයක් ලබා දී ඇත: fatal: renaming '/static/CSS' failed: Invalid argumentසමහර විට OSX හි ගොනු පද්ධතිය සිද්ධි සංවේදී නොවන නිසා විය හැකිය

ps BTW ඔබ ජැන්ගෝ භාවිතා කරන්නේ නම්, එකතු කිරීමේ ස්ථිතිකයද සිද්ධි වෙනස හඳුනා නොගන්නා අතර ස්ථිතික මූල නාමාවලියෙහිද ඉහත සඳහන් දෑ අතින් කළ යුතුය.

මම පහත සඳහන් පියවර භාවිතා කළෙමි:

git rm -r --cached .
git add --all .
git commit -a -m "Versioning untracked files"
git push origin master

මට සරල විසඳුමක්

මම අනෙක් පිළිතුරු වලින් පහත විසඳුම් උත්සාහ කළ නමුත් ඒවා ක්‍රියාත්මක වූයේ නැත:

• git mv filename
• git rm -f filename

ඔබේ ගබඩාව දුරස්ථව සත්කාරකත්වය දරන්නේ නම් (GitHub, GitLab, BitBucket), ඔබට ගොනුව ආරම්භයේදීම (GitHub.com) නැවත නම් කළ හැකි අතර ඉහළ නමකින් ගොනුවේ නම වෙනස් කිරීමට බල කරන්න.

පහත දැක්වෙන උපදෙස් GitHub ට අදාළ වේ, කෙසේ වෙතත් ඒවා පිටුපස ඇති පොදු අදහස ඕනෑම දුරස්ථ නිධිය-සත්කාරක වේදිකාවක් සඳහා අදාළ විය යුතුය. කාරණා නැවත නම් කිරීමට ඔබ උත්සාහ කරන ගොනුවේ වර්ගය මතක තබා ගන්න, එනම් එය බ්‍රව්සරය තුළ සංස්කරණය කළ හැකි (කේත, පෙළ, ආදිය) හෝ සංස්කරණය කළ නොහැකි (රූපය, ද්විමය, ආදිය) ලෙස GitHub සලකන ගොනු වර්ගයක් වේවා.

1. GitHub.com වෙත පිවිසෙන්න
2. GitHub.com හි ඔබේ ගබඩාවට සංචාලනය කර ඔබ වැඩ කරන ශාඛාව තෝරන්න
3. වෙබ් අඩවියේ ගොනු සංචාලන මෙවලම භාවිතා කරමින්, ඔබ නැවත නම් කිරීමට අදහස් කරන ගොනුව වෙත යන්න
4. බ්‍රව්සරය තුළ ගොනුව සංස්කරණය කිරීමට GitHub ඔබට ඉඩ දෙයිද?
   • a.) සංස්කරණය කළ හැකිය
     1. "මෙම ගොනුව සංස්කරණය කරන්න" අයිකනය ක්ලික් කරන්න (එය පැන්සලක් මෙන් පෙනේ)
     2. ගොනු නාම පෙළ ආදානයේ ගොනු නාමය වෙනස් කරන්න
   • ආ.) නුසුදුසු
     1. නව පටිත්තක "බාගන්න" බොත්තම විවෘත කර ගොනුව ඔබේ පරිගණකයට සුරකින්න
     2. බාගත කළ ගොනුව නැවත නම් කරන්න
     3. GitHub.com හි පෙර පටිත්තෙහි, "මෙම ගොනුව මකන්න" අයිකනය ක්ලික් කරන්න (එය කුණු කූඩයක් මෙන් පෙනේ)
     4. "කෙලින්ම branchnameශාඛාවට බැඳෙන්න " රේඩියෝ බොත්තම තෝරාගෙන ඇති බව සහතික කර "වෙනස්කම් සිදු කරන්න" බොත්තම ක්ලික් කරන්න
     5. GitHub.com හි එකම නාමාවලිය තුළම, "ගොනු උඩුගත කරන්න" බොත්තම ක්ලික් කරන්න
     6. නැවත නම් කරන ලද ගොනුව ඔබේ පරිගණකයෙන් උඩුගත කරන්න
5. "කෙලින්ම branchnameශාඛාවට බැඳෙන්න " රේඩියෝ බොත්තම තෝරාගෙන ඇති බව සහතික කර "වෙනස්කම් සිදු කරන්න" බොත්තම ක්ලික් කරන්න
6. දේශීයව, ශාඛාව පරීක්ෂා කිරීම / ලබා ගැනීම / අදින්න
7. සිදු විය

1) ප්රතිනම්කෙරුම් ගොනු Name.jpgකිරීමටname1.jpg

2) ඉවත් කළ ගොනුව සිදු කරන්න Name.jpg

3) ප්රතිනම්කෙරුම් ගොනු name1.jpgකිරීමටname.jpg

4) name.jpgපෙර කැපවීමට එකතු කළ ගොනුව ammend කරන්න

git add
git commit --amend

අපට git mv විධානය භාවිතා කළ හැකිය. පහත උදාහරණය, ​​අපි abcDEF.js ගොනුව abcdef.js ලෙස නම් කළහොත් අපට පහත විධානය පර්යන්තයෙන් ධාවනය කළ හැකිය

git mv -f .\abcDEF.js  .\abcdef.js

මැක් ඕඑස්එක්ස් හයි සියෙරා 10.13 මෙය තරමක් නිවැරදි කරයි. ඔබගේ git ව්‍යාපෘති සඳහා අතථ්‍ය APFS කොටසක් සාදන්න, පෙරනිමියෙන් එයට ප්‍රමාණයේ සීමාවක් නොමැති අතර ඉඩක් නොලැබේ.

1. තැටි උපයෝගීතාවයේ දී, බහාලුම් තැටිය තෝරා ගන්නා අතරතුර + බොත්තම ක්ලික් කරන්න
2. ආකෘතිය යටතේ APFS (Case-Sensitive) තෝරන්න
3. එය නම් කරන්න Sensitive
4. ලාභයක්
5. වෛකල්පිත: සංවේදී ලෙස ෆෝල්ඩරයක් සාදන්න gitසහln -s /Volumes/Sensitive/git /Users/johndoe/git

ඔබගේ ධාවකය ක්‍රියාත්මක වේ /Volumes/Sensitive/

Git හි සිද්ධි සංවේදී පමණක් ගොනු නාම වෙනස් කිරීම් කරන්නේ කෙසේද?

මම මැකෝස් හි කිහිප වතාවක්ම මෙම ගැටලුවට මුහුණ දී සිටිමි. Git සිද්ධි සංවේදී නමුත් මැක් යනු නඩත්තු කිරීම පමණි.

කවුරුහරි ගොනුවක් සිදු කරයි: Foobar.javaදින කිහිපයකට පසු එය නැවත නම් කිරීමට තීරණය කරයි FooBar.java. ඔබ නවතම කේතය අදින විට එය අසමත් වේThe following untracked working tree files would be overwritten by checkout...

මෙය නිවැරදි කරන මා දුටු එකම විශ්වාසදායක ක්‍රමය නම්:

1. git rm Foobar.java
2. ඔබට අතපසු කළ නොහැකි පණිවිඩයක් සමඟ එය කරන්න git commit -m 'TEMP COMMIT!!'
3. අදින්න
4. මෙය ගැටුම ඒකාබද්ධ කිරීමට ඔබට බල කරන ගැටුමක් ඇති කරයි - මන්ද ඔබේ වෙනස එය මකා දැමූ නමුත් අනෙක් වෙනස නම් කරන ලදි (එබැවින් ගැටළුව)
   1. 'මකාදැමීම' වන ඔබේ වෙනස පිළිගන්න
   2. git rebase --continue
5. දැන් ඔබේ සලසන වක් මගක් අතහැර git rebase -i HEAD~2සහ dropඑමTEMP COMMIT!!
6. ගොනුව දැන් කැඳවා ඇති බව තහවුරු කරන්න FooBar.java

ඔබ ලිපිගොනු නැවත නම් කිරීම විශාල ප්‍රමාණයක් කර ඇති අතර සමහර ඒවා ආවරණ වෙනස් කිරීමක් පමණක් වන විට, එය කුමක්දැයි මතක තබා ගැනීම අපහසුය. අතින් "git moving" ගොනුව තරමක් වැඩ කළ හැකිය. එබැවින් මගේ ගොනු නාම වෙනස් කිරීමේ කාර්යයන් අතරතුර මම කරන්නේ කුමක්ද:

1. සියලුම git නොවන ගොනු සහ ෆෝල්ඩරය වෙනත් ෆෝල්ඩරයකට / ගබඩාවකට ඉවත් කරන්න.
2. වත්මන් හිස් git ෆෝල්ඩරය සිදු කරන්න (සියලුම ලිපිගොනු මකා දැමූ විට මෙය පෙන්වනු ඇත.)
3. සියලුම ගොනු නැවත මුල් git ෆෝල්ඩරයට / ගබඩාවට එක් කරන්න.
4. වත්මන් හිස් නොවන git ෆෝල්ඩරය කරන්න.

ඔබ විසින් නම් කරන ලද ලිපිගොනු හෝ ෆෝල්ඩර මොනවාදැයි සොයා බැලීමට උත්සාහ නොකර මෙය සියලු සිද්ධි ගැටලු විසඳනු ඇත.

කිසිවක් ක්‍රියාත්මක නොවන්නේ නම් තැටියෙන් ගොනුව මකා දමා නැවත එකතු කිරීමට git rm ගොනු නාමය භාවිතා කරන්න.

මම @CBarr පිළිතුර ගෙන ලිපිගොනු ලැයිස්තුවක් සමඟ එය කිරීමට පයිතන් 3 ස්ක්‍රිප්ට් එකක් ලිවීය:

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-

import os
import shlex
import subprocess

def run_command(absolute_path, command_name):
    print( "Running", command_name, absolute_path )

    command = shlex.split( command_name )
    command_line_interface = subprocess.Popen( 
          command, stdout=subprocess.PIPE, cwd=absolute_path )

    output = command_line_interface.communicate()[0]
    print( output )

    if command_line_interface.returncode != 0:
        raise RuntimeError( "A process exited with the error '%s'..." % ( 
              command_line_interface.returncode ) )

def main():
    FILENAMES_MAPPING = \
    [
        (r"F:\\SublimeText\\Data", r"README.MD", r"README.md"),
        (r"F:\\SublimeText\\Data\\Packages\\Alignment", r"readme.md", r"README.md"),
        (r"F:\\SublimeText\\Data\\Packages\\AmxxEditor", r"README.MD", r"README.md"),
    ]

    for absolute_path, oldname, newname in FILENAMES_MAPPING:
        run_command( absolute_path, "git mv '%s' '%s1'" % ( oldname, newname ) )
        run_command( absolute_path, "git add '%s1'" % ( newname ) )
        run_command( absolute_path, 
             "git commit -m 'Normalized the \'%s\' with case-sensitive name'" % (
              newname ) )

        run_command( absolute_path, "git mv '%s1' '%s'" % ( newname, newname ) )
        run_command( absolute_path, "git add '%s'" % ( newname ) )
        run_command( absolute_path, "git commit --amend --no-edit" )

if __name__ == "__main__":
    main()