git-svn - מקוון בענן

תָכְנִית:

שֵׁם

git-svn - פעולה דו-כיוונית בין מאגר Subversion ל-Git

תַקצִיר

סילון svn [אפשרויות] [טיעונים]

תיאור

סילון svn הוא צינור פשוט לשינויים בין Subversion ל-Git. הוא מספק א
זרימה דו כיוונית של שינויים בין Subversion למאגר Git.

סילון svn יכול לעקוב אחר מאגר Subversion סטנדרטי, בהתאם למשותף
פריסת "trunk/branches/tags", עם אפשרות --stdlayout. זה יכול גם לעקוב אחר סניפים ו
תגים בכל פריסה עם אפשרויות -T/-t/-b (ראה אפשרויות ל init למטה, וגם את
לשבט פקודה).

לאחר מעקב אחר מאגר Subversion (בכל אחת מהשיטות לעיל), מאגר Git
ניתן לעדכן מ- Subversion על ידי לְהָבִיא command and Subversion עודכנו מ-Git על ידי ה
dcommit פקודה.

פקודות

init
מאתחל מאגר Git ריק עם ספריות מטא נתונים נוספות עבור סילון svn.
ניתן לציין את כתובת האתר של Subversion כארגומנט שורת פקודה, או ככתובת URL מלאה
ארגומנטים ל-T/-t/-b. לחלופין, ניתן לציין את ספריית היעד שבה יש לפעול
כטיעון שני. בדרך כלל פקודה זו מאתחלת את הספרייה הנוכחית.

