doc/source/en/glossary.xml

   1 <?xml version="1.0" encoding="UTF-8"?>\r
   2 <!DOCTYPE glossary SYSTEM "../dtd/dblite.dtd">\r
   3 <!--\r
   4  Enter Glossary definitions in alphabetical Order! \r
   5  DocBook doesn't sort them automatically.\r
   6 -->\r
   7 <glossary id="tsvn-glossary">\r
   8         <title>Glossary</title>\r
   9         <glossentry>\r
  10                 <glossterm>Add</glossterm>\r
  11                 <glossdef>\r
  12                         <para>\r
  13                                 A Subversion command that is used to add a\r
  14                                 file or directory to your working copy.\r
  15                                 The new items are added to the repository when you commit.\r
  16                         </para>\r
  17                 </glossdef>\r
  18         </glossentry>\r
  19         <glossentry>\r
  20                 <glossterm>BASE revision</glossterm>\r
  21                 <glossdef>\r
  22                         <para>\r
  23                                 The current base revision of a file or folder in your <emphasis>working copy</emphasis>. \r
  24                                 This is the revision the file or folder was in, when the last checkout,\r
  25                                 update or commit was run. The BASE revision is normally not equal to the\r
  26                                 HEAD revision.\r
  27                         </para>\r
  28                 </glossdef>\r
  29         </glossentry>\r
  30         <glossentry>\r
  31                 <glossterm>Blame</glossterm>\r
  32                 <glossdef>\r
  33                         <para>\r
  34                                 This command is for text files only, and it annotates every line to\r
  35                                 show the repository revision in which it was last changed, and the\r
  36                                 author who made that change. Our GUI implementation is called\r
  37                                 TortoiseBlame and it also shows the commit date/time and the\r
  38                                 log message when you hover the mouse of the revision number.\r
  39                         </para>\r
  40                 </glossdef>\r
  41         </glossentry>\r
  42         <glossentry>\r
  43                 <glossterm>BDB</glossterm>\r
  44                 <glossdef>\r
  45                         <para>\r
  46                                 Berkeley DB. A well tested database backend for repositories, that\r
  47                                 cannot be used on network shares. Default for pre 1.2 repositories.\r
  48                         </para>\r
  49                 </glossdef>\r
  50         </glossentry>\r
  51         <glossentry>\r
  52                 <glossterm>Branch</glossterm>\r
  53                 <glossdef>\r
  54                         <para>\r
  55                                 A term frequently used in revision control systems to describe\r
  56                                 what happens when development forks at a particular point and\r
  57                                 follows 2 separate paths. You can create a branch off the main\r
  58                                 development line so as to develop a new feature without rendering\r
  59                                 the main line unstable. Or you can branch a stable release to which\r
  60                                 you make only bug fixes, while new developments take place on the\r
  61                                 unstable trunk. In Subversion a branch is implemented as a\r
  62                                 <quote>cheap copy</quote>.\r
  63                         </para>\r
  64                 </glossdef>\r
  65         </glossentry>\r
  66         <glossentry>\r
  67                 <glossterm>Checkout</glossterm>\r
  68                 <glossdef>\r
  69                         <para>\r
  70                                 A Subversion command which creates a local working copy in an empty\r
  71                                 directory by downloading versioned files from the repository.\r
  72                         </para>\r
  73                 </glossdef>\r
  74         </glossentry>\r
  75         <glossentry>\r
  76                 <glossterm>Cleanup</glossterm>\r
  77                 <glossdef>\r
  78                         <para>\r
  79                                 To quote from the Subversion book:\r
  80                                 <quote>\r
  81                                         Recursively clean up the working copy, removing locks and resuming\r
  82                                         unfinished operations. If you ever get a\r
  83                                         <emphasis>working copy locked</emphasis> error,\r
  84                                         run this command to remove stale locks and get your working copy\r
  85                                         into a usable state again.\r
  86                                 </quote>\r
  87                                 Note that in this context <emphasis>lock</emphasis> refers to local filesystem\r
  88                                 locking, not repository locking.\r
  89                         </para>\r
  90                 </glossdef>\r
  91         </glossentry>\r
  92         <glossentry>\r
  93                 <glossterm>Commit</glossterm>\r
  94                 <glossdef>\r
  95                         <para>\r
  96                                 This Subversion command is used to pass the changes in your local\r
  97                                 working copy back into the repository, creating a new repository\r
  98                                 revision.\r
  99                         </para>\r
 100                 </glossdef>\r
 101         </glossentry>\r
 102         <glossentry>\r
 103                 <glossterm>Conflict</glossterm>\r
 104                 <glossdef>\r
 105                         <para>\r
 106                                 When changes from the repository are merged with local changes, \r
 107                                 sometimes those changes occur on the same lines. In this case\r
 108                                 Subversion cannot automatically decide which version to use and\r
 109                                 the file is said to be in conflict. You have to edit the file manually\r
 110                                 and resolve the conflict before you can commit any further changes.\r
 111                         </para>\r
 112                 </glossdef>\r
 113         </glossentry>\r
 114         <glossentry>\r
 115                 <glossterm>Copy</glossterm>\r
 116                 <glossdef>\r
 117                         <para>\r
 118                                 In a Subversion repository you can create a copy of a single file\r
 119                                 or an entire tree. These are implemented as <quote>cheap copies</quote>\r
 120                                 which act a bit like a link to the original in that they take up\r
 121                                 almost no space. Making a copy preserves the history of the item\r
 122                                 in the copy, so you can trace changes made before the copy was made.\r
 123                         </para>\r
 124                 </glossdef>\r
 125         </glossentry>\r
 126         <glossentry>\r
 127                 <glossterm>Delete</glossterm>\r
 128                 <glossdef>\r
 129                         <para>\r
 130                                 When you delete a versioned item (and commit the change) the item\r
 131                                 no longer exists in the repository after the committed revision.\r
 132                                 But of course it still exists in earlier repository revisions,\r
 133                                 so you can still access it. If necessary, you can copy a deleted\r
 134                                 item and <quote>resurrect</quote> it complete with history.\r
 135                         </para>\r
 136                 </glossdef>\r
 137         </glossentry>\r
 138         <glossentry>\r
 139                 <glossterm>Diff</glossterm>\r
 140                 <glossdef>\r
 141                         <para>\r
 142                                 Shorthand for <quote>Show Differences</quote>. Very useful when\r
 143                                 you want to see exactly what changes have been made.\r
 144                         </para>\r
 145                 </glossdef>\r
 146         </glossentry>\r
 147         <glossentry>\r
 148                 <glossterm>Export</glossterm>\r
 149                 <glossdef>\r
 150                         <para>\r
 151                                 This command produces a copy of a versioned folder,\r
 152                                 just like a working copy, but without the local\r
 153                                 <literal>.svn</literal> folders.\r
 154                         </para>\r
 155                 </glossdef>\r
 156         </glossentry>\r
 157         <glossentry>\r
 158                 <glossterm>FSFS</glossterm>\r
 159                 <glossdef>\r
 160                         <para>\r
 161                                 A proprietary Subversion filesystem backend for repositories.\r
 162                                 Can be used on network shares. Default for 1.2 and newer repositories.\r
 163                         </para>\r
 164                 </glossdef>\r
 165         </glossentry>\r
 166         <glossentry>\r
 167                 <glossterm>GPO</glossterm>\r
 168                 <glossdef>\r
 169                         <para>\r
 170                                 Group policy object\r
 171                         </para>\r
 172                 </glossdef>\r
 173         </glossentry>\r
 174         <glossentry>\r
 175                 <glossterm>HEAD revision</glossterm>\r
 176                 <glossdef>\r
 177                         <para>\r
 178                                 The latest revision of a file or folder in the <emphasis>repository</emphasis>.\r
 179                         </para>\r
 180                 </glossdef>\r
 181         </glossentry>\r
 182         <glossentry>\r
 183                 <glossterm>Import</glossterm>\r
 184                 <glossdef>\r
 185                         <para>\r
 186                                 Subversion command to import an entire folder hierarchy into the repository\r
 187                                 in a single revision.\r
 188                         </para>\r
 189                 </glossdef>\r
 190         </glossentry>\r
 191         <glossentry>\r
 192                 <glossterm>Lock</glossterm>\r
 193                 <glossdef>\r
 194                         <para>\r
 195                                 When you take out a lock on a versioned item, you mark it in\r
 196                                 the repository as non-committable, except from the working copy\r
 197                                 where the lock was taken out.\r
 198                         </para>\r
 199                 </glossdef>\r
 200         </glossentry>\r
 201         <glossentry>\r
 202                 <glossterm>Log</glossterm>\r
 203                 <glossdef>\r
 204                         <para>\r
 205                                 Show the revision history of a file or folder.\r
 206                                 Also known as <quote>History</quote>.\r
 207                         </para>\r
 208                 </glossdef>\r
 209         </glossentry>\r
 210         <glossentry>\r
 211                 <glossterm>History</glossterm>\r
 212                 <glossdef>\r
 213                         <para>\r
 214                                 Show the revision history of a file or folder.\r
 215                                 Also known as <quote>Log</quote>.\r
 216                         </para>\r
 217                 </glossdef>\r
 218         </glossentry>\r
 219         <glossentry>\r
 220                 <glossterm>Merge</glossterm>\r
 221                 <glossdef>\r
 222                         <para>\r
 223                                 The process by which changes from the repository are added to your\r
 224                                 working copy without disrupting any changes you have already made\r
 225                                 locally. Sometimes these changes cannot be reconciled automatically\r
 226                                 and the working copy is said to be in conflict.\r
 227                         </para>\r
 228                         <para>\r
 229                                 Merging happens automatically when you update your working copy.\r
 230                                 You can also merge specific changes from another branch using\r
 231                                 TortoiseGit's Merge command.\r
 232                         </para>\r
 233                 </glossdef>\r
 234         </glossentry>\r
 235         <glossentry>\r
 236                 <glossterm>Patch</glossterm>\r
 237                 <glossdef>\r
 238                         <para>\r
 239                                 If a working copy has changes to text files only, it is possible\r
 240                                 to use Subversion's Diff command to generate a single file summary\r
 241                                 of those changes in Unified Diff format. A file of this type is often\r
 242                                 referred to as a <quote>Patch</quote>, and it can be emailed to someone\r
 243                                 else (or to a mailing list) and applied to another working copy.\r
 244                                 Someone without commit access can make changes and submit a patch\r
 245                                 file for an authorized committer to apply. Or if you are unsure about\r
 246                                 a change you can submit a patch for others to review.\r
 247                         </para>\r
 248                 </glossdef>\r
 249         </glossentry>\r
 250         <glossentry>\r
 251                 <glossterm>Property</glossterm>\r
 252                 <glossdef>\r
 253                         <para>\r
 254                                 In addition to versioning your directories and files, Subversion allows\r
 255                                 you to add versioned metadata - referred to as <quote>properties</quote>\r
 256                                 to each of your versioned directories and files. Each property has a\r
 257                                 name and a value, rather like a registry key. Subversion has some\r
 258                                 special properties which it uses internally, such as\r
 259                                 <literal>svn:eol-style</literal>. TortoiseGit has some too, such as\r
 260                                 <literal>tsvn:logminsize</literal>. You can add your own properties\r
 261                                 with any name and value you choose.\r
 262                         </para>\r
 263                 </glossdef>\r
 264         </glossentry>\r
 265         <glossentry>\r
 266                 <glossterm>Relocate</glossterm>\r
 267                 <glossdef>\r
 268                         <para>\r
 269                                 If your repository moves, perhaps because you have moved it to\r
 270                                 a different directory on your server, or the server domain name\r
 271                                 has changed, you need to <quote>relocate</quote> your working copy\r
 272                                 so that its repository URLs point to the new location.\r
 273                         </para>\r
 274                         <para>\r
 275                                 Note: you should only use this command if your working copy is\r
 276                                 referring to the same location in the same repository, but the\r
 277                                 repository itself has moved. In any other circumstance you\r
 278                                 probably need the <quote>Switch</quote> command instead.\r
 279                         </para>\r
 280                 </glossdef>\r
 281         </glossentry>\r
 282         <glossentry>\r
 283                 <glossterm>Repository</glossterm>\r
 284                 <glossdef>\r
 285                         <para>\r
 286                                 A repository is a central place where data is stored and maintained. \r
 287                                 A repository can be a place where multiple databases or files are located for \r
 288                                 distribution over a network, or a repository can be a location that is \r
 289                                 directly accessible to the user without having to travel across a network.\r
 290                         </para>\r
 291                 </glossdef>\r
 292         </glossentry>\r
 293         <glossentry>\r
 294                 <glossterm>Resolve</glossterm>\r
 295                 <glossdef>\r
 296                         <para>\r
 297                                 When files in a working copy are left in a conflicted state following\r
 298                                 a merge, those conflicts must be sorted out by a human using an editor\r
 299                                 (or perhaps TortoiseMerge). This process is referred to as\r
 300                                 <quote>Resolving Conflicts</quote>. When this is complete you can mark\r
 301                                 the conflicted files as being resolved, which allows them to be committed.\r
 302                         </para>\r
 303                 </glossdef>\r
 304         </glossentry>\r
 305         <glossentry>\r
 306                 <glossterm>Revert</glossterm>\r
 307                 <glossdef>\r
 308                         <para>\r
 309                                 Subversion keeps a local <quote>pristine</quote> copy of each file as\r
 310                                 it was when you last updated your working copy. If you have made changes\r
 311                                 and decide you want to undo them, you can use the <quote>revert</quote>\r
 312                                 command to go back to the pristine copy.\r
 313                         </para>\r
 314                 </glossdef>\r
 315         </glossentry>\r
 316         <glossentry>\r
 317                 <glossterm>Revision</glossterm>\r
 318                 <glossdef>\r
 319                         <para>\r
 320                                 Every time you commit a set of changes, you create one new\r
 321                                 <quote>revision</quote> in the repository. Each revision represents\r
 322                                 the state of the repository tree at a certain point in its history.\r
 323                                 If you want to go back in time you can examine the repository as\r
 324                                 it was at revision N.\r
 325                         </para>\r
 326                         <para>\r
 327                                 In another sense, a revision can refer to the set of changes that\r
 328                                 were made when that revision was created.\r
 329                         </para>\r
 330                 </glossdef>\r
 331         </glossentry>\r
 332         <glossentry>\r
 333                 <glossterm>Revision Property (revprop)</glossterm>\r
 334                 <glossdef>\r
 335                         <para>\r
 336                                 Just as files can have properties, so can each revision in the\r
 337                                 repository. Some special revprops are added automatically\r
 338                                 when the revision is created, namely:\r
 339                                 <literal>svn:date svn:author svn:log</literal> which represent\r
 340                                 the commit date/time, the committer and the log message\r
 341                                 respectively. These properties can be edited, but they are not\r
 342                                 versioned, so any change is permanent and cannot be undone.\r
 343                         </para>\r
 344                 </glossdef>\r
 345         </glossentry>\r
 346         <glossentry>\r
 347                 <glossterm>SVN</glossterm>\r
 348                 <glossdef>\r
 349                         <para>\r
 350                                 A frequently-used abbreviation for Subversion.\r
 351                         </para>\r
 352                         <para>\r
 353                                 The name of the Subversion custom protocol used by the\r
 354                                 <quote>svnserve</quote> repository server.\r
 355                         </para>\r
 356                 </glossdef>\r
 357         </glossentry>\r
 358         <glossentry>\r
 359                 <glossterm>Switch</glossterm>\r
 360                 <glossdef>\r
 361                         <para>\r
 362                                 Just as <quote>Update-to-revision</quote> changes the time\r
 363                                 window of a working copy to look at a different point in history,\r
 364                                 so <quote>Switch</quote> changes the space window of a working copy\r
 365                                 so that it points to a different part of the repository.\r
 366                                 It is particularly useful when working on trunk and branches where\r
 367                                 only a few files differ. You can switch your working copy between\r
 368                                 the two and only the changed files will be transferred.\r
 369                         </para>\r
 370                 </glossdef>\r
 371         </glossentry>\r
 372         <glossentry>\r
 373                 <glossterm>Update</glossterm>\r
 374                 <glossdef>\r
 375                         <para>\r
 376                                 This Subversion command pulls down the latest changes from the\r
 377                                 repository into your working copy, merging any changes made by\r
 378                                 others with local changes in the working copy.\r
 379                         </para>\r
 380                 </glossdef>\r
 381         </glossentry>\r
 382         <glossentry>\r
 383                 <glossterm>Working Copy</glossterm>\r
 384                 <glossdef>\r
 385                         <para>\r
 386                                 This is your local <quote>sandbox</quote>, the area where you\r
 387                                 work on the versioned files, and it normally resides on your\r
 388                                 local hard disk. You create a working copy by doing a\r
 389                                 <quote>Checkout</quote> from a repository, and you feed your\r
 390                                 changes back into the repository using <quote>Commit</quote>.\r
 391                         </para>\r
 392                 </glossdef>\r
 393         </glossentry>\r
 394 </glossary>\r
 395 <!--\r
 396 local variables: \r
 397 sgml-parent-document: ("book.xml" "glossary")\r
 398 end:\r
 399 -->\r