##// END OF EJS Templates
glossary: don't mention obsolete graphlog extension
Martin Geisler -
r20147:7547bcc1 stable
parent child Browse files
Show More
@@ -1,407 +1,407
1 1 Ancestor
2 2 Any changeset that can be reached by an unbroken chain of parent
3 3 changesets from a given changeset. More precisely, the ancestors
4 4 of a changeset can be defined by two properties: a parent of a
5 5 changeset is an ancestor, and a parent of an ancestor is an
6 6 ancestor. See also: 'Descendant'.
7 7
8 8 Bookmark
9 9 Bookmarks are pointers to certain commits that move when
10 10 committing. They are similar to tags in that it is possible to use
11 11 bookmark names in all places where Mercurial expects a changeset
12 12 ID, e.g., with :hg:`update`. Unlike tags, bookmarks move along
13 13 when you make a commit.
14 14
15 15 Bookmarks can be renamed, copied and deleted. Bookmarks are local,
16 16 unless they are explicitly pushed or pulled between repositories.
17 17 Pushing and pulling bookmarks allow you to collaborate with others
18 18 on a branch without creating a named branch.
19 19
20 20 Branch
21 21 (Noun) A child changeset that has been created from a parent that
22 22 is not a head. These are known as topological branches, see
23 23 'Branch, topological'. If a topological branch is named, it becomes
24 24 a named branch. If a topological branch is not named, it becomes
25 25 an anonymous branch. See 'Branch, anonymous' and 'Branch, named'.
26 26
27 27 Branches may be created when changes are pulled from or pushed to
28 28 a remote repository, since new heads may be created by these
29 29 operations. Note that the term branch can also be used informally
30 30 to describe a development process in which certain development is
31 31 done independently of other development. This is sometimes done
32 32 explicitly with a named branch, but it can also be done locally,
33 33 using bookmarks or clones and anonymous branches.
34 34
35 35 Example: "The experimental branch".
36 36
37 37 (Verb) The action of creating a child changeset which results in
38 38 its parent having more than one child.
39 39
40 40 Example: "I'm going to branch at X".
41 41
42 42 Branch, anonymous
43 43 Every time a new child changeset is created from a parent that is not
44 44 a head and the name of the branch is not changed, a new anonymous
45 45 branch is created.
46 46
47 47 Branch, closed
48 48 A named branch whose branch heads have all been closed.
49 49
50 50 Branch, default
51 51 The branch assigned to a changeset when no name has previously been
52 52 assigned.
53 53
54 54 Branch head
55 55 See 'Head, branch'.
56 56
57 57 Branch, inactive
58 58 If a named branch has no topological heads, it is considered to be
59 59 inactive. As an example, a feature branch becomes inactive when it
60 60 is merged into the default branch. The :hg:`branches` command
61 61 shows inactive branches by default, though they can be hidden with
62 62 :hg:`branches --active`.
63 63
64 64 NOTE: this concept is deprecated because it is too implicit.
65 65 Branches should now be explicitly closed using :hg:`commit
66 66 --close-branch` when they are no longer needed.
67 67
68 68 Branch, named
69 69 A collection of changesets which have the same branch name. By
70 70 default, children of a changeset in a named branch belong to the
71 71 same named branch. A child can be explicitly assigned to a
72 72 different branch. See :hg:`help branch`, :hg:`help branches` and
73 73 :hg:`commit --close-branch` for more information on managing
74 74 branches.
75 75
76 76 Named branches can be thought of as a kind of namespace, dividing
77 77 the collection of changesets that comprise the repository into a
78 78 collection of disjoint subsets. A named branch is not necessarily
79 79 a topological branch. If a new named branch is created from the
80 80 head of another named branch, or the default branch, but no
81 81 further changesets are added to that previous branch, then that
82 82 previous branch will be a branch in name only.
83 83
84 84 Branch tip
85 85 See 'Tip, branch'.
86 86
87 87 Branch, topological
88 88 Every time a new child changeset is created from a parent that is
89 89 not a head, a new topological branch is created. If a topological
90 90 branch is named, it becomes a named branch. If a topological
91 91 branch is not named, it becomes an anonymous branch of the
92 92 current, possibly default, branch.
93 93
94 94 Changelog
95 95 A record of the changesets in the order in which they were added
96 96 to the repository. This includes details such as changeset id,
97 97 author, commit message, date, and list of changed files.
98 98
99 99 Changeset
100 100 A snapshot of the state of the repository used to record a change.
101 101
102 102 Changeset, child
103 103 The converse of parent changeset: if P is a parent of C, then C is
104 104 a child of P. There is no limit to the number of children that a
105 105 changeset may have.
106 106
107 107 Changeset id
108 108 A SHA-1 hash that uniquely identifies a changeset. It may be
109 109 represented as either a "long" 40 hexadecimal digit string, or a
110 110 "short" 12 hexadecimal digit string.
111 111
112 112 Changeset, merge
113 113 A changeset with two parents. This occurs when a merge is
114 114 committed.
115 115
116 116 Changeset, parent
117 117 A revision upon which a child changeset is based. Specifically, a
118 118 parent changeset of a changeset C is a changeset whose node
119 119 immediately precedes C in the DAG. Changesets have at most two
120 120 parents.
121 121
122 122 Checkout
123 123 (Noun) The working directory being updated to a specific
124 124 revision. This use should probably be avoided where possible, as
125 125 changeset is much more appropriate than checkout in this context.
126 126
127 127 Example: "I'm using checkout X."
128 128
129 129 (Verb) Updating the working directory to a specific changeset. See
130 130 :hg:`help update`.
131 131
132 132 Example: "I'm going to check out changeset X."
133 133
134 134 Child changeset
135 135 See 'Changeset, child'.
136 136
137 137 Close changeset
138 138 See 'Head, closed branch'
139 139
140 140 Closed branch
141 141 See 'Branch, closed'.
142 142
143 143 Clone
144 144 (Noun) An entire or partial copy of a repository. The partial
145 145 clone must be in the form of a revision and its ancestors.
146 146
147 147 Example: "Is your clone up to date?".
148 148
149 149 (Verb) The process of creating a clone, using :hg:`clone`.
150 150
151 151 Example: "I'm going to clone the repository".
152 152
153 153 Closed branch head
154 154 See 'Head, closed branch'.
155 155
156 156 Commit
157 157 (Noun) A synonym for changeset.
158 158
159 159 Example: "Is the bug fixed in your recent commit?"
160 160
161 161 (Verb) The act of recording changes to a repository. When files
162 162 are committed in a working directory, Mercurial finds the
163 163 differences between the committed files and their parent
164 164 changeset, creating a new changeset in the repository.
165 165
166 166 Example: "You should commit those changes now."
167 167
168 168 Cset
169 169 A common abbreviation of the term changeset.
170 170
171 171 DAG
172 172 The repository of changesets of a distributed version control
173 173 system (DVCS) can be described as a directed acyclic graph (DAG),
174 174 consisting of nodes and edges, where nodes correspond to
175 175 changesets and edges imply a parent -> child relation. This graph
176 can be visualized by graphical tools such as :hg:`glog`
177 (graphlog). In Mercurial, the DAG is limited by the requirement
178 for children to have at most two parents.
176 can be visualized by graphical tools such as :hg:`log --graph`. In
177 Mercurial, the DAG is limited by the requirement for children to
178 have at most two parents.
179 179
180 180 Default branch
181 181 See 'Branch, default'.
182 182
183 183 Descendant
184 184 Any changeset that can be reached by a chain of child changesets
185 185 from a given changeset. More precisely, the descendants of a
186 186 changeset can be defined by two properties: the child of a
187 187 changeset is a descendant, and the child of a descendant is a
188 188 descendant. See also: 'Ancestor'.
189 189
190 190 Diff
191 191 (Noun) The difference between the contents and attributes of files
192 192 in two changesets or a changeset and the current working
193 193 directory. The difference is usually represented in a standard
194 194 form called a "diff" or "patch". The "git diff" format is used
195 195 when the changes include copies, renames, or changes to file
196 196 attributes, none of which can be represented/handled by classic
197 197 "diff" and "patch".
198 198
199 199 Example: "Did you see my correction in the diff?"
200 200
201 201 (Verb) Diffing two changesets is the action of creating a diff or
202 202 patch.
203 203
204 204 Example: "If you diff with changeset X, you will see what I mean."
205 205
206 206 Directory, working
207 207 The working directory represents the state of the files tracked by
208 208 Mercurial, that will be recorded in the next commit. The working
209 209 directory initially corresponds to the snapshot at an existing
210 210 changeset, known as the parent of the working directory. See
211 211 'Parent, working directory'. The state may be modified by changes
212 212 to the files introduced manually or by a merge. The repository
213 213 metadata exists in the .hg directory inside the working directory.
214 214
215 215 Draft
216 216 Changesets in the draft phase have not been shared with publishing
217 217 repositories and may thus be safely changed by history-modifying
218 218 extensions. See :hg:`help phases`.
219 219
220 220 Graph
221 See DAG and :hg:`help graphlog`.
221 See DAG and :hg:`log --graph`.
222 222
223 223 Head
224 224 The term 'head' may be used to refer to both a branch head or a
225 225 repository head, depending on the context. See 'Head, branch' and
226 226 'Head, repository' for specific definitions.
227 227
228 228 Heads are where development generally takes place and are the
229 229 usual targets for update and merge operations.
230 230
231 231 Head, branch
232 232 A changeset with no descendants on the same named branch.
233 233
234 234 Head, closed branch
235 235 A changeset that marks a head as no longer interesting. The closed
236 236 head is no longer listed by :hg:`heads`. A branch is considered
237 237 closed when all its heads are closed and consequently is not
238 238 listed by :hg:`branches`.
239 239
240 240 Closed heads can be re-opened by committing new changeset as the
241 241 child of the changeset that marks a head as closed.
242 242
243 243 Head, repository
244 244 A topological head which has not been closed.
245 245
246 246 Head, topological
247 247 A changeset with no children in the repository.
248 248
249 249 History, immutable
250 250 Once committed, changesets cannot be altered. Extensions which
251 251 appear to change history actually create new changesets that
252 252 replace existing ones, and then destroy the old changesets. Doing
253 253 so in public repositories can result in old changesets being
254 254 reintroduced to the repository.
255 255
256 256 History, rewriting
257 257 The changesets in a repository are immutable. However, extensions
258 258 to Mercurial can be used to alter the repository, usually in such
259 259 a way as to preserve changeset contents.
260 260
261 261 Immutable history
262 262 See 'History, immutable'.
263 263
264 264 Merge changeset
265 265 See 'Changeset, merge'.
266 266
267 267 Manifest
268 268 Each changeset has a manifest, which is the list of files that are
269 269 tracked by the changeset.
270 270
271 271 Merge
272 272 Used to bring together divergent branches of work. When you update
273 273 to a changeset and then merge another changeset, you bring the
274 274 history of the latter changeset into your working directory. Once
275 275 conflicts are resolved (and marked), this merge may be committed
276 276 as a merge changeset, bringing two branches together in the DAG.
277 277
278 278 Named branch
279 279 See 'Branch, named'.
280 280
281 281 Null changeset
282 282 The empty changeset. It is the parent state of newly-initialized
283 283 repositories and repositories with no checked out revision. It is
284 284 thus the parent of root changesets and the effective ancestor when
285 285 merging unrelated changesets. Can be specified by the alias 'null'
286 286 or by the changeset ID '000000000000'.
287 287
288 288 Parent
289 289 See 'Changeset, parent'.
290 290
291 291 Parent changeset
292 292 See 'Changeset, parent'.
293 293
294 294 Parent, working directory
295 295 The working directory parent reflects a virtual revision which is
296 296 the child of the changeset (or two changesets with an uncommitted
297 297 merge) shown by :hg:`parents`. This is changed with
298 298 :hg:`update`. Other commands to see the working directory parent
299 299 are :hg:`summary` and :hg:`id`. Can be specified by the alias ".".
300 300
301 301 Patch
302 302 (Noun) The product of a diff operation.
303 303
304 304 Example: "I've sent you my patch."
305 305
306 306 (Verb) The process of using a patch file to transform one
307 307 changeset into another.
308 308
309 309 Example: "You will need to patch that revision."
310 310
311 311 Phase
312 312 A per-changeset state tracking how the changeset has been or
313 313 should be shared. See :hg:`help phases`.
314 314
315 315 Public
316 316 Changesets in the public phase have been shared with publishing
317 317 repositories and are therefore considered immutable. See :hg:`help
318 318 phases`.
319 319
320 320 Pull
321 321 An operation in which changesets in a remote repository which are
322 322 not in the local repository are brought into the local
323 323 repository. Note that this operation without special arguments
324 324 only updates the repository, it does not update the files in the
325 325 working directory. See :hg:`help pull`.
326 326
327 327 Push
328 328 An operation in which changesets in a local repository which are
329 329 not in a remote repository are sent to the remote repository. Note
330 330 that this operation only adds changesets which have been committed
331 331 locally to the remote repository. Uncommitted changes are not
332 332 sent. See :hg:`help push`.
333 333
334 334 Repository
335 335 The metadata describing all recorded states of a collection of
336 336 files. Each recorded state is represented by a changeset. A
337 337 repository is usually (but not always) found in the ``.hg``
338 338 subdirectory of a working directory. Any recorded state can be
339 339 recreated by "updating" a working directory to a specific
340 340 changeset.
341 341
342 342 Repository head
343 343 See 'Head, repository'.
344 344
345 345 Revision
346 346 A state of the repository at some point in time. Earlier revisions
347 347 can be updated to by using :hg:`update`. See also 'Revision
348 348 number'; See also 'Changeset'.
349 349
350 350 Revision number
351 351 This integer uniquely identifies a changeset in a specific
352 352 repository. It represents the order in which changesets were added
353 353 to a repository, starting with revision number 0. Note that the
354 354 revision number may be different in each clone of a repository. To
355 355 identify changesets uniquely between different clones, see
356 356 'Changeset id'.
357 357
358 358 Revlog
359 359 History storage mechanism used by Mercurial. It is a form of delta
360 360 encoding, with occasional full revision of data followed by delta
361 361 of each successive revision. It includes data and an index
362 362 pointing to the data.
363 363
364 364 Rewriting history
365 365 See 'History, rewriting'.
366 366
367 367 Root
368 368 A changeset that has only the null changeset as its parent. Most
369 369 repositories have only a single root changeset.
370 370
371 371 Secret
372 372 Changesets in the secret phase may not be shared via push, pull,
373 373 or clone. See :hg:`help phases`.
374 374
375 375 Tag
376 376 An alternative name given to a changeset. Tags can be used in all
377 377 places where Mercurial expects a changeset ID, e.g., with
378 378 :hg:`update`. The creation of a tag is stored in the history and
379 379 will thus automatically be shared with other using push and pull.
380 380
381 381 Tip
382 382 The changeset with the highest revision number. It is the changeset
383 383 most recently added in a repository.
384 384
385 385 Tip, branch
386 386 The head of a given branch with the highest revision number. When
387 387 a branch name is used as a revision identifier, it refers to the
388 388 branch tip. See also 'Branch, head'. Note that because revision
389 389 numbers may be different in different repository clones, the
390 390 branch tip may be different in different cloned repositories.
391 391
392 392 Update
393 393 (Noun) Another synonym of changeset.
394 394
395 395 Example: "I've pushed an update".
396 396
397 397 (Verb) This term is usually used to describe updating the state of
398 398 the working directory to that of a specific changeset. See
399 399 :hg:`help update`.
400 400
401 401 Example: "You should update".
402 402
403 403 Working directory
404 404 See 'Directory, working'.
405 405
406 406 Working directory parent
407 407 See 'Parent, working directory'.
General Comments 0
You need to be logged in to leave comments. Login now