Permalink
Browse files

Merge branch 'master' of git://github.com/svenfuchs/progit into kapitel3

  • Loading branch information...
2 parents 29e997e + 7c76e06 commit 12c4bab20d2484543b6e00f4df9d60080e8881d1 @florianb florianb committed Mar 30, 2010
Showing with 12,926 additions and 1,117 deletions.
  1. +260 −0 ar/01-introduction/01-chapter1.markdown
  2. +1,121 −0 ar/02-git-basics/01-chapter2.markdown
  3. 0 {zh_TW → ar}/03-git-branching/01-chapter3.markdown
  4. 0 {zh_TW → ar}/04-git-server/01-chapter4.markdown
  5. 0 {zh_TW → ar}/05-distributed-git/01-chapter5.markdown
  6. 0 {zh_TW → ar}/06-git-tools/01-chapter6.markdown
  7. 0 {zh_TW → ar}/07-customizing-git/01-chapter7.markdown
  8. 0 {zh_TW → ar}/08-git-and-other-scms/01-chapter8.markdown
  9. 0 {zh_TW → ar}/09-git-internals/01-chapter9.markdown
  10. +18 −0 ar/NOTES
  11. +14 −0 ar/README
  12. +1 −1 cs/07-customizing-git/01-chapter7.markdown
  13. +37 −20 en/04-git-server/01-chapter4.markdown
  14. +1 −1 en/09-git-internals/01-chapter9.markdown
  15. +5 −5 es/01-introduction/01-chapter1.markdown
  16. +116 −464 es/02-git-basics/01-chapter2.markdown
  17. +7 −0 es/NOTES
  18. +179 −69 fr/01-introduction/01-chapter1.markdown
  19. +517 −304 fr/02-git-basics/01-chapter2.markdown
  20. +52 −25 fr/03-git-branching/01-chapter3.markdown
  21. +318 −137 fr/09-git-internals/01-chapter9.markdown
  22. +105 −0 fr/glossaire-git.adoc
  23. 0 it/01-introduction/01-chapter1.markdown
  24. 0 it/02-git-basics/01-chapter2.markdown
  25. 0 it/03-git-branching/01-chapter3.markdown
  26. +3 −0 it/04-git-server/01-chapter4.markdown
  27. +897 −0 it/05-distributed-git/01-chapter5.markdown
  28. +268 −0 it/06-git-tools/01-chapter6.markdown
  29. 0 it/07-customizing-git/01-chapter7.markdown
  30. 0 it/08-git-and-other-scms/01-chapter8.markdown
  31. +1,010 −0 it/09-git-internals/01-chapter9.markdown
  32. +1 −1 ja/03-git-branching/01-chapter3.markdown
  33. +7 −1 latex/config.yml
  34. +5 −3 latex/makepdf
  35. +6 −3 latex/template.tex
  36. +258 −0 mk/01-introduction/01-chapter1.markdown
  37. +1,121 −0 mk/02-git-basics/01-chapter2.markdown
  38. +598 −0 mk/03-git-branching/01-chapter3.markdown
  39. +852 −0 mk/04-git-server/01-chapter4.markdown
  40. +897 −0 mk/05-distributed-git/01-chapter5.markdown
  41. +1,126 −0 mk/06-git-tools/01-chapter6.markdown
  42. +875 −0 mk/07-customizing-git/01-chapter7.markdown
  43. +685 −0 mk/08-git-and-other-scms/01-chapter8.markdown
  44. +977 −0 mk/09-git-internals/01-chapter9.markdown
  45. +54 −54 nl/01-introduction/01-chapter1.markdown
  46. +3 −3 nl/03-git-branching/01-chapter3.markdown
  47. +14 −17 ru/01-introduction/01-chapter1.markdown
  48. +4 −9 ru/02-git-basics/01-chapter2.markdown
  49. +257 −0 sr/01-introduction/01-chapter1.markdown
  50. +257 −0 th/01-introduction/01-chapter1.markdown
