ഗിറ്റ് #1- അടിസ്ഥാനങ്ങൾ

ബാലശങ്കർ സി under പരമ്പര on 27 ഡിസംബർ, 2014

വികേന്ദ്രീകൃത പതിപ്പ് കൈകാര്യ സംവിധാനമായ (Decentralized version control system) ആയ ഗിറ്റിനെ പരിചയപ്പെടുത്തുന്ന ഒരു ലേഖന പരമ്പര തുടങ്ങുകയാണു്. സ്കോട്ട് ചാക്കോണും ബെൻ സ്ട്രോബും (Scott Chacon and Ben Straub) ചേർന്ന് രചിച്ച പ്രോ ഗിറ്റ് എന്ന പുസ്തകത്തെ അടിസ്ഥാനമാക്കിയാണ് ഈ പരമ്പര പുരോഗമിക്കുന്നത്. കഴിയുന്നത്ര ഉദാഹരണങ്ങൾ ഉൾക്കൊള്ളിച്ചുകൊണ്ട് ഗിറ്റിന്റെ വിവിധ പ്രവർത്തനമേഖലകൾ വിശദീകരിക്കാൻ ശ്രമിക്കുന്നതായിരിക്കും. സംശയങ്ങൾ, വിശദീകരണാഭ്യർത്ഥനകൾ, പിഴവുകൾ ചൂണ്ടിക്കാട്ടൽ എന്നിവ ക്ഷണിക്കുന്നു.

ഗിറ്റിന്റെ ചരിത്രത്തിൽ നിന്നു് തന്നെ തുടങ്ങാം. ലിനക്സ് കേർണലിന്റെ ഉപജ്ഞാതാവായ ലിനസ് ടോർവാൾഡ്സ് ആണ് ഗിറ്റിന്റേയും പിതാവ്. കേർണലിന്റെ വികസനത്തിന്റെ പ്രാരംഭഘട്ടങ്ങളിൽ സോഫ്റ്റ്‌വെയറിൽ വരുത്തേണ്ട മാറ്റങ്ങൾ‌ നിരവധി മാർഗ്ഗങ്ങൾ ഉപയോഗിച്ച് (ഈമെയിൽ, വ്യക്തിപരമായ കൈമാറ്റം) ആണ് നടത്തിയിരുന്നത്. ഏതാണ്ട് 2002 ആയപ്പോൾ ലിനക്സ് വികസനം, അന്ന് നിലനിന്നിരുന്ന ബിറ്റ്കീപ്പർ എന്ന ഒരു പ്രൊപ്രൈറ്ററി വേർഷൻ കണ്ട്രോൾ സിസ്റ്റത്തിലേക്ക് മാറി. ഏതാണ്ട് 2005 വരെ ഇത് തുടർന്നു. ശേഷം ലിനക്സ് സമൂഹവും ബിറ്റ്‌കീപ്പർ കമ്പനിയുമായുള്ള ബന്ധം വഷളാവുകയും, ബിറ്റ്കീപ്പറിന്റെ “സൗജന്യം” എന്ന നേട്ടം നീക്കം ചെയ്യപ്പെടുകയും ചെയ്തു. ഈ കാരണത്താൽ ബിറ്റ്കീപ്പറിനു് പകരം മറ്റൊരു സംവിധാനത്തിന്റെ ആവശ്യം ഉണ്ടാവുകയും അത് സഫലീകരിക്കാൻ ലിനസ് ടോർവാൾഡ്സ് ഗിറ്റിനു്‌ ജന്മം നൽകുകയും ചെയ്തു. അന്നു് മുതൽ ഇങ്ങോട്ട് ഗിറ്റ് വളരെയധികം വളരുകയും പുരോഗമിക്കുകയും മെച്ചപ്പെടുകയും ചെയ്തിട്ടുണ്ട്. സമാന്തരമായ വികസനം, സഹകരണപരമായുള്ള വികസനം (Parallel development, collaborative development) എന്നിങ്ങനെയുള്ള വികസനരീതികളിൽ ഉപയോഗിക്കപ്പെടുന്ന സോഫ്റ്റ്‌വെയറുകളിൽ ഗിറ്റ് മുന്നിട്ടു നിൽക്കുന്നു.