-T , --trunk= , -ת , --tags= ,
-ב , --ענפים= , -s, --stdlayout
אלו הן אפשרויות שורת פקודה אופציונליות עבור init. כל אחד מהדגלים הללו יכול להצביע
נתיב מאגר יחסי (--tags=project/tags) או כתובת URL מלאה
(--tags=https://foo.org/project/tags). אתה יכול לציין יותר מ--tag אחד ו/או
--אפשרויות סניפים, למקרה שמאגר Subversion שלך מציב תגים או סניפים
תחת מספר נתיבים. האפשרות --stdlayout היא דרך קיצור של הגדרה
trunk, tags, branches בתור הנתיבים היחסיים, שהיא ברירת המחדל של Subversion. אם בכלל
מהאפשרויות האחרות ניתנות גם כן, הן בעלות עדיפות.

--ללא מטא נתונים
הגדר את noMetadata אפשרות בתצורת [svn-remote]. אפשרות זו לא
מומלץ, אנא קרא את svn.noMetadata קטע של דף ניהול זה לפני השימוש
אפשרות זו.

--use-svm-props
הגדר את useSvmProps אפשרות בתצורת [svn-remote].

--use-svnsync-props
הגדר את השתמש בSvnsyncProps אפשרות בתצורת [svn-remote].

--rewrite-root=
הגדר את rewriteRoot אפשרות בתצורת [svn-remote].

--rewrite-uuid=
הגדר את שכתוב UUID אפשרות בתצורת [svn-remote].

--שם משתמש=
עבור הובלות ש-SVN מטפל באימות עבורן (http, https ו-svn רגיל),
ציין את שם המשתמש. עבור הובלות אחרות (למשל svn+ssh://), עליך לכלול
שם המשתמש בכתובת האתר, למשל svn+ssh://[מוגן בדוא"ל]/פּרוֹיֶקט

--prefix=
זה מאפשר לציין קידומת המוצמדת לשמות השלטים if
מצוינים תא מטען/ענפים/תגים. הקידומת לא כוללת אוטומטית את א
קו נטוי נגרר, אז הקפד לכלול אחד בטיעון אם זה מה שאתה
רוצה. אם צוין --branches/-b, הקידומת חייבת לכלול קו נטוי.
מומלץ מאוד להגדיר קידומת (עם קו נטוי נגרר) בכל מקרה, כמו
השופטים שלך למעקב ה-SVN יהיו ממוקמים ב-"refs/remotes/$prefix/", אשר is
תואם עם של גיט שֶׁלוֹ מעקב מרחוק נ"צ פריסה (refs/remotes/$remote/).
הגדרת קידומת שימושית גם אם ברצונך לעקוב אחר פרויקטים מרובים המשתפים
מאגר משותף. כברירת מחדל, הקידומת מוגדרת ל מָקוֹר/.

הערות
לפני Git v2.0, קידומת ברירת המחדל הייתה "" (ללא קידומת). זה התכוון לכך
שופטי מעקב SVN הוצבו ב-"refs/remotes/*", דבר שאינו תואם כיצד
שופטי המעקב מרחוק של Git מאורגנים. אם אתה עדיין רוצה את הישן
ברירת מחדל, אתה יכול לקבל את זה על ידי העברת --prefix "" בשורת הפקודה
(--prefix="" עשוי שלא לעבוד אם ה-Perl's Getopt::Long שלך הוא < v2.37).

--ignore-paths=
כאשר הועבר ל init or לשבט הביטוי הרגולרי הזה יישמר כתצורה
מַפְתֵחַ. לִרְאוֹת לְהָבִיא לתיאור של --התעלם מנתיבים.

--include-paths=
כאשר הועבר ל init or לשבט הביטוי הרגולרי הזה יישמר כתצורה
מַפְתֵחַ. לִרְאוֹת לְהָבִיא לתיאור של --include-נתיבים.

- no-minimize-url
בעת מעקב אחר ספריות מרובות (באמצעות --stdlayout, --branches או --tags
options), git svn ינסה להתחבר לשורש (או לרמה הגבוהה ביותר המותרת)
של מאגר החתרנות. ברירת מחדל זו מאפשרת מעקב טוב יותר אחר ההיסטוריה אם
פרויקטים שלמים מועברים בתוך מאגר, אך עלולים לגרום לבעיות ב
מאגרים שבהם קיימות הגבלות גישה לקריאה. חוֹלֵף
- no-minimize-url יאפשר ל-git svn לקבל כתובות אתרים כפי שהן מבלי לנסות
להתחבר לספרייה ברמה גבוהה יותר. אפשרות זו כבויה כברירת מחדל כאשר רק אחת
מתבצע מעקב אחר כתובת האתר/סניף (זה לא יעשה טוב).

לְהָבִיא
אחזר גרסאות שלא הובאו מהשלט של Subversion שאנו עוקבים אחריהם. השם של
קטע [svn-remote "..."] בקובץ $GIT_DIR/config עשוי להיות מוגדר כאופציונלי
טיעון שורת פקודה.

זה מעדכן אוטומטית את rev_map במידת הצורך (ראה $GIT_DIR/svn/**/.rev_map.* in
הסעיף קבצים למטה לפרטים).

--זמן מקומי
אחסן את זמני ההתחייבות של Git באזור הזמן המקומי במקום UTC. זה עושה סילון היכנס
(אפילו ללא --date=local) הראה את אותן הזמנים ש-svn log היה ב-local
אזור זמן.

זה לא מפריע לפעולה הדדית עם מאגר Subversion לך
משובטים, אבל אם אתה רוצה שמאגר Git המקומי שלך יוכל
לפעול יחד עם מאגר Git המקומי של מישהו אחר, או אל תשתמש בזה
אפשרות או ששניכם צריכים להשתמש בה באותו אזור זמן מקומי.

--הוֹרֶה
אחזר רק מהאב SVN של ה-HEAD הנוכחי.

--ignore-paths=
זה מאפשר לציין ביטוי רגולרי של Perl שיגרום לדילוג על
כל הנתיבים התואמים מהקופה מ-SVN. ה --התעלם מנתיבים האפשרות צריכה להתאים
לכל לְהָבִיא (כולל שליפות אוטומטיות עקב לשבט, dcommit, השבה מחדש, וכו)
על מאגר נתון.

מפתח config: svn-remote. .התעלמות-נתיבים

אם מפתח התצורה של התעלם-נתיבים מוגדר, ואפשרות שורת הפקודה גם כן
נתון, ייעשה שימוש בשני הביטויים הרגולריים.

דוגמאות:

דלג על ספריית "doc*" עבור כל אחזור

--ignore-paths="^doc"

דלג על "ענפים" ו"תגים" של ספריות ברמה הראשונה

--ignore-paths="^[^/]+/(?:branches|tags)"

--include-paths=
זה מאפשר לציין ביטוי רגולרי של Perl שיגרום להכללה
של נתיבים תואמים בלבד מהקופה מ-SVN. ה --include-נתיבים אפשרות צריכה
התאמה לכל לְהָבִיא (כולל שליפות אוטומטיות עקב לשבט, dcommit, השבה מחדש,
וכו') במאגר נתון. --התעלם מנתיבים מקבל עדיפות על פני --include-נתיבים.

מפתח config: svn-remote. .include-paths

--log-window-size=
לְהָבִיא יומן רשומות לכל בקשה בעת סריקת היסטוריית Subversion. ברירת המחדל היא
100. עבור מאגרי Subversion גדולים מאוד, ייתכן שיהיה צורך בערכים גדולים יותר עבור
לשבט/לְהָבִיא להשלים בזמן סביר. אבל ערכים גדולים מדי עלולים להוביל
שימוש גבוה יותר בזיכרון ופסקי זמן של בקשה.

לשבט
ריצות init ו לְהָבִיא. זה יצור אוטומטית ספרייה המבוססת על שם הבסיס של
כתובת האתר שהועברה אליו; או אם הועבר טיעון שני; זה יצור ספרייה
ולעבוד בתוך זה. הוא מקבל את כל הטיעונים לפיהם init ו לְהָבִיא פקודות
לְקַבֵּל; חוץ מ --להביא הכל ו --הוֹרֶה. לאחר שיבוט מאגר,
מה היא לְהָבִיא הפקודה תוכל לעדכן גרסאות מבלי להשפיע על עץ העבודה;
ו השבה מחדש הפקודה תוכל לעדכן את עץ העבודה עם העדכנית ביותר
שינויים.

--לשמור-ריק-dirs
צור קובץ מציין מיקום במאגר Git המקומי עבור כל ספרייה ריקה
הובא מחתרנות. זה כולל ספריות שמתרוקנות על ידי הסרה
כל הערכים במאגר Subversion (אך לא בספרייה עצמה). ה
גם קבצי מצייני מיקום נבדקים ומוסרים כאשר אין צורך עוד.

--placeholder-filename=
הגדר את השם של קבצי מציין מיקום שנוצרו על ידי --preserve-empty-dirs. בְּרִירַת מֶחדָל:
".gitignore"

השבה מחדש
זה מביא גרסאות מהאב SVN של ה-HEAD הנוכחי ומבסס מחדש את הנוכחי
(לא מחויב ל-SVN) פועלים נגדו.

זה עובד בדומה לעדכון svn or סילון למשוך אלא שהוא משמר היסטוריה לינארית
עם סילון השבה מחדש במקום סילון למזג כדי להקל על ההתחייבות עם סילון svn.

זה מקבל את כל האפשרויות ש סילון svn לְהָבִיא ו סילון השבה מחדש לְקַבֵּל. למרות זאת,
--להביא הכל מאחזר רק מה[svn-remote] הנוכחי, ולא כל [svn-remote]
הגדרות.

כמו סילון השבה מחדש; זה מחייב שהעץ העובד יהיה נקי וללא מחויבות
שינויים.

זה מעדכן אוטומטית את rev_map במידת הצורך (ראה $GIT_DIR/svn/**/.rev_map.* in
הסעיף קבצים למטה לפרטים).

-ל, -מקומי
אין להביא מרחוק; רק לרוץ סילון השבה מחדש נגד ההתחייבות האחרונה שהובאו ממנה
ה-SVN במעלה הזרם.

dcommit
הגדר כל הבדל מהענף הנוכחי ישירות למאגר SVN, ולאחר מכן
rebase או reset (תלוי אם יש הבדל בין SVN ל-head).
פעולה זו תיצור גרסה ב-SVN עבור כל commit ב-Git.

כאשר שם ענף Git אופציונלי (או שם אובייקט Git commit) מצוין כ-
ארגומנט, פקודת המשנה פועלת על הענף שצוין, לא על הענף הנוכחי.

שימוש dcommit מועדף על פני סט-עץ (לְהַלָן).

--ללא בסיס מחדש
לאחר ההתחייבות, אין לבצע בסיס מחדש או לאפס.

--commit-url
התחייב לכתובת ה-SVN הזו (הנתיב המלא). זה נועד לאפשר קיים סילון svn
מאגרים שנוצרו בשיטת תחבורה אחת (למשל svn:// או http:// עבור
קריאה אנונימית) לשימוש חוזר אם מאוחר יותר תינתן למשתמש גישה לחלופה
שיטת תחבורה (למשל svn+ssh:// או https://) עבור commit.

מפתח config: svn-remote. .commiturl
מפתח config: svn.commiturl (מחליף את כל svn-remote. אפשרויות .commiturl)

שים לב שכתובת ה-SVN של מפתח התצורה commiturl כוללת את ענף SVN. אם אתה
במקום זאת רוצה להגדיר את כתובת ה-commit עבור שימוש במאגר SVN שלם
svn-remote. .pushurl במקום זאת.

מומלץ מאוד להשתמש באפשרות זו לכל מטרה אחרת (אל תשאל).

--mergeinfo=
הוסף את מידע המיזוג הנתון במהלך ה-dcommit (למשל
--mergeinfo="/branches/foo:1-10"). כל גרסאות שרת svn יכולות לאחסן את זה
מידע (כנכס), ולקוחות svn החל מגרסה 1.5 יכולים ליצור
שימוש בו. כדי לציין מידע מיזוג ממספר סניפים, השתמש ברווח יחיד
תו בין הענפים (--mergeinfo="/branches/foo:1-10
/branches/bar:3,5-6,8")

מפתח config: svn.pushmergeinfo

אפשרות זו תגרום ל-git-svn לנסות לאכלס אוטומטית את
מאפיין svn:mergeinfo במאגר SVN במידת האפשר. נכון לעכשיו, זה יכול
להיעשות רק כאשר dcommitting non-fast-forward מיזוג שבו כל ההורים מלבד
תחילה כבר נדחפו ל-SVN.

--אינטראקטיבי
בקש מהמשתמש לאשר שאכן יש לשלוח סט תיקון ל-SVN. לכל אחד
תיקון, אפשר לענות "כן" (קבל את התיקון הזה), "לא" (לזרוק את התיקון הזה), "הכל"
(קבל את כל התיקונים), או "צא".

סילון svn dcommit חוזר מיד אם התשובה היא "לא" או "צא", ללא
מתחייבים כל דבר ל-SVN.

סניף
צור סניף במאגר SVN.

-מ, --הודעה
מאפשר לציין את הודעת ההתחייבות.

-ת, --תג
צור תג על ידי שימוש ב-tags_subdir במקום ב- branches_subdir שצוין
במהלך git svn init.

-ד , --destination=
אם ניתנה אפשרות אחת --ענפים (או --תגים) ל- init or לשבט
הפקודה, עליך לספק את מיקום הסניף (או התג) שברצונך ליצור
במאגר SVN. מציין באיזה נתיב להשתמש כדי ליצור את הענף או
תג וצריך להתאים לדפוס בצד שמאל של אחד מהמוגדרים
מפרט ענפים או תגים. אתה יכול לראות את המפרטים האלה עם הפקודות

git config --get-all svn-remote. .ענפים
git config --get-all svn-remote. .tags

איפה הוא השם של מאגר ה-SVN כפי שצוין על ידי האפשרות -R ל
init (או "svn" כברירת מחדל).

--שם משתמש
ציין את שם המשתמש של SVN לביצוע ה-commit בתור. אפשרות זו עוקפת את
שם משתמש נכס תצורה.

--commit-url
השתמש בכתובת ה-URL שצוינה כדי להתחבר למאגר Subversion של היעד. זה
שימושי במקרים שבהם מאגר ה-SVN של המקור הוא לקריאה בלבד. אפשרות זו
עוקף את מאפיין התצורה commiturl.

git config --get-all svn-remote. .commiturl

--הורים
צור תיקיות אב. פרמטר זה שווה ערך לפרמטר --parents on
svn cp פקודות והוא שימושי עבור פריסות מאגר לא סטנדרטיות.

תג
צור תג במאגר SVN. זה קיצור של סניף -t.

היכנס
זה אמור להקל על חיפוש הודעות יומן svn כאשר משתמשי svn מתייחסים אליהם
-r/--מספרי גרסה.

התכונות הבאות מ-'svn log' נתמכות:

-ר [: ], --revision= [: ]
נתמך, ארגומנטים לא מספריים אינם: HEAD, NEXT, BASE, PREV וכו'...

-v, --מלל
זה לא לגמרי תואם לפלט --verbose ב-svn log, אבל
קרוב למדי.

--limit=
אינו זהה ל--max-count, אינו סופר התחייבויות ממוזגות/לא נכללות

--מצטבר
נתמך

תכונות חדשות:

--show-commit
מציג גם את ה-Git commit sha1

--שורה אחת
הגרסה שלנו של --pretty=oneline

הערות
SVN עצמו מאחסן רק זמנים ב-UTC ותו לא. לקוח svn הרגיל
ממירה את זמן UTC לזמן מקומי (או בהתבסס על סביבת TZ=). זֶה
לפקודה יש ​​את אותה התנהגות.
כל טיעון אחר מועבר ישירות אל סילון היכנס

להאשים
הראה איזה גרסה ומחבר שינו לאחרונה כל שורה בקובץ. הפלט של זה
המצב תואם פורמט עם הפלט של 'svn blame' כברירת מחדל. כמו ה-SVN
פקודת blame, מתעלמים משינויים מקומיים לא מחויבים בעץ העבודה; הגרסא
של הקובץ בגירסת HEAD מסומנת. ארגומנטים לא ידועים מועברים ישירות
ל סילון להאשים.

--git-format
הפק פלט באותו פורמט כמו סילון להאשים, אבל עם מספרי גרסת SVN
במקום Git לבצע hashes. במצב זה, שינויים שלא התחייבו אליהם
SVN (כולל עריכות מקומיות של עותק עבודה) מוצגות כגרסה 0.

find-rev
כאשר ניתן מספר גרסה SVN של הטופס rN, מחזיר את ה-Git commit התואם
hash (אפשר לעקוב אחריו עץ-ish כדי לציין איזה ענף צריך להיות
חיפשו). כאשר ניתן עץ-ish, מחזיר את מספר גרסת ה-SVN המתאים.

-ב, -לפני
אל תדרוש התאמה מדויקת אם ניתן גרסה של SVN, במקום זאת מצא את ה-commit
המתאים למצב מאגר SVN (בסניף הנוכחי) ב-
גרסה שצוינה.

-א, --אחרי
אל תדרוש התאמה מדויקת אם ניתנת גרסה של SVN; אם אין מדוייק
match החזר את ההתאמה הקרובה ביותר בחיפוש קדימה בהיסטוריה.

סט-עץ
כדאי לשקול להשתמש dcommit במקום הפקודה הזו. התחייבות מוגדרת או
עץ מתנגד ל-SVN. זה מסתמך על עדכניות נתוני האחזור המיובאים שלך. זֶה
לא עושה שום ניסיון לבצע תיקון בעת ​​התחייבות ל-SVN, זה פשוט
מחליף קבצים עם אלה שצוינו בעץ או ב-commit. ההנחה היא שכל מיזוג
התקיימו ללא תלות ב סילון svn פונקציות.

ליצור-התעלם
מוצא באופן רקורסיבי את המאפיין svn:ignore על ספריות ויוצר התאמה
קבצי .gitignore. הקבצים המתקבלים מבוימים להיות מחויבים, אבל לא
מְחוּיָב. השתמש ב-r/--revision כדי להתייחס לגרסה ספציפית.

הצג-התעלם
מוצא באופן רקורסיבי ומפרט את המאפיין svn:ignore על ספריות. הפלט הוא
מתאים להוספה לקובץ $GIT_DIR/info/exclude.

mkdirs
ניסיונות ליצור מחדש ספריות ריקות ש-Core Git לא יכול לעקוב אחריהם על סמך מידע
ב-$GIT_DIR/svn/ קבצי /unhandled.log. ספריות ריקות מתבצעות באופן אוטומטי
נוצר מחדש בעת שימוש ב-"git svn clone" ו-"git svn rebase", אז "mkdirs" מיועד עבור
השתמש לאחר פקודות כמו "git checkout" או "git reset". (ראה את
svn-remote. אפשרות קובץ התצורה של .automkdirs למידע נוסף.)

commit-diff
מבצע את ההפרש של שני ארגומנטים של עצים משורת הפקודה. הפקודה הזו עושה זאת
לא להסתמך על הימצאות בתוך מאגר init-ed של git svn. פקודה זו לוקחת שלושה
ארגומנטים, (א) העץ המקורי שיש להבדיל מולו, (ב) תוצאת העץ החדשה, (ג) כתובת האתר
של מאגר היעד Subversion. ניתן להשמיט את הארגומנט הסופי (URL) אם אתה
עובדים מא סילון svn-aware repository (שנפתח עם סילון svn).
-ר נדרשת אפשרות לכך.

מידע
מציג מידע על קובץ או ספריה בדומה למה ש'svn info' מספק. עושה
לא תומך כרגע בטיעון -r/--revision. השתמש באפשרות --url לפלט בלבד
הערך של כתובת האתר: שדה.

proplist
מפרט את המאפיינים המאוחסנים במאגר Subversion לגבי קובץ נתון או
מַדרִיך. השתמש ב-r/--revision כדי להתייחס לגרסה ספציפית של Subversion.

פרוגט
מקבל את המאפיין Subversion שניתן כארגומנט הראשון, עבור קובץ. ספציפי
ניתן לציין גרסה עם -r/--revision.

שואו-חיצוניים
מציג את החיצוניות של Subversion. השתמש ב-r/--revision כדי לציין גרסה ספציפית.

gc
דחוס $GIT_DIR/svn/ קבצי /unhandled.log והסר
$GIT_DIR/svn/ קבצי /index.

לאתחל
מבטל את ההשפעות של לְהָבִיא חזרה לגרסה שצוינה. זה מאפשר לך
מחדשלְהָבִיא גרסה של SVN. בדרך כלל התוכן של גרסת SVN לעולם לא אמור להשתנות
ו לאתחל לא צריך להיות נחוץ. עם זאת, אם הרשאות SVN משתנות, או אם תשנה
אפשרות --ignore-paths שלך, א לְהָבִיא עלול להיכשל עם "לא נמצא ב-commit" (קובץ לא
גלוי בעבר) או "אי התאמה של סכום בדיקה" (פספס שינוי). אם הבעיה
לא ניתן להתעלם מהקובץ לנצח (עם --ignore-paths) הדרך היחידה לתקן את ה-repo
הוא להשתמש לאתחל.

רק ה- rev_map ו- refs/remotes/git-svn משתנים (ראה $GIT_DIR/svn/**/.rev_map.*
בסעיף קבצים למטה לפרטים). לעקוב אחר לאתחל עם לְהָבִיא ולאחר מכן סילון לאתחל
or סילון השבה מחדש להעביר סניפים מקומיים אל העץ החדש.

-ר , --revision=
ציין את הגרסה האחרונה שיש לשמור. כל הגרסאות המאוחרות יותר נמחקות.

-p, --הורה
בטל גם את הגרסה המצוינת, שמור במקום זאת את ההורה הקרוב ביותר.

דוגמא:
נניח שיש לך שינויים מקומיים ב"מאסטר", אבל אתה צריך לאחזר את "r2".

שלטי r1---r2---r3/git-svn
\
א---ב מאסטר

תקן את בעיית ה- ignore-paths או הרשאות SVN שגרמה ל-"r2" להיות לא שלם
במקום הראשון. לאחר מכן:

git svn reset -r2 -p
git svn להביא

שלטי r1---r2'--r3'/git-svn
\
r2---r3---A---B master

ואז לתקן "מאסטר" עם סילון השבה מחדש. אל תשתמש סילון למזג או שההיסטוריה שלך לא תעשה זאת
להיות תואם לעתיד dcommit!

git rebase --onto remotes/git-svn A^ master

שלטי r1---r2'--r3'/git-svn
\
א'--ב' מאסטר

אפשרויות

--shared[=(false|true|umask|group|all|world|כולם)], --template=
משמש רק עם init פקודה. אלה מועברים ישירות אל סילון init.

-ר , --עדכון
בשימוש עם ה לְהָבִיא פקודה.

זה מאפשר לתמוך בטווחי גרסאות עבור היסטוריה חלקית/צרובה. $NUMBER,
$NUMBER1:$NUMBER2 (טווחים מספריים), $NUMBER:HEAD ו-BASE:$NUMBER נתמכים כולם.

זה יכול לאפשר לך ליצור מראות חלקיות בעת הפעלת אחזור; אבל בדרך כלל לא
מומלץ כי ההיסטוריה תידלג ותאבד.

-, --סטדין
משמש רק עם סט-עץ פקודה.

קרא רשימה של התחייבויות מ-stdin ובצע אותם בסדר הפוך. רק המובילים
sha1 נקרא מכל שורה, אז סילון רשימת סיבובים --pretty=oneline ניתן להשתמש בפלט.

--rmdir
משמש רק עם dcommit, סט-עץ ו commit-diff פקודות.

הסר ספריות מעץ SVN אם לא נותרו קבצים מאחור. SVN יכול
ספריות ריקות בגרסה, והן אינן מוסרות כברירת מחדל אם אין קבצים
נותר בהם. Git לא יכול לגרסת ספריות ריקות. הפעלת דגל זה תגרום ל-
להתחייב ל-SVN להתנהג כמו Git.

מפתח config: svn.rmdir

-e, - Tit
משמש רק עם dcommit, סט-עץ ו commit-diff פקודות.

ערוך את הודעת ההתחייבות לפני התחייבות ל-SVN. זה כבוי כברירת מחדל עבור אובייקטים
שהם מתחייבים, ומאולצים בעת ביצוע חפצי עץ.

מפתח config: svn.edit

-ל , --מצא-עותקים-קשה יותר
משמש רק עם dcommit, סט-עץ ו commit-diff פקודות.

שניהם מועברים ישירות אל סילון עץ הבדל; ראה git-diff-tree(1) לעוד
מידע.

מפתח config: svn.l
מפתח config: svn.findcopiesharder

-א , --authors-file=
תחביר תואם לקובץ שבו משתמש סילון cvsimport:

loginname = Joe User[מוגן בדוא"ל]>

אם אפשרות זו מוגדרת ו- סילון svn נתקל בשם committer SVN שלא
קיים בקובץ המחברים, סילון svn יבטל את הפעולה. לאחר מכן המשתמש יצטרך
הוסף את הערך המתאים. הפעלה מחדש של הקודם סילון svn הפקודה לאחר
קובץ authors השתנה צריך להמשיך לפעול.

מפתח config: svn.authorsfile

--authors-prog=
אם אפשרות זו צוינה, עבור כל שם מחייב SVN שלא קיים ב-
קובץ authors, הקובץ הנתון מבוצע עם שם ה-committer בתור הראשון
טַעֲנָה. התוכנית צפויה להחזיר שורה בודדת בטופס "שם ",
אשר יטופל כאילו נכלל בקובץ המחברים.

-ש, -שקט
לעשות סילון svn פחות מילולי. ציין פעם שניה כדי להפוך את זה אפילו פחות מילולי.

-מ, --מיזוג, -ש , --אסטרטגיה= , -p, --שמר-מיזוג
אלה משמשים רק עם dcommit ו השבה מחדש פקודות.

עבר ישירות ל סילון השבה מחדש בעת שימוש dcommit אם סילון לאתחל לא ניתן להשתמש (ראה
dcommit).

-n, --- יבש-ריצה
זה יכול לשמש עם dcommit, השבה מחדש, סניף ו תג פקודות.

בעד dcommit, הדפיסו את סדרת הארגומנטים של Git שיראו אילו הבדלים יהיו
להיות מחויב ל-SVN.

בעד השבה מחדש, הצג את הסניף המקומי המשויך למאגר svn במעלה הזרם
המשויך לסניף הנוכחי ולכתובת ה-URL של מאגר svn שיאוחזר
מ.

בעד סניף ו תג, הצג את כתובות האתרים שישמשו להעתקה בעת יצירת ה
סניף או תג.

--use-log-author
בעת אחזור svn commits לתוך Git (כחלק מ לְהָבִיא, השבה מחדש, או dcommit
פעולות), חפש את השורה הראשונה מאת: או חתום על ידי: בהודעת היומן ו
השתמש בזה כמחרוזת המחבר.

--הוסף-מחבר-מאת
כאשר מתחייבים ל-svn מ-Git (כחלק מ commit-diff, סט-עץ or dcommit
פעולות), אם הודעת היומן הקיימת עדיין לא מכילה מאת: או
חתום על ידי: שורה, הוסף שורה מאת: המבוססת על מחרוזת המחבר של ה-Git commit. אם
אתה משתמש בזה, אז --use-log-author יאחזר מחרוזת מחבר חוקית עבור כולם
מתחייב.

מתקדם אפשרויות

-אני , --id
זה מגדיר GIT_SVN_ID (במקום להשתמש בסביבה). זה מאפשר למשתמש
לעקוף את ברירת המחדל של שם החלפה לאחזור בעת מעקב אחר כתובת אתר בודדת. ה היכנס ו
dcommit פקודות כבר לא דורשות את המתג הזה כארגומנט.

-ר , --svn-remote
ציין את [svn-remote " "] קטע לשימוש, זה מאפשר SVN מרובה
מאגרים שיש לעקוב אחריהם. ברירת מחדל: "svn"

--עקוב-הורה
אפשרות זו רלוונטית רק אם אנו עוקבים אחר סניפים (באמצעות אחד מהמאגרים
אפשרויות פריסה --trunk, --tags, --branches, --stdlayout). עבור כל סניף במעקב, נסה
כדי לברר מאיפה הגרסה שלו הועתקה, ולהגדיר הורה מתאים בראשון
Git commit עבור הסניף. זה מועיל במיוחד כאשר אנו עוקבים אחר ספרייה
שהועבר בתוך המאגר. אם תכונה זו מושבתת, ה-
סניפים שנוצרו על ידי סילון svn כולם יהיו ליניאריים ולא חולקים שום היסטוריה, כלומר
לא יהיה מידע על היכן הסתעפו או אוחדו סניפים. למרות זאת,
מעקב אחר היסטוריות ארוכות/מפותלות עשוי להימשך זמן רב, לכן השבתת תכונה זו
עשוי להאיץ את תהליך השיבוט. תכונה זו מופעלת כברירת מחדל, השתמש
--no-follow-parent כדי להשבית אותו.

מפתח config: svn.followparent

התצורה קובץ בלבד אפשרויות

svn.noMetadata, svn-remote. .noMetadata
זה נפטר מה- git-svn-id: שורות בסוף כל commit.

אפשרות זו יכולה לשמש רק עבור יבוא חד פעמי כמו סילון svn לא יוכל להביא
שוב ללא מטא נתונים. בנוסף, אם תאבד את שלך $GIT_DIR/svn/**/.rev_map.*
קבצים, סילון svn לא יוכלו לבנות אותם מחדש.

השמיים סילון svn היכנס הפקודה לא תעבוד גם על מאגרים המשתמשים בזה. משתמש בזה
מתנגשים עם useSvmProps אפשרות מסיבות ברורות (בתקווה).

אפשרות זו אינה מומלצת מכיוון שהיא מקשה על מעקב אחר הפניות ישנות
למספרי גרסאות SVN בתיעוד קיים, דוחות באגים וארכיונים. אם אתה
מתכננים בסופו של דבר להגר מ-SVN ל-Git ובטוחים לגבי ביטול היסטוריית ה-SVN,
לשקול git-filter-branch(1) במקום זאת. filter-branch מאפשר גם עיצוב מחדש של
מטא נתונים עבור קלות קריאה ושכתוב מידע מחבר עבור שאינו "svn.authorsFile"
משתמשים.

svn.useSvmProps, svn-remote. .useSvmProps
זה מאפשר סילון svn למיפוי מחדש של כתובות אתרים של מאגר ו-UUID ממראות שנוצרו באמצעות
SVN::Mirror (או svk) עבור מטא נתונים.

אם לגרסה של SVN יש מאפיין, "svm:headrev", סביר להניח שהגרסה הייתה
נוצר על ידי SVN::Mirror (בשימוש גם על ידי SVK). הנכס מכיל UUID של מאגר ו
עדכון. אנחנו רוצים לגרום לזה להיראות כאילו אנחנו משקפים את כתובת האתר המקורית, אז
הצג פונקציית עוזר שמחזירה את כתובת האתר וה-UUID המקורית של הזהות, והשתמש
זה בעת יצירת מטא נתונים בהודעות commit.

svn.useSvnsyncProps, svn-remote. .useSvnsyncprops
בדומה לאפשרות useSvmProps; זה מיועד למשתמשים של svnsync(1) פקודה
מופץ עם SVN 1.4.x ואילך.

svn-remote. .rewriteRoot
זה מאפשר למשתמשים ליצור מאגרים מכתובות URL חלופיות. לדוגמה, א
מנהל יכול לפעול סילון svn בשרת באופן מקומי (ניגש דרך file://) אבל רוצה
כדי להפיץ את המאגר עם כתובת http:// או svn:// ציבורית במטא נתונים כך
המשתמשים בו יראו את כתובת האתר הציבורית.

svn-remote. .rewriteUUID
בדומה לאפשרות useSvmProps; זה מיועד למשתמשים שצריכים למפות מחדש את ה-UUID
באופן ידני. זה עשוי להיות שימושי במצבים שבהם ה-UUID המקורי אינו זמין
באמצעות useSvmProps או useSvnsyncProps.

svn-remote. .pushurl
דומה לזה של Git מְרוּחָק. .pushurl, מפתח זה מיועד לשימוש במקרים שבהם
כתובת אתר מצביע על מאגר SVN באמצעות תעבורה לקריאה בלבד, כדי לספק חלופה
קריאה/כתיבה תחבורה. ההנחה היא ששני המפתחות מצביעים על אותו מאגר.
שונה commiturl, pushurl הוא נתיב בסיס. או זה או זה commiturl or pushurl יכול להיות
בשימוש, commiturl מקבל עדיפות.

svn.brokenSymlink Workaround
זה משבית בדיקות שעלולות להיות יקרות כדי לעקוף קישורים סימליים שבורים שנכנסו אליהם
SVN על ידי לקוחות שבורים. הגדר אפשרות זו ל-"false" אם אתה עוקב אחר מאגר SVN עם
כתמים ריקים רבים שאינם סימלינקים. אפשרות זו עשויה להשתנות תוך כדי סילון svn is
פועל וייכנס לתוקף בגרסה הבאה שאוחזר. אם לא מוגדר, סילון svn מניח זאת
אפשרות להיות "אמת".

svn.pathnameencoding
זה מורה ל-git svn לקודד מחדש שמות נתיבים לקידוד נתון. ניתן להשתמש בו על ידי
משתמשי Windows ועל ידי אלה שעובדים באזורים שאינם UTF8 כדי להימנע משמות קבצים פגומים
עם תווים שאינם ASCII. קידודים חוקיים הם אלה הנתמכים על ידי ה-Encode של Perl
מודול.

svn-remote. .automkdirs
בדרך כלל, הפקודות "גיt svn clone" ו-"git svn rebase" מנסות ליצור מחדש ריקים
ספריות שנמצאות במאגר Subversion. אם אפשרות זו מוגדרת ל-"false",
אז ספריות ריקות ייווצרו רק אם הפקודה "git svn mkdirs" מופעלת
בִּמְפוּרָשׁ. אם לא מוגדר, סילון svn מניח שהאפשרות הזו היא "אמיתית".

מאז האפשרויות noMetadata, rewriteRoot, rewriteUUID, useSvnsyncProps ו-useSvmProps
כולם משפיעים על המטא נתונים שנוצרים ומשמשים על ידי סילון svn; הֵם צריך להיות מוגדר ב
קובץ התצורה לפני ייבוא ​​היסטוריה כלשהי, והגדרות אלו לעולם לא צריכות להיות
השתנו ברגע שהם מוגדרים.

בנוסף, ניתן להשתמש רק באחת מהאפשרויות הללו לכל קטע svn-remote מכיוון שהם
להשפיע git-svn-id: שורת metadata, למעט rewriteRoot ו-rewriteUUID שיכולות להיות
בשימוש יחד.

בסיסי דוגמאות

מעקב ותרומה לטראנק של פרויקט מנוהל Subversion (התעלמות מתגיות ו
ענפים):

# שיבוט ריפו (כמו שיבוט git):
שיבוט gn svn http://svn.example.com/project/trunk
# היכנס לספרייה ששובטת לאחרונה:
תא מטען CD
# אתה צריך להיות בסניף מאסטר, בדוק שוב עם 'git branch'
ענף git
# עשה עבודה והתחייבות מקומית ל-Git:
git commit...
# משהו מחויב ל-SVN, בסיס מחדש את השינויים המקומיים שלך מול ה-
# שינויים אחרונים ב-SVN:
git svn rebase
# כעת בצע את השינויים שלך (שבוצעו בעבר באמצעות Git) ל-SVN,
# כמו גם עדכון אוטומטי של HEAD העובד שלך:
git svn dcommit
# הוסף את הגדרות svn:ignore לקובץ Git exclude המוגדר כברירת מחדל:
git svn show-ignore >> .git/info/exclude

מעקב ותרומה לפרויקט שלם המנוהל על ידי Subversion (שלם עם תא מטען,
תגיות וסניפים):

# שיבוט ריפו עם פריסת ספריית SVN סטנדרטית (כמו שיבוט git):
שיבוט gn svn http://svn.example.com/project --stdlayout --prefix svn/
# או, אם ה-repo משתמש בפריסת ספרייה לא סטנדרטית:
שיבוט gn svn http://svn.example.com/project -T tr -b branch -t tag --prefix svn/
# הצג את כל הענפים והתגים ששבטת:
ענף git -r
# צור סניף חדש ב-SVN
git svn branch waldo
# אפס את המאסטר שלך לתא המטען (או כל ענף אחר, תוך החלפת 'תא מטען'
# עם השם המתאים):
git reset --hard svn/trunk
# אתה יכול להתחייב רק לענף/תג/מטען אחד בכל פעם. השימוש
# של dcommit/rebase/show-ignore צריך להיות זהה לעיל.

הראשוני סילון svn לשבט יכול להיות די גוזל זמן (במיוחד עבור Subversion גדולות
מאגרים). אם מספר אנשים (או אדם אחד עם מספר מכונות) רוצים להשתמש סילון
svn כדי ליצור אינטראקציה עם אותו מאגר Subversion, אתה יכול לעשות את ההתחלה סילון svn לשבט
למאגר בשרת ולאפשר לכל אדם לשכפל איתו את המאגר הזה סילון לשבט:

# בצע את הייבוא ​​הראשוני בשרת
שרת ssh "cd /pub && git svn clone http://svn.example.com/project [אפשרויות...]"
# שיבוט מקומי - ודא שהמפרטים/השלטים/הרווחים תואמים לשרת
פרויקט mkdir
פרויקט CD
git init
git מרחוק הוסף שרת מקור:/pub/project
git config --replace-all remote.origin.fetch '+refs/remotes/*:refs/remotes/*'
אחזור git
# מנע אחזור/משיכה משרת Git מרוחק בעתיד,
# אנחנו רוצים להשתמש רק ב-git svn עבור עדכונים עתידיים
git config --remove-section remote.origin
# צור סניף מקומי מאחד הסניפים שזה עתה הובא
git checkout -b מאסטר FETCH_HEAD
# אתחול 'git svn' באופן מקומי (הקפד להשתמש באותה כתובת URL ו
# אפשרויות קידומת --stdlayout/-T/-b/-t/-- כפי שהיו בשימוש בשרת)
git svn init http://svn.example.com/project [אפשרויות...]
# משוך את השינויים האחרונים מ-Subversion
git svn rebase

REBASE לעומת. משוך/מיזוג

מעדיף להשתמש סילון svn השבה מחדש or סילון השבה מחדש, ולא סילון למשוך or סילון למזג ל
סנכרן commits לא משולבים עם a סילון svn ענף. פעולה זו תשמור את ההיסטוריה של
unintegrated מתחייב ליניארי ביחס למאגר SVN במעלה הזרם ומאפשר את השימוש
של המועדפים סילון svn dcommit תת-פקודה לדחיפת מחויבות לא משולבות בחזרה ל-SVN.

במקור, סילון svn המליץ ​​למפתחים למשוך או להתמזג מה סילון svn ענף.
זה היה בגלל שהמחבר העדיף את git svn set-tree B לחייב ראש בודד ולא
סימון git svn set-tree A..B לביצוע מספר commits. שימוש ב סילון למשוך or סילון
למזג עם git svn set-tree A..B יגרום להיסטוריה לא ליניארית להיות שטוחה כאשר
התחייבות ל-SVN וזה יכול להוביל להתחייבויות מיזוג שהופכות באופן בלתי צפוי לקודמות
מתחייב ב-SVN.

מיזוג מעקב

בעוד סילון svn יכול לעקוב אחר היסטוריית ההעתקות (כולל ענפים ותגים) עבור מאגרים
מאמצת פריסה סטנדרטית, היא עדיין לא יכולה לייצג את היסטוריית המיזוג שהתרחשה בתוך git
חזרה במעלה הזרם למשתמשי SVN. לכן מומלץ למשתמשים לשמור על היסטוריה לינארית כמו
אפשרי בתוך Git כדי להקל על התאימות עם SVN (ראה סעיף CAVEATS למטה).

מטפל OF SVN ענפים

If סילון svn מוגדר להביא סניפים (ו--follow-branches בתוקף), זה
לפעמים יוצר מספר סניפים של Git עבור סניף SVN אחד, כאשר הסניפים הנוספים
יש שמות של הטופס branchname@nnn (עם nnn מספר גרסת SVN). אלה נוספים
סניפים נוצרים אם סילון svn לא יכול למצוא התחייבות הורה עבור ההתחייבות הראשונה ב-SVN
סניף, לחיבור הסניף להיסטוריה של שאר הסניפים.

בדרך כלל, ההתחייבות הראשונה בסניף SVN מורכבת מפעולת העתקה. סילון svn יצטרך
קרא את ההתחייבות הזו כדי לקבל את גרסת ה-SVN שממנה נוצר הסניף. אז זה ינסה
מצא את ה-Git commit שמתאים לגרסה זו של SVN, והשתמש בזה בתור האב של
הענף. עם זאת, ייתכן שאין מחויבות Git מתאימה לשמש
הוֹרֶה. זה יקרה, בין היתר, אם סניף SVN הוא עותק של גרסה
שלא הובא על ידי סילון svn (למשל בגלל שזה גרסה ישנה שדילג עליה
-- עדכון), או אם ב-SVN הועתקה ספרייה שלא עוקבים אחריה סילון svn (כגון א
סניף שאינו במעקב כלל, או ספריית משנה של סניף במעקב). במקרים אלו,
סילון svn עדיין תיצור ענף Git, אבל במקום להשתמש ב-Git commit קיים בתור
האב של הסניף, הוא יקרא את היסטוריית ה-SVN של הספרייה שהסניף הועתק
וצור התחייבויות Git מתאימות. זה מסומן על ידי ההודעה "אתחול
הוֹרֶה: ".

בנוסף, זה יצור סניף מיוחד בשם @, שם
הוא מספר גרסת ה-SVN שממנו הועתק הסניף. הסניף הזה יהיה
להצביע על מחויבות ההורים החדשה שנוצרה בסניף. אם ב-SVN הסניף נמחק
ובהמשך נוצר מחדש מגרסה אחרת, יהיו מספר סניפים כאלה עם an
@.

שים לב שמשמעות הדבר עשויה להיות שנוצרות מספר התחייבויות Git עבור גרסה אחת של SVN.

דוגמה: במאגר SVN עם פריסת trunk/tags/branches סטנדרטית, ספרייה
trunk/sub נוצר ב-r.100. ב-r.200, תא המטען/משנה מסועף על ידי העתקתו לסניפים/.
סילון svn לשבט -s לאחר מכן יצור סניף להלן. זה גם יצור התחייבויות Git חדשות עבור
r.100 עד r.199 והשתמש בהם כהיסטוריה של הסניף להלן. כך יהיו שני Git
מתחייב עבור כל גרסה מ-r.100 ל-r.199 (אחד מכיל את ה- trunk/, אחד המכיל
trunk/sub/). לבסוף, זה יצור סניף sub@200 מצביע על מחויבות ההורה החדשה של
סניף להלן (כלומר ההתחייבות עבור r.200 ו- trunk/sub/).

מערות

למען הפשטות ושיתוף הפעולה עם Subversion, מומלץ לכולם
סילון svn משתמשים משכפלים, מאחזרים ומתחייבים ישירות משרת ה-SVN, ונמנעים מכל סילון
לשבט/למשוך/למזג/לדחוף פעולות בין מאגרי Git וסניפים. המומלץ
שיטת החלפת קוד בין סניפי Git למשתמשים היא סילון פורמט-תיקון ו סילון am,
או פשוט 'מתחייב' למאגר SVN.

ריצה סילון למזג or סילון למשוך לא מומלץ בסניף שאתה מתכנן dcommit החל מ-
כי משתמשי Subversion לא יכולים לראות מיזוגים שביצעת. יתר על כן, אם תמזג או
למשוך מענף Git שהוא מראה של ענף SVN, dcommit עלול להתחייב לטעות
ענף.

אם אתה ממזג, שים לב לכלל הבא: סילון svn dcommit ינסה להתחייב על גבי
התחייבות SVN הנקראת ב

git log --grep=^git-svn-id: --first-parent -1

אתה צריך לכן ודא שההתחייבות האחרונה של הסניף שאתה רוצה להתחייב אליו
האם ה ראשון האב של המיזוג. כאוס יתרחש אחרת, במיוחד אם הראשון
הורה הוא מחויב מבוגר יותר באותו סניף SVN.

סילון לשבט אינו משכפל סניפים תחת השופטים / השלטים / ההיררכיה או כל דבר אחר סילון svn
metadata, או config. אז מאגרים נוצרו ונוהלו באמצעות שימוש סילון svn צריך להשתמש
rsync לשיבוט, אם בכלל צריך לעשות שיבוט.

השאלה היא איך? dcommit משתמש ב-rebase באופן פנימי, כל Git מסניף אותך סילון לדחוף לקודם dcommit on
ידרוש לכפות החלפה של ה-ref הקיים במאגר המרוחק. זה
בדרך כלל נחשב נוהג רע, ראה את git-push(1) תיעוד לפרטים.

אל תשתמש באפשרות --amend של git-commit(1) על שינוי שכבר ביצעת. זה
נחשב לתרגול רע - לתקן commits שכבר דחפת למאגר מרוחק
עבור משתמשים אחרים, ו-dcommit עם SVN מקביל לזה.

בעת שיבוט מאגר SVN, אם אף אחת מהאפשרויות לתיאור המאגר
נעשה שימוש בפריסה (--trunk, --tags, --branches, --stdlayout), סילון svn לשבט תיצור Git
מאגר עם היסטוריה ליניארית לחלוטין, שבו ענפים ותגים מופיעים כנפרדים
ספריות בעותק העבודה. אמנם זו הדרך הקלה ביותר להשיג עותק של קובץ שלם
מאגר, עבור פרויקטים עם סניפים רבים זה יוביל עותק עבודה פעמים רבות
גדול יותר מסתם תא המטען. כך עבור פרויקטים המשתמשים במבנה הספריות הסטנדרטי
(טראנק/ענפים/תגים), מומלץ לשכפל עם אופציה --stddlayout. אם הפרויקט
משתמש במבנה לא סטנדרטי, ו/או אם לא נדרשים ענפים ותגים, זה הכי קל
לשכפל רק ספרייה אחת (בדרך כלל טראנק), מבלי לתת שום פריסת מאגר
אפשרויות. אם נדרשת ההיסטוריה המלאה עם סניפים ותגים, האפשרויות --חדק /
--ענפים / -תגים חייב להשתמש.

בעת שימוש במספר --ענפים או --תגים, סילון svn אינו מטפל אוטומטית בשם
התנגשויות (לדוגמה, אם לשני ענפים מנתיבים שונים יש אותו שם, או אם א
לסניף ולתג יש אותו שם). במקרים אלה, השתמש init כדי להגדיר את ה-Git שלך
מאגר אז, לפני הראשון שלך לְהָבִיא, ערוך את קובץ $GIT_DIR/config כך שה-
ענפים ותגים משויכים למרחבי שמות שונים. לדוגמה:

branches = stable/*:refs/remotes/svn/stable/*
branches = debug/*:refs/remotes/svn/debug/*

השתמש ב-git-svn באינטרנט באמצעות שירותי onworks.net