Sorry, we could not display the entire diff because it was too big.
View
260 ar/01-introduction/01-chapter1.markdown
@@ -0,0 +1,260 @@
+# الإستعداد للبدء! #
+
+يحتوي هذا الفصل على معلومات تعدك للبدء بإستخدام Git. سنبدأ بشرح بعض المعلومات الأساسية عن نظم إدارة الإصدارات (Version Control System)، ثم سننتقل إلى كيفية تنصيب وتشغيل Git على نظامك ومن ثم كيف يمكنك استخدامها في عملك. في نهاية الفصل ستكون قد تعرفت على أهمية وجود Git، لماذا عليك إستخدامها وكيف تستعد لذلك.
+
+## إدارة الإصدارات (Version Control) ##
+
+ما هو نظام إدارة الإصدارات، ولماذا عليك أن تهتم به؟ تمكنك هذه الأنظمة من تسحيل التغيرات التي تحدث على ملف أو مجموعة ملفات خلال الزمن بحيث يمكنك الرجوع الى مرحلة معينة (إصدار) لاحقاً. فعلى سبيل المثال، ستستخدم في هذا الكتاب الكود المصدري للملفات في حين أنه تتم إدارتها من قبل نظام إدارة الإصدارات، ولكن في الحقيقة يمكنك استخدام هذه الأنظمة مع أي نوع من الملفات على حاسوبك.
+
+إذا كنت تعمل كمصمم غرافيك أو ويب وتريد طريقة لمتابعة جميع الإصدارت والتعديلات التي تجريها على صورة أو قالب ما (الأمر الذي سيعجبك بالتأكيد)، فإن نظام إدارة الإصدارات (VCS) هو الحل الأمثل. حيث يمكنك من إرجاع الملفات الى حالة كانت عليها سابقاً، أو ارجاع المشروع بأكمله لحالة سابقة، يمكنك أيضاً مقارنة التغيرات الحاصلة مع مرور الزمن، أو معرفة من قام بتعديل معين أدى الى خطأ ما، من قام بتقديم إقتراح ومتى قام بذلك، والمزيد. إستخدامك لنظام إدارة الإصدارات يعني أيضاً أنه اذا قمت بخطأ ما في مرحلة من المراحل أو خسرت ملفات المشروع لسبب ما، يمكنك استرجاعها الى حالها بسهولة. كل هذه الميزات مقابل تعب خفيف منك.
+
+### نظم إدارة الإصدارات المحلية ###
+
+تقوم الطريقة التي يقوم بها معظم المستخدمين لإدارة إصداراة مشاريعهم على "نسخ الملفات" الى مكان آخر. يقوم المعظم بهذه الطريقة لأنها تبدوا وكأنها الحل الأسهل، ولكنها تجلب المشاكل والأخطاء بشكل لا يحتمل أيضاً. من السهل جداً أن تنسى بأي مجلد وضعت نسخة معينة أو أن تقوم بالتغيير أو الحذف عن طريق الخطا لملف ما.
+
+لعلاج هذه المشكلة، قام المبرمجون بتطوير أنظمة إدارة إصدارات المحلية، حيث تستخدم قاعدة بيانات بسيطة تحفظ فيها التغيرات على الملفات في نظام إصدارات معين (إنظر الشكل 1-1).
+
+
+Insert 18333fig0101.png
+الشكل 1-1. مخطط أنظمة إدارة الإصدارات المحلية.
+
+أحد أشهر أنظمة إدارة الإصدارات هو نظام يدعى rcs، والذي مازال يتم توزيعه مع العديد من الحواسيب في يومنا هذا. حتى أن أنظمة Mac OS X الشهيرة تحوي نظام rcs مضمنة في حزمة برامج التطوير Developer Tools. يقوم عمل هذه الأداة ببساطة على حفظ مجموعات من الإصلاحات (Patch sets) (أي فروقات بين الملفات بمعنى آخر) من تغيير الى آخر بطريقة خاصة; يمكنها بعد ذلك اعادة تشكيل أي ملف بالطريقة التي كان عليها في أي مرحلة خلال حياة الملف عن طريق اضافة جميع هذه التغيرات.
+
+### أنظمة إدارة الإصدارات المركزية ###
+
+المشكلة التالية التي ظهرت هي الرغبة في التعاون والتشارك بين المطورين الذين يعملون على أنظمة أخرى. لحل هذه المشكلة تم إنشاء أنظمة إدارة الإصدارات المركزية Centralized Version Control Systems. تقوم هذه الأنظمة، مثل CVS, Subversion و Perforce على مخدم Server واحد يحتوي على جميع الملفات، وعدد من المستخدمين Clients تقوم بطلب هذه الملفات من مكان وجودها المركزي. للعديد من السنوات، كانت هذه الأنظمة هي المسيطرة على عالم إدارة الإصدارات (انظر الشكل 1-2).
+
+Insert 18333fig0102.png
+الشكل 1-2. مخطط أنظمة إدارة الإصدارات المركزية.
+
+تقدم هذه الطرقة العديد من الأفضليات على أنظمة ادارة الإصدارات المحلية. فعلى سبيل المثال، جميع المشاركين في المشروع يعرف مالذي يقوم به المشارك الآخر الى حد معين. مدراء المشروع يستطيعون التحكم بمن يستطيع فعل ماذا في النظام العام; وبالطبع فإنه من الأسهل التعامل مع أنظمة إدارة الإصدارات المركزية على التعامل مع الأنظمة المحلية وقاعدات بياناتها من قبل كل مستخدم.
+
+ولكن، ومن جهة ثانية، فإن لهذه الطريقة جانباً سيئاً أيضاً. أهم هذه النقاط السيئة هي أنه هذه الأنظمة المركزية تقوم على مركز واحد للكود، أي إنه اذا حصل وتوقف المخدم لساعة، فلن يتمكن أحد من خفظ التغييرات أو القيام بأي تعديل على أي شيء يعمل عليه. إذا حصل وأن تعطل القرص الأساسي والذي يحوي على قاعدة البيانات المركزية، ولم تعمل النسخ الإحتياطية المخبأة، فإنك ستخسر كل شي عن تاريخ عملك في المشروع. تعاني أنظمة إدارة الإصدارات المحلية من هذه المشكلة أيضاً، وهي أنه عندما تكون جميع ملفات المشروع في مكان واحد فإنك على خطر من خساراة كل شيء!
+
+### أنظمة إدارة الإصدارات الموزعة ###
+
+وهنا تأتي أنظمة إدارة الإصدارات الموزعة لحل المشكلة. في هذه الأنظمة (مثل Git, Mercurial, Bazaar أو Darcs) يحصل المستخدمون ليس فقط على آخر نسخة من الملفات الموجود على المخدم، بل على كامل تاريخ النظام. في هذه الحال، إن تعطل النظام، فإنه يمكن الحصول على نسخة من المشروع من أي مستخدم الى المخدم مرة أخرى. أي أن كل عملية طلب للكود هي في الحقيقة عملية حفظ كاملة وشاملة لتاريخ المشروع (إنظ الشكل 1-3).
+
+
+Insert 18333fig0103.png
+الشكل 1-3. مخطط أنظمة إدارة الإصدارات الموزعة.
+
+وفوق هذا فإن معظم هذه الأنظمة يتعامل بشكل جيد جداً مع أكثر من نسخة خارجية للمشروع، أي يمكنك التعاون مع أكثر من مجموعة مختلفة من الأشخاص في طرقة مختلفة وفي وقت واحد وعلى مشروع واحد. يمكنك هذا من تطوير أكثر من طريقة عمل واحدة مناسبة لك، الأمر الذي لم يكن متاحاً مع أنظمة إدارة الإصدارات المركزية.
+
+## لمخة تاريخية عن Git ##
+
+كما تبدأ العديد من الأشياء الجميلة في الحياة، بدأت Git كنوع من التدمير المبدع المثير للجدل. الـ Linux Kernel المعروف هو برنامج مفتوح المصدر ذو إطار واسع نوعاً ما. طوال حياة هذا المشروع (من 1991-2002)، كان يتم تناقل التعديلات على شكل ملفات إصلاح و ملفات مؤرشفة (مضغوطة). في 2002، في 2002 بدأ المشروع باستخدام نظام إدارة إصارات موزعة DVCS يدعى BitKeepter.
+
+في 2005، بدأت العلاقة بالإنهيار بين المجتمع المطور للـ Linux Kernel والمجتمع التجاري المطور لـ BitKeeper، وتم العدول عن توفير البنامج بشكل مجاني. أثار هذا التغيير الرغبة في المجتمع المطور لـ Linux (وبالتحديد لينوس تورفالدوس، منشيء Linux) الى تطوير نظامهم الخاص بناء على الدروس التي تعلموها عند استخدامهم لـ BitKee[per. وتم وضع أهداف لكي يحققها النظام الجديد مشمولة بـ:
+
+* السرعة
+* التصميم البسيط
+* الدعم القوي للبرمجة الغير خطية (الكثير من أشجار التطوير الفرعي)
+* التوزيع بشكل كامل
+* القدرة على تحمل مشروعات ضمة مثل الـ Linux Kernel بشكل فعال (السرعة وحجم المعلومات)
+
+منذ ولادة Git في 2005، تطورت لكي تصبح ناضجة مع المحافظة على السهولة والمبادئ الأساسية التي وضعت عليها. حيث أنها سريعة بشكل لايصدق، و فعالة مع المشاريع الكبيرة، وتحوي على نظام تشجير ممتاز لدعم التطوير الغير خطي (انظر الفصل 3).
+
+## أوليات Git ##
+
+لنتحدث الآن عن Git بشكل سريع. هذا القسم هام جداً لك، لأنك إذا عرفت ماهي Git وماهيا أوليات عملها، سيكون من السهل عليك استخدام Git بشكل أسهل وأفضل. وخلال تعلمك لـ Git حاول أن تفرغ ذهنك من المعلومات السابقة عن أنظمة إدارة الإصدارات الأخرى، مثل Subversion أو Perforce; سيجنبك هذا من الخلط بين المعلومات عند استخدام هذه الأداة. تقوم Git بالتعامل وتخزين المعلومات بشكل مختلف تماماً عن الأنظمة الأخرى، وبالرغم من أن واجهة الإستخدام بسيطة نسبياً; سيكون فهمك لهذه الإختلافات سيبعد عنك الحيرة عند الإستخدام.
+
+### لمحات، وليست تغيرات ###
+
+الفرق الرئيسي بين Git وأي نظام إدارة إصدارات آخر (Subversion وأصدقاءه) هو الطريقة التي تتعامل بها Git مع المعلومات. تقوم معظم هذه الأنظمة بتخزين المعلومات كقائمة من التغيرات القائمة على الملفات. هذه الأنظمة (مثل CVS، Subversion، Perforce، Bazaar وغيرها) تتعامل مع المعلومات التي تحفظها كمجموعة ملفات والتغيرات القائمة عليها مع مرور الوقت، كما هو موضح في الشكل 1-4.
+
+Insert 18333fig0104.png
+الشكل 1-4. الأنظمة الاخرى تقوم بحفظ معلومات التغيرات الحاصلة على كل ملف وكنها الإصدار الأول.
+
+تتعامل Git مع المعلومات المخزنة بطريقة مختلفة. ف
+Git doesn’t think of or store its data this way. Instead, Git thinks of its data more like a set of snapshots of a mini filesystem. Every time you commit, or save the state of your project in Git, it basically takes a picture of what all your files look like at that moment and stores a reference to that snapshot. To be efficient, if files have not changed, Git doesn’t store the file again—just a link to the previous identical file it has already stored. Git thinks about its data more like Figure 1-5.
+
+Insert 18333fig0105.png
+Figure 1-5. Git stores data as snapshots of the project over time.
+
+This is an important distinction between Git and nearly all other VCSs. It makes Git reconsider almost every aspect of version control that most other systems copied from the previous generation. This makes Git more like a mini filesystem with some incredibly powerful tools built on top of it, rather than simply a VCS. We’ll explore some of the benefits you gain by thinking of your data this way when we cover Git branching in Chapter 3.
+
+### Nearly Every Operation Is Local ###
+
+Most operations in Git only need local files and resources to operate – generally no information is needed from another computer on your network. If you’re used to a CVCS where most operations have that network latency overhead, this aspect of Git will make you think that the gods of speed have blessed Git with unworldly powers. Because you have the entire history of the project right there on your local disk, most operations seem almost instantaneous.
+
+For example, to browse the history of the project, Git doesn’t need to go out to the server to get the history and display it for you—it simply reads it directly from your local database. This means you see the project history almost instantly. If you want to see the changes introduced between the current version of a file and the file a month ago, Git can look up the file a month ago and do a local difference calculation, instead of having to either ask a remote server to do it or pull an older version of the file from the remote server to do it locally.
+
+This also means that there is very little you can’t do if you’re offline or off VPN. If you get on an airplane or a train and want to do a little work, you can commit happily until you get to a network connection to upload. If you go home and can’t get your VPN client working properly, you can still work. In many other systems, doing so is either impossible or painful. In Perforce, for example, you can’t do much when you aren’t connected to the server; and in Subversion and CVS, you can edit files, but you can’t commit changes to your database (because your database is offline). This may not seem like a huge deal, but you may be surprised what a big difference it can make.
+
+### Git Has Integrity ###
+
+Everything in Git is check-summed before it is stored and is then referred to by that checksum. This means it’s impossible to change the contents of any file or directory without Git knowing about it. This functionality is built into Git at the lowest levels and is integral to its philosophy. You can’t lose information in transit or get file corruption without Git being able to detect it.
+
+The mechanism that Git uses for this checksumming is called a SHA-1 hash. This is a 40-character string composed of hexadecimal characters (0–9 and a–f) and calculated based on the contents of a file or directory structure in Git. A SHA-1 hash looks something like this:
+
+ 24b9da6552252987aa493b52f8696cd6d3b00373
+
+You will see these hash values all over the place in Git because it uses them so much. In fact, Git stores everything not by file name but in the Git database addressable by the hash value of its contents.
+
+### Git Generally Only Adds Data ###
+
+When you do actions in Git, nearly all of them only add data to the Git database. It is very difficult to get the system to do anything that is not undoable or to make it erase data in any way. As in any VCS, you can lose or mess up changes you haven’t committed yet; but after you commit a snapshot into Git, it is very difficult to lose, especially if you regularly push your database to another repository.
+
+This makes using Git a joy because we know we can experiment without the danger of severely screwing things up. For a more in-depth look at how Git stores its data and how you can recover data that seems lost, see “Under the Covers” in Chapter 9.
+
+### The Three States ###
+
+Now, pay attention. This is the main thing to remember about Git if you want the rest of your learning process to go smoothly. Git has three main states that your files can reside in: committed, modified, and staged. Committed means that the data is safely stored in your local database. Modified means that you have changed the file but have not committed it to your database yet. Staged means that you have marked a modified file in its current version to go into your next commit snapshot.
+
+This leads us to the three main sections of a Git project: the Git directory, the working directory, and the staging area.
+
+Insert 18333fig0106.png
+Figure 1-6. Working directory, staging area, and git directory.
+
+The Git directory is where Git stores the metadata and object database for your project. This is the most important part of Git, and it is what is copied when you clone a repository from another computer.
+
+The working directory is a single checkout of one version of the project. These files are pulled out of the compressed database in the Git directory and placed on disk for you to use or modify.
+
+The staging area is a simple file, generally contained in your Git directory, that stores information about what will go into your next commit. It’s sometimes referred to as the index, but it’s becoming standard to refer to it as the staging area.
+
+The basic Git workflow goes something like this:
+
+1. You modify files in your working directory.
+2. You stage the files, adding snapshots of them to your staging area.
+3. You do a commit, which takes the files as they are in the staging area and stores that snapshot permanently to your Git directory.
+
+If a particular version of a file is in the git directory, it’s considered committed. If it’s modified but has been added to the staging area, it is staged. And if it was changed since it was checked out but has not been staged, it is modified. In Chapter 2, you’ll learn more about these states and how you can either take advantage of them or skip the staged part entirely.
+
+## Installing Git ##
+
+Let’s get into using some Git. First things first—you have to install it. You can get it a number of ways; the two major ones are to install it from source or to install an existing package for your platform.
+
+### Installing from Source ###
+
+If you can, it’s generally useful to install Git from source, because you’ll get the most recent version. Each version of Git tends to include useful UI enhancements, so getting the latest version is often the best route if you feel comfortable compiling software from source. It is also the case that many Linux distributions contain very old packages; so unless you’re on a very up-to-date distro or are using backports, installing from source may be the best bet.
+
+To install Git, you need to have the following libraries that Git depends on: curl, zlib, openssl, expat, and libiconv. For example, if you’re on a system that has yum (such as Fedora) or apt-get (such as a Debian based system), you can use one of these commands to install all of the dependencies:
+
+ $ yum install curl-devel expat-devel gettext-devel \
+ openssl-devel zlib-devel
+
+ $ apt-get install libcurl4-gnutls-dev libexpat1-dev gettext \
+ libz-dev
+
+When you have all the necessary dependencies, you can go ahead and grab the latest snapshot from the Git web site:
+
+ http://git-scm.com/download
+
+Then, compile and install:
+
+ $ tar -zxf git-1.6.0.5.tar.gz
+ $ cd git-1.6.0.5
+ $ make prefix=/usr/local all
+ $ sudo make prefix=/usr/local install
+
+After this is done, you can also get Git via Git itself for updates:
+
+ $ git clone git://git.kernel.org/pub/scm/git/git.git
+
+### Installing on Linux ###
+
+If you want to install Git on Linux via a binary installer, you can generally do so through the basic package-management tool that comes with your distribution. If you’re on Fedora, you can use yum:
+
+ $ yum install git-core
+
+Or if you’re on a Debian-based distribution like Ubuntu, try apt-get:
+
+ $ apt-get install git-core
+
+### Installing on Mac ###
+
+There are two easy ways to install Git on a Mac. The easiest is to use the graphical Git installer, which you can download from the Google Code page (see Figure 1-7):
+
+ http://code.google.com/p/git-osx-installer
+
+Insert 18333fig0107.png
+Figure 1-7. Git OS X installer.
+
+The other major way is to install Git via MacPorts (`http://www.macports.org`). If you have MacPorts installed, install Git via
+
+ $ sudo port install git-core +svn +doc +bash_completion +gitweb
+
+You don’t have to add all the extras, but you’ll probably want to include +svn in case you ever have to use Git with Subversion repositories (see Chapter 8).
+
+### Installing on Windows ###
+
+Installing Git on Windows is very easy. The msysGit project has one of the easier installation procedures. Simply download the installer exe file from the Google Code page, and run it:
+
+ http://code.google.com/p/msysgit
+
+After it’s installed, you have both a command-line version (including an SSH client that will come in handy later) and the standard GUI.
+
+## First-Time Git Setup ##
+
+Now that you have Git on your system, you’ll want to do a few things to customize your Git environment. You should have to do these things only once; they’ll stick around between upgrades. You can also change them at any time by running through the commands again.
+
+Git comes with a tool called git config that lets you get and set configuration variables that control all aspects of how Git looks and operates. These variables can be stored in three different places:
+
+* `/etc/gitconfig` file: Contains values for every user on the system and all their repositories. If you pass the option` --system` to `git config`, it reads and writes from this file specifically.
+* `~/.gitconfig` file: Specific to your user. You can make Git read and write to this file specifically by passing the `--global` option.
+* config file in the git directory (that is, `.git/config`) of whatever repository you’re currently using: Specific to that single repository. Each level overrides values in the previous level, so values in `.git/config` trump those in `/etc/gitconfig`.
+
+On Windows systems, Git looks for the `.gitconfig` file in the `$HOME` directory (`C:\Documents and Settings\$USER` for most people). It also still looks for /etc/gitconfig, although it’s relative to the MSys root, which is wherever you decide to install Git on your Windows system when you run the installer.
+
+### Your Identity ###
+
+The first thing you should do when you install Git is to set your user name and e-mail address. This is important because every Git commit uses this information, and it’s immutably baked into the commits you pass around:
+
+ $ git config --global user.name "John Doe"
+ $ git config --global user.email johndoe@example.com
+
+Again, you need to do this only once if you pass the `--global` option, because then Git will always use that information for anything you do on that system. If you want to override this with a different name or e-mail address for specific projects, you can run the command without the `--global` option when you’re in that project.
+
+### Your Editor ###
+
+Now that your identity is set up, you can configure the default text editor that will be used when Git needs you to type in a message. By default, Git uses your system’s default editor, which is generally Vi or Vim. If you want to use a different text editor, such as Emacs, you can do the following:
+
+ $ git config --global core.editor emacs
+
+### Your Diff Tool ###
+
+Another useful option you may want to configure is the default diff tool to use to resolve merge conflicts. Say you want to use vimdiff:
+
+ $ git config --global merge.tool vimdiff
+
+Git accepts kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, and opendiff as valid merge tools. You can also set up a custom tool; see Chapter 7 for more information about doing that.
+
+### Checking Your Settings ###
+
+If you want to check your settings, you can use the `git config --list` command to list all the settings Git can find at that point:
+
+ $ git config --list
+ user.name=Scott Chacon
+ user.email=schacon@gmail.com
+ color.status=auto
+ color.branch=auto
+ color.interactive=auto
+ color.diff=auto
+ ...
+
+You may see keys more than once, because Git reads the same key from different files (`/etc/gitconfig` and `~/.gitconfig`, for example). In this case, Git uses the last value for each unique key it sees.
+
+You can also check what Git thinks a specific key’s value is by typing `git config {key}`:
+
+ $ git config user.name
+ Scott Chacon
+
+## Getting Help ##
+
+If you ever need help while using Git, there are three ways to get the manual page (manpage) help for any of the Git commands:
+
+ $ git help <verb>
+ $ git <verb> --help
+ $ man git-<verb>
+
+For example, you can get the manpage help for the config command by running
+
+ $ git help config
+
+These commands are nice because you can access them anywhere, even offline.
+If the manpages and this book aren’t enough and you need in-person help, you can try the `#git` or `#github` channel on the Freenode IRC server (irc.freenode.net). These channels are regularly filled with hundreds of people who are all very knowledgeable about Git and are often willing to help.
+
+## Summary ##
+
+You should have a basic understanding of what Git is and how it’s different from the CVCS you may have been using. You should also now have a working version of Git on your system that’s set up with your personal identity. It’s now time to learn some Git basics.
View
1,121 ar/02-git-basics/01-chapter2.markdown
@@ -0,0 +1,1121 @@
+# Git Basics #
+
+If you can read only one chapter to get going with Git, this is it. This chapter covers every basic command you need to do the vast majority of the things you’ll eventually spend your time doing with Git. By the end of the chapter, you should be able to configure and initialize a repository, begin and stop tracking files, and stage and commit changes. We’ll also show you how to set up Git to ignore certain files and file patterns, how to undo mistakes quickly and easily, how to browse the history of your project and view changes between commits, and how to push and pull from remote repositories.
+
+## Getting a Git Repository ##
+
+You can get a Git project using two main approaches. The first takes an existing project or directory and imports it into Git. The second clones an existing Git repository from another server.
+
+### Initializing a Repository in an Existing Directory ###
+
+If you’re starting to track an existing project in Git, you need to go to the project’s directory and type
+
+ $ git init
+
+This creates a new subdirectory named .git that contains all of your necessary repository files — a Git repository skeleton. At this point, nothing in your project is tracked yet. (See Chapter 9 for more information about exactly what files are contained in the `.git` directory you just created.)
+
+If you want to start version-controlling existing files (as opposed to an empty directory), you should probably begin tracking those files and do an initial commit. You can accomplish that with a few git add commands that specify the files you want to track, followed by a commit:
+
+ $ git add *.c
+ $ git add README
+ $ git commit –m 'initial project version'
+
+We’ll go over what these commands do in just a minute. At this point, you have a Git repository with tracked files and an initial commit.
+
+### Cloning an Existing Repository ###
+
+If you want to get a copy of an existing Git repository — for example, a project you’d like to contribute to — the command you need is git clone. If you’re familiar with other VCS systems such as Subversion, you’ll notice that the command is clone and not checkout. This is an important distinction — Git receives a copy of nearly all data that the server has. Every version of every file for the history of the project is pulled down when you run `git clone`. In fact, if your server disk gets corrupted, you can use any of the clones on any client to set the server back to the state it was in when it was cloned (you may lose some server-side hooks and such, but all the versioned data would be there—see Chapter 4 for more details).
+
+You clone a repository with `git clone [url]`. For example, if you want to clone the Ruby Git library called Grit, you can do so like this:
+
+ $ git clone git://github.com/schacon/grit.git
+
+That creates a directory named "grit", initializes a `.git` directory inside it, pulls down all the data for that repository, and checks out a working copy of the latest version. If you go into the new `grit` directory, you’ll see the project files in there, ready to be worked on or used. If you want to clone the repository into a directory named something other than grit, you can specify that as the next command-line option:
+
+ $ git clone git://github.com/schacon/grit.git mygrit
+
+That command does the same thing as the previous one, but the target directory is called mygrit.
+
+Git has a number of different transfer protocols you can use. The previous example uses the `git://` protocol, but you may also see `http(s)://` or `user@server:/path.git`, which uses the SSH transfer protocol. Chapter 4 will introduce all of the available options the server can set up to access your Git repository and the pros and cons of each.
+
+## Recording Changes to the Repository ##
+
+You have a bona fide Git repository and a checkout or working copy of the files for that project. You need to make some changes and commit snapshots of those changes into your repository each time the project reaches a state you want to record.
+
+Remember that each file in your working directory can be in one of two states: tracked or untracked. Tracked files are files that were in the last snapshot; they can be unmodified, modified, or staged. Untracked files are everything else - any files in your working directory that were not in your last snapshot and are not in your staging area. When you first clone a repository, all of your files will be tracked and unmodified because you just checked them out and haven’t edited anything.
+
+As you edit files, Git sees them as modified, because you’ve changed them since your last commit. You stage these modified files and then commit all your staged changes, and the cycle repeats. This lifecycle is illustrated in Figure 2-1.
+
+Insert 18333fig0201.png
+Figure 2-1. The lifecycle of the status of your files.
+
+### Checking the Status of Your Files ###
+
+The main tool you use to determine which files are in which state is the git status command. If you run this command directly after a clone, you should see something like this:
+
+ $ git status
+ # On branch master
+ nothing to commit (working directory clean)
+
+This means you have a clean working directory—in other words, there are no tracked and modified files. Git also doesn’t see any untracked files, or they would be listed here. Finally, the command tells you which branch you’re on. For now, that is always master, which is the default; you won’t worry about it here. The next chapter will go over branches and references in detail.
+
+Let’s say you add a new file to your project, a simple README file. If the file didn’t exist before, and you run `git status`, you see your untracked file like so:
+
+ $ vim README
+ $ git status
+ # On branch master
+ # Untracked files:
+ # (use "git add <file>..." to include in what will be committed)
+ #
+ # README
+ nothing added to commit but untracked files present (use "git add" to track)
+
+You can see that your new README file is untracked, because it’s under the “Untracked files” heading in your status output. Untracked basically means that Git sees a file you didn’t have in the previous snapshot (commit); Git won’t start including it in your commit snapshots until you explicitly tell it to do so. It does this so you don’t accidentally begin including generated binary files or other files that you did not mean to include. You do want to start including README, so let’s start tracking the file.
+
+### Tracking New Files ###
+
+In order to begin tracking a new file, you use the command `git add`. To begin tracking the README file, you can run this:
+
+ $ git add README
+
+If you run your status command again, you can see that your README file is now tracked and staged:
+
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ #
+
+You can tell that it’s staged because it’s under the “Changes to be committed” heading. If you commit at this point, the version of the file at the time you ran git add is what will be in the historical snapshot. You may recall that when you ran git init earlier, you then ran git add (files) — that was to begin tracking files in your directory. The git add command takes a path name for either a file or a directory; if it’s a directory, the command adds all the files in that directory recursively.
+
+### Staging Modified Files ###
+
+Let’s change a file that was already tracked. If you change a previously tracked file called `benchmarks.rb` and then run your `status` command again, you get something that looks like this:
+
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ #
+ # Changed but not updated:
+ # (use "git add <file>..." to update what will be committed)
+ #
+ # modified: benchmarks.rb
+ #
+
+The benchmarks.rb file appears under a section named “Changed but not updated” — which means that a file that is tracked has been modified in the working directory but not yet staged. To stage it, you run the `git add` command (it’s a multipurpose command — you use it to begin tracking new files, to stage files, and to do other things like marking merge-conflicted files as resolved). Let’s run `git add` now to stage the benchmarks.rb file, and then run `git status` again:
+
+ $ git add benchmarks.rb
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ # modified: benchmarks.rb
+ #
+
+Both files are staged and will go into your next commit. At this point, suppose you remember one little change that you want to make in benchmarks.rb before you commit it. You open it again and make that change, and you’re ready to commit. However, let’s run `git status` one more time:
+
+ $ vim benchmarks.rb
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ # modified: benchmarks.rb
+ #
+ # Changed but not updated:
+ # (use "git add <file>..." to update what will be committed)
+ #
+ # modified: benchmarks.rb
+ #
+
+What the heck? Now benchmarks.rb is listed as both staged and unstaged. How is that possible? It turns out that Git stages a file exactly as it is when you run the git add command. If you commit now, the version of benchmarks.rb as it was when you last ran the git add command is how it will go into the commit, not the version of the file as it looks in your working directory when you run git commit. If you modify a file after you run `git add`, you have to run `git add` again to stage the latest version of the file:
+
+ $ git add benchmarks.rb
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ # modified: benchmarks.rb
+ #
+
+### Ignoring Files ###
+
+Often, you’ll have a class of files that you don’t want Git to automatically add or even show you as being untracked. These are generally automatically generated files such as log files or files produced by your build system. In such cases, you can create a file listing patterns to match them named .gitignore. Here is an example .gitignore file:
+
+ $ cat .gitignore
+ *.[oa]
+ *~
+
+The first line tells Git to ignore any files ending in .o or .a — object and archive files that may be the product of building your code. The second line tells Git to ignore all files that end with a tilde (`~`), which is used by many text editors such as Emacs to mark temporary files. You may also include a log, tmp, or pid directory; automatically generated documentation; and so on. Setting up a .gitignore file before you get going is generally a good idea so you don’t accidentally commit files that you really don’t want in your Git repository.
+
+The rules for the patterns you can put in the .gitignore file are as follows:
+
+* Blank lines or lines starting with # are ignored.
+* Standard glob patterns work.
+* You can end patterns with a forward slash (`/`) to specify a directory.
+* You can negate a pattern by starting it with an exclamation point (`!`).
+
+Glob patterns are like simplified regular expressions that shells use. An asterisk (`*`) matches zero or more characters; `[abc]` matches any character inside the brackets (in this case a, b, or c); a question mark (`?`) matches a single character; and brackets enclosing characters separated by a hyphen(`[0-9]`) matches any character between them (in this case 0 through 9) .
+
+Here is another example .gitignore file:
+
+ # a comment – this is ignored
+ *.a # no .a files
+ !lib.a # but do track lib.a, even though you're ignoring .a files above
+ /TODO # only ignore the root TODO file, not subdir/TODO
+ build/ # ignore all files in the build/ directory
+ doc/*.txt # ignore doc/notes.txt, but not doc/server/arch.txt
+
+### Viewing Your Staged and Unstaged Changes ###
+
+If the `git status` command is too vague for you — you want to know exactly what you changed, not just which files were changed — you can use the `git diff` command. We’ll cover `git diff` in more detail later; but you’ll probably use it most often to answer these two questions: What have you changed but not yet staged? And what have you staged that you are about to commit? Although `git status` answers those questions very generally, `git diff` shows you the exact lines added and removed — the patch, as it were.
+
+Let’s say you edit and stage the README file again and then edit the benchmarks.rb file without staging it. If you run your `status` command, you once again see something like this:
+
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ #
+ # Changed but not updated:
+ # (use "git add <file>..." to update what will be committed)
+ #
+ # modified: benchmarks.rb
+ #
+
+To see what you’ve changed but not yet staged, type `git diff` with no other arguments:
+
+ $ git diff
+ diff --git a/benchmarks.rb b/benchmarks.rb
+ index 3cb747f..da65585 100644
+ --- a/benchmarks.rb
+ +++ b/benchmarks.rb
+ @@ -36,6 +36,10 @@ def main
+ @commit.parents[0].parents[0].parents[0]
+ end
+
+ + run_code(x, 'commits 1') do
+ + git.commits.size
+ + end
+ +
+ run_code(x, 'commits 2') do
+ log = git.commits('master', 15)
+ log.size
+
+That command compares what is in your working directory with what is in your staging area. The result tells you the changes you’ve made that you haven’t yet staged.
+
+If you want to see what you’ve staged that will go into your next commit, you can use `git diff –-cached`. (In Git versions 1.6.1 and later, you can also use `git diff –-staged`, which may be easier to remember.) This command compares your staged changes to your last commit:
+
+ $ git diff --cached
+ diff --git a/README b/README
+ new file mode 100644
+ index 0000000..03902a1
+ --- /dev/null
+ +++ b/README2
+ @@ -0,0 +1,5 @@
+ +grit
+ + by Tom Preston-Werner, Chris Wanstrath
+ + http://github.com/mojombo/grit
+ +
+ +Grit is a Ruby library for extracting information from a Git repository
+
+It’s important to note that `git diff` by itself doesn’t show all changes made since your last commit — only changes that are still unstaged. This can be confusing, because if you’ve staged all of your changes, `git diff` will give you no output.
+
+For another example, if you stage the benchmarks.rb file and then edit it, you can use `git diff` to see the changes in the file that are staged and the changes that are unstaged:
+
+ $ git add benchmarks.rb
+ $ echo '# test line' >> benchmarks.rb
+ $ git status
+ # On branch master
+ #
+ # Changes to be committed:
+ #
+ # modified: benchmarks.rb
+ #
+ # Changed but not updated:
+ #
+ # modified: benchmarks.rb
+ #
+
+Now you can use `git diff` to see what is still unstaged
+
+ $ git diff
+ diff --git a/benchmarks.rb b/benchmarks.rb
+ index e445e28..86b2f7c 100644
+ --- a/benchmarks.rb
+ +++ b/benchmarks.rb
+ @@ -127,3 +127,4 @@ end
+ main()
+
+ ##pp Grit::GitRuby.cache_client.stats
+ +# test line
+
+and `git diff --cached` to see what you’ve staged so far:
+
+ $ git diff --cached
+ diff --git a/benchmarks.rb b/benchmarks.rb
+ index 3cb747f..e445e28 100644
+ --- a/benchmarks.rb
+ +++ b/benchmarks.rb
+ @@ -36,6 +36,10 @@ def main
+ @commit.parents[0].parents[0].parents[0]
+ end
+
+ + run_code(x, 'commits 1') do
+ + git.commits.size
+ + end
+ +
+ run_code(x, 'commits 2') do
+ log = git.commits('master', 15)
+ log.size
+
+### Committing Your Changes ###
+
+Now that your staging area is set up the way you want it, you can commit your changes. Remember that anything that is still unstaged — any files you have created or modified that you haven’t run `git add` on since you edited them — won’t go into this commit. They will stay as modified files on your disk.
+In this case, the last time you ran `git status`, you saw that everything was staged, so you’re ready to commit your changes. The simplest way to commit is to type `git commit`:
+
+ $ git commit
+
+Doing so launches your editor of choice. (This is set by your shell’s `$EDITOR` environment variable — usually vim or emacs, although you can configure it with whatever you want using the `git config --global core.editor` command as you saw in Chapter 1).
+
+The editor displays the following text (this example is a Vim screen):
+
+ # Please enter the commit message for your changes. Lines starting
+ # with '#' will be ignored, and an empty message aborts the commit.
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # new file: README
+ # modified: benchmarks.rb
+ ~
+ ~
+ ~
+ ".git/COMMIT_EDITMSG" 10L, 283C
+
+You can see that the default commit message contains the latest output of the `git status` command commented out and one empty line on top. You can remove these comments and type your commit message, or you can leave them there to help you remember what you’re committing. (For an even more explicit reminder of what you’ve modified, you can pass the `-v` option to `git commit`. Doing so also puts the diff of your change in the editor so you can see exactly what you did.) When you exit the editor, Git creates your commit with that commit message (with the comments and diff stripped out).
+
+Alternatively, you can type your commit message inline with the `commit` command by specifying it after a -m flag, like this:
+
+ $ git commit -m "Story 182: Fix benchmarks for speed"
+ [master]: created 463dc4f: "Fix benchmarks for speed"
+ 2 files changed, 3 insertions(+), 0 deletions(-)
+ create mode 100644 README
+
+Now you’ve created your first commit! You can see that the commit has given you some output about itself: which branch you committed to (master), what SHA-1 checksum the commit has (`463dc4f`), how many files were changed, and statistics about lines added and removed in the commit.
+
+Remember that the commit records the snapshot you set up in your staging area. Anything you didn’t stage is still sitting there modified; you can do another commit to add it to your history. Every time you perform a commit, you’re recording a snapshot of your project that you can revert to or compare to later.
+
+### Skipping the Staging Area ###
+
+Although it can be amazingly useful for crafting commits exactly how you want them, the staging area is sometimes a bit more complex than you need in your workflow. If you want to skip the staging area, Git provides a simple shortcut. Providing the `-a` option to the `git commit` command makes Git automatically stage every file that is already tracked before doing the commit, letting you skip the `git add` part:
+
+ $ git status
+ # On branch master
+ #
+ # Changed but not updated:
+ #
+ # modified: benchmarks.rb
+ #
+ $ git commit -a -m 'added new benchmarks'
+ [master 83e38c7] added new benchmarks
+ 1 files changed, 5 insertions(+), 0 deletions(-)
+
+Notice how you don’t have to run `git add` on the benchmarks.rb file in this case before you commit.
+
+### Removing Files ###
+
+To remove a file from Git, you have to remove it from your tracked files (more accurately, remove it from your staging area) and then commit. The `git rm` command does that and also removes the file from your working directory so you don’t see it as an untracked file next time around.
+
+If you simply remove the file from your working directory, it shows up under the “Changed but not updated” (that is, _unstaged_) area of your `git status` output:
+
+ $ rm grit.gemspec
+ $ git status
+ # On branch master
+ #
+ # Changed but not updated:
+ # (use "git add/rm <file>..." to update what will be committed)
+ #
+ # deleted: grit.gemspec
+ #
+
+Then, if you run `git rm`, it stages the file’s removal:
+
+ $ git rm grit.gemspec
+ rm 'grit.gemspec'
+ $ git status
+ # On branch master
+ #
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # deleted: grit.gemspec
+ #
+
+The next time you commit, the file will be gone and no longer tracked. If you modified the file and added it to the index already, you must force the removal with the `-f` option. This is a safety feature to prevent accidental removal of data that hasn’t yet been recorded in a snapshot and that can’t be recovered from Git.
+
+Another useful thing you may want to do is to keep the file in your working tree but remove it from your staging area. In other words, you may want to keep the file on your hard drive but not have Git track it anymore. This is particularly useful if you forgot to add something to your `.gitignore` file and accidentally added it, like a large log file or a bunch of `.a` compiled files. To do this, use the `--cached` option:
+
+ $ git rm --cached readme.txt
+
+You can pass files, directories, and file-glob patterns to the `git rm` command. That means you can do things such as
+
+ $ git rm log/\*.log
+
+Note the backslash (`\`) in front of the `*`. This is necessary because Git does its own filename expansion in addition to your shell’s filename expansion. This command removes all files that have the `.log` extension in the `log/` directory. Or, you can do something like this:
+
+ $ git rm \*~
+
+This command removes all files that end with `~`.
+
+### Moving Files ###
+
+Unlike many other VCS systems, Git doesn’t explicitly track file movement. If you rename a file in Git, no metadata is stored in Git that tells it you renamed the file. However, Git is pretty smart about figuring that out after the fact — we’ll deal with detecting file movement a bit later.
+
+Thus it’s a bit confusing that Git has a `mv` command. If you want to rename a file in Git, you can run something like
+
+ $ git mv file_from file_to
+
+and it works fine. In fact, if you run something like this and look at the status, you’ll see that Git considers it a renamed file:
+
+ $ git mv README.txt README
+ $ git status
+ # On branch master
+ # Your branch is ahead of 'origin/master' by 1 commit.
+ #
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # renamed: README.txt -> README
+ #
+
+However, this is equivalent to running something like this:
+
+ $ mv README.txt README
+ $ git rm README.txt
+ $ git add README
+
+Git figures out that it’s a rename implicitly, so it doesn’t matter if you rename a file that way or with the `mv` command. The only real difference is that `mv` is one command instead of three — it’s a convenience function. More important, you can use any tool you like to rename a file, and address the add/rm later, before you commit.
+
+## Viewing the Commit History ##
+
+After you have created several commits, or if you have cloned a repository with an existing commit history, you’ll probably want to look back to see what has happened. The most basic and powerful tool to do this is the `git log` command.
+
+These examples use a very simple project called simplegit that I often use for demonstrations. To get the project, run
+
+ git clone git://github.com/schacon/simplegit-progit.git
+
+When you run `git log` in this project, you should get output that looks something like this:
+
+ $ git log
+ commit ca82a6dff817ec66f44342007202690a93763949
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Mon Mar 17 21:52:11 2008 -0700
+
+ changed the version number
+
+ commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sat Mar 15 16:40:33 2008 -0700
+
+ removed unnecessary test code
+
+ commit a11bef06a3f659402fe7563abf99ad00de2209e6
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sat Mar 15 10:31:28 2008 -0700
+
+ first commit
+
+By default, with no arguments, `git log` lists the commits made in that repository in reverse chronological order. That is, the most recent commits show up first. As you can see, this command lists each commit with its SHA-1 checksum, the author’s name and e-mail, the date written, and the commit message.
+
+A huge number and variety of options to the `git log` command are available to show you exactly what you’re looking for. Here, we’ll show you some of the most-used options.
+
+One of the more helpful options is `-p`, which shows the diff introduced in each commit. You can also use `-2`, which limits the output to only the last two entries:
+
+ $ git log –p -2
+ commit ca82a6dff817ec66f44342007202690a93763949
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Mon Mar 17 21:52:11 2008 -0700
+
+ changed the version number
+
+ diff --git a/Rakefile b/Rakefile
+ index a874b73..8f94139 100644
+ --- a/Rakefile
+ +++ b/Rakefile
+ @@ -5,7 +5,7 @@ require 'rake/gempackagetask'
+ spec = Gem::Specification.new do |s|
+ - s.version = "0.1.0"
+ + s.version = "0.1.1"
+ s.author = "Scott Chacon"
+
+ commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sat Mar 15 16:40:33 2008 -0700
+
+ removed unnecessary test code
+
+ diff --git a/lib/simplegit.rb b/lib/simplegit.rb
+ index a0a60ae..47c6340 100644
+ --- a/lib/simplegit.rb
+ +++ b/lib/simplegit.rb
+ @@ -18,8 +18,3 @@ class SimpleGit
+ end
+
+ end
+ -
+ -if $0 == __FILE__
+ - git = SimpleGit.new
+ - puts git.show
+ -end
+ \ No newline at end of file
+
+This option displays the same information but with a diff directly following each entry. This is very helpful for code review or to quickly browse what happened during a series of commits that a collaborator has added.
+You can also use a series of summarizing options with `git log`. For example, if you want to see some abbreviated stats for each commit, you can use the `--stat` option:
+
+ $ git log --stat
+ commit ca82a6dff817ec66f44342007202690a93763949
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Mon Mar 17 21:52:11 2008 -0700
+
+ changed the version number
+
+ Rakefile | 2 +-
+ 1 files changed, 1 insertions(+), 1 deletions(-)
+
+ commit 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sat Mar 15 16:40:33 2008 -0700
+
+ removed unnecessary test code
+
+ lib/simplegit.rb | 5 -----
+ 1 files changed, 0 insertions(+), 5 deletions(-)
+
+ commit a11bef06a3f659402fe7563abf99ad00de2209e6
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sat Mar 15 10:31:28 2008 -0700
+
+ first commit
+
+ README | 6 ++++++
+ Rakefile | 23 +++++++++++++++++++++++
+ lib/simplegit.rb | 25 +++++++++++++++++++++++++
+ 3 files changed, 54 insertions(+), 0 deletions(-)
+
+As you can see, the `--stat` option prints below each commit entry a list of modified files, how many files were changed, and how many lines in those files were added and removed. It also puts a summary of the information at the end.
+Another really useful option is `--pretty`. This option changes the log output to formats other than the default. A few prebuilt options are available for you to use. The oneline option prints each commit on a single line, which is useful if you’re looking at a lot of commits. In addition, the `short`, `full`, and `fuller` options show the output in roughly the same format but with less or more information, respectively:
+
+ $ git log --pretty=oneline
+ ca82a6dff817ec66f44342007202690a93763949 changed the version number
+ 085bb3bcb608e1e8451d4b2432f8ecbe6306e7e7 removed unnecessary test code
+ a11bef06a3f659402fe7563abf99ad00de2209e6 first commit
+
+The most interesting option is `format`, which allows you to specify your own log output format. This is especially useful when you’re generating output for machine parsing — because you specify the format explicitly, you know it won’t change with updates to Git:
+
+ $ git log --pretty=format:"%h - %an, %ar : %s"
+ ca82a6d - Scott Chacon, 11 months ago : changed the version number
+ 085bb3b - Scott Chacon, 11 months ago : removed unnecessary test code
+ a11bef0 - Scott Chacon, 11 months ago : first commit
+
+Table 2-1 lists some of the more useful options that format takes.
+
+ Option Description of Output
+ %H Commit hash
+ %h Abbreviated commit hash
+ %T Tree hash
+ %t Abbreviated tree hash
+ %P Parent hashes
+ %p Abbreviated parent hashes
+ %an Author name
+ %ae Author e-mail
+ %ad Author date (format respects the –date= option)
+ %ar Author date, relative
+ %cn Committer name
+ %ce Committer email
+ %cd Committer date
+ %cr Committer date, relative
+ %s Subject
+
+You may be wondering what the difference is between _author_ and _committer_. The author is the person who originally wrote the work, whereas the committer is the person who last applied the work. So, if you send in a patch to a project and one of the core members applies the patch, both of you get credit — you as the author and the core member as the committer. We’ll cover this distinction a bit more in Chapter 5.
+
+The oneline and format options are particularly useful with another `log` option called `--graph`. This option adds a nice little ASCII graph showing your branch and merge history, which we can see our copy of the Grit project repository:
+
+ $ git log --pretty=format:"%h %s" --graph
+ * 2d3acf9 ignore errors from SIGCHLD on trap
+ * 5e3ee11 Merge branch 'master' of git://github.com/dustin/grit
+ |\
+ | * 420eac9 Added a method for getting the current branch.
+ * | 30e367c timeout code and tests
+ * | 5a09431 add timeout protection to grit
+ * | e1193f8 support for heads with slashes in them
+ |/
+ * d6016bc require time for xmlschema
+ * 11d191e Merge branch 'defunkt' into local
+
+Those are only some simple output-formatting options to `git log` — there are many more. Table 2-2 lists the options we’ve covered so far and some other common formatting options that may be useful, along with how they change the output of the log command.
+
+ Option Description
+ -p Show the patch introduced with each commit.
+ --stat Show statistics for files modified in each commit.
+ --shortstat Display only the changed/insertions/deletions line from the --stat command.
+ --name-only Show the list of files modified after the commit information.
+ --name-status Show the list of files affected with added/modified/deleted information as well.
+ --abbrev-commit Show only the first few characters of the SHA-1 checksum instead of all 40.
+ --relative-date Display the date in a relative format (for example, “2 weeks ago”) instead of using the full date format.
+ --graph Display an ASCII graph of the branch and merge history beside the log output.
+ --pretty Show commits in an alternate format. Options include oneline, short, full, fuller, and format (where you specify your own format).
+
+### Limiting Log Output ###
+
+In addition to output-formatting options, git log takes a number of useful limiting options — that is, options that let you show only a subset of commits. You’ve seen one such option already — the `-2` option, which show only the last two commits. In fact, you can do `-<n>`, where `n` is any integer to show the last `n` commits. In reality, you’re unlikely to use that often, because Git by default pipes all output through a pager so you see only one page of log output at a time.
+
+However, the time-limiting options such as `--since` and `--until` are very useful. For example, this command gets the list of commits made in the last two weeks:
+
+ $ git log --since=2.weeks
+
+This command works with lots of formats — you can specify a specific date (“2008-01-15”) or a relative date such as “2 years 1 day 3 minutes ago”.
+
+You can also filter the list to commits that match some search criteria. The `--author` option allows you to filter on a specific author, and the `--grep` option lets you search for keywords in the commit messages. (Note that if you want to specify both author and grep options, you have to add `--all-match` or the command will match commits with either.)
+
+The last really useful option to pass to `git log` as a filter is a path. If you specify a directory or file name, you can limit the log output to commits that introduced a change to those files. This is always the last option and is generally preceded by double dashes (`--`) to separate the paths from the options.
+
+In Table 2-3 we’ll list these and a few other common options for your reference.
+
+ Option Description
+ -(n) Show only the last n commits
+ --since, --after Limit the commits to those made after the specified date.
+ --until, --before Limit the commits to those made before the specified date.
+ --author Only show commits in which the author entry matches the specified string.
+ --committer Only show commits in which the committer entry matches the specified string.
+
+For example, if you want to see which commits modifying test files in the Git source code history were committed by Junio Hamano and were not merges in the month of October 2008, you can run something like this:
+
+ $ git log --pretty="%h - %s" --author=gitster --since="2008-10-01" \
+ --before="2008-11-01" --no-merges -- t/
+ 5610e3b - Fix testcase failure when extended attribute
+ acd3b9e - Enhance hold_lock_file_for_{update,append}()
+ f563754 - demonstrate breakage of detached checkout wi
+ d1a43f2 - reset --hard/read-tree --reset -u: remove un
+ 51a94af - Fix "checkout --track -b newbranch" on detac
+ b0ad11e - pull: allow "git pull origin $something:$cur
+
+Of the nearly 20,000 commits in the Git source code history, this command shows the 6 that match those criteria.
+
+### Using a GUI to Visualize History ###
+
+If you like to use a more graphical tool to visualize your commit history, you may want to take a look at a Tcl/Tk program called gitk that is distributed with Git. Gitk is basically a visual `git log` tool, and it accepts nearly all the filtering options that `git log` does. If you type gitk on the command line in your project, you should see something like Figure 2-2.
+
+Insert 18333fig0202.png
+Figure 2-2. The gitk history visualizer.
+
+You can see the commit history in the top half of the window along with a nice ancestry graph. The diff viewer in the bottom half of the window shows you the changes introduced at any commit you click.
+
+## Undoing Things ##
+
+At any stage, you may want to undo something. Here, we’ll review a few basic tools for undoing changes that you’ve made. Be careful, because you can’t always undo some of these undos. This is one of the few areas in Git where you may lose some work if you do it wrong.
+
+### Changing Your Last Commit ###
+
+One of the common undos takes place when you commit too early and possibly forget to add some files, or you mess up your commit message. If you want to try that commit again, you can run commit with the `--amend` option:
+
+ $ git commit --amend
+
+This command takes your staging area and uses it for the commit. If you’ve have made no changes since your last commit (for instance, you run this command immediately after your previous commit), then your snapshot will look exactly the same and all you’ll change is your commit message.
+
+The same commit-message editor fires up, but it already contains the message of your previous commit. You can edit the message the same as always, but it overwrites your previous commit.
+
+As an example, if you commit and then realize you forgot to stage the changes in a file you wanted to add to this commit, you can do something like this:
+
+ $ git commit -m 'initial commit'
+ $ git add forgotten_file
+ $ git commit --amend
+
+All three of these commands end up with a single commit — the second commit replaces the results of the first.
+
+### Unstaging a Staged File ###
+
+The next two sections demonstrate how to wrangle your staging area and working directory changes. The nice part is that the command you use to determine the state of those two areas also reminds you how to undo changes to them. For example, let’s say you’ve changed two files and want to commit them as two separate changes, but you accidentally type `git add *` and stage them both. How can you unstage one of the two? The `git status` command reminds you:
+
+ $ git add .
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # modified: README.txt
+ # modified: benchmarks.rb
+ #
+
+Right below the “Changes to be committed” text, it says use `git reset HEAD <file>...` to unstage. So, let’s use that advice to unstage the benchmarks.rb file:
+
+ $ git reset HEAD benchmarks.rb
+ benchmarks.rb: locally modified
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # modified: README.txt
+ #
+ # Changed but not updated:
+ # (use "git add <file>..." to update what will be committed)
+ # (use "git checkout -- <file>..." to discard changes in working directory)
+ #
+ # modified: benchmarks.rb
+ #
+
+The command is a bit strange, but it works. The benchmarks.rb file is modified but once again unstaged.
+
+### Unmodifying a Modified File ###
+
+What if you realize that you don’t want to keep your changes to the benchmarks.rb file? How can you easily unmodify it — revert it back to what it looked like when you last committed (or initially cloned, or however you got it into your working directory)? Luckily, `git status` tells you how to do that, too. In the last example output, the unstaged area looks like this:
+
+ # Changed but not updated:
+ # (use "git add <file>..." to update what will be committed)
+ # (use "git checkout -- <file>..." to discard changes in working directory)
+ #
+ # modified: benchmarks.rb
+ #
+
+It tells you pretty explicitly how to discard the changes you’ve made (at least, the newer versions of Git, 1.6.1 and later, do this — if you have an older version, we highly recommend upgrading it to get some of these nicer usability features). Let’s do what it says:
+
+ $ git checkout -- benchmarks.rb
+ $ git status
+ # On branch master
+ # Changes to be committed:
+ # (use "git reset HEAD <file>..." to unstage)
+ #
+ # modified: README.txt
+ #
+
+You can see that the changes have been reverted. You should also realize that this is a dangerous command: any changes you made to that file are gone — you just copied another file over it. Don’t ever use this command unless you absolutely know that you don’t want the file. If you just need to get it out of the way, we’ll go over stashing and branching in the next chapter; these are generally better ways to go.
+
+Remember, anything that is committed in Git can almost always be recovered. Even commits that were on branches that were deleted or commits that were overwritten with an `--amend` commit can be recovered (see Chapter 9 for data recovery). However, anything you lose that was never committed is likely never to be seen again.
+
+## Working with Remotes ##
+
+To be able to collaborate on any Git project, you need to know how to manage your remote repositories. Remote repositories are versions of your project that are hosted on the Internet or network somewhere. You can have several of them, each of which generally is either read-only or read/write for you. Collaborating with others involves managing these remote repositories and pushing and pulling data to and from them when you need to share work.
+Managing remote repositories includes knowing how to add remote repositories, remove remotes that are no longer valid, manage various remote branches and define them as being tracked or not, and more. In this section, we’ll cover these remote-management skills.
+
+### Showing Your Remotes ###
+
+To see which remote servers you have configured, you can run the git remote command. It lists the shortnames of each remote handle you’ve specified. If you’ve cloned your repository, you should at least see origin — that is the default name Git gives to the server you cloned from:
+
+ $ git clone git://github.com/schacon/ticgit.git
+ Initialized empty Git repository in /private/tmp/ticgit/.git/
+ remote: Counting objects: 595, done.
+ remote: Compressing objects: 100% (269/269), done.
+ remote: Total 595 (delta 255), reused 589 (delta 253)
+ Receiving objects: 100% (595/595), 73.31 KiB | 1 KiB/s, done.
+ Resolving deltas: 100% (255/255), done.
+ $ cd ticgit
+ $ git remote
+ origin
+
+You can also specify `-v`, which shows you the URL that Git has stored for the shortname to be expanded to:
+
+ $ git remote -v
+ origin git://github.com/schacon/ticgit.git
+
+If you have more than one remote, the command lists them all. For example, my Grit repository looks something like this.
+
+ $ cd grit
+ $ git remote -v
+ bakkdoor git://github.com/bakkdoor/grit.git
+ cho45 git://github.com/cho45/grit.git
+ defunkt git://github.com/defunkt/grit.git
+ koke git://github.com/koke/grit.git
+ origin git@github.com:mojombo/grit.git
+
+This means we can pull contributions from any of these users pretty easily. But notice that only the origin remote is an SSH URL, so it’s the only one I can push to (we’ll cover why this is in Chapter 4).
+
+### Adding Remote Repositories ###
+
+I’ve mentioned and given some demonstrations of adding remote repositories in previous sections, but here is how to do it explicitly. To add a new remote Git repository as a shortname you can reference easily, run `git remote add [shortname] [url]`:
+
+ $ git remote
+ origin
+ $ git remote add pb git://github.com/paulboone/ticgit.git
+ $ git remote -v
+ origin git://github.com/schacon/ticgit.git
+ pb git://github.com/paulboone/ticgit.git
+
+Now you can use the string pb on the command line in lieu of the whole URL. For example, if you want to fetch all the information that Paul has but that you don’t yet have in your repository, you can run git fetch pb:
+
+ $ git fetch pb
+ remote: Counting objects: 58, done.
+ remote: Compressing objects: 100% (41/41), done.
+ remote: Total 44 (delta 24), reused 1 (delta 0)
+ Unpacking objects: 100% (44/44), done.
+ From git://github.com/paulboone/ticgit
+ * [new branch] master -> pb/master
+ * [new branch] ticgit -> pb/ticgit
+
+Paul’s master branch is accessible locally as `pb/master` — you can merge it into one of your branches, or you can check out a local branch at that point if you want to inspect it.
+
+### Fetching and Pulling from Your Remotes ###
+
+As you just saw, to get data from your remote projects, you can run:
+
+ $ git fetch [remote-name]
+
+The command goes out to that remote project and pulls down all the data from that remote project that you don’t have yet. After you do this, you should have references to all the branches from that remote, which you can merge in or inspect at any time. (We’ll go over what branches are and how to use them in much more detail in Chapter 3.)
+
+If you clone a repository, the command automatically adds that remote repository under the name origin. So, `git fetch origin` fetches any new work that has been pushed to that server since you cloned (or last fetched from) it. It’s important to note that the fetch command pulls the data to your local repository — it doesn’t automatically merge it with any of your work or modify what you’re currently working on. You have to merge it manually into your work when you’re ready.
+
+If you have a branch set up to track a remote branch (see the next section and Chapter 3 for more information), you can use the `git pull` command to automatically fetch and then merge a remote branch into your current branch. This may be an easier or more comfortable workflow for you; and by default, the `git clone` command automatically sets up your local master branch to track the remote master branch on the server you cloned from (assuming the remote has a master branch). Running `git pull` generally fetches data from the server you originally cloned from and automatically tries to merge it into the code you’re currently working on.
+
+### Pushing to Your Remotes ###
+
+When you have your project at a point that you want to share, you have to push it upstream. The command for this is simple: `git push [remote-name] [branch-name]`. If you want to push your master branch to your `origin` server (again, cloning generally sets up both of those names for you automatically), then you can run this to push your work back up to the server:
+
+ $ git push origin master
+
+This command works only if you cloned from a server to which you have write access and if nobody has pushed in the meantime. If you and someone else clone at the same time and they push upstream and then you push upstream, your push will rightly be rejected. You’ll have to pull down their work first and incorporate it into yours before you’ll be allowed to push. See Chapter 3 for more detailed information on how to push to remote servers.
+
+### Inspecting a Remote ###
+
+If you want to see more information about a particular remote, you can use the `git remote show [remote-name]` command. If you run this command with a particular shortname, such as `origin`, you get something like this:
+
+ $ git remote show origin
+ * remote origin
+ URL: git://github.com/schacon/ticgit.git
+ Remote branch merged with 'git pull' while on branch master
+ master
+ Tracked remote branches
+ master
+ ticgit
+
+It lists the URL for the remote repository as well as the tracking branch information. The command helpfully tells you that if you’re on the master branch and you run `git pull`, it will automatically merge in the master branch on the remote after it fetches all the remote references. It also lists all the remote references it has pulled down.
+
+That is a simple example you’re likely to encounter. When you’re using Git more heavily, however, you may see much more information from `git remote show`:
+
+ $ git remote show origin
+ * remote origin
+ URL: git@github.com:defunkt/github.git
+ Remote branch merged with 'git pull' while on branch issues
+ issues
+ Remote branch merged with 'git pull' while on branch master
+ master
+ New remote branches (next fetch will store in remotes/origin)
+ caching
+ Stale tracking branches (use 'git remote prune')
+ libwalker
+ walker2
+ Tracked remote branches
+ acl
+ apiv2
+ dashboard2
+ issues
+ master
+ postgres
+ Local branch pushed with 'git push'
+ master:master
+
+This command shows which branch is automatically pushed when you run `git push` on certain branches. It also shows you which remote branches on the server you don’t yet have, which remote branches you have that have been removed from the server, and multiple branches that are automatically merged when you run `git pull`.
+
+### Removing and Renaming Remotes ###
+
+If you want to rename a reference, in newer versions of Git you can run `git remote rename` to change a remote’s shortname. For instance, if you want to rename `pb` to `paul`, you can do so with `git remote rename`:
+
+ $ git remote rename pb paul
+ $ git remote
+ origin
+ paul
+
+It’s worth mentioning that this changes your remote branch names, too. What used to be referenced at `pb/master` is now at `paul/master`.
+
+If you want to remove a reference for some reason — you’ve moved the server or are no longer using a particular mirror, or perhaps a contributor isn’t contributing anymore — you can use `git remote rm`:
+
+ $ git remote rm paul
+ $ git remote
+ origin
+
+## Tagging ##
+
+Like most VCSs, Git has the ability to tag specific points in history as being important. Generally, people use this functionality to mark release points (v1.0, and so on). In this section, you’ll learn how to list the available tags, how to create new tags, and what the different types of tags are.
+
+### Listing Your Tags ###
+
+Listing the available tags in Git is straightforward. Just type `git tag`:
+
+ $ git tag
+ v0.1
+ v1.3
+
+This command lists the tags in alphabetical order; the order in which they appear has no real importance.
+
+You can also search for tags with a particular pattern. The Git source repo, for instance, contains more than 240 tags. If you’re only interested in looking at the 1.4.2 series, you can run this:
+
+ $ git tag -l 'v1.4.2.*'
+ v1.4.2.1
+ v1.4.2.2
+ v1.4.2.3
+ v1.4.2.4
+
+### Creating Tags ###
+
+Git uses two main types of tags: lightweight and annotated. A lightweight tag is very much like a branch that doesn’t change — it’s just a pointer to a specific commit. Annotated tags, however, are stored as full objects in the Git database. They’re checksummed; contain the tagger name, e-mail, and date; have a tagging message; and can be signed and verified with GNU Privacy Guard (GPG). It’s generally recommended that you create annotated tags so you can have all this information; but if you want a temporary tag or for some reason don’t want to keep the other information, lightweight tags are available too.
+
+### Annotated Tags ###
+
+Creating an annotated tag in Git is simple. The easiest way is to specify `-a` when you run the `tag` command:
+
+ $ git tag -a v1.4 -m 'my version 1.4'
+ $ git tag
+ v0.1
+ v1.3
+ v1.4
+
+The `-m` specifies a tagging message, which is stored with the tag. If you don’t specify a message for an annotated tag, Git launches your editor so you can type it in.
+
+You can see the tag data along with the commit that was tagged by using the `git show` command:
+
+ $ git show v1.4
+ tag v1.4
+ Tagger: Scott Chacon <schacon@gee-mail.com>
+ Date: Mon Feb 9 14:45:11 2009 -0800
+
+ my version 1.4
+ commit 15027957951b64cf874c3557a0f3547bd83b3ff6
+ Merge: 4a447f7... a6b4c97...
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sun Feb 8 19:02:46 2009 -0800
+
+ Merge branch 'experiment'
+
+That shows the tagger information, the date the commit was tagged, and the annotation message before showing the commit information.
+
+### Signed Tags ###
+
+You can also sign your tags with GPG, assuming you have a private key. All you have to do is use `-s` instead of `-a`:
+
+ $ git tag -s v1.5 -m 'my signed 1.5 tag'
+ You need a passphrase to unlock the secret key for
+ user: "Scott Chacon <schacon@gee-mail.com>"
+ 1024-bit DSA key, ID F721C45A, created 2009-02-09
+
+If you run `git show` on that tag, you can see your GPG signature attached to it:
+
+ $ git show v1.5
+ tag v1.5
+ Tagger: Scott Chacon <schacon@gee-mail.com>
+ Date: Mon Feb 9 15:22:20 2009 -0800
+
+ my signed 1.5 tag
+ -----BEGIN PGP SIGNATURE-----
+ Version: GnuPG v1.4.8 (Darwin)
+
+ iEYEABECAAYFAkmQurIACgkQON3DxfchxFr5cACeIMN+ZxLKggJQf0QYiQBwgySN
+ Ki0An2JeAVUCAiJ7Ox6ZEtK+NvZAj82/
+ =WryJ
+ -----END PGP SIGNATURE-----
+ commit 15027957951b64cf874c3557a0f3547bd83b3ff6
+ Merge: 4a447f7... a6b4c97...
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sun Feb 8 19:02:46 2009 -0800
+
+ Merge branch 'experiment'
+
+A bit later, you’ll learn how to verify signed tags.
+
+### Lightweight Tags ###
+
+Another way to tag commits is with a lightweight tag. This is basically the commit checksum stored in a file — no other information is kept. To create a lightweight tag, don’t supply the `-a`, `-s`, or `-m` option:
+
+ $ git tag v1.4-lw
+ $ git tag
+ v0.1
+ v1.3
+ v1.4
+ v1.4-lw
+ v1.5
+
+This time, if you run `git show` on the tag, you don’t see the extra tag information. The command just shows the commit:
+
+ $ git show v1.4-lw
+ commit 15027957951b64cf874c3557a0f3547bd83b3ff6
+ Merge: 4a447f7... a6b4c97...
+ Author: Scott Chacon <schacon@gee-mail.com>
+ Date: Sun Feb 8 19:02:46 2009 -0800
+
+ Merge branch 'experiment'
+
+### Verifying Tags ###
+
+To verify a signed tag, you use `git tag -v [tag-name]`. This command uses GPG to verify the signature. You need the signer’s public key in your keyring for this to work properly:
+
+ $ git tag -v v1.4.2.1
+ object 883653babd8ee7ea23e6a5c392bb739348b1eb61
+ type commit
+ tag v1.4.2.1
+ tagger Junio C Hamano <junkio@cox.net> 1158138501 -0700
+
+ GIT 1.4.2.1
+
+ Minor fixes since 1.4.2, including git-mv and git-http with alternates.
+ gpg: Signature made Wed Sep 13 02:08:25 2006 PDT using DSA key ID F3119B9A
+ gpg: Good signature from "Junio C Hamano <junkio@cox.net>"
+ gpg: aka "[jpeg image of size 1513]"
+ Primary key fingerprint: 3565 2A26 2040 E066 C9A7 4A7D C0C6 D9A4 F311 9B9A
+
+If you don’t have the signer’s public key, you get something like this instead:
+
+ gpg: Signature made Wed Sep 13 02:08:25 2006 PDT using DSA key ID F3119B9A
+ gpg: Can't check signature: public key not found
+ error: could not verify the tag 'v1.4.2.1'
+
+### Tagging Later ###
+
+You can also tag commits after you’ve moved past them. Suppose your commit history looks like this:
+
+ $ git log --pretty=oneline
+ 15027957951b64cf874c3557a0f3547bd83b3ff6 Merge branch 'experiment'
+ a6b4c97498bd301d84096da251c98a07c7723e65 beginning write support
+ 0d52aaab4479697da7686c15f77a3d64d9165190 one more thing
+ 6d52a271eda8725415634dd79daabbc4d9b6008e Merge branch 'experiment'
+ 0b7434d86859cc7b8c3d5e1dddfed66ff742fcbc added a commit function
+ 4682c3261057305bdd616e23b64b0857d832627b added a todo file
+ 166ae0c4d3f420721acbb115cc33848dfcc2121a started write support
+ 9fceb02d0ae598e95dc970b74767f19372d61af8 updated rakefile
+ 964f16d36dfccde844893cac5b347e7b3d44abbc commit the todo
+ 8a5cbc430f1a9c3d00faaeffd07798508422908a updated readme
+
+Now, suppose you forgot to tag the project at v1.2, which was at the "updated rakefile" commit. You can add it after the fact. To tag that commit, you specify the commit checksum (or part of it) at the end of the command:
+
+ $ git tag -a v1.2 9fceb02
+
+You can see that you’ve tagged the commit:
+
+ $ git tag
+ v0.1
+ v1.2
+ v1.3
+ v1.4
+ v1.4-lw
+ v1.5
+
+ $ git show v1.2
+ tag v1.2
+ Tagger: Scott Chacon <schacon@gee-mail.com>
+ Date: Mon Feb 9 15:32:16 2009 -0800
+
+ version 1.2
+ commit 9fceb02d0ae598e95dc970b74767f19372d61af8
+ Author: Magnus Chacon <mchacon@gee-mail.com>
+ Date: Sun Apr 27 20:43:35 2008 -0700
+
+ updated rakefile
+ ...
+
+### Sharing Tags ###
+
+By default, the `git push` command doesn’t transfer tags to remote servers. You will have to explicitly push tags to a shared server after you have created them. This process is just like sharing remote branches – you can run `git push origin [tagname]`.
+
+ $ git push origin v1.5
+ Counting objects: 50, done.
+ Compressing objects: 100% (38/38), done.
+ Writing objects: 100% (44/44), 4.56 KiB, done.
+ Total 44 (delta 18), reused 8 (delta 1)
+ To git@github.com:schacon/simplegit.git
+ * [new tag] v1.5 -> v1.5
+
+If you have a lot of tags that you want to push up at once, you can also use the `--tags` option to the `git push` command. This will transfer all of your tags to the remote server that are not already there.
+
+ $ git push origin --tags
+ Counting objects: 50, done.
+ Compressing objects: 100% (38/38), done.
+ Writing objects: 100% (44/44), 4.56 KiB, done.
+ Total 44 (delta 18), reused 8 (delta 1)
+ To git@github.com:schacon/simplegit.git
+ * [new tag] v0.1 -> v0.1
+ * [new tag] v1.2 -> v1.2
+ * [new tag] v1.4 -> v1.4
+ * [new tag] v1.4-lw -> v1.4-lw
+ * [new tag] v1.5 -> v1.5
+
+Now, when someone else clones or pulls from your repository, they will get all your tags as well.
+
+## Tips and Tricks ##
+
+Before we finish this chapter on basic Git, a few little tips and tricks may make your Git experience a bit simpler, easier, or more familiar. Many people use Git without using any of these tips, and we won’t refer to them or assume you’ve used them later in the book; but you should probably know how to do them.
+
+### Auto-Completion ###
+
+If you use the Bash shell, Git comes with a nice auto-completion script you can enable. Download the Git source code, and look in the `contrib/completion` directory; there should be a file called `git-completion.bash`. Copy this file to your home directory, and add this to your `.bashrc` file:
+
+ source ~/.git-completion.bash
+
+If you want to set up Git to automatically have Bash shell completion for all users, copy this script to the `/opt/local/etc/bash_completion.d` directory on Mac systems or to the `/etc/bash_completion.d/` directory on Linux systems. This is a directory of scripts that Bash will automatically load to provide shell completions.
+
+If you’re using Windows with Git Bash, which is the default when installing Git on Windows with msysGit, auto-completion should be preconfigured.
+
+Press the Tab key when you’re writing a Git command, and it should return a set of suggestions for you to pick from:
+
+ $ git co<tab><tab>
+ commit config
+
+In this case, typing git co and then pressing the Tab key twice suggests commit and config. Adding `m<tab>` completes `git commit` automatically.
+
+This also works with options, which is probably more useful. For instance, if you’re running a `git log` command and can’t remember one of the options, you can start typing it and press Tab to see what matches:
+
+ $ git log --s<tab>
+ --shortstat --since= --src-prefix= --stat --summary
+
+That’s a pretty nice trick and may save you some time and documentation reading.
+
+### Git Aliases ###
+
+Git doesn’t infer your command if you type it in partially. If you don’t want to type the entire text of each of the Git commands, you can easily set up an alias for each command using `git config`. Here are a couple of examples you may want to set up:
+
+ $ git config --global alias.co checkout
+ $ git config --global alias.br branch
+ $ git config --global alias.ci commit
+ $ git config --global alias.st status
+
+This means that, for example, instead of typing `git commit`, you just need to type `git ci`. As you go on using Git, you’ll probably use other commands frequently as well; in this case, don’t hesitate to create new aliases.
+
+This technique can also be very useful in creating commands that you think should exist. For example, to correct the usability problem you encountered with unstaging a file, you can add your own unstage alias to Git:
+
+ $ git config --global alias.unstage 'reset HEAD --'
+
+This makes the following two commands equivalent:
+
+ $ git unstage fileA
+ $ git reset HEAD fileA
+
+This seems a bit clearer. It’s also common to add a `last` command, like this:
+
+ $ git config --global alias.last 'log -1 HEAD'
+
+This way, you can see the last commit easily:
+
+ $ git last
+ commit 66938dae3329c7aebe598c2246a8e6af90d04646
+ Author: Josh Goebel <dreamer3@example.com>
+ Date: Tue Aug 26 19:48:51 2008 +0800
+
+ test for current head
+
+ Signed-off-by: Scott Chacon <schacon@example.com>
+
+As you can tell, Git simply replaces the new command with whatever you alias it for. However, maybe you want to run an external command, rather than a Git subcommand. In that case, you start the command with a `!` character. This is useful if you write your own tools that work with a Git repository. We can demonstrate by aliasing `git visual` to run `gitk`:
+
+ $ git config --global alias.visual "!gitk"
+
+## Summary ##
+
+At this point, you can do all the basic local Git operations — creating or cloning a repository, making changes, staging and committing those changes, and viewing the history of all the changes the repository has been through. Next, we’ll cover Git’s killer feature: its branching model.
View
0 zh_TW/03-git-branching/01-chapter3.markdown → ar/03-git-branching/01-chapter3.markdown
File renamed without changes.
View
0 zh_TW/04-git-server/01-chapter4.markdown → ar/04-git-server/01-chapter4.markdown
File renamed without changes.
View
0 ...W/05-distributed-git/01-chapter5.markdown → ar/05-distributed-git/01-chapter5.markdown
File renamed without changes.
View
0 zh_TW/06-git-tools/01-chapter6.markdown → ar/06-git-tools/01-chapter6.markdown
File renamed without changes.
View
0 ...W/07-customizing-git/01-chapter7.markdown → ar/07-customizing-git/01-chapter7.markdown
File renamed without changes.
View
0 ...8-git-and-other-scms/01-chapter8.markdown → ...8-git-and-other-scms/01-chapter8.markdown
File renamed without changes.
View
0 zh_TW/09-git-internals/01-chapter9.markdown → ar/09-git-internals/01-chapter9.markdown
File renamed without changes.
View
18 ar/NOTES
@@ -0,0 +1,18 @@
+ملاحظات حول الترجمة
+=======================
+
+فيما يلي قائمة بالمصطلحات الإنكليزية ومحاولتي لتعريبها، يمكنك المشاركة في تعديل هذه المصطلحات وإقتراح الأفضل إن أردت.
+
+* نظام إدارة الإصدارات = Version Control System.
+* نظم إدارة الإصدارات المحلية = Local Version Control Systems.
+* نظم إدارة الإصدارات المركزية = Centralized Version Control Systens.
+
+
+ملاحظة: ستجد الكلمة الإنكليزية الأصلية بعد ترجمتي المقترحة لها في سياق الكتاب أول مرة تظهر فيها الكلمة في كل فصل فقط (أو أكثر حسب الحاجة).
+
+يحتاج الى ترجمة
+=======================
+
+فيما يلي قائمة بالمصطلحات التي لم استطع العثور على ترجمة صحيحة لها، إذا كان لديك أي إقتراح أرجو التغيير أو المراسة beshrkayali at gmail dot com.
+
+* ش
View
14 ar/README
@@ -0,0 +1,14 @@
+محتويات كتاب احترف Git
+=======================
+هذا هو الكود المصدري لكتاب احترف Git. هذا الكتاب مرخص تحت Creative Commons Attribution-Non Commercial-Share Alike 3.0. أتمنى أن تجد فائدة في هذا الكتاب. يمكنك الحصول على نسخة مطبوعة من الكتاب من Apress (لدعم الكاتب) من متجر أمازون:
+
+http://tinyurl.com/amazonprogit
+
+عثرت على خطأ؟
+=======================
+إذا عثرت على أي خطأ تقني أو في الترجمة أرجو منك مراسلتي وإعلامي بالأمر على: schacon at gmail dot com.
+
+
+الترجمة
+=======================
+هذه هي الترجمة العربية لكتاب Pro Git (احترف Git). يمكنك المساعدة في ترجمة الكتاب عن طريق الذهاب الى صفحة المشروع على GitHub.
View
2 cs/07-customizing-git/01-chapter7.markdown
@@ -1,4 +1,4 @@
-# Customizing Git #
+# Prizpusobeni Git #
So far, I’ve covered the basics of how Git works and how to use it, and I’ve introduced a number of tools that Git provides to help you use it easily and efficiently. In this chapter, I’ll go through some operations that you can use to make Git operate in a more customized fashion by introducing several important configuration settings and the hooks system. With these tools, it’s easy to get Git to work exactly the way you, your company, or your group needs it to.
View
57 en/04-git-server/01-chapter4.markdown
@@ -511,7 +511,7 @@ Gitolite allows you to specify permissions not just by repository (like Gitosis
### Installing ###
-Installing Gitolite is very easy, even if you don't read the extensive documentation that comes with it. You need an account on a Unix server of some kind (various Linux flavours, and Solaris 10, have been tested), with git, perl, and an openssh compatible ssh server installed. In the examples below, we will use the `gitolite` account on a host called `gitserver`.
+Installing Gitolite is very easy, even if you don't read the extensive documentation that comes with it. You need an account on a Unix server of some kind; various Linux flavours, and Solaris 10, have been tested. You do not need root access, assuming git, perl, and an openssh compatible ssh server are already installed. In the examples below, we will use the `gitolite` account on a host called `gitserver`.
Curiously, Gitolite is installed by running a script *on the workstation*, so your workstation must have a bash shell available. Even the bash that comes with msysgit will do, in case you're wondering.
@@ -538,9 +538,7 @@ That last command does produce a fair amount of output, which might be interesti
### Customising the Install ###
-While the default, quick, install works for most people, there are some ways to customise the install if you need to. Firstly, there are two other branches that you may be interested in installing, instead of "master". The "wildrepos" branch allows you to specify repositories by wildcards (regular expressions) in the configuration file; an extremely powerful feature that we will not be covering in this article. And if your server side git is older than 1.5.6 or so, you should use the "oldgits" branch.
-
-Finally, if you omit the `-q` argument, you get a "verbose" mode install -- detailed information on what the install is doing at each step. The verbose mode also allows you to change certain server-side parameters, such as the location of the actual repositories, by editing an "rc" file that the server uses. This "rc" file is liberally commented so you should be able to make any changes you need quite easily, save it, and continue.
+While the default, quick, install works for most people, there are some ways to customise the install if you need to. If you omit the `-q` argument, you get a "verbose" mode install -- detailed information on what the install is doing at each step. The verbose mode also allows you to change certain server-side parameters, such as the location of the actual repositories, by editing an "rc" file that the server uses. This "rc" file is liberally commented so you should be able to make any changes you need quite easily, save it, and continue. This file also contains various settings that you can change to enable or disable some of gitolite's advanced features.
### Config File and Access Control Rules ###
@@ -601,29 +599,54 @@ There are two levels of access control in gitolite. The first is at the reposit
The second level, applicable only to "write" access, is by branch or tag within a repository. The username, the access being attempted (`W` or `+`), and the refname being updated are known. The access rules are checked in order of appearance in the config file, looking for a match for this combination (but remember that the refname is regex-matched, not merely string-matched). If a match is found, the push succeeds. A fallthrough results in access being denied.
-### Advanced Access Control -- "deny" rules ###
+### Advanced Access Control with "deny" rules ###
-As you can see, permissions can be one of `R`, `RW`, or `RW+`. There is another permission available: `-`, standing for "deny". This gives you a lot more power, at the expense of some complexity, because now fallthrough is not the *only* way for access to be denied, and so the *order of the rules now matters*!
+So far, we've only seen permissions to be one or `R`, `RW`, or `RW+`. However, gitolite allows another permission: `-`, standing for "deny". This gives you a lot more power, at the expense of some complexity, because now fallthrough is not the *only* way for access to be denied, so the *order of the rules now matters*!
-Let us say, in the situation above, we want engineers to be able to rewind any branch *except* master and integ. Here's how:
+Let us say, in the situation above, we want engineers to be able to rewind any branch *except* master and integ. Here's how to do that:
RW master integ = @engineers
- master integ = @engineers
RW+ = @engineers
-Again, you simply follow the rules top down until you hit a match for your access mode, *or* a deny. Non-rewind push to master or integ is allowed by the first rule. A rewind push to those refs does not match the first rule, drops down to the second, and is therefore denied. Any push (rewind or non-rewind) to refs other than master or integ won't match the first two rules anyway, and the third rule allows it.
+Again, you simply follow the rules top down until you hit a match for your access mode, or a deny. Non-rewind push to master or integ is allowed by the first rule. A rewind push to those refs does not match the first rule, drops down to the second, and is therefore denied. Any push (rewind or non-rewind) to refs other than master or integ won't match the first two rules anyway, and the third rule allows it.
+
+### Restricting pushes by files changed ###
+
+In addition to restricting what branches a user can push changes to, you can also restrict what files they are allowed to touch. For example, perhaps the Makefile (or some other program) is really not supposed to be changed by just anyone, because a lot of things depend on it or would break if the changes are not done *just right*. You can tell gitolite:
+
+ repo foo
+ RW = @junior_devs @senior_devs
+
+ RW NAME/ = @senior_devs
+ - NAME/Makefile = @junior_devs
+ RW NAME/ = @junior_devs
+
+This powerful feature is documented in `conf/example.conf`.
-If that sounds complicated, you may want to play with it to increase your understanding. Also, most of the time you don't need "deny" rules anyway, so you can choose to just avoid them if you prefer.
+### Personal Branches ###
+
+Gitolite also has a feature called "personal branches" (or rather, "personal branch namespace") that can be very useful in a corporate environment.
+
+A lot of code exchange in the git world happens by "please pull" requests. In a corporate environment, however, unauthenticated access is a no-no, and a developer workstation cannot do authentication, so you have to push to the central server and ask someone to pull from there.
+
+This would normally cause the same branch name clutter as in a centralised VCS, plus setting up permissions for this becomes a chore for the admin.
+
+Gitolite lets you define a "personal" or "scratch" namespace prefix for each developer (for example, `refs/personal/<devname>/*`), with full permissions for that dev only, and read access for everyone else. Just choose a verbose install and set the `$PERSONAL` variable in the "rc" file to `refs/personal`. That's all; it's pretty much fire and forget as far as the admin is concerned, even if there is constant churn in the project team composition.
+
+### "Wildcard" repositories ###
+
+Gitolite allows you to specify repositories with wildcards (actually perl regexes), like, for example `assignments/s[0-9][0-9]/a[0-9][0-9]`, to pick a random example. This is a *very* powerful feature, which has to be enabled by setting `$GL_WILDREPOS = 1;` in the rc file. It allows you to assign a new permission mode ("C") which allows users to create repositories based on such wild cards, automatically assigns ownership to the specific user who created it, allows him/her to hand out R and RW permissions to other users to collaborate, etc. This feature is documented in `doc/4-wildcard-repositories.mkd`.
### Other Features ###
We'll round off this discussion with a bunch of other features, all of which are described in great detail in the "faqs, tips, etc" document.
-Gitolite logs all successful accesses. If you were somewhat relaxed about giving people rewind permissions (`RW+`) and some kid blew away "master", the log file is a life saver, in terms of easily and quickly finding the SHA that got hosed.
+**Logging**: Gitolite logs all successful accesses. If you were somewhat relaxed about giving people rewind permissions (`RW+`) and some kid blew away "master", the log file is a life saver, in terms of easily and quickly finding the SHA that got hosed.
-One extremely useful convenience feature in gitolite is support for git installed outside the normal `$PATH` (this is more common than you think; some corporate environments or even some hosting providers refuse to install things system-wide and you end up putting them in your own directories). Normally, you are forced to make the *client-side* git aware of this non-standard location of the git binaries in some way. With gitolite, just choose a verbose install and set `$GIT_PATH` in the "rc" files. No client-side changes are required after that :-)
+**Git outside normal PATH**: One extremely useful convenience feature in gitolite is support for git installed outside the normal `$PATH` (this is more common than you think; some corporate environments or even some hosting providers refuse to install things system-wide and you end up putting them in your own directories). Normally, you are forced to make the *client-side* git aware of this non-standard location of the git binaries in some way. With gitolite, just choose a verbose install and set `$GIT_PATH` in the "rc" files. No client-side changes are required after that :-)
-Another convenient feature is what happens when you try and just ssh to the server. Older versions of gitolite used to complain about the `SSH_ORIGINAL_COMMAND` environment variable being empty (see the ssh documentation if interested). Now Gitolite comes up with something like this:
+**Access rights reporting**: Another convenient feature is what happens when you try and just ssh to the server. Older versions of gitolite used to complain about the `SSH_ORIGINAL_COMMAND` environment variable being empty (see the ssh documentation if interested). Now Gitolite comes up with something like this:
hello sitaram, the gitolite version here is v0.90-9-g91e1e9f
you have the following permissions:
@@ -635,15 +658,9 @@ Another convenient feature is what happens when you try and just ssh to the serv
R indic_web_input
R shreelipi_converter
-For really large installations, you can delegate responsibility for groups of repositories to various people and have them manage those pieces independently. This reduces the load on the main admin, and makes him less of a bottleneck. This feature has its own documentation file in the `doc/` directory.
-
-Finally, Gitolite also has a feature called "personal branches" (or rather, "personal branch namespace") that can be very useful in a corporate environment.
+**Delegation**: For really large installations, you can delegate responsibility for groups of repositories to various people and have them manage those pieces independently. This reduces the load on the main admin, and makes him less of a bottleneck. This feature has its own documentation file in the `doc/` directory.
-A lot of code exchange in the git world happens by "please pull" requests. In a corporate environment, however, unauthenticated access is a no-no, and a developer workstation cannot do authentication, so you have to push to the central server and ask someone to pull from there.
-
-This would normally cause the same branch name clutter as in a centralised VCS, plus setting up permissions for this becomes a chore for the admin.
-
-Gitolite lets you define a "personal" or "scratch" namespace prefix for each developer (for example, `refs/personal/<devname>/*`), with full permissions for that dev only, and read access for everyone else. Just choose a verbose install and set the `$PERSONAL` variable in the "rc" file to `refs/personal`. That's all; it's pretty much fire and forget as far as the admin is concerned, even if there is constant churn in the project team composition.
+**Gitweb support**: Gitolite supports gitweb in several ways. You can specify which repos are visible via gitweb. You can set the "owner" and "description" for gitweb from the gitolite config file. Gitweb has a mechanism for you to implement access control based on HTTP authentication, so you can make it use the "compiled" config file that gitolite produces, which means the same access control rules (for read access) apply for gitweb and gitolite.
## Git Daemon ##
View
2 en/09-git-internals/01-chapter9.markdown
@@ -392,7 +392,7 @@ Notice that the object entry points to the commit SHA-1 value that you tagged. A
$ git cat-file blob junio-gpg-pub
-in the Git source code. The Linux kernel also has a non-commit-pointing tag object — the first tag created points to the initial tree of the import of the source code.
+in the Git source code repository. The Linux kernel repository also has a non-commit-pointing tag object — the first tag created points to the initial tree of the import of the source code.
### Remotes ###
View
10 es/01-introduction/01-chapter1.markdown
@@ -28,7 +28,7 @@ Figura 1-2. Diagrama de control de versiones centralizado.
Esta configuración ofrece muchas ventajas, especialmente frente a VCSs locales. Por ejemplo, todo el mundo sabe hasta cierto punto en qué está trabajando el resto de gente en el proyecto. Los administradores tienen control detallado de qué puede hacer cada uno; y es mucho más fácil administrar un CVCS que tener que lidiar con bases de datos locales en cada cliente.
-Sin embargo, esta configuración también tiene serias desventajas. La más obvia es el punto único de fallo que representa el servidor centralizado. Si ese servidor se cae durante una hora, entonces durante esa hora nadie puede colaborar o guardar cambios versionados de aquello en que están trabajando. Si el disco duro en el que se encuentra la base de datos central se corrompe, y no se han llevado copias de seguridad adecuadamente, pierdes absolutamente todo - toda la historia del proyecto salvo aquellas instantáneas que la gente pueda tener en sus máquinas locales. Los VCSs locales sufren de este mismo problema - cuando tienes toda la historia del proyecto en un único lugar, te arriesgas a perderlo todo.
+Sin embargo, esta configuración también tiene serias desventajas. La más obvia es el punto único de fallo que representa el servidor centralizado. Si ese servidor se cae durante una hora, entonces durante esa hora nadie puede colaborar o guardar cambios versionados de aquello en que están trabajando. Si el disco duro en el que se encuentra la base de datos central se corrompe, y no se han llevado copias de seguridad adecuadamente, pierdes absolutamente todo —toda la historia del proyecto salvo aquellas instantáneas que la gente pueda tener en sus máquinas locales. Los VCSs locales sufren de este mismo problema— cuando tienes toda la historia del proyecto en un único lugar, te arriesgas a perderlo todo.
### Sistemas de control de versiones distribuidos ###
@@ -64,7 +64,7 @@ La principal diferencia entre Git y cualquier otro VCS (Subversion y compañía
Insert 18333fig0104.png
Figura 1-4. Otros sistemas tienden a almacenar los datos como cambios de cada archivo respecto a una versión base.
-Git no modela ni almacena sus datos de este modo. En cambio, Git modela sus datos más como un conjunto de instantáneas de un mini sistema de archivos. Cada vez que confirmas un cambio, o guardas el estado de tu proyecto en Git, él básicamente hace una foto del aspecto de todos tus archivos en ese momento, y guarda una referencia a esa instantánea. Para ser eficiente, si los archivos no se han modificado, Git no almacena el archivo de nuevo - sólo un enlace al archivo anterior idéntico que ya tiene almacenado. Git modela sus datos más como en la Figura 1-5.
+Git no modela ni almacena sus datos de este modo. En cambio, Git modela sus datos más como un conjunto de instantáneas de un mini sistema de archivos. Cada vez que confirmas un cambio, o guardas el estado de tu proyecto en Git, él básicamente hace una foto del aspecto de todos tus archivos en ese momento, y guarda una referencia a esa instantánea. Para ser eficiente, si los archivos no se han modificado, Git no almacena el archivo de nuevo —sólo un enlace al archivo anterior idéntico que ya tiene almacenado—. Git modela sus datos más como en la Figura 1-5.
Insert 18333fig0105.png
Figura 1-5. Git almacena la información como instantáneas del proyecto a lo largo del tiempo.
@@ -73,9 +73,9 @@ Esta es una distinción importante entre Git y prácticamente todos los demás V
### Casi cualquier operación es local ###
-La mayoría de las operaciones en Git sólo necesitan archivos y recursos locales para operar - por lo general no se necesita información de ningún otro ordenador de tu red. Si estás acostumbrado a un CVCS donde la mayoría de las operaciones tienen esa sobrecarga del retardo de la red, este aspecto de Git te va a hacer pensar que los dioses de la velocidad han bendecido Git con poderes sobrenaturales. Como tienes toda la historia del proyecto ahí mismo, en tu disco local, la mayoría de las operaciones parecen prácticamente inmediatas.
+La mayoría de las operaciones en Git sólo necesitan archivos y recursos locales para operar —por lo general no se necesita información de ningún otro ordenador de tu red—. Si estás acostumbrado a un CVCS donde la mayoría de las operaciones tienen esa sobrecarga del retardo de la red, este aspecto de Git te va a hacer pensar que los dioses de la velocidad han bendecido Git con poderes sobrenaturales. Como tienes toda la historia del proyecto ahí mismo, en tu disco local, la mayoría de las operaciones parecen prácticamente inmediatas.
-Por ejemplo, para navegar por la historia del proyecto, Git no necesita salir al servidor para obtener la historia y mostrártela - simplemente la lee directamente de tu base de datos local. Esto significa que ves la historia del proyecto casi al instante. Si quieres ver los cambios introducidos entre la versión actual de un archivo y ese archivo hace un mes, Git puede buscar el archivo hace un mes y hacer un cálculo de diferencias localmente, en lugar de tener que pedirle a un servidor remoto que lo haga, u obtener una versión antigua del archivo del servidor remoto y hacerlo de manera local.
+Por ejemplo, para navegar por la historia del proyecto, Git no necesita salir al servidor para obtener la historia y mostrártela —simplemente la lee directamente de tu base de datos local—. Esto significa que ves la historia del proyecto casi al instante. Si quieres ver los cambios introducidos entre la versión actual de un archivo y ese archivo hace un mes, Git puede buscar el archivo hace un mes y hacer un cálculo de diferencias localmente, en lugar de tener que pedirle a un servidor remoto que lo haga, u obtener una versión antigua del archivo del servidor remoto y hacerlo de manera local.
Esto también significa que hay muy poco que no puedas hacer si estás desconectado o sin VPN. Si te subes a un avión o a un tren y quieres trabajar un poco, puedes confirmar tus cambios felizmente hasta que consigas una conexión de red para subirlos. Si te vas a casa y no consigues que tu cliente VPN funcione correctamente, puedes seguir trabajando. En muchos otros sistemas, esto es imposible o muy doloroso. En Perforce, por ejemplo, no puedes hacer mucho cuando no estás conectado al servidor; y en Subversion y CVS, puedes editar archivos, pero no puedes confirmar los cambios a tu base de datos (porque tu base de datos no tiene conexión). Esto puede no parecer gran cosa, pero te sorprendería la diferencia que puede suponer.
@@ -120,7 +120,7 @@ Si una versión concreta de un archivo está en el directorio de Git, se conside
## Instalando Git ##
-Vamos a empezar a usar un poco de Git. Lo primero es lo primero - tienes que instalarlo. Puedes obtenerlo de varias maneras; las dos principales son instalarlo desde código fuente, o instalar un paquete existente para tu plataforma.
+Vamos a empezar a usar un poco de Git. Lo primero es lo primero: tienes que instalarlo. Puedes obtenerlo de varias maneras; las dos principales son instalarlo desde código fuente, o instalar un paquete existente para tu plataforma.
### Instalando desde código fuente ###
View
580 es/02-git-basics/01-chapter2.markdown
116 additions, 464 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
View
7 es/NOTES
@@ -20,3 +20,10 @@
- Stage/Staged: Lo traduzco como *preparar*/*preparado*, pero pongo entre () el término original.
- Staging area: Parece ser un término militar. Se refiere a una localización temporal donde se reúnen recursos antes de un ataque o invasión. Lo traduzco como *área de preparación*, pero pongo entre () el término original.
- Track/Tracking: Lo traduzco como *seguir*/*seguimiento*.
+
+
+# Anotaciones sobre las anotaciones [afgomez]
+
+- No creo que sea necesario poner entre parentesis los términos originales de "rama" y "unión". Es una traduccion lo suficientemente clara como para no necesitarlos.
+- A lo largo del texto se utilizan guiones '-' para indicar aclaraciones en el texto. En Español el signo correcto es la raya ('—', &mdash; en HTML), y debe ir siempre cerrado, por lo que se han modificado en el texto.
+ Más información: http://es.wikipedia.org/wiki/Raya_%28puntuaci%C3%B3n%29
View
248 fr/01-introduction/01-chapter1.markdown
@@ -1,225 +1,331 @@
# Démarrage rapide #
-Ce chapitre traite du démarrage rapide avec Git. Nous commencerons par expliquer les bases des gestions de version, puis nous parlerons de l'installation de Git sur votre système et finalement comment le paramétrer pour commencer à l'utiliser. À la fin de ce chapitre vous devriez en savoir assez pour comprendre pourquoi on parle beaucoup de Git, pourquoi vous devriez l'utiliser et vous devriez en avoir une installation prête à l'emploi.
+Ce chapitre traite du démarrage rapide avec Git.
+Nous commencerons par expliquer les bases de la gestion de version, puis nous parlerons de l'installation de Git sur votre système et finalement comment le paramétrer pour commencer à l'utiliser.
+À la fin de ce chapitre vous devriez en savoir assez pour comprendre pourquoi on parle beaucoup de Git, pourquoi vous devriez l'utiliser et vous devriez en avoir une installation prête à l'emploi.
## À propos de la gestion de version ##
-Qu'est-ce que la gestion de version et pourquoi devriez-vous vous en soucier ? La gestion de version est un système qui enregistre l'évolution d'un fichier ou d'un ensemble de fichiers au cours du temps de manière à ce qu'on puisse rappeler une version antérieure d'un fichier à tout moment. Pour les exemples de ce livre, nous utiliserons des fichiers sources de logiciel comme fichiers sous gestion de version, bien qu'en réalité on puisse l'utiliser avec pratiquement tous les types de fichiers d'un ordinateur.
+Qu'est-ce que la gestion de version et pourquoi devriez-vous vous en soucier ?
+Un gestionnaire de version est un système qui enregistre l'évolution d'un fichier ou d'un ensemble de fichiers au cours du temps de manière à ce qu'on puisse rappeler une version antérieure d'un fichier à tout moment.
+Dans les exemples de ce livre, nous utiliserons des fichiers sources de logiciel comme fichiers sous gestion de version, bien qu'en réalité on puisse l'utiliser avec pratiquement tous les types de fichiers d'un ordinateur.
-Si vous êtes un dessinateur ou un designer web et voulez conserver toutes les versions d'une image ou d'une mise en page (ce que vous voudriez surement faire), un système de gestion de version (VCS en anglais pour Version Control System) est un outil qu'il est très sage d'utiliser. Il vous permet de ramener un fichier à un état précédent, ramener le projet complet à un état précédent, comparer les changements au cours du temps, voir qui a modifié quelque chose qui pourrait causer un problème, qui a introduit un problème et quand, et plus encore. Utiliser un VCS signifie aussi généralement que si vous vous trompez ou vous perdez des fichiers, vous pouvez facilement revenir à un état stable. De plus, vous obtenez tous ces avantages pour peu de surcharge de travail.
+Si vous êtes un dessinateur ou un développeur web, et que vous voulez conserver toutes les versions d'une image ou d'une mise en page (ce que vous souhaiteriez assurément), un système de gestion de version (VCS en anglais pour Version Control System) est un outil qu'il est très sage d'utiliser.
+Il vous permet de ramener un fichier à un état précédent, ramener le projet complet à un état précédent, comparer les changements au cours du temps, voir qui a modifié quelque chose qui pourrait causer un problème, qui a introduit un problème et quand, et plus encore.
+Utiliser un VCS signifie aussi généralement que si vous vous trompez ou que vous perdez des fichiers, vous pouvez facilement revenir à un état stable.
+De plus, vous obtenez tous ces avantages avec une faible surcharge de travail.
### Les systèmes de gestion de version locaux ###
-La méthode commune pour la gestion de version est généralement de recopier les fichiers dans un autre répertoire (peut-être avec un nom incluant la date pour les plus malins). Cette méthode est la plus commune parce que c'est la plus simple, mais c'est aussi la plus grande source d'erreurs. Il est facile d'oublier le répertoire dans lequel vous êtes et d'écrire accidentellement dans le mauvais fichier ou d'écraser des fichiers que vous vouliez conserver.
+La méthode commune pour la gestion de version est généralement de recopier les fichiers dans un autre répertoire (peut-être avec un nom incluant la date dans le meilleur des cas).
+Cette méthode est la plus commune parce que c'est la plus simple, mais c'est aussi la moins fiable.
+Il est facile d'oublier le répertoire dans lequel vous êtes et d'écrire accidentellement dans le mauvais fichier ou d'écraser des fichiers que vous vouliez conserver.
-Pour traiter ce problème, les programmeurs ont développé il y a longtemps des VCSs locaux qui utilisaient une base de données simple pour conserver les modifications d'un fichier (Cf. figure 1-1).
+Pour traiter ce problème, les programmeurs ont développé il y a longtemps des VCSs locaux qui utilisaient une base de données simple pour conserver les modifications d'un fichier (voir figure 1-1).
Insert 18333fig0101.png
Figure 1-1. Diagramme des systèmes de gestion de version locaux.
-Un des systèmes les plus populaires était RCS, qui est encore distribué avec de nombreux systèmes d'exploitation aujourd'hui. Même le système d'exploitation populaire Mac OS X inclut le programme RCS lorsqu'on installe les outils de développement logiciel. Cet outil fonctionne en conservant les patch sets (c'est-à-dire la différence entre les fichiers) d'une version à l'autre dans un format spécial sur disque ; il peut alors recréer ce qu'était n'importe quel fichier à n'importe quel instant en ajoutant toutes les différences.
+Un des systèmes les plus populaires était RCS, qui est encore distribué avec de nombreux systèmes d'exploitation aujourd'hui.
+Même le système d'exploitation populaire Mac OS X inclut le programme rcs lorsqu'on installe les outils de développement logiciel.
+Cet outil fonctionne en conservant des ensembles de patch (c'est-à-dire la différence entre les fichiers) d'une version à l'autre dans un format spécial sur disque ;
+il peut alors restituer l'état de n'importe quel fichier à n'importe quel instant en ajoutant toutes les différences.
### Les systèmes de gestion de version centralisés ###
-Le problème majeur suivant que les gens rencontrent est qu'ils ont besoin de collaborer avec des développeurs sur d'autres ordinateurs. Pour traiter ce problème, les systèmes de gestion de version centralisés (CVCS en anglais pour *Centralized Version Control Systems*) furent développés. Ces systèmes tels que CVS, Subversion, et Perforce, mettent en place un serveur central qui contient tous les fichiers sous version, et des clients qui peuvent extraire les fichiers de ce dépot central. Pendant de nombreuses années, celà a été le standard pour la gestion de version (Cf. Figure 1-2).
+Le problème majeur que les gens rencontrent est qu'ils ont besoin de collaborer avec des développeurs sur d'autres ordinateurs.
+Pour traiter ce problème, les systèmes de gestion de version centralisés (CVCS en anglais pour *Centralized Version Control Systems*) furent développés.
+Ces systèmes tels que CVS, Subversion, et Perforce, mettent en place un serveur central qui contient tous les fichiers sous gestion de version, et des clients qui peuvent extraire les fichiers de ce dépôt central.
+Pendant de nombreuses années, cela a été le standard pour la gestion de version (voir Figure 1-2).
Insert 18333fig0102.png
Figure 1-2. Diagramme de la gestion de version centralisée.
-Ce schéma offre de nombreux avantages par rapport à la gestion de version locale. Par exemple, chacun sait jusqu'à un certain point ce que tout les autres sont en train de faire sur le projet. Les administrateurs ont un contrôle fin des permissions et il est beaucoup plus facile d'administrer un CVCS qu'il l'est de devoir gérer des bases de données locales.
+Ce schéma offre de nombreux avantages par rapport à la gestion de version locale.
+Par exemple, chacun sait jusqu'à un certain point ce que tout les autres sont en train de faire sur le projet.
+Les administrateurs ont un contrôle fin des permissions et il est beaucoup plus facile d'administrer un CVCS que de gérer des bases de données locales.
-Cependant ce système a aussi de nombreux défauts. Le plus visible est le point unique de panne que le serveur centralisé représente. Si ce serveur est en panne pendant une heure, alors durant cette heure, aucun client ne peut collaborer ou enregistrer les modifications issues de son travail. Si le disque dur du serveur central se corrompt, et s'il n'y a pas eu de sauvegarde, vous perdez absolument tout de l'historique d'un projet en dehors des sauvegardes locales que les gens auraient pu réaliser sur leur machines locales. Les systèmes de gestion de version locaux souffrent du même problème - dès qu'on a tout l'historique d'un projet sauvegardé à un endroit unique, on prend le risque de tout perdre.
+Cependant ce système a aussi de nombreux défauts.
+Le plus visible est le point unique de panne que le serveur centralisé représente.
+Si ce serveur est en panne pendant une heure, alors durant cette heure, aucun client ne peut collaborer ou enregistrer les modifications issues de son travail.
+Si le disque dur du serveur central se corrompt, et s'il n'y a pas eu de sauvegarde, vous perdez absolument tout de l'historique d'un projet en dehors des sauvegardes locales que les gens auraient pu réaliser sur leur machines locales.
+Les systèmes de gestion de version locaux souffrent du même problème - dès qu'on a tout l'historique d'un projet sauvegardé à un endroit unique, on prend le risque de tout perdre.
### Les systèmes de gestion de version distribués ###
-C'est à ce moment que les systèmes de gestion de version distribués entrent en jeu (DVCSs en anglais pour *Distributed Version Control Systems*). Dans un DVCS (tel que Git, Mercurial, Bazaar or Darcs), les clients n'extraient plus seulement la dernière version d'un fichier : il dupliquent complètement le dépot. Ainsi, si le serveur disparaît, et si les systèmes collaboraient via ce serveur, n'importe quel dépot d'un des clients peut être copié sur le serveur pour le restaurer. Chaque extraction devient une sauvegarde complète de toutes les données (cf. Figure 1-3).
+C'est à ce moment que les systèmes de gestion de version distribués entrent en jeu (DVCSs en anglais pour *Distributed Version Control Systems*).
+Dans un DVCS (tel que Git, Mercurial, Bazaar or Darcs), les clients n'extraient plus seulement la dernière version d'un fichier, mais ils dupliquent complètement le dépôt.
+Ainsi, si le serveur disparaît, et si les systèmes collaboraient via ce serveur, n'importe quel dépôt d'un des clients peut être copié sur le serveur pour le restaurer.
+Chaque extraction devient une sauvegarde complète de toutes les données (voir figure 1-3).
Insert 18333fig0103.png
Figure 1-3. Diagramme de gestion de version de contrôle centralisée.
-De plus, un grand nombre de ces systèmes gère particulièrement bien le fait d'avoir plusieurs dépots avec lesquels travailler, vous permettant de collaborer avec différents groupes de personnes de manière différentes simultanément dans le même projet. Celà permet la mise en place de différentes chaînes de traitement qui ne sont pas réalisables avec les systèmes centralisés, tels que les modèles hierarchiques.
+De plus, un grand nombre de ces systèmes gère particulièrement bien le fait d'avoir plusieurs dépôts avec lesquels travailler, vous permettant de collaborer avec différents groupes de personnes de manière différentes simultanément dans le même projet.
+Cela permet la mise en place de différentes chaînes de traitement qui ne sont pas réalisables avec les systèmes centralisés, tels que les modèles hiérarchiques.
## Une rapide histoire de Git ##
-Comme de nombreuses choses extraordinaires de la vie, Git est né avec une dose de destruction créative et de controverse houleuse. Le noyau Linux est un projet libre de grande envergure. Pour la plus grande partie de sa vie (1991–2002), les modifications étaient transmises sous forme de patchs et d'archives de fichiers. En 2002, le projet du kernel Linux commença à utiliser un DVCS propriétaire appelé BitKeeper.
+Comme de nombreuses choses extraordinaires de la vie, Git est né avec une dose de destruction créative et de controverse houleuse.
+Le noyau Linux est un projet libre de grande envergure.
+Pour la plus grande partie de sa vie (1991–2002), les modifications étaient transmises sous forme de patchs et d'archives de fichiers.
+En 2002, le projet du noyau Linux commença à utiliser un DVCS propriétaire appelé BitKeeper.
-En 2005, les relations entre la communinauté développant le noyau linux et la société en charge du développement de BitKeeper furent rompues, et le statut de gratuité de l'outil fut révoqué. Celà poussa la communauté du développement de Linux (et plus particulièrement Linus Torvalds, le créateur de Linux) à developper leur propre outil en se basant sur les leçons apprises lors de l'utilisation de BitKeeper. Certains des objectifs du nouveau système étaient les suivants :
+En 2005, les relations entre la communauté développant le noyau linux et la société en charge du développement de BitKeeper furent rompues, et le statut de gratuité de l'outil fut révoqué.
+Cela poussa la communauté du développement de Linux (et plus particulièrement Linus Torvalds, le créateur de Linux) à développer leur propre outil en se basant sur les leçons apprises lors de l'utilisation de BitKeeper.
+Certains des objectifs du nouveau système étaient les suivants :
* Vitesse
* Conception simple
* Support pour les développements non linéaires (milliers de branches parallèles)
* Complètement distribué
* Capacité à gérer efficacement des projets d'envergure tels que le noyau Linux (vitesse et compacité des données)
-Depuis sa naissance en 2005, Git a évolé et mûri pour être facile à utiliser mais en conservant cepandant ces qualités initiales. Il est incroyablement rapide, il est très efficace avec de grands projets et il a un incroyable système de branches pour des développements non-linéaires (voir chapitre 3).
+Depuis sa naissance en 2005, Git a évolué et mûri pour être facile à utiliser tout en conservant ses qualités initiales.
+Il est incroyablement rapide, il est très efficace pour de grands projets et il a un incroyable système de branches pour des développements non linéaires (voir chapitre 3).
## Rudiments de Git ##
-Donc, qu'est-ce que Git en quelques concepts ? Il est important de bien comprendre cette section, parce que si on comprend ce que Git est et les principes sur lesquels il repose, alors utiliser efficacement Git devient simple. Au cours de l'apprentissage de Git, essayez de libérer votre esprit de ce que vous pourriez connaître d'autres VCSs, tels que Subversion et Perforce ; ce faisant, vous vous éviterez de petites confusions à l'utilisation de cet outil. Git sauve et gère l'information très différemment des autres systèmes, même si l'interface utilisateur paraît similaire ; comprendre ses différences vous évitera des confusions à l'utilisation.
+Donc, qu'est-ce que Git en quelques mots ?
+Il est important de bien comprendre cette section, parce que si on comprend ce que Git est et les principes sur lesquels il repose, alors utiliser efficacement Git devient simple.
+Au cours de l'apprentissage de Git, essayez de libérer votre esprit de ce que vous pourriez connaître d'autres VCS, tels que Subversion et Perforce ;
+ce faisant, vous vous éviterez de petites confusions à l'utilisation de cet outil.
+Git enregistre et gère l'information très différemment des autres systèmes, même si l'interface utilisateur paraît similaire ;
+comprendre ces différences vous évitera des confusions à l'utilisation.
### Des instantanés, pas des différences ###
-La différence majeure entre Git et les autres VCSs (Subversion et autres) réside dans la manière dont Git considère les données. Au niveau conceptuel, la plupart des autres VCSs gèrent l'information comme une liste de modifications de fichiers. Ces systèmes (CVS, Subversion, Perforce, Bazaar, et autres) considèrent l'information qu'il gèrent comme une liste de fichiers et les modifications effectuées sur chaque fichier dans le temps, comme illustré en Figure 1-4.
+La différence majeure entre Git et les autres VCS (Subversion et autres) réside dans la manière dont Git considère les données.
+Au niveau conceptuel, la plupart des autres VCS gèrent l'information comme une liste de modifications de fichiers.
+Ces systèmes (CVS, Subversion, Perforce, Bazaar et autres) considèrent l'information qu'il gèrent comme une liste de fichiers et les modifications effectuées sur chaque fichier dans le temps, comme illustré en figure 1-4.
Insert 18333fig0104.png
-Figure 1-4. Les autres système tendent à sauvegarder l'information comme des modifications sur des fichiers d'origine.
+Figure 1-4. Les autres systèmes tendent à sauvegarder l'information comme des modifications sur des fichiers d'origine.
+
+Git ne gère pas et ne stocke pas les informations de cette manière.
+À la place, Git pense ses données plus comme un instantané d'un mini système de fichiers.
+A chaque fois que vous commitez ou enregistrez l'état du projet dans Git, il prend effectivement un instantané du contenu de votre espace de travail à ce moment et enregistre une référence à cet instantané.
+Pour être efficace, si les fichiers n'ont pas changé, Git ne stocke pas le fichier à nouveau, juste une référence vers le fichier original qui n'a pas été modifié.
+Git pense ses données plus à la manière de la figure 1-5.
-Git ne gère pas et ne stocke pas les informations de cette manière. A la place, Git pense ses données plus comme un instantané d'un mini système de fichiers. A chaque fois que vous commitez ou sauvez l'état du projet dan Git, il prend effectivement un instantané du contenu de votre espace de travail à ce moment et sauve une référence à cet instantané. Pour être efficace, si les fichiers n'ont pas changé, Git ne stocke pas le fichier à nouveau, juste une référence vers le fichier original qui n'a pas été modifié. Git pense ses données plus à la manière de la figure 1-5.
Insert 18333fig0105.png
Figure 1-5. Git stocke les données comme des instantanés du projet au cours du temps
-C'est une distinction importante entre Git et quasiment tous les autres VCSs. Celà permet à Git de reconsidérer quasiment tous les aspects de la gestion de version que la plupart des autres système ont copié des générations précédentes. Celà fait quasiment de Git un mini système de fichiers avec des outils incroyablement puissants construit par dessus, plutôt qu'un simple VCS. Nous explorerons les bénéfices qu'il y a à penser les données de cette manière quand nous aborderons la gestion de branches au Chapitre 3.
+C'est une distinction importante entre Git et quasiment tous les autres VCSs.
+Git a reconsidéré quasiment tous les aspects de la gestion de version que la plupart des autres système ont copié des générations précédentes.
+Cela fait quasiment de Git un mini système de fichiers avec des outils incroyablement puissants construits au-dessus, plutôt qu'un simple VCS.
+Nous explorerons les bénéfices qu'il y a à penser les données de cette manière quand nous aborderons la gestion de branches au chapitre 3.
+
+### Presque toutes les opérations sont locales ###
-### Presque toutes les opération sont locales ###
+La plupart des opérations de Git ne nécessite que des fichiers et ressources locales - généralement aucune information venant d'un autre ordinateur du réseau n'est nécessaire.
+Si vous êtes habitué à un CVCS où toutes les opérations sont ralenties par la latence des échanges réseau, cet aspect de Git vous fera penser que les dieux de la vitesse ont octroyé leurs pouvoirs à Git.
+Comme vous disposez de l'historique complet du projet localement sur votre disque dur, la plupart des opérations semblent instantanées.
-La plupart des opération sous Git ne nécessite que des fichiers et ressources locales - généralement aucune information venant d'un autre ordinateur du réseau n'est nécessaire. Si vous êtes habitué à un CVCS où toutes les opérations sont ralenties par la latence des échanges réseau, cet aspect de Git vous fera penser que les dieux de la vitesse ont octroyé à Git des pouvoirs divins de vitesse. Comme vous disposez de l'historique complet du projet localement sur votre disque dur, la plupart des opérations semblent instantanées.
+Par exemple, pour parcourir l'historique d'un projet, Git n'a pas besoin d'aller la chercher sur un serveur pour vous l'afficher ;
+il n'a qu'à simplement la lire directement dans votre base de donnée locale.
+Cela signifie que vous avez quasi-instantanément accès à l'historique du projet.
+Si vous souhaitez connaître les modifications introduites entre la version actuelle d'un fichier et son état un mois auparavant, Git peut rechercher l'état du fichier un mois auparavant et réaliser le calcul de différence, au lieu d'avoir à demander cette différence à un serveur ou à devoir récupérer l'ancienne version sur le serveur pour calculer la différence localement.
-Par exemple, pour parcourir l'historique d'un projet, Git n'a pas besoin d'aller la chercher sur un serveur pour vous l'afficher - Il n'a qu'à simplement la lire directement dans votre base de donnée locale. Celà signifie que vous avez quasi-instantanément accès à l'historique du projet.Si vous souhaitez connaître les modifications introduites entre la version actuelle d'un fichier et son état un mois auparavant, Git peut rechercher l'état du fichier un mois auparavant et réaliser le calcul de différence, au lieu d'avoir à demander cette différence à un serveur ou à devoir récupérer l'ancienne version sur le serveur pour calculer la différence localement.
+Cela signifie aussi qu'il y a très peu de choses que vous ne puissiez réaliser si vous n'êtes pas connecté ou hors VPN.
+Si vous voyagez en train ou en avion et voulez avancer votre travail, vous pouvez continuer à gérer vos versions sans soucis en attendant de pouvoir de nouveau vous connecter pour partager votre travail.
+Si vous êtes chez vous et ne pouvez avoir une liaison VPN avec votre entreprise, vous pouvez tout de même travailler.
+Pour de nombreux autres systèmes, faire de même est impossible ou au mieux très contraignant.
+Avec Perforce par exemple, vous ne pouvez pas faire grand'chose tant que vous n'êtes pas connecté au serveur.
+Avec Subversion ou CVS, vous pouvez éditer les fichiers, mais vous ne pourrez pas soumettre des modifications à votre base de données (car celle-ci est sur le serveur non accessible).
+Cela peut sembler peu important à priori, mais vous seriez étonné de découvrir quelle grande différence cela peut constituer à l'usage.
-Celà signifie aussi qu'il y a très peu de choses que vous ne puissiez réaliser si vous n'êtes pas connecté ou hors VPN. Si vous voyagez en train ou en avion et voulez avancer votre travail, vous pouvez continuer à gérer vos versions sans soucis en attendant de pouvoir de nouveau vous connecter pour partager votre travail. Si vous êtes chez vous et ne pouvez avoir une liaison VPN avec votre entreprise, vous pouvez tout de même travailler. Pour de nombreux autres systèmes, faire de même est au choix impossible ou vraiment très contraignant. Avec Perforce par éxemple, vous ne pouvez pas faire grand'chose tant que vous n'êtes pas connecté au serveur de version ; et avec Subversion ou CVS, vous pouvez éditer les fichiers, mais vous ne pourrez pas gérer de version dans votre base de données (car celle-ci est sur le serveur non accessible). Celà peut sembler peu important a priori, mais vous seriez étonné de découvrir quelle grande différence ça peut faire à l'usage.
### Git gère l'intégrité ###
-Dans Git,tout est vérifié par somme de contrôle avant d'être stocké et par la suite la somme de contrôle, signature unique, sert de référence. Celà signifie qu'il est impossible de modifier le contenu d'un fichier ou d'un répertoire sans que Git ne s'en aperçoive. Cette fonctionnalité est ancrée dans les fondations de Git et fait partie intégrante de sa philosphie. Vous ne pouvez pas perdre des données en cours de transfert ou corrompre un fichier sans que Git ne le détecte immédiatement.
+Dans Git, tout est vérifié par une somme de contrôle avant d'être stocké et par la suite cette somme de contrôle, signature unique, sert de référence.
+Cela signifie qu'il est impossible de modifier le contenu d'un fichier ou d'un répertoire sans que Git ne s'en aperçoive.
+Cette fonctionnalité est ancrée dans les fondations de Git et fait partie intégrante de sa philosophie.
+Vous ne pouvez pas perdre des données en cours de transfert ou corrompre un fichier sans que Git ne puisse le détecter.
-Le mécanisme que Git utilise pour réaliser les sommes de contrôle est appelé SHA-1. C'est une chaîne de caractères composée de 40 caractères héxadécimaux (de '0' à '9' et de 'a' à 'f') calculée en fonction du contenu du fichier ou de la structure du répertoire considéré. Une signature SHA-1 ressembe à ceci :
+Le mécanisme que Git utilise pour réaliser les sommes de contrôle est appelé une empreinte SHA-1.
+C'est une chaîne de caractères composée de 40 caractères hexadécimaux (de '0' à '9' et de 'a' à 'f') calculée en fonction du contenu du fichier ou de la structure du répertoire considéré.
+Une empreinte SHA-1 ressemble à ceci :
24b9da6552252987aa493b52f8696cd6d3b00373
-Vous trouverez ces valeurs à peu près partout dans Git car il les utilise pour tout. En fait, Git stocke tout non pas avec des noms de fichier, mais dans la base de données Git indéxée par ces valeurs.
+Vous trouverez ces valeurs à peu près partout dans Git car il les utilise pour tout.
+En fait, Git stocke tout non pas avec des noms de fichier, mais dans la base de données Git indexée par ces valeurs.
### Généralement, Git ne fait qu'ajouter des données ###
-Quand vous réalisez des actions dans Git, la quasi-totalité d'entre elles ne font qu'ajouter des données dans la base de données de Git. Il est très difficile de faire réaliser au système des actions qui ne soient pas réversibles ou de lui faire effacer des données d'une quelconque manière. Par contre, comme dans la plupart des systèmes de gestion de version, vous pouvez perdre ou corrompre des modifications qui n'ont pas encore été entrées en base ; mais dès que vous avez commité un instantané dans Git, il est très difficile de le perdre, spécialement si en plus vous synchronisez votre base de données locale avec un dépot distant.
+Quand vous réalisez des actions dans Git, la quasi-totalité d'entre elles ne font qu'ajouter des données dans la base de données de Git.
+Il est très difficile de faire réaliser au système des actions qui ne soient pas réversibles ou de lui faire effacer des données d'une quelconque manière.
+Par contre, comme dans la plupart des systèmes de gestion de version, vous pouvez perdre ou corrompre des modifications qui n'ont pas encore été entrées en base ;
+mais dès que vous avez commité un instantané dans Git, il est très difficile de le perdre, spécialement si en plus vous synchronisez votre base de données locale avec un dépôt distant.
-Celà fait de l'usage de Git un vrai plaisir, car on peut expérimenter sans danger de casser définitivement notre projet. Pour une information plus approfondie de la manière dont Git stocke ses données et de comment récupérer des données qui pourraient sembler perdues, référez-vous au chapitre 9 "Sous le capot".
+Cela fait de l'usage de Git un vrai plaisir, car on peut expérimenter sans danger de casser définitivement son projet.
+Pour une information plus approfondie sur la manière dont Git stocke ses données et comment récupérer des données qui pourraient sembler perdues, référez-vous au chapitre 9 "Sous le capot".
### Les trois états ###
-Ici, il faut être attentif. Il est primordial de se souvenir de ce qui suit si vous souhaitez que le reste de votre apprentissage s'effectue sans difficulté. Git gère trois états dans lequel les fichiers peuvent résider : commité, modifié et indexé. Commité signifie que les données sont stockées en sécurité dans votre base de données locale. Modifié signifie que vous avez modifié le fichier mais qu'il n'a pas encore été commité en base. Indéxé signifie que vous avez marqué un fichier modifié dans sa version actuelle pour qu'il fasse partie du prochain instantané du projet.
+Ici, il faut être attentif.
+Il est primordial de se souvenir de ce qui suit si vous souhaitez que le reste de votre apprentissage s'effectue sans difficulté.
+Git gère trois états dans lequel les fichiers peuvent résider : commité, modifié et indexé.
+Commité signifie que les données sont stockées en sécurité dans votre base de données locale.
+Modifié signifie que vous avez modifié le fichier mais qu'il n'a pas encore été commité en base.
+Indexé signifie que vous avez marqué un fichier modifié dans sa version actuelle pour qu'il fasse partie du prochain instantané du projet.
-Ceci nous mène aux trois sections principales d'un projet Git : le répertoire Git, le répertoire de travail et la zone d'index.
+Ceci nous mène aux trois sections principales d'un projet Git : le répertoire Git, le répertoire de travail et la zone d'index.
Insert 18333fig0106.png
Figure 1-6. Répertoire de travail, zone d'index et répertoire Git.
-Le répertoire Git est l'endroit où Git stocke les métadonnées et la base de données des objets de votre projet. C'est la partie la plus importante de Git, et c'est ce qui est copié lorsque vous clonez une dépot depuis un autre ordinateur.
+Le répertoire Git est l'endroit où Git stocke les méta-données et la base de données des objets de votre projet.
+C'est la partie la plus importante de Git, et c'est ce qui est copié lorsque vous clonez une dépôt depuis un autre ordinateur.
+
+Le répertoire de travail est une extraction unique d'un version du projet.
+Ces fichiers sont extraits depuis la base de données compressée dans le répertoire Git et placés sur le disque pour pouvoir être utilisés ou modifiés.
-Le répertoire de travail est une extraction unique d'un version du projet. Ces fichiers sont extraits depuis la base de données compressée dans le répertoire Git et placés sur le disque pour pouvoir être utilisés ou modifiés.
+La zone d'index est un simple fichier, généralement situé sans le répertoire Git, qui stocke les informations concernant ce qui fera partie du prochain instantané.
-La zone d'index est un simple fichier, généralement situé sans le répertoire Git, qui stocke les informations concernant ce qui fera partie du prochain instantané.
-L'utilisation standard de Git se passe comme suit :
+L'utilisation standard de Git se passe comme suit :
1. Vous modifiez des fichiers dans votre répertoire de travail
-2. Vous indéxez les fichiers modifiés, ce qui ajoute des instantanés de ces fichiers dans la zone d'index
+2. Vous indexez les fichiers modifiés, ce qui ajoute des instantanés de ces fichiers dans la zone d'index
3. Vous réalisez un commit, ce qui a pour effet de basculer les instantanés des fichiers de l'index dans la base de donnée du répertoire Git.
-Si une version particulière d'un fichier est dans le répertoire Git, il est considéré comme commité. S'il est modifié mais a été ajouté dans la zone d'index, il est indéxé. S'il a été modifié depuis le dernier instantané mais n'a pas été indéxé, il est modifié. Dans le chapitre 2, vous en apprendrez plus sur ces états et commment vous pouvez en tirer parti ou complètement les occulter.
+Si une version particulière d'un fichier est dans le répertoire Git, il est considéré comme commité.
+S'il est modifié mais a été ajouté dans la zone d'index, il est indexé.
+S'il a été modifié depuis le dernier instantané mais n'a pas été indexé, il est modifié.
+Dans le chapitre 2, vous en apprendrez plus sur ces états et comment vous pouvez en tirer parti ou complètement les occulter.
## Installation de Git ##
-Commençons donc à utiliser Git. La première des choses est de l'installer. Vous pouvez l'obtenir par de nombreuses manières ; les deux principales sont de l'installer à partir des sources ou d'installer un paquetage éxistant sur votre plateforme.
+Commençons donc à utiliser Git.
+La première chose à faire est de l'installer.
+Vous pouvez l'obtenir par de nombreuses manières ;
+les deux principales sont de l'installer à partir des sources ou d'installer un paquet existant sur votre plate-forme.
### Installation depuis les sources ###
-Si vous le pouvez, il est généralement mieux d'installer Git à partir des sources, car vous obtiendrez la version la plus récente. Chaque nouvelle version de Git tend à inclure des améliorations utiles de l'interface utilisateur, donc récupérer la toute dernière version est souvent le mieux si vous savez compiler des logiciels à partir des sources. Comme la plupart du temps les distributions contiennent des version très anciennes de logiciels, à moins que vous ne travailliez sur une distribution très récente ou que vous n'utilisiez des backports, une installation à partir des sources est gage de meilleur fonctionnement.
+Si vous le pouvez, il est généralement conseillé d'installer Git à partir des sources, car vous obtiendrez la version la plus récente.
+Chaque nouvelle version de Git tend à inclure des améliorations utiles de l'interface utilisateur, donc récupérer la toute dernière version est souvent la meilleure option si vous savez compiler des logiciels à partir des sources.
+Comme la plupart du temps les distributions contiennent des version très anciennes de logiciels, à moins que vous ne travailliez sur une distribution
+très récente ou que vous n'utilisiez des backports, une installation à partir des sources peut être le meilleur choix.
-Pour installer Git, vous avez besoin des bibliothèques suivantes : curl, zlib, openssl, expat, libiconv. Par éxemple, si vous avez un système d'exploitation qui utilise yum (tel que Fedora) ou apt-get (tel qu'un système basé sur Debian), vous pouvez utiliser les commandes suivantes pour installer les dépendances :
+Pour installer Git, vous avez besoin des bibliothèques suivantes : curl, zlib, openssl, expat, libiconv.
+Par exemple, si vous avez un système d'exploitation qui utilise yum (tel que Fedora) ou apt-get (tel qu'un système basé sur Debian), vous pouvez utiliser l'une des commandes suivantes pour installer les dépendances :
$ yum install curl-devel expat-devel gettext-devel \
openssl-devel zlib-devel
$ apt-get install libcurl4-gnutls-dev libexpat1-dev gettext \
libz-dev
-Quand vous avez toutes les dépendances nécessaires, vous pouvez poursuivre et télécharger la dernière version de Git depuis le site :
+Quand vous avez toutes les dépendances nécessaires, vous pouvez poursuivre et télécharger la dernière version de Git depuis le site :
http://git-scm.com/download
-Puis, compiler et installer :
+Puis, compiler et installer :
$ tar -zxf git-1.6.0.5.tar.gz
$ cd git-1.6.0.5
$ make prefix=/usr/local all
$ sudo make prefix=/usr/local install
-Après ceci, vous pouvez obtenir Git par Git lui-même pour le mises à jour :
+Après ceci, vous pouvez obtenir Git par Git lui-même pour les mises à jour :
$ git clone git://git.kernel.org/pub/scm/git/git.git
### Installation sur Linux ###
-Si vous souhaitez installer Git sur Linux via un installeur d'application, vous pouvez généralement le faire via le système de gestion de paquetage de base fourni avec votre distribution. Si vous êtes sur Fedora, vous pouvez utiliser yum :
+Si vous souhaitez installer Git sur Linux via un installateur d'application, vous pouvez généralement le faire via le système de gestion de paquet de base fourni avec votre distribution.
+Si vous êtes sur Fedora, vous pouvez utiliser yum :
$ yum install git-core
-Si vous êtes sur un système basé sur Debian, tel qu'Ubuntu, essayez apt-get :
+Si vous êtes sur un système basé sur Debian, tel qu'Ubuntu, essayez apt-get :
$ apt-get install git-core
### Installation sur Mac ###
-Il y a deux moyens simples d'installer Git sur Mac. Le plus simple et d'utiliser l'installateur graphique de Git que vous pouvez télécharger depuis les pages Google Code (Cf. Figure 1-7) :
+Il y a deux moyens simples d'installer Git sur Mac.
+Le plus simple et d'utiliser l'installateur graphique de Git que vous pouvez télécharger depuis les pages Google Code (voir figure 1-7) :
http://code.google.com/p/git-osx-installer
Insert 18333fig0107.png
Figure 1-7. Installateur OS X de Git.
-L'autre méthode consiste à installer Git par les MacPorts ((`http://www.macports.org`). Si vous avez installé MacPorts, installez Git par :
+L'autre méthode consiste à installer Git par les MacPorts (`http://www.macports.org`).
+Si vous avez installé MacPorts, installez Git par :
$ sudo port install git-core +svn +doc +bash_completion +gitweb
-Vous n'avez pas à ajouter tous les extras, mais vous souhaiterez surement inclure +svn dans le cas où vous chercheriez à utiliser Git avec des dépots Subversion (voir Chapitre 8).
+Vous n'avez pas à ajouter tous les extras, mais vous souhaiterez sûrement inclure +svn si vous êtes amené à utiliser Git avec des dépôts Subversion (voir chapitre 8).
### Installation sur Windows ###
-Installer Git sur Windows est très facile. Le projet msysGit fournit une des procédures d'installation les plus faciles. Téléchargez simplement le fichier exe d'installateur depuis la page Google Code, et lancez-le :
+Installer Git sur Windows est très facile.
+Le projet msysGit fournit une des procédures d'installation les plus simples.
+Téléchargez simplement le fichier exe d'installateur depuis la page Google Code, et lancez-le :
http://code.google.com/p/msysgit
Après son installation, vous avez à la fois la version en ligne de commande (avec un client SSH utile pour la suite) ou l'interface graphique standard.
## Paramétrage à la première utilisation de Git ##
-Maintenant que vous avez Git installé sur votre système, vous voudrez personnaliser votre environnement Git. Vous ne devriez avoir à réaliser ces réglages qu'une seule fois ; elles persisteront lors des mises à jour. Vous pouvez aussi les changer à tout instant en relançant les mêmes commandes.
+Maintenant que vous avez installé Git sur votre système, vous voudrez personnaliser votre environnement Git.
+Vous ne devriez avoir à réaliser ces réglages qu'une seule fois ;
+ils persisteront lors des mises à jour.
+Vous pouvez aussi les changer à tout instant en relançant les mêmes commandes.
-Git contient un outil appelé git config pour vous permettre de voir et modifier les variables de configuration qui contrôlent tous les aspects de l'apparence et du comportement de Git. Ces variables peuvent être stockées dans trois endroits différents :
+Git contient un outil appelé git config pour vous permettre de voir et modifier les variables de configuration qui contrôlent tous les aspects de l'apparence et du comportement de Git.
+Ces variables peuvent être stockées dans trois endroits différents :
-* Fichier `/etc/gitconfig` : Contient les valeurs pour tous les utilisateurs et tous les dépots du système. Si vous passez l'option `--system` à `git config`, il lit et écrit ce fichier spécifiquement.
-* Fichier `~/.gitconfig` : Spécifique à votre utilisateur. Vous pouvez forcer Git à lire et écrire ce fichier en passant l'option `--global`.
-* Fichier `config` dans le répertoire Git (c'est à dire, `.git/config`) du dépot en cours d'utilisation : spécifique au seul dépot en cours. Chaque niveau surcharge le niveau précédent, donc les valeurs dans `.git/config` surchargent celles de `/etc/gitconfig`.
+* Fichier `/etc/gitconfig` : Contient les valeurs pour tous les utilisateurs et tous les dépôts du système.
+Si vous passez l'option `--system` à `git config`, il lit et écrit ce fichier spécifiquement.
+* Fichier `~/.gitconfig` : Spécifique à votre utilisateur.
+Vous pouvez forcer Git à lire et écrire ce fichier en passant l'option `--global`.
+* Fichier `config` dans le répertoire Git (c'est à dire `.git/config`) du dépôt en cours d'utilisation : spécifique au seul dépôt en cours.
+Chaque niveau surcharge le niveau précédent, donc les valeurs dans `.git/config` surchargent celles de `/etc/gitconfig`.
-Sur les systèmes Windows, Git recherche le fichier `.gitconfig` dans le répertoire `$HOME` (`C:\Documents and Settings\$USER` la plupart du temps). Il recherche tout de même `/etc/gitconfig`, bien qu'il soit relatif à la racine MSys, qui se trouve où vous aurez décidé d'installer Git sur votre système Windows.
+Sur les systèmes Windows, Git recherche le fichier `.gitconfig` dans le répertoire `$HOME` (`C:\Documents and Settings\$USER` la plupart du temps).
+Il recherche tout de même `/etc/gitconfig`, bien qu'il soit relatif à la racine MSys, qui se trouve où vous aurez décidé d'installer Git sur votre système Windows.
### Votre identité ###
-La première chose à faire après l'installation de Git est de renseigner votre nom et votre adress e-mail. C'est important car tous les commits Git utilisent cette information et elle est indélébile dans tous les commits que vous pourrez manipuler :
+La première chose à faire après l'installation de Git est de renseigner votre nom et votre adresse e-mail.
+C'est important car tous les commits Git utilisent cette information et elle est indélébile dans tous les commits que vous pourrez manipuler :
$ git config --global user.name "John Doe"
$ git config --global user.email johndoe@example.com
-Encore une fois, cette étape n'est nécessaire qu'une fois si vous passez l'option `--global`, parce que Git utilisera toujours cette information pour tout ce que votre utilisateur fera sur ce système. Si vous souhaitez surcharger ces valeurs avec un nom ou une adresse e-mail différents pour un projet spécifique, vous pouvez lancer ces commandes sans option `--global` lorsque vous êtes dans ce projet.
+Encore une fois, cette étape n'est nécessaire qu'une fois si vous passez l'option `--global`, parce que Git utilisera toujours cette information pour tout ce que votre utilisateur fera sur ce système.
+Si vous souhaitez surcharger ces valeurs avec un nom ou une adresse e-mail différents pour un projet spécifique, vous pouvez lancer ces commandes sans option `--global` lorsque vous êtes dans ce projet.
### Votre éditeur de texte ###
-À présent que votre identité est renseignée, vous pouvez configurer l'éditeur de texte qui sera utilisé par défaut quand Git vous enjoint à taper un message. Par défaut, Git utilise votre éditeur par défaut au niveau système, qui est généralement Vi ou Vim. Si vous souhaitez utiliser un éditeur de texte différent, comme Emacs, vous pouvez faire ce qui suit :
+À présent que votre identité est renseignée, vous pouvez configurer l'éditeur de texte qui sera utilisé par défaut quand Git vous demande de saisir un message.
+Par défaut, Git utilise l'éditeur par défaut au niveau système, qui est généralement Vi ou Vim.
+Si vous souhaitez utiliser un éditeur de texte différent, comme Emacs, vous pouvez entrer ce qui suit :
$ git config --global core.editor emacs
-### Votre outil de diff ###
+### Votre outil de différences ###
-Une autre option utile est le paramétrage de l'outil de diff à utiliser pour la résolution des conflits de fusion. Supposons que vous souhaitiez utiliser vimdiff :
+Une autre option utile est le paramétrage de l'outil de différences à utiliser pour la résolution des conflits de fusion.
+Supposons que vous souhaitiez utiliser vimdiff :
$ git config --global merge.tool vimdiff
-Git accepte kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, et opendiff comme outils valides de fusion. Vous pouvez aussi paramétrer un outil personnalisé ; référez-vous au chapitre 7 pour plus d'information sur cette procédure.
+Git accepte kdiff3, tkdiff, meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, et opendiff comme outils valides de fusion.
+Vous pouvez aussi paramétrer un outil personnalisé ;
+référez-vous au chapitre 7 pour plus d'information sur cette procédure.
### Vérifier vos paramètres ###
-Si vous souhaitez vérifier vos réglages, vous pouvez utiliser la commande `git config --list` pour lister tous les réglages que Git a pu trouver jusqu'ici :
+Si vous souhaitez vérifier vos réglages, vous pouvez utiliser la commande `git config --list` pour lister tous les réglages que Git a pu trouver jusqu'ici :
$ git config --list
user.name=Scott Chacon
@@ -230,28 +336,32 @@ Si vous souhaitez vérifier vos réglages, vous pouvez utiliser la commande `git
color.diff=auto
...
-Vous pourrez voir certains paramètres apparaître plusieurs fois, car Git lit les mêmes paramètres depuis plusieurs fichiers (`/etc/gitconfig` et `~/.gitconfig`, par exemple). Git utilise la dernière valeur pour chaque paramètre.
+Vous pourrez voir certains paramètres apparaître plusieurs fois, car Git lit les mêmes paramètres depuis plusieurs fichiers (`/etc/gitconfig` et `~/.gitconfig`, par exemple).
+Git utilise la dernière valeur pour chaque paramètre.
-Vous pouvez aussi vérifier la valeur particulière utilisée d'un paramètre en tapant `git config {paramètre}`:
+Vous pouvez aussi vérifier la valeur effective d'un paramètre particulier en tapant `git config <paramètre>` :
$ git config user.name
Scott Chacon
## Obtenir de l'aide ##
-Si vous avez besoin d'aide pour utiliser Git, il y a trois moyens d'obtenir les pages de manuel (manpage) pour toutes les commandes de Git :
+Si vous avez besoin d'aide pour utiliser Git, il y a trois moyens d'obtenir les pages de manuel pour toutes les commandes de Git :
$ git help <verbe>
- $ git <verb> --help
+ $ git <verbe> --help
$ man git-<verbe>
-
-Par exemple, vous pouvez obtenir la page de manuel pour la commande config en lançant :
+
+Par exemple, vous pouvez obtenir la page de manuel pour la commande config en lançant :
$ git help config
Ces commandes sont vraiment sympathiques car vous pouvez y accéder depuis partout, y compris hors connexion.
-Si les manpages et ce livre ne sont pas suffisants, vous pouvez essayer les canaux `#git` ou `#github` sur le serveur IRC Freenode (irc.freenode.net). Ces canaux sont régulièrement peuplés de centaines de personnes qui ont une bonne connaissance de Git et sont souvent prêtes à aider.
+Si les pages de manuel et ce livre ne sont pas suffisant, vous pouvez essayer les canaux `#git` ou `#github` sur le serveur IRC Freenode (irc.freenode.net).
+Ces canaux sont régulièrement peuplés de centaines de personnes qui ont une bonne connaissance de Git et sont souvent prêtes à aider.
## Résumé ##
-Vous devriez avoir à présent une compréhension initiale de ce que Git est et en quoi il est différent des CVCS que vous pourriez déjà avoir utilisés. Vous devriez aussi avoir une version de Git en état de fonctionnement sur votre système, paramétrée avec votre identité. Il est temps d'apprendre les bases d'utilisation de Git.
+Vous devriez avoir à présent une compréhension initiale de ce que Git est et en quoi il est différent des CVCS que vous pourriez déjà avoir utilisés.
+Vous devriez aussi avoir une version de Git en état de fonctionnement sur votre système, paramétrée avec votre identité.
+Il est temps d'apprendre les bases d'utilisation de Git.
View
821 fr/02-git-basics/01-chapter2.markdown
517 additions, 304 deletions not shown because the diff is too large. Please use a local Git client to view these changes.
View
77 fr/03-git-branching/01-chapter3.markdown
@@ -1,61 +1,88 @@
-# Git Branching #
+# Les branches avec Git #
-Nearly every VCS has some form of branching support. Branching means you diverge from the main line of development and continue to do work without messing with that main line. In many VCS tools, this is a somewhat expensive process, often requiring you to create a new copy of your source code directory, which can take a long time for large projects.
+Quasiment tous les VCSs ont une forme ou une autre de gestion de branche.
+Faire une branche signifie diverger de la ligne principale de développement et continuer à travailler sans se préoccuper de cette ligne principale.
+Dans de nombreux outils de gestion de version, cette fonctionnalité est souvent chère en ressources, et nécessite souvent de créer une nouvelle copie du répertoire de travail, ce qui peut prendre longtemps dans le cas de grands projets.
-Some people refer to the branching model in Git as its “killer feature,” and it certainly sets Git apart in the VCS community. Why is it so special? The way Git branches is incredibly lightweight, making branching operations nearly instantaneous and switching back and forth between branches generally just as fast. Unlike many other VCSs, Git encourages a workflow that branches and merges often, even multiple times in a day. Understanding and mastering this feature gives you a powerful and unique tool and can literally change the way that you develop.
+De nombreuses personnes font référence au modèle de gestion de branche de Git comme LA fonctionnalité et c'est surement la spécificité de Git par rapport à la communauté des gestionnaires de version.
+Pourquoi est-elle si spéciale ?
+La méthode de Git pour gérer les branches est particulièrement légère, permettant de réaliser des embranchements quasi-instantanément et de basculer de branche généralement aussi rapidement.
+À la différence de nombreux autres gestionnaires de version, Git encourage à travailler avec des méthodes qui privilègient la creation et la fusion de branches, jusqu'à plusieurs fois par jour.
+Bien comprendre et maîtriser cette fonctionnalité est un atout pour faire de Git un outil unique qui peut littéralement changer la manière de développer.
-## What a Branch Is ##
+## Ce qu'est une branche ##
-To really understand the way Git does branching, we need to take a step back and examine how Git stores its data. As you may remember from Chapter 1, Git doesn’t store data as a series of changesets or deltas, but instead as a series of snapshots.
+Pour réellement comprendre comment Git gère les branches, nous devons revenir en arrière et examiner de plus près comment Git stocke ses données.
+Comme vous pouvez vous en souvenir du chapitre 1, Git ne stocke pas ses données comme une série de changesets ou deltas, mais comme une série d'instantanés.
-When you commit in Git, Git stores a commit object that contains a pointer to the snapshot of the content you staged, the author and message metadata, and zero or more pointers to the commit or commits that were the direct parents of this commit: zero parents for the first commit, one parent for a normal commit, and multiple parents for a commit that results from a merge of two or more branches.
+Lors qu'on valide dans Git, Git stock un objet commit qui contient un pointeur vers l'instantané du contenu qui a été indexé, les métadonnées d'auteur et de message, et zéro ou plusieurs pointeurs vers le ou les commits qui sont les parents directs de ce commit :
+zéro parent pour la première validation, un parent pour un commit normal, et des parents multiples pour des commits qui sont le résultat de la fusion d'une ou plusieurs branches.
-To visualize this, let’s assume that you have a directory containing three files, and you stage them all and commit. Staging the files checksums each one (the SHA-1 hash we mentioned in Chapter 1), stores that version of the file in the Git repository (Git refers to them as blobs), and adds that checksum to the staging area:
+Pour visualiser ce concept, supposons un répertoire contenant trois fichiers, ces trois fichiers étant indexés puis validés.
+Indexer les fichiers signifie calculer la somme de contrôle pour chacun (la fonction de hachage SHA-1 mentionnée au chapitre 1), stocker cette version du fichier dans le dépot Git (Git les nomme blobs), et ajouter la somme de contrôle à la zone d'index :
- $ git add README test.rb LICENSE
- $ git commit -m 'initial commit of my project'
+ $ git add LISEZMOI test.rb LICENSE
+ $ git commit -m 'commit initial de mon projet'
-When you create the commit by running `git commit`, Git checksums each subdirectory (in this case, just the root project directory) and stores those tree objects in the Git repository. Git then creates a commit object that has the metadata and a pointer to the root project tree so it can re-create that snapshot when needed.
+Lorsque vous créez le commit en lançant la commande `git commit`, Git calcule la somme de contrôle de chaque répertoire (ici, seulement pour le répertoire racine) et stocke ces objets arbres dans le dépot Git.
+Git crée alors un objet commit qui contient les méta-données et un pointeur vers l'arbre projet d'origine de manière à pouvoir recréer l'instantané si besoin.
-Your Git repository now contains five objects: one blob for the contents of each of your three files, one tree that lists the contents of the directory and specifies which file names are stored as which blobs, and one commit with the pointer to that root tree and all the commit metadata. Conceptually, the data in your Git repository looks something like Figure 3-1.
+Votre dépot Git contient à présent cinq objets :
+un blob pour le contenu de chacun des trois fichiers, un arbre qui liste les contenus des répertoires et spécifie quels noms de fichier sont attachés à quels blobs, et un objet commit avec le pointeur vers l'arbre d'origine et toutes les méta-données attachées au commit.
+Conceptuellement, les données contenues dans votre dépôt git ressemblent à la Figure 3-1.
Insert 18333fig0301.png
-Figure 3-1. Single commit repository data.
+Figure 3-1. Données d'un unique commit.
-If you make some changes and commit again, the next commit stores a pointer to the commit that came immediately before it. After two more commits, your history might look something like Figure 3-2.
+Si vous réalisez des modifications et validez à nouveau, le prochain commit stocke un pointeur vers le commit immédiatement précédent.
+Après deux autres validations, l'historique pourrait ressembler à la figure 3-2.
Insert 18333fig0302.png
-Figure 3-2. Git object data for multiple commits.
+Figure 3-2. Données et objets Git pour des validations multiples.
-A branch in Git is simply a lightweight movable pointer to one of these commits. The default branch name in Git is master. As you initially make commits, you’re given a master branch that points to the last commit you made. Every time you commit, it moves forward automatically.
+Une branche dans Git est tout simplement un pointeur mobile léger vers un de ces objets commit.
+La branche par défaut dans Git s'appelle master.
+Au fur et à mesure des validations, la branche master pointe vers le dernier des commits réalisés.
+À chaque validation, le pointeur de la branche master avance automatiquement.
Insert 18333fig0303.png
-Figure 3-3. Branch pointing into the commit data’s history.
+Figure 3-3.
+Branche pointant dans l'historique des données de commit.
-What happens if you create a new branch? Well, doing so creates a new pointer for you to move around. Let’s say you create a new branch called testing. You do this with the `git branch` command:
+Que se passe-t-il si vous créez une nouvelle branche ?
+Et bien, cela crée un nouveau pointeur à déplacer.
+Supposons que vous créez une nouvelle branche nommée testing.
+Vous utilisez la commande `git branch` :
$ git branch testing
-This creates a new pointer at the same commit you’re currently on (see Figure 3-4).
+Cela crée un nouveau pointeur vers le commit actuel (Cf. figure 3-4).
Insert 18333fig0304.png
-Figure 3-4. Multiple branches pointing into the commit’s data history.
+Figure 3-4. Branches multiples pointant dans l'historique des données de commit.
-How does Git know what branch you’re currently on? It keeps a special pointer called HEAD. Note that this is a lot different than the concept of HEAD in other VCSs you may be used to, such as Subversion or CVS. In Git, this is a pointer to the local branch you’re currently on. In this case, you’re still on master. The git branch command only created a new branch — it didn’t switch to that branch (see Figure 3-5).
+Comment Git connaît-il la branche sur laquelle vous vous trouvez ?
+Il conserve un pointeur spécial appelé HEAD.
+Remarquez que sous cette appellation se cache un concept très différent de celui utilisé dans les autres VCSs tels que Subversion ou CVS.
+Dans Git, c'est un pointeur sur la branche locale où vous vous trouvez.
+Dans notre cas, vous vous trouvez toujours sur master.
+La commande git branch n'a fait que créer une nouvelle branche — elle n'a pas fait basculer la copie de travail vers cette branche (Cf. figure 3-5).