ആദ്യമായി ഗിറ്റ് എങ്ങനെ ഇൻസ്റ്റാൾ ചെയ്യാം എന്ന് നോക്കാം. ഗിറ്റ് ഉപയോഗിക്കുന്നതിനു്‌ നിരവധി ഗ്രാഫിക്കൽ ടൂളുകൾ ഉണ്ടെങ്കിലും കൂടുതൽ ശക്തിയുള്ളതിനാലും ഏതൊരു ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തിലും സമാനമായി ഉപയോഗിക്കാം എന്നുള്ളതിനാലും കമാൻഡ് ലൈൻ വഴിയുള്ള കൈകാര്യം ചെയ്യലായിരിക്കും നമ്മൾ പിന്തുടരുന്നതു്.

  1. ഗ്നു/ലിനക്സിൽ -
    1. ഫെഡോറ അടിസ്ഥാനമാക്കിയുള്ള ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളിൽ - yum install git
    2. ഡെബിയൻ അടിസ്ഥാനമാക്കിയുള്ള (ഉബുണ്ടു മുതലായവ) ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളിൽ - apt-get install git

    എന്നീ ആജ്ഞകൾ ഉപയോഗിച്ച് ഗിറ്റ് ഇൻസ്റ്റാൾ ചെയ്യാം

  2. വിൻഡോസിൽ Git for Windows എന്ന സോഫ്റ്റ്‌വെയർ ഇൻസ്റ്റാൾ ചെയ്ത് ഗിറ്റ് ഉപയോഗിക്കാവുന്നതാണ് - http://git-scm.com/download/win

  3. ആപ്പിൾ മാകിൽ XCode Command Line Tools ഉപയോഗിച്ച് ഗിറ്റ് ഇൻസ്റ്റാൾ ചെയ്യാവുന്നതാണു്. ടെർമിനലിൽ git എന്നു് കൊടുത്താൽ ഗിറ്റ് ഇൻസ്റ്റാൾ ചെയ്തിട്ടില്ലെങ്കിൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ ഉള്ള അവസരം ലഭിക്കുന്നതാണു്.

ഈ ലേഖനം സ്വതന്ത്ര ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തിനെ അടിസ്ഥാനമാക്കിയായിരിക്കും മുന്നോട്ട് പോകുക (ക്ഷമിച്ചേ ഒക്കൂ, എന്റെ കയ്യിൽ തൽക്കാലം വിൻഡോസ്/മാക് ഉള്ള കമ്പ്യൂട്ടറൊന്നും ഇല്ല)

ഗിറ്റ് ഇൻസ്റ്റാൾ ചെയ്തതിനു് ശേഷം ചെയ്യാവുന്ന ആദ്യകാര്യം നിങ്ങളുടെ യൂസർനെയിമും ഈമെയിൽ വിലാസവും ഗിറ്റിനെ അറിയിക്കുക എന്നാണു്. നിങ്ങൾ ഓരോ തവണ ഗിറ്റിൽ എന്തെങ്കിലും സൂക്ഷിക്കുമ്പോളും ആ വിവരങ്ങൾ ഉപയോഗിക്കും. അവ ക്രമീകരിക്കുന്നതിനായി താഴെ പറയുന്ന ആജ്ഞകൾ ഉപയോഗിക്കാം ( $ എന്നത് ടൈപ്പ് ചെയ്യണ്ട.. അത് നമ്മുടെ ഷെൽ നമുക്ക് തരുന്ന പ്രോംറ്റ് ആണ്)

$ git config --global user.name "Gopalan Kutty"
$ git config --global user.email gopalankutty@example.com

ഇതിൽ ആദ്യത്തെ ഭാഗം git എന്നതാണു്. ഗിറ്റിനെ ക്രമീകരിക്കാൻ ഉപയോഗിക്കുന്ന എല്ലാ ആജ്ഞകളും ഈ വാക്ക് ഉപയോഗിച്ചാണു് തുടങ്ങുന്നത്. config എന്നതു് കൊണ്ട്‌ നമ്മൾ ഗിറ്റിന്റെ ക്രമീകരണം മാറ്റുകയാണു് എന്നറിയിക്കുന്നു. --global ഉപയോഗിച്ച് സിസ്റ്റത്തിൽ ആകമാനം ഇനി പറയുന്ന ക്രമീകരണം നടപ്പിലാക്കുക എന്നും പറയുന്നു. ബാക്കി വായിച്ചാൽ മനസ്സിലാവുന്നതേയുള്ളു എന്ന് കരുതുന്നു.

$ git config --list

എന്ന ആജ്ഞ കൊടുത്താൽ ക്രമീകരണങ്ങൾ കാണുവാനും അതുവഴി അവ ശരിയാണോയെന്ന് പരിശോധിക്കുവാനും സാധിക്കും.

ഇപ്പോൾ നമ്മുടെ സിസ്റ്റം ഗിറ്റ് ഉപയോഗിക്കാൻ സജ്ജമായി കഴിഞ്ഞു. ഇനി നമുക്ക് ഗിറ്റിന്റെ അടിസ്ഥാനങ്ങളിലേക്ക് കടക്കാം. ഗിറ്റുമായി പരിചയപ്പെട്ട് തുടങ്ങുമ്പോൾ തന്നെ കേൾക്കുന്ന ഒരു പദമാണ് “റെപ്പോസിറ്ററി” (repository). ഗിറ്റ് നമ്മൾ ഉപയോഗിക്കുന്നത് സോഴ്സ് ഫയലുകൾ സൂക്ഷിക്കാനാണെന്ന് (മറ്റു പലതിനും കൂടിയാണെന്ന് മറക്കരുത്) പറഞ്ഞല്ലോ. ഏതൊരു വസ്തുവും സൂക്ഷിച്ചുവെക്കാൻ ഒരു പെട്ടി വേണമല്ലോ. അത്തരത്തിൽ ഉള്ള പെട്ടികളാണ് ഗിറ്റ് റെപ്പോസിറ്ററികൾ. റെപ്പോസിറ്ററികളാണ് ഏതൊരു ഗിറ്റ് സിസ്റ്റത്തിന്റേയും അടിത്തറ. അപ്പോൾ, ഗിറ്റ് ഉപയോഗിച്ചു തുടങ്ങണമെങ്കിൽ രണ്ട് വഴികളുണ്ട്. ഒന്നുകിൽ പുതിയ ഒരു റെപ്പോസിറ്ററി നിർമ്മിക്കുക അല്ലെങ്കിൽ നിലവിലുള്ള ഒരു റെപ്പോസിറ്ററി ഉപയോഗിക്കുക. ആദ്യം നമുക്ക് പുതിയ ഒരു റെപ്പോസിറ്ററി എങ്ങനെ നിർമ്മിക്കാം എന്ന് നോക്കാം

ഇതിനായി ആദ്യമായി നമ്മുടെ ഫയലുകൾ സൂക്ഷിക്കാനായി ഒരു അറ അഥവാ ഡയറക്ടറി നിർമ്മിക്കുക

$ mkdir myapp

ഇനി ആ അറയിലേക്ക് കടക്കുക

$ cd myapp

ഒരു റെപ്പോസിറ്ററി തുടങ്ങുന്നതിനായി അഥവാ initialize ചെയ്യുന്നതിനായി താഴെ പറയുന്ന ആജ്ഞ ഉപയോഗിക്കാം

$ git init

ഇപ്പോൾ ആ അറ ഒരു ഗിറ്റ് റെപ്പോസിറ്ററി ആയിക്കഴിഞ്ഞിരിക്കുന്നു. ആ അറയിലെ ഉള്ളടക്കം നോക്കിയാൽ .git എന്നൊരു അദൃശ്യമായ അറ ഉണ്ടെന്ന് (ls -a എന്ന ആജ്ഞ നൽകിയാൽ മതി) കാണാം. ആ റെപ്പോസിറ്ററിയെ സംബന്ധിച്ച വിവരങ്ങളും ക്രമീകരണങ്ങളും ആ അറയ്ക്കുള്ളിലാണ് സൂക്ഷിച്ചിരിക്കുന്നതു്. അതിനെ പറ്റി പിന്നീട് വിശദമായി സംസാരിക്കാം.

ഗിറ്റിനെ സംബന്ധിച്ച് മൂന്ന് അവസ്ഥകളാണ് നമ്മൾ പരിചയപ്പെടേണ്ടത്. Working Directory, Staging Area, Commit. ഇവയെ എളുപ്പത്തിൽ മനസ്സിലാക്കാനായി ഇങ്ങനെ കരുതാം - വർക്കിങ്ങ് ഡയറക്ടറി എന്ന് പറഞ്ഞാൽ നമ്മൾ പണിയെടുക്കുന്ന മേശപ്പുറം, സ്റ്റേജിങ്ങ് ഏരിയ എന്ന് പറഞ്ഞാൽ മേൽപറഞ്ഞ മേശപ്പുറത്തു് നിന്നും ഇപ്പോഴത്തെ അവസ്ഥയിലുള്ള എല്ലാ ഫയലുകളെയും കൂടെ ഒരു പൊതിയാക്കിയ അവസ്ഥ. കമ്മിറ്റ് എന്ന് പറഞ്ഞാൽ ഈ പൊതികളെ നമ്മുടെ റെപ്പോസിറ്ററി ആകുന്ന പെട്ടിയിലേക്ക് ഇടുന്നതും.

(ഇവിടെ ഓർക്കേണ്ട ഒരു കാര്യം, നമ്മൾ ഫയലുകളെ അതുപോലെ എടുത്തല്ല പൊതിയുന്നതും പെട്ടിയിലേക്കിടുന്നതും. പകരം ഓരോ ഫയലിന്റേയും അതാത് സമയത്തുള്ള രൂപത്തെയാണ്. യഥാർത്ഥ ഫയൽ നമ്മുടെ അറയ്ക്കകത്ത് തന്നെ ഉണ്ടാകും).

ഒരു ഫയലിനെ സംബന്ധിച്ച് അത് ഈ ഘട്ടങ്ങൾ ഒക്കെ കടന്നാണ് റെപ്പോയിൽ എത്തുക. ആദ്യം അതിനെ എടുത്ത് മേശപ്പുറത്ത് വെക്കും, പിന്നെ അതിൽ പണിയെടുക്കും, അങ്ങനെ മറ്റു ഫയലുകളേയും, എല്ലാം കഴിഞ്ഞാൽ എല്ലാത്തിനേയും കൂടെ ഒരു പൊതിയാക്കും, എന്നിട്ട് ഒരു പെട്ടിയിലേക്കിടും .

ഒരു ഫയലിനു് നാല് രീതിയിൽ ഒരു റെപ്പോയിൽ പ്രത്യക്ഷപ്പെടാം:

  1. Untracked - ആ ഫയലിൽ എന്ത് സംഭവിക്കുന്നു എന്ന് ഗിറ്റ് നോക്കുന്നില്ല.
  2. Unmodified - ഗിറ്റിൽ സൂക്ഷിച്ചിരിക്കുന്ന (കമ്മിറ്റ് ചെയ്തിരിക്കുന്ന) അവസ്ഥയിൽ നിന്ന് ആ ഫയലിനു് ഒരു മാറ്റവും സംഭവിച്ചിട്ടില്ല.
  3. Modified - ഗിറ്റിൽ സൂക്ഷിച്ചിരിക്കുന്ന (കമ്മിറ്റ് ചെയ്തിരിക്കുന്ന) അവസ്ഥയിൽ നിന്ന് ആ ഫയലിനു് മാറ്റം സംഭവിച്ചിട്ടുണ്ട് എന്നാൽ ആ മാറ്റം സ്റ്റേജ് ഏരിയയിൽ എത്തിയിട്ടില്ല അതിനാൽ തന്നെ കമ്മിറ്റ് ചെയ്യപ്പെടാനും പോകുന്നില്ല..
  4. Staged - ഫയലിനു് കമ്മിറ്റ് ചെയ്ത അവസ്ഥയിൽ നിന്നും മാറ്റം വരികയും, ആ മാറ്റത്തിനെ കമ്മിറ്റ് ചെയ്യപ്പെടാവുന്ന രീതിയിൽ സ്റ്റേജിങ്ങ് ഏരിയയിൽ എത്തിച്ചിരിക്കുകയും ചെയ്തിരിക്കുന്നു ഒരു ഫയൽ കമ്മിറ്റ് ചെയ്തുകഴിഞ്ഞാൽ അത് തനിയേ Unmodified അവസ്ഥയിലേക്ക് മാറും.

അടുത്ത ലക്കത്തിൽ ഫയൽ ഈ വിവിധ അവസ്ഥകളിൽ എത്തുന്നതു് (എത്തിക്കുന്നതു്) എങ്ങനെയെന്ന് നോക്കാം.